shennian 0.2.73 → 0.2.74

package/dist/src/agents/external-channel-instructions.js

@@ -31,6 +31,40 @@ function buildReplyCommandInstructions(mode, sessionHint, workdirHint) {
         '只发送用户可见的最终内容，不要发送内部推理、工具日志或实现细节。',
     ].filter(Boolean).join('\n');
 }
+function externalChannelMessageLabel(channel) {
+    if (channel?.type === 'wechat-rpa')
+        return '个人微信群';
+    if (channel?.type === 'feishu')
+        return '飞书群';
+    if (channel?.type === 'wecom')
+        return '企业微信群';
+    return '外部群';
+}
+function attachmentStatusInstructions(channel) {
+    if (channel?.type !== 'wechat-rpa') {
+        return '外部消息里的附件会作为本地文件或可下载链接进入对话；需要转发时先落到本地文件，再用 send-image/send-video/send-file。';
+    }
+    return [
+        '个人微信附件可能带状态：edge-local 表示附件只在绑定电脑本地可用；metadata-only 表示目前只识别到图片/视频/文件气泡或文件名；pending-download 表示等待本机 RPA 下载。',
+        '收到 metadata-only 或 pending-download 附件时，不要假装已经看过文件内容；如果需要内容，先说明需要绑定机器下载/同步，或等待下一轮本机 RPA 本地化后再处理。',
+        '转发 edge-local 附件时优先使用随消息进入对话的本地附件路径；不要把仅本机可用的路径当成远端用户也能打开的链接。',
+    ].join('\n');
+}
+function weChatRpaRuntimeInstructions(channel) {
+    if (channel?.type !== 'wechat-rpa')
+        return '';
+    const groups = Array.isArray(channel.wechatRpaGroups)
+        ? channel.wechatRpaGroups.map((group) => group.name).filter(Boolean)
+        : [];
+    return [
+        '这是运行在绑定电脑上的个人微信 RPA 通道，不是云端托管企业微信账号。',
+        groups.length ? `当前监听群：${groups.join('、')}。只把这些群里的消息当成此通道上下文。` : '',
+        channel.forceForeground ? '本通道允许在用户空闲时短暂前台化微信。' : '本通道默认不强制抢前台；用户正在操作时可能延迟收发。',
+        channel.cloudOcrMode && channel.cloudOcrMode !== 'off'
+            ? `截图识别不足时会通过神念服务端调用云端 OCR fallback（模式：${channel.cloudOcrMode}），边缘端不直接持有千问 API key。`
+            : '默认只用本机 OCR/视觉结果；不要假设云端多模态已经理解图片内容。',
+    ].filter(Boolean).join('\n');
+}
 export function buildExternalChannelInstructions(channel, workDir, sessionId, mode = 'agent') {
     if (!channel?.configured && !channel?.connected)
         return '';
@@ -44,8 +78,10 @@ export function buildExternalChannelInstructions(channel, workDir, sessionId, mo
         : '如果使用 shell_command，请设置 workdir 为当前对话的项目目录。不要用裸 /bin/zsh -lc 或 command_execution 运行此命令，因为那种环境可能拿不到当前对话的外部通道身份。';
     const sections = [
         `当前对话已接入外部消息通道：${channelName}。`,
-        `外部企业微信群消息会以如下格式进入对话：\n外部企业微信群消息\n<时间> <用户昵称>: <内容>`,
+        `外部${externalChannelMessageLabel(channel)}消息会以如下格式进入对话：\n外部${externalChannelMessageLabel(channel)}消息\n<时间> <用户昵称>: <内容>`,
         EXTERNAL_REQUEST_GUARDRAILS,
+        weChatRpaRuntimeInstructions(channel),
+        attachmentStatusInstructions(channel),
         channel.canReply === false
             ? '当前通道只允许接收消息，不要尝试向外部通道发送回复。'
             : buildReplyCommandInstructions(mode, sessionHint, workdirHint),

package/dist/src/channels/base.d.ts

@@ -1,3 +1,5 @@
+import type { ExternalChannelSessionStatus } from '@shennian/wire';
+export type ExternalChannelRuntimeStatus = Pick<ExternalChannelSessionStatus, 'wechatRpaRuntimeState' | 'wechatRpaLastRunAt' | 'wechatRpaLastMessageAt' | 'wechatRpaLastInterruptedAt' | 'wechatRpaPendingReplyCount' | 'wechatRpaLastError' | 'wechatRpaLastCloudOcrAt' | 'wechatRpaLastCloudOcrPurpose' | 'wechatRpaLastCloudOcrRequestId' | 'wechatRpaLastCloudOcrImageHash' | 'wechatRpaLastCloudOcrUsage'>;
 export type ExternalChannelType = 'wecom' | 'websocket' | 'wechat-rpa';
 export type ExternalChannelConfig = {
     id: string;
@@ -28,6 +30,34 @@ export type ExternalChannelView = {
     tokenConfigured?: boolean;
     canReply?: boolean;
     systemPrompt?: string;
+    wechatRpaSource?: string;
+    wechatRpaGroups?: Array<{
+        name: string;
+    }>;
+    pollIntervalMs?: number;
+    recentLimit?: number;
+    idleSeconds?: number;
+    forceForeground?: boolean;
+    noRestore?: boolean;
+    downloadAttachments?: boolean;
+    downloadAttachmentsDir?: string;
+    cloudOcrUrl?: string;
+    cloudOcrToken?: string;
+    cloudOcrMode?: string;
+    wechatRpaRuntimeState?: ExternalChannelSessionStatus['wechatRpaRuntimeState'];
+    wechatRpaLastRunAt?: string | null;
+    wechatRpaLastMessageAt?: string | null;
+    wechatRpaLastInterruptedAt?: string | null;
+    wechatRpaLastError?: string | null;
+    wechatRpaLastCloudOcrAt?: string | null;
+    wechatRpaLastCloudOcrPurpose?: string | null;
+    wechatRpaLastCloudOcrRequestId?: string | null;
+    wechatRpaLastCloudOcrImageHash?: string | null;
+    wechatRpaLastCloudOcrUsage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    } | null;
 };
 export type ExternalMessageEvent = {
     type: 'external.message';
@@ -40,29 +70,51 @@ export type ExternalMessageEvent = {
         name?: string | null;
     };
     text: string;
-    attachments: Array<{
-        type: string;
-        name?: string;
-        url?: string;
-        mimeType?: string;
-        size?: number;
-    }>;
+    attachments: ExternalMessageAttachment[];
     receivedAt: string;
     replyTarget: string;
     rawRef?: string | null;
 };
+export type ExternalMessageAttachment = {
+    type: string;
+    name?: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    localPath?: string;
+    thumbnailPath?: string;
+    hash?: string;
+    availability?: 'edge-local' | 'server-url' | 'pending-download' | 'metadata-only' | 'unavailable-large';
+    machineId?: string;
+    expiresAt?: string;
+    providerError?: string;
+};
+export type ExternalReplyAttachment = {
+    kind: 'image' | 'video' | 'file';
+    name: string;
+    mimeType: string;
+    size: number;
+    dataBase64?: string;
+    localPath?: string;
+    url?: string;
+};
 export type ExternalReply = {
     channelId: string;
     conversationId: string;
     text: string;
+    attachment?: ExternalReplyAttachment;
     messageId?: string;
     idempotencyKey?: string;
 };
+export type ExternalChannelSendResult = void | {
+    status: 'sent' | 'queued';
+    reason?: string;
+};
 export interface ExternalChannelAdapter {
     readonly type: ExternalChannelType;
     connect(config: ExternalChannelConfig): Promise<void>;
     disconnect(config: ExternalChannelConfig): Promise<void>;
-    send(config: ExternalChannelConfig, reply: ExternalReply): Promise<void>;
+    send(config: ExternalChannelConfig, reply: ExternalReply): Promise<ExternalChannelSendResult>;
     health(config: ExternalChannelConfig): Promise<{
         ok: boolean;
         message?: string;
@@ -71,4 +123,5 @@ export interface ExternalChannelAdapter {
         conversationId: string;
         conversationName?: string;
     }>;
+    runtimeStatus?(config: ExternalChannelConfig): Partial<ExternalChannelRuntimeStatus>;
 }

package/dist/src/channels/runtime.d.ts

@@ -6,6 +6,7 @@ export declare class ChannelRuntime {
     private configs;
     private secrets;
     private adapters;
+    private completedReplyKeys;
     constructor(onExternalMessage: (sessionId: string, event: ExternalMessageEvent) => void, createReplyTarget: (input: {
         managerSessionId: string;
         channelId: string;
@@ -21,10 +22,14 @@ export declare class ChannelRuntime {
         managerSessionId: string;
     }): Promise<{
         ok: true;
+        pending?: boolean;
     } | {
         ok: false;
         error: string;
     }>;
+    private isReplyCompleted;
+    private markReplyCompleted;
+    private loadReplyCompletionSet;
     getDefaultReplyTarget(sessionId: string): Promise<{
         channelId: string;
         conversationId: string;
@@ -35,15 +40,8 @@ export declare class ChannelRuntime {
     getChannelById(channelId: string, opts?: {
         includeSecret?: boolean;
     }): ExternalChannelView | null;
-    getManagerChannelStatus(managerSessionId: string): {
-        configured: boolean;
-        connected: boolean;
-        type?: string;
-        channelId?: string;
-        name?: string;
-        canReply?: boolean;
-        systemPrompt?: string;
-    } | null;
+    getChannelStatusById(channelId: string): ExternalChannelSessionStatus | null;
+    getManagerChannelStatus(managerSessionId: string): ExternalChannelSessionStatus | null;
     listManagerChannelStatuses(): Array<{
         managerSessionId: string;
         status: {
@@ -71,4 +69,38 @@ export declare class ChannelRuntime {
         canReply?: boolean;
         systemPrompt?: string;
     }): Promise<ExternalChannelView>;
+    upsertManagerWeChatRpaChannel(input: {
+        id: string;
+        managerSessionId: string;
+        sessionId?: string;
+        workDir: string;
+        name?: string;
+        agentType?: string;
+        agentSessionId?: string | null;
+        modelId?: string | null;
+        enabled: boolean;
+        groups: Array<{
+            name: string;
+        }>;
+        canReply?: boolean;
+        systemPrompt?: string;
+        source?: 'macos-flow' | 'macos-probe' | 'fixture-jsonl';
+        pollIntervalMs?: number;
+        recentLimit?: number;
+        idleSeconds?: number;
+        forceForeground?: boolean;
+        noRestore?: boolean;
+        downloadAttachments?: boolean;
+        downloadAttachmentsDir?: string;
+        flowScriptPath?: string;
+        cloudOcrUrl?: string;
+        cloudOcrToken?: string;
+        cloudOcrMode?: 'off' | 'fallback' | 'always';
+    }): Promise<ExternalChannelView>;
 }
+export type ExternalReplySendPlanItem = {
+    text: string;
+    attachment?: ExternalReply['attachment'];
+    idempotencyKey?: string;
+};
+export declare function planExternalReplySends(channelType: ExternalChannelConfig['type'], input: Pick<ExternalReply, 'text' | 'attachment' | 'idempotencyKey'>): ExternalReplySendPlanItem[];

package/dist/src/channels/runtime.js

@@ -1,17 +1,23 @@
 // @arch docs/features/manager-agent.md
 // @test src/__tests__/manager-runtime.test.ts
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
 import { ChannelConfigRegistry } from './registry.js';
 import { ChannelSecretRegistry } from './secret-registry.js';
 import { WeComChannelAdapter } from './wecom.js';
 import { WeChatRpaChannelAdapter } from './wechat-rpa.js';
 import { ExternalWebSocketChannelAdapter } from './websocket.js';
 import { splitExternalReplyText } from './reply-split.js';
+import { loadConfig } from '../config/index.js';
+import { SERVERS } from '../region.js';
 export class ChannelRuntime {
     onExternalMessage;
     createReplyTarget;
     configs = new ChannelConfigRegistry();
     secrets = new ChannelSecretRegistry();
     adapters = new Map();
+    completedReplyKeys = new Map();
     constructor(onExternalMessage, createReplyTarget) {
         this.onExternalMessage = onExternalMessage;
         this.createReplyTarget = createReplyTarget;
@@ -56,24 +62,55 @@ export class ChannelRuntime {
         if (!adapter)
             return { ok: false, error: `Unsupported channel type: ${config.type}` };
         try {
-            const parts = splitExternalReplyText(input.text);
-            if (!parts.length)
-                return { ok: false, error: 'Reply text is required' };
-            for (const [index, text] of parts.entries()) {
-                await adapter.send(config, {
+            const sends = planExternalReplySends(config.type, input);
+            if (!sends.length)
+                return { ok: false, error: 'Reply text or attachment is required' };
+            let pending = false;
+            for (const send of sends) {
+                const idempotencyKey = send.idempotencyKey;
+                if (idempotencyKey && this.isReplyCompleted(config, input.conversationId, idempotencyKey))
+                    continue;
+                const result = await adapter.send(config, {
                     ...input,
-                    text,
-                    idempotencyKey: parts.length > 1 && input.idempotencyKey
-                        ? `${input.idempotencyKey}:${index + 1}`
-                        : input.idempotencyKey,
+                    ...send,
                 });
+                if (result?.status === 'queued') {
+                    pending = true;
+                    continue;
+                }
+                if (idempotencyKey)
+                    this.markReplyCompleted(config, input.conversationId, idempotencyKey);
             }
-            return { ok: true };
+            return pending ? { ok: true, pending: true } : { ok: true };
         }
         catch (err) {
             return { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
     }
+    isReplyCompleted(config, conversationId, idempotencyKey) {
+        const set = this.loadReplyCompletionSet(config);
+        return set.has(replyCompletionKey(config.id, conversationId, idempotencyKey));
+    }
+    markReplyCompleted(config, conversationId, idempotencyKey) {
+        const set = this.loadReplyCompletionSet(config);
+        set.add(replyCompletionKey(config.id, conversationId, idempotencyKey));
+        try {
+            persistReplyCompletionSet(config.workDir, set);
+        }
+        catch {
+            // Some tests and diagnostic channels use virtual workDirs. In-memory idempotency
+            // still protects the current daemon; persistence resumes when workDir is writable.
+        }
+    }
+    loadReplyCompletionSet(config) {
+        const cacheKey = path.resolve(config.workDir);
+        const cached = this.completedReplyKeys.get(cacheKey);
+        if (cached)
+            return cached;
+        const set = readReplyCompletionSet(config.workDir);
+        this.completedReplyKeys.set(cacheKey, set);
+        return set;
+    }
     async getDefaultReplyTarget(sessionId) {
         const config = this.configs.list().find((channel) => (channel.sessionId ?? channel.managerSessionId) === sessionId && channel.enabled);
         if (!config)
@@ -94,6 +131,7 @@ export class ChannelRuntime {
         if (!config)
             return null;
         const secret = this.secrets.get(config.secretRef);
+        const adapterStatus = this.adapters.get(config.type)?.runtimeStatus?.(config) ?? {};
         return {
             id: config.id,
             type: config.type,
@@ -110,6 +148,8 @@ export class ChannelRuntime {
             tokenConfigured: Boolean(secret?.token),
             canReply: Boolean(secret?.canReply),
             systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
+            ...wechatRpaViewFields(secret, opts.includeSecret),
+            ...adapterStatus,
         };
     }
     getChannelById(channelId, opts = {}) {
@@ -117,6 +157,7 @@ export class ChannelRuntime {
         if (!config)
             return null;
         const secret = this.secrets.get(config.secretRef);
+        const adapterStatus = this.adapters.get(config.type)?.runtimeStatus?.(config) ?? {};
         return {
             id: config.id,
             type: config.type,
@@ -133,6 +174,26 @@ export class ChannelRuntime {
             tokenConfigured: Boolean(secret?.token),
             canReply: Boolean(secret?.canReply),
             systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
+            ...wechatRpaViewFields(secret, opts.includeSecret),
+            ...adapterStatus,
+        };
+    }
+    getChannelStatusById(channelId) {
+        const config = this.configs.get(channelId);
+        if (!config)
+            return null;
+        const secret = this.secrets.get(config.secretRef);
+        const adapterStatus = this.adapters.get(config.type)?.runtimeStatus?.(config) ?? {};
+        return {
+            configured: true,
+            connected: isChannelSecretConfigured(config, secret),
+            type: config.type,
+            channelId: config.id,
+            name: config.name,
+            canReply: Boolean(secret?.canReply),
+            systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
+            ...wechatRpaStatusFields(secret),
+            ...adapterStatus,
         };
     }
     getManagerChannelStatus(managerSessionId) {
@@ -140,14 +201,17 @@ export class ChannelRuntime {
         if (!config)
             return null;
         const secret = this.secrets.get(config.secretRef);
+        const adapterStatus = this.adapters.get(config.type)?.runtimeStatus?.(config) ?? {};
         return {
             configured: true,
-            connected: Boolean(secret?.token),
+            connected: isChannelSecretConfigured(config, secret),
             type: config.type,
             channelId: config.id,
             name: config.name,
             canReply: Boolean(secret?.canReply),
             systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
+            ...wechatRpaStatusFields(secret),
+            ...adapterStatus,
         };
     }
     listManagerChannelStatuses() {
@@ -164,14 +228,17 @@ export class ChannelRuntime {
             .filter((channel) => channel.enabled && (channel.sessionId ?? channel.managerSessionId) === managerSessionId)
             .map((channel) => {
             const secret = this.secrets.get(channel.secretRef);
+            const adapterStatus = this.adapters.get(channel.type)?.runtimeStatus?.(channel) ?? {};
             return {
                 configured: true,
-                connected: Boolean(secret?.token),
+                connected: isChannelSecretConfigured(channel, secret),
                 type: channel.type,
                 channelId: channel.id,
                 name: channel.name,
                 canReply: Boolean(secret?.canReply),
                 systemPrompt: typeof secret?.systemPrompt === 'string' ? secret.systemPrompt : '',
+                ...wechatRpaStatusFields(secret),
+                ...adapterStatus,
             };
         });
     }
@@ -227,4 +294,210 @@ export class ChannelRuntime {
         }
         return this.getManagerChannel(boundSessionId, input.type, { includeSecret: true });
     }
+    async upsertManagerWeChatRpaChannel(input) {
+        const previous = this.configs.get(input.id);
+        const allConfigs = this.configs.list();
+        const boundSessionId = input.sessionId || input.managerSessionId;
+        const groups = normalizeWeChatRpaGroups(input.groups);
+        if (input.enabled && !groups.length)
+            throw new Error('WeChat RPA 至少需要配置一个群');
+        const nextConfig = {
+            id: input.id,
+            type: 'wechat-rpa',
+            name: input.name?.trim() || previous?.name || '本机微信 RPA',
+            sessionId: boundSessionId,
+            managerSessionId: boundSessionId,
+            workDir: input.workDir,
+            agentType: input.agentType || previous?.agentType,
+            agentSessionId: input.agentSessionId ?? previous?.agentSessionId ?? null,
+            modelId: input.modelId ?? previous?.modelId ?? null,
+            enabled: input.enabled,
+            secretRef: previous?.secretRef || `channel:${input.id}`,
+        };
+        const priorSecret = this.secrets.get(nextConfig.secretRef);
+        const source = input.source || (priorSecret?.source === 'macos-probe' || priorSecret?.source === 'fixture-jsonl' || priorSecret?.source === 'macos-flow' ? priorSecret.source : 'macos-flow');
+        const configs = allConfigs
+            .filter((channel) => channel.id !== nextConfig.id)
+            .map((channel) => (channel.sessionId ?? channel.managerSessionId) === boundSessionId && channel.type === 'wechat-rpa'
+            ? { ...channel, enabled: false }
+            : channel);
+        configs.push(nextConfig);
+        this.configs.replaceAll(configs);
+        const cloudOcrMode = normalizeCloudOcrMode(input.cloudOcrMode ?? priorSecret?.cloudOcrMode);
+        const cloudOcrDefaults = cloudOcrMode === 'off' ? {} : defaultWeChatRpaCloudOcrConfig();
+        this.secrets.upsert(nextConfig.secretRef, {
+            type: 'wechat-rpa',
+            source,
+            groups,
+            pollIntervalMs: clampOptionalNumber(input.pollIntervalMs, priorSecret?.pollIntervalMs),
+            recentLimit: clampOptionalNumber(input.recentLimit, priorSecret?.recentLimit),
+            idleSeconds: clampOptionalNumber(input.idleSeconds, priorSecret?.idleSeconds),
+            forceForeground: input.forceForeground ?? Boolean(priorSecret?.forceForeground),
+            noRestore: input.noRestore ?? (priorSecret?.noRestore === undefined ? true : Boolean(priorSecret.noRestore)),
+            downloadAttachments: input.downloadAttachments ?? (priorSecret?.downloadAttachments === undefined ? true : Boolean(priorSecret.downloadAttachments)),
+            downloadAttachmentsDir: input.downloadAttachmentsDir?.trim() || stringOrUndefined(priorSecret?.downloadAttachmentsDir),
+            flowScriptPath: input.flowScriptPath?.trim() || stringOrUndefined(priorSecret?.flowScriptPath),
+            cloudOcrUrl: input.cloudOcrUrl?.trim() || stringOrUndefined(priorSecret?.cloudOcrUrl) || cloudOcrDefaults.cloudOcrUrl,
+            cloudOcrToken: input.cloudOcrToken?.trim() || stringOrUndefined(priorSecret?.cloudOcrToken) || cloudOcrDefaults.cloudOcrToken,
+            cloudOcrMode,
+            canReply: input.canReply ?? priorSecret?.canReply ?? false,
+            systemPrompt: input.systemPrompt ?? (typeof priorSecret?.systemPrompt === 'string' ? priorSecret.systemPrompt : ''),
+        });
+        const adapter = this.adapters.get(nextConfig.type);
+        for (const config of allConfigs) {
+            if ((config.sessionId ?? config.managerSessionId) === boundSessionId && config.type === 'wechat-rpa' && config.enabled) {
+                await this.adapters.get(config.type)?.disconnect(config).catch(() => { });
+            }
+        }
+        if (nextConfig.enabled) {
+            void adapter?.connect(nextConfig).catch(() => { });
+        }
+        return this.getManagerChannel(boundSessionId, 'wechat-rpa', { includeSecret: true });
+    }
+}
+function isChannelSecretConfigured(config, secret) {
+    if (!secret || secret.type !== config.type)
+        return false;
+    if (config.type === 'wechat-rpa')
+        return true;
+    if (config.type === 'websocket')
+        return Boolean(secret.wsUrl && secret.token);
+    if (config.type === 'wecom')
+        return Boolean(secret.token || secret.botId || secret.secret);
+    return Boolean(secret.token);
+}
+function wechatRpaViewFields(secret, includeSecret) {
+    if (!secret || secret.type !== 'wechat-rpa')
+        return {};
+    return {
+        wechatRpaSource: typeof secret.source === 'string' ? secret.source : '',
+        wechatRpaGroups: normalizeWeChatRpaGroups(Array.isArray(secret.groups) ? secret.groups : []),
+        pollIntervalMs: Number.isFinite(secret.pollIntervalMs) ? Number(secret.pollIntervalMs) : undefined,
+        recentLimit: Number.isFinite(secret.recentLimit) ? Number(secret.recentLimit) : undefined,
+        idleSeconds: Number.isFinite(secret.idleSeconds) ? Number(secret.idleSeconds) : undefined,
+        forceForeground: Boolean(secret.forceForeground),
+        noRestore: secret.noRestore === undefined ? undefined : Boolean(secret.noRestore),
+        downloadAttachments: secret.downloadAttachments === undefined ? true : Boolean(secret.downloadAttachments),
+        downloadAttachmentsDir: typeof secret.downloadAttachmentsDir === 'string' ? secret.downloadAttachmentsDir : '',
+        cloudOcrUrl: typeof secret.cloudOcrUrl === 'string' ? secret.cloudOcrUrl : '',
+        cloudOcrToken: includeSecret && typeof secret.cloudOcrToken === 'string' ? secret.cloudOcrToken : '',
+        cloudOcrMode: typeof secret.cloudOcrMode === 'string' ? secret.cloudOcrMode : 'off',
+    };
+}
+function wechatRpaStatusFields(secret) {
+    if (!secret || secret.type !== 'wechat-rpa')
+        return {};
+    return {
+        wechatRpaSource: typeof secret.source === 'string' ? secret.source : null,
+        wechatRpaGroups: normalizeWeChatRpaGroups(Array.isArray(secret.groups) ? secret.groups : []),
+        pollIntervalMs: Number.isFinite(secret.pollIntervalMs) ? Number(secret.pollIntervalMs) : null,
+        recentLimit: Number.isFinite(secret.recentLimit) ? Number(secret.recentLimit) : null,
+        idleSeconds: Number.isFinite(secret.idleSeconds) ? Number(secret.idleSeconds) : null,
+        forceForeground: Boolean(secret.forceForeground),
+        noRestore: secret.noRestore === undefined ? null : Boolean(secret.noRestore),
+        downloadAttachments: secret.downloadAttachments === undefined ? true : Boolean(secret.downloadAttachments),
+        downloadAttachmentsDir: typeof secret.downloadAttachmentsDir === 'string' ? secret.downloadAttachmentsDir : null,
+        cloudOcrUrl: typeof secret.cloudOcrUrl === 'string' ? secret.cloudOcrUrl : null,
+        cloudOcrMode: typeof secret.cloudOcrMode === 'string' ? secret.cloudOcrMode : 'off',
+    };
+}
+function normalizeWeChatRpaGroups(groups) {
+    const seen = new Set();
+    const result = [];
+    for (const group of groups) {
+        const name = String(group?.name || '').replace(/\s+/g, ' ').trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        result.push({ name });
+    }
+    return result;
+}
+function normalizeCloudOcrMode(value) {
+    return value === 'fallback' || value === 'always' ? value : 'off';
+}
+function defaultWeChatRpaCloudOcrConfig() {
+    const config = loadConfig();
+    const serverUrl = (config.serverUrl || SERVERS.cn.url).replace(/\/+$/, '');
+    const token = config.machineToken?.trim() || config.accessToken?.trim();
+    return {
+        cloudOcrUrl: `${serverUrl}/integrations/wechat-rpa/ocr`,
+        ...(token ? { cloudOcrToken: token } : {}),
+    };
+}
+export function planExternalReplySends(channelType, input) {
+    const parts = splitExternalReplyText(input.text);
+    if (!parts.length && !input.attachment)
+        return [];
+    if (channelType === 'wechat-rpa' && input.attachment && parts.length <= 1) {
+        return [{
+                text: parts[0] ?? '',
+                attachment: input.attachment,
+                idempotencyKey: input.idempotencyKey,
+            }];
+    }
+    const sends = parts.map((text, index) => ({
+        text,
+        attachment: undefined,
+        idempotencyKey: parts.length > 1 && input.idempotencyKey
+            ? `${input.idempotencyKey}:${index + 1}`
+            : input.idempotencyKey,
+    }));
+    if (input.attachment) {
+        sends.push({
+            text: '',
+            attachment: input.attachment,
+            idempotencyKey: parts.length && input.idempotencyKey
+                ? `${input.idempotencyKey}:attachment`
+                : input.idempotencyKey,
+        });
+    }
+    return sends;
+}
+function replyCompletionKey(channelId, conversationId, idempotencyKey) {
+    return crypto.createHash('sha256')
+        .update(`${channelId}\n${conversationId}\n${idempotencyKey}`)
+        .digest('hex')
+        .slice(0, 32);
+}
+function replyCompletionFile(workDir) {
+    return path.join(workDir, '.shennian', 'external-reply-idempotency.json');
+}
+function readReplyCompletionSet(workDir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(replyCompletionFile(workDir), 'utf8'));
+        const rows = Array.isArray(parsed.completed) ? parsed.completed : [];
+        return new Set(rows
+            .map((row) => {
+            if (typeof row === 'string')
+                return row;
+            if (row && typeof row === 'object' && typeof row.key === 'string') {
+                return row.key;
+            }
+            return '';
+        })
+            .filter(Boolean));
+    }
+    catch {
+        return new Set();
+    }
+}
+function persistReplyCompletionSet(workDir, set) {
+    const filePath = replyCompletionFile(workDir);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const keys = Array.from(set).slice(-500);
+    fs.writeFileSync(filePath, JSON.stringify({
+        updatedAt: new Date().toISOString(),
+        completed: keys.map((key) => ({ key })),
+    }, null, 2));
+    set.clear();
+    for (const key of keys)
+        set.add(key);
+}
+function clampOptionalNumber(value, fallback) {
+    const number = Number(value ?? fallback);
+    return Number.isFinite(number) && number >= 0 ? number : undefined;
+}
+function stringOrUndefined(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }

package/dist/src/channels/secret-registry.d.ts

@@ -6,9 +6,22 @@ type ChannelSecretRecord = {
     token?: string;
     canReply?: boolean;
     systemPrompt?: string;
-    source?: 'macos-probe' | 'fixture-jsonl';
+    source?: 'macos-probe' | 'macos-flow' | 'fixture-jsonl';
     fixturePath?: string;
     pollIntervalMs?: number;
+    groups?: Array<{
+        name: string;
+    }>;
+    forceForeground?: boolean;
+    noRestore?: boolean;
+    downloadAttachments?: boolean;
+    downloadAttachmentsDir?: string;
+    idleSeconds?: number;
+    recentLimit?: number;
+    flowScriptPath?: string;
+    cloudOcrUrl?: string;
+    cloudOcrToken?: string;
+    cloudOcrMode?: 'off' | 'fallback' | 'always';
     updatedAt: string;
 };
 export declare class ChannelSecretRegistry {