shennian 0.2.72 → 0.2.74

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/macos.d.ts

@@ -0,0 +1,11 @@
+import type { WeChatRpaObservedMessage } from './normalizer.js';
+export type WeChatRpaProbeResult = {
+    ok: boolean;
+    platform: NodeJS.Platform;
+    wechatRunning: boolean;
+    frontmost: boolean;
+    windowTitle?: string;
+    message?: string;
+};
+export declare function probeMacWeChat(): Promise<WeChatRpaProbeResult>;
+export declare function observedMessageFromProbe(result: WeChatRpaProbeResult): WeChatRpaObservedMessage | null;

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

@@ -0,0 +1,63 @@
+// @arch docs/features/wechat-rpa-channel.md
+// @test src/__tests__/wechat-rpa-normalizer.test.ts
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const WECHAT_PROBE_SCRIPT = `
+tell application "System Events"
+  set isRunning to exists process "WeChat"
+  if isRunning is false then
+    return "not_running"
+  end if
+  tell process "WeChat"
+    set isFront to frontmost
+    set titleText to ""
+    if (count of windows) > 0 then
+      try
+        set titleText to name of window 1
+      end try
+    end if
+    return (isFront as text) & "\n" & titleText
+  end tell
+end tell
+`;
+export async function probeMacWeChat() {
+    if (process.platform !== 'darwin') {
+        return { ok: false, platform: process.platform, wechatRunning: false, frontmost: false, message: 'macOS only' };
+    }
+    try {
+        const { stdout } = await execFileAsync('osascript', ['-e', WECHAT_PROBE_SCRIPT], { timeout: 5_000 });
+        const output = stdout.trim();
+        if (output === 'not_running') {
+            return { ok: true, platform: process.platform, wechatRunning: false, frontmost: false };
+        }
+        const [frontmostText, ...titleParts] = output.split('\n');
+        return {
+            ok: true,
+            platform: process.platform,
+            wechatRunning: true,
+            frontmost: frontmostText === 'true',
+            windowTitle: titleParts.join('\n').trim() || undefined,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            platform: process.platform,
+            wechatRunning: false,
+            frontmost: false,
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export function observedMessageFromProbe(result) {
+    if (!result.ok || !result.wechatRunning || !result.windowTitle)
+        return null;
+    return {
+        conversationName: result.windowTitle,
+        senderName: 'WeChat RPA',
+        text: `[微信窗口可见性探测] WeChat ${result.frontmost ? '位于前台' : '未位于前台'}，当前窗口：${result.windowTitle}`,
+        observedAt: new Date().toISOString(),
+        rawId: `probe:${result.windowTitle}:${result.frontmost}`,
+    };
+}

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

@@ -0,0 +1,42 @@
+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;
+    messageId: string;
+    sender: {
+        id: string;
+        name?: string | null;
+    };
+    text: string;
+    attachments: WeChatRpaObservedAttachment[];
+    receivedAt: string;
+    rawRef: string | null;
+};
+export declare class WeChatRpaDeduper {
+    private seen;
+    private queue;
+    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

@@ -0,0 +1,99 @@
+// @arch docs/features/wechat-rpa-channel.md
+// @test src/__tests__/wechat-rpa-normalizer.test.ts
+import { createHash } from 'node:crypto';
+const MAX_DEDUP_KEYS = 500;
+export class WeChatRpaDeduper {
+    seen = new Set();
+    queue = [];
+    accept(messageId) {
+        if (this.seen.has(messageId))
+            return false;
+        this.seen.add(messageId);
+        this.queue.push(messageId);
+        while (this.queue.length > MAX_DEDUP_KEYS) {
+            const old = this.queue.shift();
+            if (old)
+                this.seen.delete(old);
+        }
+        return true;
+    }
+}
+export function normalizeWeChatRpaMessage(input) {
+    const conversationName = cleanText(input.conversationName);
+    const text = cleanText(input.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 = 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${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();
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? new Date().toISOString() : date.toISOString();
+}
+function stableId(prefix, value) {
+    return `${prefix}:${createHash('sha256').update(value).digest('hex').slice(0, 24)}`;
+}

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

@@ -0,0 +1,51 @@
+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: WeChatRpaEvent) => void) | undefined);
+    connect(config: ExternalChannelConfig): Promise<void>;
+    disconnect(config: ExternalChannelConfig): 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 {};