return [];

}

const payload = (await res.json().catch(() => null)) as Record<string, unknown> | null;

const data = payload && typeof payload.data !== "undefined" ? (payload.data as unknown) : null;

const data = payload && payload.data !== undefined ? (payload.data as unknown) : null;

return Array.isArray(data) ? (data as BlueBubblesChatRecord[]) : [];

}

return [];

}

const payload = (await res.json().catch(() => null)) as Record<string, unknown> | null;

const data = payload && typeof payload.data !== "undefined" ? (payload.data as unknown) : null;

const data = payload && payload.data !== undefined ? (payload.data as unknown) : null;

return Array.isArray(data) ? (data as BlueBubblesChatRecord[]) : [];

}

function resolveCompactionWaitTimeoutMs(): number {

const raw = process.env.OPENCLAW_CODEX_COMPACTION_WAIT_TIMEOUT_MS?.trim();

const parsed = raw ? Number.parseInt(raw, 10) : NaN;

const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;

if (Number.isFinite(parsed) && parsed > 0) {

return parsed;

}

"csv=p=0",

filePath,

]);

const duration = parseFloat(stdout.trim());

if (isNaN(duration)) {

const duration = Number.parseFloat(stdout.trim());

if (Number.isNaN(duration)) {

throw new Error("Could not parse duration");

}

return Math.round(duration * 100) / 100; // Round to 2 decimal places

const DECRYPT_FAILURE_WINDOW_MS = 30_000;

const DECRYPT_FAILURE_RECONNECT_THRESHOLD = 3;

const DECRYPT_FAILURE_PATTERN = /DecryptionFailed\(/;

const DAVE_PASSTHROUGH_DISABLED_PATTERN = /UnencryptedWhenPassthroughDisabled/;

const DECRYPT_FAILURE_MARKER = "DecryptionFailed(";

const DAVE_PASSTHROUGH_DISABLED_MARKER = "UnencryptedWhenPassthroughDisabled";

export const DAVE_RECEIVE_PASSTHROUGH_INITIAL_EXPIRY_SECONDS = 30;

export const DAVE_RECEIVE_PASSTHROUGH_REARM_EXPIRY_SECONDS = 15;

export function analyzeVoiceReceiveError(err: unknown): VoiceReceiveErrorAnalysis {

const message = formatErrorMessage(err);

const shouldAttemptPassthrough = DAVE_PASSTHROUGH_DISABLED_PATTERN.test(message);

const shouldAttemptPassthrough = message.includes(DAVE_PASSTHROUGH_DISABLED_MARKER);

return {

message,

isAbortLike: isAbortLikeReceiveError(err),

shouldAttemptPassthrough,

countsAsDecryptFailure: DECRYPT_FAILURE_PATTERN.test(message) || shouldAttemptPassthrough,

countsAsDecryptFailure: message.includes(DECRYPT_FAILURE_MARKER) || shouldAttemptPassthrough,

};

}

.replace(/&mdash;/g, "--")

.replace(/&hellip;/g, "...")

.replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))

.replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)));

.replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(Number.parseInt(code, 16)));

}

function stripHtml(html: string): string {

export type GroupSessionScope = "group" | "group_sender" | "group_topic" | "group_topic_sender";

type FeishuLogger = {

(...args: unknown[]): void;

};

type FeishuLogger = (...args: unknown[]) => void;

export type ResolvedFeishuGroupSession = {

peerId: string;

log?.(`feishu: merge_forward contains ${subMessages.length} sub-messages`);

subMessages.sort(

(a, b) => parseInt(a.create_time || "0", 10) - parseInt(b.create_time || "0", 10),

(a, b) => Number.parseInt(a.create_time || "0", 10) - Number.parseInt(b.create_time || "0", 10),

);

const lines = ["[Merged and Forwarded Messages]"];

ReturnType<ReturnType<typeof createFeishuClient>["contact"]["user"]["get"]>

>;

type FeishuLogger = {

(...args: unknown[]): void;

};

type FeishuLogger = (...args: unknown[]) => void;

const IGNORED_PERMISSION_SCOPE_TOKENS = ["contact:contact.base:readonly"];

const FEISHU_SCOPE_CORRECTIONS: Record<string, string> = {

// instead of the delivery/processing time. Feishu uses a millisecond

// epoch string; fall back to Date.now() only when the field is absent.

const messageCreateTimeMs = event.message.create_time

? parseInt(event.message.create_time, 10)

? Number.parseInt(event.message.create_time, 10)

: Date.now();

let requireMention = false; // DMs never require mention; groups may override below

import fs from "fs";

import path from "path";

import { Readable } from "stream";

import fs from "node:fs";

import path from "node:path";

import { Readable } from "node:stream";

import type * as Lark from "@larksuiteoapi/node-sdk";

import { mediaKindFromMime } from "openclaw/plugin-sdk/media-runtime";

import { withTempDownloadPath } from "openclaw/plugin-sdk/temp-path";

if (routing.msgType === "image") {

const { imageKey } = await uploadImageFeishu({ cfg, image: buffer, accountId });

return sendImageFeishu({ cfg, to, imageKey, replyToMessageId, replyInThread, accountId });

} else {

const { fileKey } = await uploadFileFeishu({

cfg,

file: buffer,

fileName: name,

fileType: routing.fileType ?? "stream",

accountId,

});

return sendFileFeishu({

cfg,

to,

fileKey,

msgType: routing.msgType,

replyToMessageId,

replyInThread,

accountId,

});

}

const { fileKey } = await uploadFileFeishu({

cfg,

file: buffer,

fileName: name,

fileType: routing.fileType ?? "stream",

accountId,

});

return sendFileFeishu({

cfg,

to,

fileKey,

msgType: routing.msgType,

replyToMessageId,

replyInThread,

accountId,

});

}