openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/imessage/monitor/monitor-provider.js

@@ -1,441 +0,0 @@
-import fs from "node:fs/promises";
-import { resolveHumanDelayConfig } from "../../agents/identity.js";
-import { resolveTextChunkLimit } from "../../auto-reply/chunk.js";
-import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
-import { clearHistoryEntriesIfEnabled, DEFAULT_GROUP_HISTORY_LIMIT, } from "../../auto-reply/reply/history.js";
-import { createReplyDispatcher } from "../../auto-reply/reply/reply-dispatcher.js";
-import { createChannelInboundDebouncer, shouldDebounceTextInbound, } from "../../channels/inbound-debounce-policy.js";
-import { createReplyPrefixOptions } from "../../channels/reply-prefix.js";
-import { recordInboundSession } from "../../channels/session.js";
-import { loadConfig } from "../../config/config.js";
-import { resolveOpenProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce, } from "../../config/runtime-group-policy.js";
-import { readSessionUpdatedAt, resolveStorePath } from "../../config/sessions.js";
-import { danger, logVerbose, shouldLogVerbose, warn } from "../../globals.js";
-import { normalizeScpRemoteHost } from "../../infra/scp-host.js";
-import { waitForTransportReady } from "../../infra/transport-ready.js";
-import { isInboundPathAllowed, resolveIMessageAttachmentRoots, resolveIMessageRemoteAttachmentRoots, } from "../../media/inbound-path-policy.js";
-import { kindFromMime } from "../../media/mime.js";
-import { buildPairingReply } from "../../pairing/pairing-messages.js";
-import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../../pairing/pairing-store.js";
-import { resolvePinnedMainDmOwnerFromAllowlist } from "../../security/dm-policy-shared.js";
-import { truncateUtf16Safe } from "../../utils.js";
-import { resolveIMessageAccount } from "../accounts.js";
-import { createIMessageRpcClient } from "../client.js";
-import { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS } from "../constants.js";
-import { probeIMessage } from "../probe.js";
-import { sendMessageIMessage } from "../send.js";
-import { normalizeIMessageHandle } from "../targets.js";
-import { attachIMessageMonitorAbortHandler } from "./abort-handler.js";
-import { deliverReplies } from "./deliver.js";
-import { createSentMessageCache } from "./echo-cache.js";
-import { buildIMessageInboundContext, resolveIMessageInboundDecision, } from "./inbound-processing.js";
-import { parseIMessageNotification } from "./parse-notification.js";
-import { normalizeAllowList, resolveRuntime } from "./runtime.js";
-/**
- * Try to detect remote host from an SSH wrapper script like:
- *   exec ssh -T openclaw@192.168.64.3 /opt/homebrew/bin/imsg "$@"
- *   exec ssh -T mac-mini imsg "$@"
- * Returns the user@host or host portion if found, undefined otherwise.
- */
-async function detectRemoteHostFromCliPath(cliPath) {
-    try {
-        // Expand ~ to home directory
-        const expanded = cliPath.startsWith("~")
-            ? cliPath.replace(/^~/, process.env.HOME ?? "")
-            : cliPath;
-        const content = await fs.readFile(expanded, "utf8");
-        // Match user@host pattern first (e.g., openclaw@192.168.64.3)
-        const userHostMatch = content.match(/\bssh\b[^\n]*?\s+([a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+)/);
-        if (userHostMatch) {
-            return userHostMatch[1];
-        }
-        // Fallback: match host-only before imsg command (e.g., ssh -T mac-mini imsg)
-        const hostOnlyMatch = content.match(/\bssh\b[^\n]*?\s+([a-zA-Z][a-zA-Z0-9._-]*)\s+\S*\bimsg\b/);
-        return hostOnlyMatch?.[1];
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function monitorIMessageProvider(opts = {}) {
-    const runtime = resolveRuntime(opts);
-    const cfg = opts.config ?? loadConfig();
-    const accountInfo = resolveIMessageAccount({
-        cfg,
-        accountId: opts.accountId,
-    });
-    const imessageCfg = accountInfo.config;
-    const historyLimit = Math.max(0, imessageCfg.historyLimit ??
-        cfg.messages?.groupChat?.historyLimit ??
-        DEFAULT_GROUP_HISTORY_LIMIT);
-    const groupHistories = new Map();
-    const sentMessageCache = createSentMessageCache();
-    const textLimit = resolveTextChunkLimit(cfg, "imessage", accountInfo.accountId);
-    const allowFrom = normalizeAllowList(opts.allowFrom ?? imessageCfg.allowFrom);
-    const groupAllowFrom = normalizeAllowList(opts.groupAllowFrom ??
-        imessageCfg.groupAllowFrom ??
-        (imessageCfg.allowFrom && imessageCfg.allowFrom.length > 0 ? imessageCfg.allowFrom : []));
-    const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
-    const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy({
-        providerConfigPresent: cfg.channels?.imessage !== undefined,
-        groupPolicy: imessageCfg.groupPolicy,
-        defaultGroupPolicy,
-    });
-    warnMissingProviderGroupPolicyFallbackOnce({
-        providerMissingFallbackApplied,
-        providerKey: "imessage",
-        accountId: accountInfo.accountId,
-        log: (message) => runtime.log?.(warn(message)),
-    });
-    const dmPolicy = imessageCfg.dmPolicy ?? "pairing";
-    const includeAttachments = opts.includeAttachments ?? imessageCfg.includeAttachments ?? false;
-    const mediaMaxBytes = (opts.mediaMaxMb ?? imessageCfg.mediaMaxMb ?? 16) * 1024 * 1024;
-    const cliPath = opts.cliPath ?? imessageCfg.cliPath ?? "imsg";
-    const dbPath = opts.dbPath ?? imessageCfg.dbPath;
-    const probeTimeoutMs = imessageCfg.probeTimeoutMs ?? DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS;
-    const attachmentRoots = resolveIMessageAttachmentRoots({
-        cfg,
-        accountId: accountInfo.accountId,
-    });
-    const remoteAttachmentRoots = resolveIMessageRemoteAttachmentRoots({
-        cfg,
-        accountId: accountInfo.accountId,
-    });
-    // Resolve remoteHost: explicit config, or auto-detect from SSH wrapper script.
-    // Accept only a safe host token to avoid option/argument injection into SCP.
-    const configuredRemoteHost = normalizeScpRemoteHost(imessageCfg.remoteHost);
-    if (imessageCfg.remoteHost && !configuredRemoteHost) {
-        logVerbose("imessage: ignoring unsafe channels.imessage.remoteHost value");
-    }
-    let remoteHost = configuredRemoteHost;
-    if (!remoteHost && cliPath && cliPath !== "imsg") {
-        const detected = await detectRemoteHostFromCliPath(cliPath);
-        const normalizedDetected = normalizeScpRemoteHost(detected);
-        if (detected && !normalizedDetected) {
-            logVerbose("imessage: ignoring unsafe auto-detected remoteHost from cliPath");
-        }
-        remoteHost = normalizedDetected;
-        if (remoteHost) {
-            logVerbose(`imessage: detected remoteHost=${remoteHost} from cliPath`);
-        }
-    }
-    const { debouncer: inboundDebouncer } = createChannelInboundDebouncer({
-        cfg,
-        channel: "imessage",
-        buildKey: (entry) => {
-            const sender = entry.message.sender?.trim();
-            if (!sender) {
-                return null;
-            }
-            const conversationId = entry.message.chat_id != null
-                ? `chat:${entry.message.chat_id}`
-                : (entry.message.chat_guid ?? entry.message.chat_identifier ?? "unknown");
-            return `imessage:${accountInfo.accountId}:${conversationId}:${sender}`;
-        },
-        shouldDebounce: (entry) => {
-            return shouldDebounceTextInbound({
-                text: entry.message.text,
-                cfg,
-                hasMedia: Boolean(entry.message.attachments && entry.message.attachments.length > 0),
-            });
-        },
-        onFlush: async (entries) => {
-            const last = entries.at(-1);
-            if (!last) {
-                return;
-            }
-            if (entries.length === 1) {
-                await handleMessageNow(last.message);
-                return;
-            }
-            const combinedText = entries
-                .map((entry) => entry.message.text ?? "")
-                .filter(Boolean)
-                .join("\n");
-            const syntheticMessage = {
-                ...last.message,
-                text: combinedText,
-                attachments: null,
-            };
-            await handleMessageNow(syntheticMessage);
-        },
-        onError: (err) => {
-            runtime.error?.(`imessage debounce flush failed: ${String(err)}`);
-        },
-    });
-    async function handleMessageNow(message) {
-        const messageText = (message.text ?? "").trim();
-        const attachments = includeAttachments ? (message.attachments ?? []) : [];
-        const effectiveAttachmentRoots = remoteHost ? remoteAttachmentRoots : attachmentRoots;
-        const validAttachments = attachments.filter((entry) => {
-            const attachmentPath = entry?.original_path?.trim();
-            if (!attachmentPath || entry?.missing) {
-                return false;
-            }
-            if (isInboundPathAllowed({ filePath: attachmentPath, roots: effectiveAttachmentRoots })) {
-                return true;
-            }
-            logVerbose(`imessage: dropping inbound attachment outside allowed roots: ${attachmentPath}`);
-            return false;
-        });
-        const firstAttachment = validAttachments[0];
-        const mediaPath = firstAttachment?.original_path ?? undefined;
-        const mediaType = firstAttachment?.mime_type ?? undefined;
-        // Build arrays for all attachments (for multi-image support)
-        const mediaPaths = validAttachments.map((a) => a.original_path).filter(Boolean);
-        const mediaTypes = validAttachments.map((a) => a.mime_type ?? undefined);
-        const kind = kindFromMime(mediaType ?? undefined);
-        const placeholder = kind
-            ? `<media:${kind}>`
-            : validAttachments.length
-                ? "<media:attachment>"
-                : "";
-        const bodyText = messageText || placeholder;
-        const storeAllowFrom = await readChannelAllowFromStore("imessage", process.env, accountInfo.accountId).catch(() => []);
-        const decision = resolveIMessageInboundDecision({
-            cfg,
-            accountId: accountInfo.accountId,
-            message,
-            opts,
-            messageText,
-            bodyText,
-            allowFrom,
-            groupAllowFrom,
-            groupPolicy,
-            dmPolicy,
-            storeAllowFrom,
-            historyLimit,
-            groupHistories,
-            echoCache: sentMessageCache,
-            logVerbose,
-        });
-        if (decision.kind === "drop") {
-            return;
-        }
-        const chatId = message.chat_id ?? undefined;
-        if (decision.kind === "pairing") {
-            const sender = (message.sender ?? "").trim();
-            if (!sender) {
-                return;
-            }
-            const { code, created } = await upsertChannelPairingRequest({
-                channel: "imessage",
-                id: decision.senderId,
-                accountId: accountInfo.accountId,
-                meta: {
-                    sender: decision.senderId,
-                    chatId: chatId ? String(chatId) : undefined,
-                },
-            });
-            if (created) {
-                logVerbose(`imessage pairing request sender=${decision.senderId}`);
-                try {
-                    await sendMessageIMessage(sender, buildPairingReply({
-                        channel: "imessage",
-                        idLine: `Your iMessage sender id: ${decision.senderId}`,
-                        code,
-                    }), {
-                        client,
-                        maxBytes: mediaMaxBytes,
-                        accountId: accountInfo.accountId,
-                        ...(chatId ? { chatId } : {}),
-                    });
-                }
-                catch (err) {
-                    logVerbose(`imessage pairing reply failed for ${decision.senderId}: ${String(err)}`);
-                }
-            }
-            return;
-        }
-        const storePath = resolveStorePath(cfg.session?.store, {
-            agentId: decision.route.agentId,
-        });
-        const previousTimestamp = readSessionUpdatedAt({
-            storePath,
-            sessionKey: decision.route.sessionKey,
-        });
-        const { ctxPayload, chatTarget } = buildIMessageInboundContext({
-            cfg,
-            decision,
-            message,
-            previousTimestamp,
-            remoteHost,
-            historyLimit,
-            groupHistories,
-            media: {
-                path: mediaPath,
-                type: mediaType,
-                paths: mediaPaths,
-                types: mediaTypes,
-            },
-        });
-        const updateTarget = chatTarget || decision.sender;
-        const pinnedMainDmOwner = resolvePinnedMainDmOwnerFromAllowlist({
-            dmScope: cfg.session?.dmScope,
-            allowFrom,
-            normalizeEntry: normalizeIMessageHandle,
-        });
-        await recordInboundSession({
-            storePath,
-            sessionKey: ctxPayload.SessionKey ?? decision.route.sessionKey,
-            ctx: ctxPayload,
-            updateLastRoute: !decision.isGroup && updateTarget
-                ? {
-                    sessionKey: decision.route.mainSessionKey,
-                    channel: "imessage",
-                    to: updateTarget,
-                    accountId: decision.route.accountId,
-                    mainDmOwnerPin: pinnedMainDmOwner && decision.senderNormalized
-                        ? {
-                            ownerRecipient: pinnedMainDmOwner,
-                            senderRecipient: decision.senderNormalized,
-                            onSkip: ({ ownerRecipient, senderRecipient }) => {
-                                logVerbose(`imessage: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`);
-                            },
-                        }
-                        : undefined,
-                }
-                : undefined,
-            onRecordError: (err) => {
-                logVerbose(`imessage: failed updating session meta: ${String(err)}`);
-            },
-        });
-        if (shouldLogVerbose()) {
-            const preview = truncateUtf16Safe(String(ctxPayload.Body ?? ""), 200).replace(/\n/g, "\\n");
-            logVerbose(`imessage inbound: chatId=${chatId ?? "unknown"} from=${ctxPayload.From} len=${String(ctxPayload.Body ?? "").length} preview="${preview}"`);
-        }
-        const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
-            cfg,
-            agentId: decision.route.agentId,
-            channel: "imessage",
-            accountId: decision.route.accountId,
-        });
-        const dispatcher = createReplyDispatcher({
-            ...prefixOptions,
-            humanDelay: resolveHumanDelayConfig(cfg, decision.route.agentId),
-            deliver: async (payload) => {
-                const target = ctxPayload.To;
-                if (!target) {
-                    runtime.error?.(danger("imessage: missing delivery target"));
-                    return;
-                }
-                await deliverReplies({
-                    replies: [payload],
-                    target,
-                    client,
-                    accountId: accountInfo.accountId,
-                    runtime,
-                    maxBytes: mediaMaxBytes,
-                    textLimit,
-                    sentMessageCache,
-                });
-            },
-            onError: (err, info) => {
-                runtime.error?.(danger(`imessage ${info.kind} reply failed: ${String(err)}`));
-            },
-        });
-        const { queuedFinal } = await dispatchInboundMessage({
-            ctx: ctxPayload,
-            cfg,
-            dispatcher,
-            replyOptions: {
-                disableBlockStreaming: typeof accountInfo.config.blockStreaming === "boolean"
-                    ? !accountInfo.config.blockStreaming
-                    : undefined,
-                onModelSelected,
-            },
-        });
-        if (!queuedFinal) {
-            if (decision.isGroup && decision.historyKey) {
-                clearHistoryEntriesIfEnabled({
-                    historyMap: groupHistories,
-                    historyKey: decision.historyKey,
-                    limit: historyLimit,
-                });
-            }
-            return;
-        }
-        if (decision.isGroup && decision.historyKey) {
-            clearHistoryEntriesIfEnabled({
-                historyMap: groupHistories,
-                historyKey: decision.historyKey,
-                limit: historyLimit,
-            });
-        }
-    }
-    const handleMessage = async (raw) => {
-        const message = parseIMessageNotification(raw);
-        if (!message) {
-            logVerbose("imessage: dropping malformed RPC message payload");
-            return;
-        }
-        await inboundDebouncer.enqueue({ message });
-    };
-    await waitForTransportReady({
-        label: "imsg rpc",
-        timeoutMs: 30_000,
-        logAfterMs: 10_000,
-        logIntervalMs: 10_000,
-        pollIntervalMs: 500,
-        abortSignal: opts.abortSignal,
-        runtime,
-        check: async () => {
-            const probe = await probeIMessage(probeTimeoutMs, { cliPath, dbPath, runtime });
-            if (probe.ok) {
-                return { ok: true };
-            }
-            if (probe.fatal) {
-                throw new Error(probe.error ?? "imsg rpc unavailable");
-            }
-            return { ok: false, error: probe.error ?? "unreachable" };
-        },
-    });
-    if (opts.abortSignal?.aborted) {
-        return;
-    }
-    const client = await createIMessageRpcClient({
-        cliPath,
-        dbPath,
-        runtime,
-        onNotification: (msg) => {
-            if (msg.method === "message") {
-                void handleMessage(msg.params).catch((err) => {
-                    runtime.error?.(`imessage: handler failed: ${String(err)}`);
-                });
-            }
-            else if (msg.method === "error") {
-                runtime.error?.(`imessage: watch error ${JSON.stringify(msg.params)}`);
-            }
-        },
-    });
-    let subscriptionId = null;
-    const abort = opts.abortSignal;
-    const detachAbortHandler = attachIMessageMonitorAbortHandler({
-        abortSignal: abort,
-        client,
-        getSubscriptionId: () => subscriptionId,
-    });
-    try {
-        const result = await client.request("watch.subscribe", {
-            attachments: includeAttachments,
-        });
-        subscriptionId = result?.subscription ?? null;
-        await client.waitForClose();
-    }
-    catch (err) {
-        if (abort?.aborted) {
-            return;
-        }
-        runtime.error?.(danger(`imessage: monitor failed: ${String(err)}`));
-        throw err;
-    }
-    finally {
-        detachAbortHandler();
-        await client.stop();
-    }
-}
-export const __testing = {
-    resolveIMessageRuntimeGroupPolicy: resolveOpenProviderRuntimeGroupPolicy,
-    resolveDefaultGroupPolicy,
-};
-//# sourceMappingURL=monitor-provider.js.map

package/dist/openclaw/src/imessage/monitor/parse-notification.d.ts

@@ -1,3 +0,0 @@
-import type { IMessagePayload } from "./types.js";
-export declare function parseIMessageNotification(raw: unknown): IMessagePayload | null;
-//# sourceMappingURL=parse-notification.d.ts.map

package/dist/openclaw/src/imessage/monitor/parse-notification.js

@@ -1,65 +0,0 @@
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isOptionalString(value) {
-    return value === undefined || value === null || typeof value === "string";
-}
-function isOptionalStringOrNumber(value) {
-    return (value === undefined || value === null || typeof value === "string" || typeof value === "number");
-}
-function isOptionalNumber(value) {
-    return value === undefined || value === null || typeof value === "number";
-}
-function isOptionalBoolean(value) {
-    return value === undefined || value === null || typeof value === "boolean";
-}
-function isOptionalStringArray(value) {
-    return (value === undefined ||
-        value === null ||
-        (Array.isArray(value) && value.every((entry) => typeof entry === "string")));
-}
-function isOptionalAttachments(value) {
-    if (value === undefined || value === null) {
-        return true;
-    }
-    if (!Array.isArray(value)) {
-        return false;
-    }
-    return value.every((attachment) => {
-        if (!isRecord(attachment)) {
-            return false;
-        }
-        return (isOptionalString(attachment.original_path) &&
-            isOptionalString(attachment.mime_type) &&
-            isOptionalBoolean(attachment.missing));
-    });
-}
-export function parseIMessageNotification(raw) {
-    if (!isRecord(raw)) {
-        return null;
-    }
-    const maybeMessage = raw.message;
-    if (!isRecord(maybeMessage)) {
-        return null;
-    }
-    const message = maybeMessage;
-    if (!isOptionalNumber(message.id) ||
-        !isOptionalNumber(message.chat_id) ||
-        !isOptionalString(message.sender) ||
-        !isOptionalBoolean(message.is_from_me) ||
-        !isOptionalString(message.text) ||
-        !isOptionalStringOrNumber(message.reply_to_id) ||
-        !isOptionalString(message.reply_to_text) ||
-        !isOptionalString(message.reply_to_sender) ||
-        !isOptionalString(message.created_at) ||
-        !isOptionalAttachments(message.attachments) ||
-        !isOptionalString(message.chat_identifier) ||
-        !isOptionalString(message.chat_guid) ||
-        !isOptionalString(message.chat_name) ||
-        !isOptionalStringArray(message.participants) ||
-        !isOptionalBoolean(message.is_group)) {
-        return null;
-    }
-    return message;
-}
-//# sourceMappingURL=parse-notification.js.map

package/dist/openclaw/src/imessage/monitor/runtime.d.ts

@@ -1,5 +0,0 @@
-import { type RuntimeEnv } from "../../runtime.js";
-import type { MonitorIMessageOpts } from "./types.js";
-export declare function resolveRuntime(opts: MonitorIMessageOpts): RuntimeEnv;
-export declare function normalizeAllowList(list?: Array<string | number>): string[];
-//# sourceMappingURL=runtime.d.ts.map

package/dist/openclaw/src/imessage/monitor/runtime.js

@@ -1,9 +0,0 @@
-import { createNonExitingRuntime } from "../../runtime.js";
-import { normalizeStringEntries } from "../../shared/string-normalization.js";
-export function resolveRuntime(opts) {
-    return opts.runtime ?? createNonExitingRuntime();
-}
-export function normalizeAllowList(list) {
-    return normalizeStringEntries(list);
-}
-//# sourceMappingURL=runtime.js.map

package/dist/openclaw/src/imessage/monitor/types.d.ts

@@ -1,38 +0,0 @@
-import type { OpenClawConfig } from "../../config/config.js";
-import type { RuntimeEnv } from "../../runtime.js";
-export type IMessageAttachment = {
-    original_path?: string | null;
-    mime_type?: string | null;
-    missing?: boolean | null;
-};
-export type IMessagePayload = {
-    id?: number | null;
-    chat_id?: number | null;
-    sender?: string | null;
-    is_from_me?: boolean | null;
-    text?: string | null;
-    reply_to_id?: number | string | null;
-    reply_to_text?: string | null;
-    reply_to_sender?: string | null;
-    created_at?: string | null;
-    attachments?: IMessageAttachment[] | null;
-    chat_identifier?: string | null;
-    chat_guid?: string | null;
-    chat_name?: string | null;
-    participants?: string[] | null;
-    is_group?: boolean | null;
-};
-export type MonitorIMessageOpts = {
-    runtime?: RuntimeEnv;
-    abortSignal?: AbortSignal;
-    cliPath?: string;
-    dbPath?: string;
-    accountId?: string;
-    config?: OpenClawConfig;
-    allowFrom?: Array<string | number>;
-    groupAllowFrom?: Array<string | number>;
-    includeAttachments?: boolean;
-    mediaMaxMb?: number;
-    requireMention?: boolean;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/openclaw/src/imessage/monitor/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/openclaw/src/imessage/monitor.d.ts

@@ -1,3 +0,0 @@
-export { monitorIMessageProvider } from "./monitor/monitor-provider.js";
-export type { MonitorIMessageOpts } from "./monitor/types.js";
-//# sourceMappingURL=monitor.d.ts.map

package/dist/openclaw/src/imessage/monitor.js

@@ -1,2 +0,0 @@
-export { monitorIMessageProvider } from "./monitor/monitor-provider.js";
-//# sourceMappingURL=monitor.js.map

package/dist/openclaw/src/imessage/probe.d.ts

@@ -1,18 +0,0 @@
-import type { BaseProbeResult } from "../channels/plugins/types.js";
-import type { RuntimeEnv } from "../runtime.js";
-export { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS } from "./constants.js";
-export type IMessageProbe = BaseProbeResult & {
-    fatal?: boolean;
-};
-export type IMessageProbeOptions = {
-    cliPath?: string;
-    dbPath?: string;
-    runtime?: RuntimeEnv;
-};
-/**
- * Probe iMessage RPC availability.
- * @param timeoutMs - Explicit timeout in ms. If undefined, uses config or default.
- * @param opts - Additional options (cliPath, dbPath, runtime).
- */
-export declare function probeIMessage(timeoutMs?: number, opts?: IMessageProbeOptions): Promise<IMessageProbe>;
-//# sourceMappingURL=probe.d.ts.map

package/dist/openclaw/src/imessage/probe.js

@@ -1,80 +0,0 @@
-import { detectBinary } from "../commands/onboard-helpers.js";
-import { loadConfig } from "../config/config.js";
-import { runCommandWithTimeout } from "../process/exec.js";
-import { createIMessageRpcClient } from "./client.js";
-import { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS } from "./constants.js";
-// Re-export for backwards compatibility
-export { DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS } from "./constants.js";
-const rpcSupportCache = new Map();
-async function probeRpcSupport(cliPath, timeoutMs) {
-    const cached = rpcSupportCache.get(cliPath);
-    if (cached) {
-        return cached;
-    }
-    try {
-        const result = await runCommandWithTimeout([cliPath, "rpc", "--help"], { timeoutMs });
-        const combined = `${result.stdout}\n${result.stderr}`.trim();
-        const normalized = combined.toLowerCase();
-        if (normalized.includes("unknown command") && normalized.includes("rpc")) {
-            const fatal = {
-                supported: false,
-                fatal: true,
-                error: 'imsg CLI does not support the "rpc" subcommand (update imsg)',
-            };
-            rpcSupportCache.set(cliPath, fatal);
-            return fatal;
-        }
-        if (result.code === 0) {
-            const supported = { supported: true };
-            rpcSupportCache.set(cliPath, supported);
-            return supported;
-        }
-        return {
-            supported: false,
-            error: combined || `imsg rpc --help failed (code ${String(result.code ?? "unknown")})`,
-        };
-    }
-    catch (err) {
-        return { supported: false, error: String(err) };
-    }
-}
-/**
- * Probe iMessage RPC availability.
- * @param timeoutMs - Explicit timeout in ms. If undefined, uses config or default.
- * @param opts - Additional options (cliPath, dbPath, runtime).
- */
-export async function probeIMessage(timeoutMs, opts = {}) {
-    const cfg = opts.cliPath || opts.dbPath ? undefined : loadConfig();
-    const cliPath = opts.cliPath?.trim() || cfg?.channels?.imessage?.cliPath?.trim() || "imsg";
-    const dbPath = opts.dbPath?.trim() || cfg?.channels?.imessage?.dbPath?.trim();
-    // Use explicit timeout if provided, otherwise fall back to config, then default
-    const effectiveTimeout = timeoutMs ?? cfg?.channels?.imessage?.probeTimeoutMs ?? DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS;
-    const detected = await detectBinary(cliPath);
-    if (!detected) {
-        return { ok: false, error: `imsg not found (${cliPath})` };
-    }
-    const rpcSupport = await probeRpcSupport(cliPath, effectiveTimeout);
-    if (!rpcSupport.supported) {
-        return {
-            ok: false,
-            error: rpcSupport.error ?? "imsg rpc unavailable",
-            fatal: rpcSupport.fatal,
-        };
-    }
-    const client = await createIMessageRpcClient({
-        cliPath,
-        dbPath,
-        runtime: opts.runtime,
-    });
-    try {
-        await client.request("chats.list", { limit: 1 }, { timeoutMs: effectiveTimeout });
-        return { ok: true };
-    }
-    catch (err) {
-        return { ok: false, error: String(err) };
-    }
-    finally {
-        await client.stop();
-    }
-}
-//# sourceMappingURL=probe.js.map