shennian 0.2.73 → 0.2.75

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

@@ -0,0 +1,77 @@
+export type MacWeChatRpaFlowOptions = {
+    groupName: string;
+    replyText?: string;
+    attachmentPath?: string;
+    scriptPath?: string;
+    workDir?: string;
+    forceForeground?: boolean;
+    noRestore?: boolean;
+    idleSeconds?: number;
+    recentLimit?: number;
+    downloadAttachmentsDir?: string;
+    timeoutMs?: number;
+    cloudOcrUrl?: string;
+    cloudOcrToken?: string;
+    cloudOcrMode?: 'off' | 'fallback' | 'always';
+    cloudOcrChannelId?: string;
+};
+export type MacWeChatRpaFlowResult = {
+    ok: boolean;
+    groupName: string;
+    interrupted?: boolean;
+    reason?: string;
+    screenshotPath?: string;
+    recentMessages?: MacWeChatRpaFlowMessage[];
+    newMessages?: MacWeChatRpaFlowMessage[];
+    sentReply?: boolean;
+    sentReplyObserved?: boolean;
+    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;
+    confidence?: number;
+    attachments?: MacWeChatRpaAttachment[];
+};
+export type MacWeChatRpaAttachment = {
+    type: string;
+    name?: string;
+    mimeType?: string;
+    size?: number;
+    url?: string;
+    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 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

@@ -0,0 +1,254 @@
+// @arch docs/features/wechat-rpa-channel.md
+// @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);
+export async function runMacWeChatRpaFlow(options) {
+    if (process.platform !== 'darwin') {
+        throw new Error('WeChat RPA macOS flow can only run on macOS');
+    }
+    const scriptPath = resolveFlowScriptPath(options.scriptPath, options.workDir);
+    const args = [
+        scriptPath,
+        '--group',
+        options.groupName,
+        '--idle-seconds',
+        String(Number.isFinite(options.idleSeconds) ? options.idleSeconds : 15),
+    ];
+    if (options.forceForeground)
+        args.push('--force');
+    if (options.noRestore)
+        args.push('--no-restore');
+    if (options.replyText)
+        args.push('--reply-text', options.replyText);
+    if (options.attachmentPath)
+        args.push('--attachment-path', options.attachmentPath);
+    if (options.downloadAttachmentsDir)
+        args.push('--download-attachments-dir', options.downloadAttachmentsDir);
+    if (Number.isFinite(options.recentLimit) && Number(options.recentLimit) > 0) {
+        args.push('--recent-limit', String(options.recentLimit));
+    }
+    let stdout = '';
+    let stderr = '';
+    try {
+        const result = await execFileAsync(process.execPath, args, {
+            cwd: options.workDir || process.cwd(),
+            timeout: options.timeoutMs ?? 120_000,
+            maxBuffer: 20 * 1024 * 1024,
+        });
+        stdout = result.stdout;
+        stderr = result.stderr;
+    }
+    catch (error) {
+        const execError = error;
+        stdout = execError.stdout || '';
+        stderr = execError.stderr || '';
+        const parsed = parseFlowStdout(stdout);
+        if (parsed?.interrupted)
+            return parsed;
+        throw new Error(stderr.trim() || stdout.slice(0, 1_000) || execError.message || 'WeChat RPA flow failed');
+    }
+    try {
+        const parsed = JSON.parse(stdout);
+        if (parsed.interrupted)
+            return parsed;
+        if (!parsed.ok)
+            throw new Error(parsed.error || 'WeChat RPA flow failed');
+        return await maybeEnrichWithCloudOcr(parsed, options);
+    }
+    catch (error) {
+        const detail = stderr.trim() || stdout.slice(0, 1_000);
+        throw new Error(detail || (error instanceof Error ? error.message : String(error)));
+    }
+}
+function parseFlowStdout(stdout) {
+    try {
+        return JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+async function maybeEnrichWithCloudOcr(result, options) {
+    const mode = options.cloudOcrMode ?? 'off';
+    const request = selectCloudOcrRequest(result, mode);
+    if (!request || !options.cloudOcrUrl || !options.cloudOcrToken)
+        return result;
+    const imageBase64 = fs.readFileSync(request.screenshotPath).toString('base64');
+    const response = await fetch(options.cloudOcrUrl, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${options.cloudOcrToken}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            imageBase64,
+            mimeType: 'image/png',
+            conversationName: options.groupName,
+            purpose: request.purpose,
+            channelId: options.cloudOcrChannelId,
+        }),
+    });
+    if (!response.ok)
+        return result;
+    const payload = await response.json().catch(() => null);
+    const observations = Array.isArray(payload?.observations) ? payload.observations : [];
+    if (!observations.length)
+        return result;
+    const cloudMessages = messagesFromCloudOcrObservations(options.groupName, observations);
+    const recentLimit = Math.max(1, options.recentLimit || 5);
+    return {
+        ...result,
+        cloudOcrPurpose: request.purpose,
+        cloudOcrObservations: observations,
+        ...(payload?.requestId ? { cloudOcrRequestId: payload.requestId } : {}),
+        ...(payload?.imageHash ? { cloudOcrImageHash: payload.imageHash } : {}),
+        ...(payload?.usage ? { cloudOcrUsage: payload.usage } : {}),
+        newMessages: mergeCloudMessages(result.newMessages ?? [], cloudMessages),
+        recentMessages: mergeCloudMessages(result.recentMessages ?? [], cloudMessages).slice(-recentLimit),
+    };
+}
+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,
+        process.env.SHENNIAN_WECHAT_RPA_FLOW_SCRIPT,
+        workDir ? path.join(workDir, 'scripts/wechat-rpa-flow.mjs') : '',
+        path.resolve(process.cwd(), 'scripts/wechat-rpa-flow.mjs'),
+    ].filter(Boolean);
+    const found = candidates.find((candidate) => fs.existsSync(candidate));
+    if (!found) {
+        throw new Error('WeChat RPA flow script is missing; set SHENNIAN_WECHAT_RPA_FLOW_SCRIPT or channel flowScriptPath');
+    }
+    return path.resolve(found);
+}

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

@@ -2,9 +2,24 @@ export type WeChatRpaObservedMessage = {
     conversationName: string;
     senderName?: string | null;
     text: string;
+    attachments?: WeChatRpaObservedAttachment[];
     observedAt?: string | null;
     rawId?: string | null;
 };
+export type WeChatRpaObservedAttachment = {
+    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 WeChatRpaNormalizedMessage = {
     conversationId: string;
     conversationName: string;
@@ -14,6 +29,7 @@ export type WeChatRpaNormalizedMessage = {
         name?: string | null;
     };
     text: string;
+    attachments: WeChatRpaObservedAttachment[];
     receivedAt: string;
     rawRef: string | null;
 };
@@ -23,3 +39,4 @@ export declare class WeChatRpaDeduper {
     accept(messageId: string): boolean;
 }
 export declare function normalizeWeChatRpaMessage(input: WeChatRpaObservedMessage): WeChatRpaNormalizedMessage | null;
+export declare function weChatRpaConversationId(conversationName: string): string;

package/dist/src/channels/wechat-rpa/normalizer.js

@@ -21,29 +21,73 @@ export class WeChatRpaDeduper {
 export function normalizeWeChatRpaMessage(input) {
     const conversationName = cleanText(input.conversationName);
     const text = cleanText(input.text);
-    if (!conversationName || !text)
+    const attachments = normalizeAttachments(input.attachments);
+    if (!conversationName || (!text && attachments.length === 0))
         return null;
     const senderName = cleanText(input.senderName || '') || null;
     const receivedAt = normalizeIso(input.observedAt);
-    const conversationId = stableId('wechat-conversation', conversationName);
+    const conversationId = weChatRpaConversationId(conversationName);
     const senderId = stableId('wechat-sender', senderName || 'unknown');
     const rawRef = cleanText(input.rawId || '') || null;
     const messageId = rawRef
         ? stableId('wechat-message', `${conversationName}\n${rawRef}`)
-        : stableId('wechat-message', `${conversationName}\n${senderName || ''}\n${text}\n${receivedAt}`);
+        : stableId('wechat-message', `${conversationName}\n${senderName || ''}\n${text}\n${attachments.map((item) => item.name || item.url || item.type).join('\n')}\n${receivedAt}`);
     return {
         conversationId,
         conversationName,
         messageId,
         sender: { id: senderId, name: senderName },
         text,
+        attachments,
         receivedAt,
         rawRef,
     };
 }
+export function weChatRpaConversationId(conversationName) {
+    return stableId('wechat-conversation', cleanText(conversationName));
+}
 function cleanText(value) {
     return value.replace(/\s+/g, ' ').trim();
 }
+function normalizeAttachments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        const url = item?.url ? cleanText(item.url) : '';
+        const localPath = item?.localPath ? cleanText(item.localPath) : '';
+        const availability = normalizeAvailability(item?.availability, { url, localPath });
+        return {
+            type: cleanText(String(item?.type || 'file')) || 'file',
+            ...(item?.name ? { name: cleanText(item.name) } : {}),
+            ...(url ? { url } : {}),
+            ...(item?.mimeType ? { mimeType: cleanText(item.mimeType) } : {}),
+            ...(Number.isFinite(item?.size) && Number(item.size) > 0 ? { size: Number(item.size) } : {}),
+            ...(localPath ? { localPath } : {}),
+            ...(item?.thumbnailPath ? { thumbnailPath: cleanText(item.thumbnailPath) } : {}),
+            ...(item?.hash ? { hash: cleanText(item.hash) } : {}),
+            ...(availability ? { availability } : {}),
+            ...(item?.machineId ? { machineId: cleanText(item.machineId) } : {}),
+            ...(item?.expiresAt ? { expiresAt: cleanText(item.expiresAt) } : {}),
+            ...(item?.providerError ? { providerError: cleanText(item.providerError) } : {}),
+        };
+    })
+        .filter((item) => item.type);
+}
+function normalizeAvailability(value, sources) {
+    if (value === 'edge-local'
+        || value === 'server-url'
+        || value === 'pending-download'
+        || value === 'metadata-only'
+        || value === 'unavailable-large') {
+        return value;
+    }
+    if (sources.localPath)
+        return 'edge-local';
+    if (sources.url)
+        return 'server-url';
+    return 'metadata-only';
+}
 function normalizeIso(value) {
     if (!value)
         return new Date().toISOString();

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

@@ -1,34 +1,51 @@
-import type { ExternalChannelAdapter, ExternalChannelConfig, ExternalReply } from './base.js';
+import type { ExternalChannelAdapter, ExternalChannelConfig, ExternalChannelRuntimeStatus, ExternalMessageAttachment, ExternalReply } from './base.js';
+import { type WeChatRpaObservedMessage } from './wechat-rpa/normalizer.js';
+type WeChatRpaEvent = {
+    managerSessionId: string;
+    channelId: string;
+    channelType: 'wechat-rpa';
+    conversationId: string;
+    messageId: string;
+    sender: {
+        id: string;
+        name?: string | null;
+    };
+    text: string;
+    attachments: ExternalMessageAttachment[];
+    receivedAt: string;
+    replyTarget: string;
+    rawRef?: string | null;
+};
 export declare class WeChatRpaChannelAdapter implements ExternalChannelAdapter {
     private onMessage?;
     readonly type: "wechat-rpa";
     private secrets;
     private connections;
-    constructor(onMessage?: ((event: {
-        managerSessionId: string;
-        channelId: string;
-        channelType: "wechat-rpa";
-        conversationId: string;
-        messageId: string;
-        sender: {
-            id: string;
-            name?: string | null;
-        };
-        text: string;
-        attachments: [];
-        receivedAt: string;
-        replyTarget: string;
-        rawRef?: string | null;
-    }) => void) | undefined);
+    constructor(onMessage?: ((event: WeChatRpaEvent) => void) | undefined);
     connect(config: ExternalChannelConfig): Promise<void>;
     disconnect(config: ExternalChannelConfig): Promise<void>;
-    send(_config: ExternalChannelConfig, _reply: ExternalReply): Promise<void>;
+    send(config: ExternalChannelConfig, reply: ExternalReply): Promise<{
+        status: 'sent' | 'queued';
+        reason?: string;
+    }>;
     health(config: ExternalChannelConfig): Promise<{
         ok: boolean;
         message?: string;
     }>;
+    defaultConversation(config: ExternalChannelConfig): Promise<{
+        conversationId: string;
+        conversationName?: string;
+    }>;
+    runtimeStatus(config: ExternalChannelConfig): Partial<ExternalChannelRuntimeStatus>;
     private ensureConnection;
+    private enqueueOperation;
     private readSecret;
     private pollOnce;
+    private drainPendingReplies;
     private readObservedMessages;
+    private seedConfiguredConversations;
+    private resolveConversationName;
 }
+export declare function materializeWeChatRpaOutboundAttachment(workDir: string, attachment: NonNullable<ExternalReply['attachment']>): Promise<string>;
+export declare function annotateWeChatRpaInboundAttachments(attachments: WeChatRpaObservedMessage['attachments']): WeChatRpaObservedMessage['attachments'];
+export {};