shennian 0.2.87 → 0.2.89

package/dist/src/channels/wechat-channel/runtime.js

@@ -0,0 +1,66 @@
+// @arch docs/features/wechat-rpa-productization-plan.md
+// @arch docs/features/wechat-rpa-helper-runtime.md
+// @test src/__tests__/wechat-channel-runtime.test.ts
+export const WECHAT_CHANNEL_RUNTIME_KIND = 'wechat_channel';
+export const WECHAT_CHANNEL_RUNTIME_VERSION = 1;
+export const WECHAT_CHANNEL_RECENT_MESSAGE_WINDOW = 20;
+export const WECHAT_CHANNEL_DEFAULT_POLL_INTERVAL_MS = 5 * 60 * 1000;
+export const WECHAT_CHANNEL_MIN_POLL_INTERVAL_MS = 60 * 1000;
+export const WECHAT_CHANNEL_MAX_POLL_INTERVAL_MS = 10 * 60 * 1000;
+export function defaultWeChatChannelRuntimePolicy(pollIntervalMs) {
+    return {
+        kind: WECHAT_CHANNEL_RUNTIME_KIND,
+        runtimeVersion: WECHAT_CHANNEL_RUNTIME_VERSION,
+        platform: 'darwin',
+        pollIntervalMs: normalizeWeChatChannelPollIntervalMs(pollIntervalMs),
+        minPollIntervalMs: WECHAT_CHANNEL_MIN_POLL_INTERVAL_MS,
+        maxPollIntervalMs: WECHAT_CHANNEL_MAX_POLL_INTERVAL_MS,
+        recentMessageWindow: WECHAT_CHANNEL_RECENT_MESSAGE_WINDOW,
+        requiresServerDecision: true,
+        requiresMacHelper: true,
+        productRuntimeUsesLabFacade: false,
+    };
+}
+export function normalizeWeChatChannelPollIntervalMs(value) {
+    if (!Number.isFinite(value))
+        return WECHAT_CHANNEL_DEFAULT_POLL_INTERVAL_MS;
+    return Math.min(WECHAT_CHANNEL_MAX_POLL_INTERVAL_MS, Math.max(WECHAT_CHANNEL_MIN_POLL_INTERVAL_MS, Number(value)));
+}
+export function createWeChatChannelRuntime(config) {
+    const runtimeId = normalizeRequiredString(config.runtimeId, 'runtimeId');
+    const machineId = normalizeRequiredString(config.machineId, 'machineId');
+    const pollIntervalMs = normalizeWeChatChannelPollIntervalMs(config.pollIntervalMs);
+    return {
+        kind: WECHAT_CHANNEL_RUNTIME_KIND,
+        runtimeId,
+        machineId,
+        foregroundPolicy: config.foregroundPolicy === 'work' ? 'work' : 'polite',
+        policy: defaultWeChatChannelRuntimePolicy(pollIntervalMs),
+        bindings: normalizeBindings(config.bindings ?? []),
+    };
+}
+function normalizeBindings(bindings) {
+    const seen = new Set();
+    const result = [];
+    for (const binding of bindings) {
+        const bindingId = normalizeRequiredString(binding.bindingId, 'bindingId');
+        if (seen.has(bindingId))
+            continue;
+        seen.add(bindingId);
+        result.push({
+            bindingId,
+            sessionId: normalizeRequiredString(binding.sessionId, 'sessionId'),
+            conversationDisplayName: normalizeRequiredString(binding.conversationDisplayName, 'conversationDisplayName'),
+            enabled: binding.enabled !== false,
+            allowReply: binding.allowReply !== false,
+            downloadMedia: binding.downloadMedia !== false,
+        });
+    }
+    return result;
+}
+function normalizeRequiredString(value, field) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        throw new Error(`WeChat channel ${field} is required`);
+    return normalized;
+}

package/dist/src/channels/wechat-channel/scheduler.d.ts

@@ -0,0 +1,30 @@
+import type { WeChatChannelRuntime, WeChatChannelBindingConfig } from './runtime.js';
+import type { WeChatChannelApiClient, WeChatChannelObservedMessage } from './client.js';
+export type WeChatChannelSchedulerOptions = {
+    runtime: WeChatChannelRuntime;
+    workDir: string;
+    api: Pick<WeChatChannelApiClient, 'upsertRuntime' | 'ingest' | 'reportRunStatus'> & Partial<Pick<WeChatChannelApiClient, 'reportOutboundStatus'>>;
+    observeBinding: (binding: WeChatChannelBindingConfig) => Promise<WeChatChannelObservedMessage[]>;
+    onInboundMessages?: (binding: WeChatChannelBindingConfig, messages: WeChatChannelObservedMessage[]) => Promise<void> | void;
+    ledgerPath?: string;
+    outboundLedgerPath?: string;
+};
+export type WeChatChannelSchedulerTickResult = {
+    bindingId: string;
+    observedCount: number;
+    newInboundCount: number;
+    confirmedEchoCount: number;
+    manualReviewCount: number;
+    revision: number;
+}[];
+export declare class WeChatChannelScheduler {
+    private options;
+    private timer;
+    private running;
+    constructor(options: WeChatChannelSchedulerOptions);
+    start(): Promise<void>;
+    stop(): void;
+    tick(): Promise<WeChatChannelSchedulerTickResult | void>;
+    noteInterruption(bindingId: string, reason?: string, now?: Date): void;
+    private reportOutboundProjections;
+}

package/dist/src/channels/wechat-channel/scheduler.js

@@ -0,0 +1,152 @@
+// @arch docs/features/wechat-rpa-productization-plan.md
+// @test src/__tests__/wechat-channel-scheduler.test.ts
+import path from 'node:path';
+import { loadWeChatChannelLedger, markWeChatChannelBindingDisabled, saveWeChatChannelLedger, updateWeChatChannelBindingLedger, } from './ledger.js';
+import { classifyWeChatOutboundEchoes, loadWeChatChannelOutboundLedger, saveWeChatChannelOutboundLedger, } from './outbound-ledger.js';
+import { clearExpiredWeChatChannelCooldown, isWeChatChannelCooldownActive, noteWeChatChannelInterruption, noteWeChatChannelStableRun, } from './cooldown.js';
+export class WeChatChannelScheduler {
+    options;
+    timer = null;
+    running = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        if (this.timer)
+            return;
+        await this.tick();
+        this.timer = setInterval(() => {
+            void this.tick().catch(() => { });
+        }, this.options.runtime.policy.pollIntervalMs);
+        this.timer.unref();
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    async tick() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            const ledgerPath = this.options.ledgerPath || defaultLedgerPath(this.options.workDir, this.options.runtime.runtimeId);
+            const outboundLedgerPath = this.options.outboundLedgerPath || defaultOutboundLedgerPath(this.options.workDir, this.options.runtime.runtimeId);
+            const ledger = loadWeChatChannelLedger(ledgerPath, this.options.runtime.runtimeId);
+            const outboundLedger = loadWeChatChannelOutboundLedger(outboundLedgerPath, this.options.runtime.runtimeId);
+            const results = [];
+            for (const binding of this.options.runtime.bindings.filter((item) => !item.enabled)) {
+                if (!ledger.bindings[binding.bindingId]?.disabledSince) {
+                    markWeChatChannelBindingDisabled({ ledger, bindingId: binding.bindingId });
+                }
+            }
+            for (const binding of this.options.runtime.bindings.filter((item) => item.enabled)) {
+                await this.options.api.upsertRuntime(this.options.runtime, binding);
+                const existingBinding = ledger.bindings[binding.bindingId];
+                if (existingBinding?.cooldown) {
+                    existingBinding.cooldown = clearExpiredWeChatChannelCooldown(existingBinding.cooldown);
+                    if (isWeChatChannelCooldownActive(existingBinding.cooldown)) {
+                        await this.options.api.reportRunStatus(this.options.runtime, binding, {
+                            status: 'cooldown',
+                            reasonCode: existingBinding.cooldown.manualReviewReason || 'user_interruption_cooldown',
+                        });
+                        results.push({
+                            bindingId: binding.bindingId,
+                            observedCount: 0,
+                            newInboundCount: 0,
+                            confirmedEchoCount: 0,
+                            manualReviewCount: 0,
+                            revision: existingBinding.revision,
+                        });
+                        continue;
+                    }
+                }
+                const observedMessages = await this.options.observeBinding(binding);
+                const echoes = classifyWeChatOutboundEchoes({
+                    ledger: outboundLedger,
+                    bindingId: binding.bindingId,
+                    messages: observedMessages,
+                });
+                const state = updateWeChatChannelBindingLedger({
+                    ledger,
+                    bindingId: binding.bindingId,
+                    observedMessages,
+                });
+                state.binding.cooldown = noteWeChatChannelStableRun(state.binding.cooldown);
+                await this.options.api.ingest(this.options.runtime, binding, {
+                    idempotencyKey: `${binding.bindingId}:${state.binding.revision}:${lastMessageKey(state.binding.recent)}`,
+                    messages: state.binding.recent,
+                });
+                if (state.newMessages.length > 0)
+                    await this.options.onInboundMessages?.(binding, state.newMessages);
+                await this.reportOutboundProjections(binding, [...echoes.confirmedRecords, ...echoes.manualReviewRecords]);
+                await this.options.api.reportRunStatus(this.options.runtime, binding, {
+                    status: runStatusForTick(state.newMessages.length, echoes.confirmedRecords, echoes.manualReviewRecords),
+                });
+                results.push({
+                    bindingId: binding.bindingId,
+                    observedCount: observedMessages.length,
+                    newInboundCount: state.newMessages.length,
+                    confirmedEchoCount: echoes.confirmedRecords.length,
+                    manualReviewCount: echoes.manualReviewRecords.length,
+                    revision: state.binding.revision,
+                });
+            }
+            saveWeChatChannelLedger(ledgerPath, ledger);
+            saveWeChatChannelOutboundLedger(outboundLedgerPath, outboundLedger);
+            return results;
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    noteInterruption(bindingId, reason, now = new Date()) {
+        const ledgerPath = this.options.ledgerPath || defaultLedgerPath(this.options.workDir, this.options.runtime.runtimeId);
+        const ledger = loadWeChatChannelLedger(ledgerPath, this.options.runtime.runtimeId);
+        const existing = ledger.bindings[bindingId] ?? {
+            bindingId,
+            baselineEstablished: false,
+            revision: 0,
+            recent: [],
+            pendingSendKeys: [],
+        };
+        existing.cooldown = noteWeChatChannelInterruption({ state: existing.cooldown, reason, now });
+        ledger.bindings[bindingId] = existing;
+        saveWeChatChannelLedger(ledgerPath, ledger);
+    }
+    async reportOutboundProjections(binding, records) {
+        if (!this.options.api.reportOutboundStatus)
+            return;
+        for (const record of records) {
+            await this.options.api.reportOutboundStatus(this.options.runtime, binding, {
+                replyId: record.replyId,
+                idempotencyKey: record.idempotencyKey,
+                status: record.sendStatus,
+                replyBaseRevision: record.replyBaseRevision,
+                sentAt: record.sentAt,
+                confirmedAt: record.confirmedAt,
+                failureCode: record.failureCode,
+                lastErrorSummary: record.lastErrorSummary,
+            });
+        }
+    }
+}
+function defaultLedgerPath(workDir, runtimeId) {
+    return path.join(workDir, 'wechat-channel', `${runtimeId}.ledger.json`);
+}
+function defaultOutboundLedgerPath(workDir, runtimeId) {
+    return path.join(workDir, 'wechat-channel', `${runtimeId}.outbound-ledger.json`);
+}
+function lastMessageKey(messages) {
+    return messages.at(-1)?.stableMessageKey || 'empty';
+}
+function runStatusForTick(newMessageCount, confirmedRecords, manualReviewRecords) {
+    if (manualReviewRecords.length > 0)
+        return 'manual_review';
+    if (newMessageCount > 0)
+        return 'new_messages_ingested';
+    if (confirmedRecords.length > 0)
+        return 'outbound_echo_confirmed';
+    return 'baseline_or_no_change';
+}

package/dist/src/channels/wechat-rpa/macos-flow.d.ts

@@ -10,10 +10,6 @@ export type MacWeChatRpaFlowOptions = {
     recentLimit?: number;
     downloadAttachmentsDir?: string;
     timeoutMs?: number;
-    cloudOcrUrl?: string;
-    cloudOcrToken?: string;
-    cloudOcrMode?: 'off' | 'fallback' | 'always';
-    cloudOcrChannelId?: string;
 };
 export type MacWeChatRpaFlowResult = {
     ok: boolean;
@@ -30,14 +26,8 @@ export type MacWeChatRpaFlowResult = {
     sentAttachment?: boolean;
     sentAttachmentObserved?: boolean;
     postSendScreenshotPath?: string;
-    cloudOcrPurpose?: MacWeChatRpaCloudOcrPurpose;
-    cloudOcrObservations?: MacWeChatRpaCloudOcrObservation[];
-    cloudOcrRequestId?: string;
-    cloudOcrImageHash?: string;
-    cloudOcrUsage?: MacWeChatRpaCloudOcrUsage;
     error?: string;
 };
-export type MacWeChatRpaCloudOcrPurpose = 'message-read' | 'attachment-localization' | 'send-confirmation';
 export type MacWeChatRpaFlowMessage = {
     id?: string;
     text?: string;
@@ -62,22 +52,4 @@ export type MacWeChatRpaAttachment = {
     expiresAt?: string;
     providerError?: string;
 };
-export type MacWeChatRpaCloudOcrObservation = {
-    text: string;
-    confidence?: number;
-    role?: string;
-    attachment?: MacWeChatRpaAttachment;
-};
-export type MacWeChatRpaCloudOcrUsage = {
-    inputTokens?: number;
-    outputTokens?: number;
-    totalTokens?: number;
-};
 export declare function runMacWeChatRpaFlow(options: MacWeChatRpaFlowOptions): Promise<MacWeChatRpaFlowResult>;
-export declare function selectCloudOcrRequest(result: Pick<MacWeChatRpaFlowResult, 'newMessages' | 'recentMessages' | 'screenshotPath' | 'postSendScreenshotPath' | 'sentReply' | 'sentAttachment'>, mode: 'off' | 'fallback' | 'always'): {
-    screenshotPath: string;
-    purpose: MacWeChatRpaCloudOcrPurpose;
-} | null;
-export declare function shouldUseCloudOcr(result: Pick<MacWeChatRpaFlowResult, 'newMessages' | 'recentMessages'>, mode: 'off' | 'fallback' | 'always'): boolean;
-export declare function mergeCloudMessages(localMessages: MacWeChatRpaFlowMessage[], cloudMessages: MacWeChatRpaFlowMessage[]): MacWeChatRpaFlowMessage[];
-export declare function messagesFromCloudOcrObservations(groupName: string, observations: MacWeChatRpaCloudOcrObservation[]): MacWeChatRpaFlowMessage[];

package/dist/src/channels/wechat-rpa/macos-flow.js

@@ -2,7 +2,6 @@
 // @test src/__tests__/wechat-rpa-normalizer.test.ts
 import fs from 'node:fs';
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
@@ -61,7 +60,7 @@ export async function runMacWeChatRpaFlow(options) {
             return parsed;
         if (!parsed.ok)
             throw new Error(parsed.error || 'WeChat RPA flow failed');
-        return await maybeEnrichWithCloudOcr(parsed, options);
+        return parsed;
     }
     catch (error) {
         const detail = stderr.trim() || stdout.slice(0, 1_000);
@@ -82,138 +81,6 @@ function hasPartialSendProgress(result) {
 function hasSendAttempt(result) {
     return Boolean(result.sentReply || result.sentAttachment || result.sentReplyObserved || result.sentAttachmentObserved);
 }
-async function maybeEnrichWithCloudOcr(result, options) {
-    void options;
-    return result;
-}
-export function selectCloudOcrRequest(result, mode) {
-    if (!shouldUseCloudOcr(result, mode))
-        return null;
-    if ((result.sentReply || result.sentAttachment) && result.postSendScreenshotPath) {
-        return { screenshotPath: result.postSendScreenshotPath, purpose: 'send-confirmation' };
-    }
-    if (!result.screenshotPath)
-        return null;
-    const messages = [...(result.newMessages ?? []), ...(result.recentMessages ?? [])];
-    const hasUnresolvedAttachment = messages.some((message) => (message.attachments ?? []).some((attachment) => attachment.availability === 'metadata-only'
-        || attachment.availability === 'pending-download'
-        || Boolean(attachment.providerError)));
-    return {
-        screenshotPath: result.screenshotPath,
-        purpose: hasUnresolvedAttachment ? 'attachment-localization' : 'message-read',
-    };
-}
-export function shouldUseCloudOcr(result, mode) {
-    if (mode === 'off')
-        return false;
-    if (mode === 'always')
-        return true;
-    const messages = [...(result.newMessages ?? []), ...(result.recentMessages ?? [])];
-    if (!(result.newMessages?.length))
-        return true;
-    if (messages.some((message) => Number.isFinite(message.confidence) && Number(message.confidence) < 0.65))
-        return true;
-    return messages.some((message) => (message.attachments ?? []).some((attachment) => attachment.availability === 'metadata-only'
-        || attachment.availability === 'pending-download'
-        || Boolean(attachment.providerError)));
-}
-export function mergeCloudMessages(localMessages, cloudMessages) {
-    const merged = [...localMessages];
-    for (const cloud of cloudMessages) {
-        const signature = messageSignature(cloud);
-        const index = merged.findIndex((message) => messageSignature(message) === signature);
-        if (index < 0) {
-            merged.push(cloud);
-            continue;
-        }
-        const existingAttachments = merged[index]?.attachments ?? [];
-        const cloudAttachments = cloud.attachments ?? [];
-        if (!existingAttachments.length && cloudAttachments.length) {
-            const existing = merged[index] ?? {};
-            merged[index] = { ...existing, attachments: cloudAttachments };
-        }
-    }
-    return merged;
-}
-export function messagesFromCloudOcrObservations(groupName, observations) {
-    const messages = [];
-    for (const item of observations) {
-        const text = String(item.text || '').trim();
-        if (!text)
-            continue;
-        const role = String(item.role || 'unknown');
-        if (!['message', 'attachment', 'unknown'].includes(role))
-            continue;
-        const attachment = normalizeCloudAttachment(item.attachment) ?? (role === 'attachment' ? attachmentFromText(text) : null);
-        messages.push({
-            id: `cloud:${stableId(`${groupName}\n${role}\n${text}`)}`,
-            text,
-            confidence: item.confidence,
-            attachments: attachment ? [attachment] : [],
-        });
-    }
-    return messages;
-}
-function messageSignature(message) {
-    const text = String(message.text || '').replace(/\s+/g, ' ').trim().toLowerCase();
-    const attachments = (message.attachments ?? [])
-        .map((attachment) => `${attachment.type}:${attachment.name || ''}:${attachment.mimeType || ''}`)
-        .sort()
-        .join('|');
-    return text || attachments || String(message.id || '');
-}
-function normalizeCloudAttachment(value) {
-    if (!value || typeof value !== 'object')
-        return null;
-    const record = value;
-    const type = String(record.type || 'file').trim() || 'file';
-    const name = String(record.name || '').replace(/\s+/g, ' ').trim();
-    const mimeType = String(record.mimeType || '').replace(/\s+/g, ' ').trim();
-    const size = Number(record.size);
-    return {
-        type: ['image', 'video', 'audio', 'file'].includes(type) ? type : 'file',
-        ...(name ? { name } : {}),
-        ...(mimeType ? { mimeType } : {}),
-        ...(Number.isFinite(size) && size > 0 ? { size } : {}),
-        availability: 'metadata-only',
-    };
-}
-function attachmentFromText(text) {
-    const matches = Array.from(text.matchAll(/[\p{L}\p{N}_().[\]-]+\.(png|jpe?g|gif|webp|heic|mp4|mov|avi|mkv|pdf|docx?|xlsx?|pptx?|txt|md|csv|zip|rar)/giu));
-    const filename = matches.at(-1)?.[0]?.trim();
-    if (!filename)
-        return null;
-    const ext = path.extname(filename).toLowerCase();
-    return { type: attachmentTypeFromExt(ext), name: filename, mimeType: mimeTypeFromExt(ext), availability: 'metadata-only' };
-}
-function attachmentTypeFromExt(ext) {
-    if (['.png', '.jpg', '.jpeg', '.gif', '.webp', '.heic'].includes(ext))
-        return 'image';
-    if (['.mp4', '.mov', '.avi', '.mkv'].includes(ext))
-        return 'video';
-    return 'file';
-}
-function mimeTypeFromExt(ext) {
-    const map = {
-        '.png': 'image/png',
-        '.jpg': 'image/jpeg',
-        '.jpeg': 'image/jpeg',
-        '.gif': 'image/gif',
-        '.webp': 'image/webp',
-        '.heic': 'image/heic',
-        '.mp4': 'video/mp4',
-        '.mov': 'video/quicktime',
-        '.pdf': 'application/pdf',
-        '.txt': 'text/plain',
-        '.md': 'text/markdown',
-        '.csv': 'text/csv',
-        '.zip': 'application/zip',
-    };
-    return map[ext] || 'application/octet-stream';
-}
-function stableId(value) {
-    return crypto.createHash('sha256').update(value).digest('hex').slice(0, 24);
-}
 function resolveFlowScriptPath(scriptPath, workDir) {
     const candidates = [
         scriptPath,

package/dist/src/channels/wechat-rpa.d.ts

@@ -1,5 +1,25 @@
 import type { ExternalChannelAdapter, ExternalChannelConfig, ExternalChannelRuntimeStatus, ExternalChannelSendResult, ExternalMessageEvent, ExternalReply } from './base.js';
 import { type WeChatRpaObservedMessage } from './wechat-rpa/normalizer.js';
+type WeChatRpaSecret = {
+    type: 'wechat-rpa';
+    source?: 'macos-probe' | 'macos-flow' | 'windows-visual-flow' | 'wechat-rpa-lab' | 'fixture-jsonl';
+    fixturePath?: string;
+    pollIntervalMs?: number;
+    groups?: Array<{
+        name: string;
+    }>;
+    forceForeground?: boolean;
+    noRestore?: boolean;
+    downloadAttachments?: boolean;
+    downloadAttachmentsDir?: string;
+    idleSeconds?: number;
+    recentLimit?: number;
+    selfNickname?: string;
+    flowScriptPath?: string;
+    canReply?: boolean;
+    systemPrompt?: string;
+    updatedAt: string;
+};
 export declare function selectWeChatRpaLabReadKind(recentLimit?: number | null): 'read-latest' | 'scroll-read';
 type WeChatRpaEvent = ExternalMessageEvent & {
     type: 'external.message';
@@ -51,5 +71,6 @@ export declare function planWeChatRpaLabSendTasks(input: {
 }): Array<Record<string, unknown>>;
 export declare function weChatRpaLabTaskKindForAttachment(filePath: string): 'send-image' | 'send-video' | 'send-file';
 export declare function materializeWeChatRpaOutboundAttachment(workDir: string, attachment: NonNullable<ExternalReply['attachment']>): Promise<string>;
+export declare function resolveWeChatRpaInboundAttachmentDir(config: Pick<ExternalChannelConfig, 'id'>, secret: Pick<WeChatRpaSecret, 'downloadAttachments' | 'downloadAttachmentsDir'>): string | undefined;
 export declare function annotateWeChatRpaInboundAttachments(attachments: WeChatRpaObservedMessage['attachments']): WeChatRpaObservedMessage['attachments'];
 export {};