@rezti/dsh-rez-wechat 0.1.6 → 0.1.7

package/README.md

@@ -4,9 +4,16 @@
 
 | 能力 | 做法 |
 |---|---|
-| 个人微信（QClaw / ClawBot） | 打开 dsh Web → Rez 面板 → **微信** → 扫码。之后直接在微信里说话。 |
+| 个人微信（QClaw / ClawBot） | 打开 dsh Web → Rez 面板 → **微信** → 扫码。之后直接在微信里说话。消息进左侧 **微信** 文件夹的同一会话，模型跟网页默认。 |
 | 企业微信发到群 | `wecom-mcp`（`mcp__wechat__*`）+ `REZ_WECHAT_WEBHOOK` |
 
-个人微信复用现成 `dsh-wechat-bridge`（腾讯官方 iLink），不自写 WebSocket，也不用员工再跑 `npx weixin-mcp login`。
+个人微信复用现成 `dsh-wechat-bridge`（腾讯官方 iLink），不自写 WebSocket，也不用员工再跑 `npx weixin-mcp login`。桥接到正在跑的 `dsh web`（不是 `dsh --profile headless`），所以：
+
+- 左侧工作区分组是 **微信**，不是 Ungrouped
+- 连续消息延续同一会话，不会一条一个窗口
+- 模型跟网页默认（在网页里用 Kimi Code，微信也会用）
+- 能用 web profile 里已经挂上的 Odoo 等 MCP
+
+网页端必须开着。微信里 `/new <名字>` 会新开一条网页会话。
 
 这是 ClawBot 客服会话，不是用个人微信号管好友/群。

package/lib/channel.d.ts

@@ -11,6 +11,7 @@ export interface WeixinStatus {
     qrDataUrl?: string;
     hint: string;
 }
+export declare function weixinRunEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare class WeixinChannel {
     private loginChild;
     private runChild;

package/lib/channel.js

@@ -5,9 +5,20 @@
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { weixinBridgeEnv, writeWeixinDshLauncher } from './web-shim.js';
 const DATA_DIR = join(homedir(), '.dsh', 'dsh-rez-weixin');
 const AUTH_FILE = join(DATA_DIR, 'weixin-auth.json');
+const SHIM_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'web-shim-cli.js');
+export function weixinRunEnv(env = process.env) {
+    const launcher = writeWeixinDshLauncher({
+        dataDir: DATA_DIR,
+        shimScript: SHIM_SCRIPT,
+        nodePath: process.execPath,
+    });
+    return weixinBridgeEnv({ env, dataDir: DATA_DIR, launcherPath: launcher, shimScript: SHIM_SCRIPT });
+}
 function extractQrContent(chunk) {
     const labeled = chunk.match(/二维码链接[^\n]*\n\s*(\S+)/);
     if (labeled?.[1] !== undefined && labeled[1].length > 8)
@@ -94,7 +105,7 @@ export class WeixinChannel {
                 this.loginChild = undefined;
             if (code === 0 && existsSync(AUTH_FILE)) {
                 this.phase = 'listening';
-                this.hint = '已登录。直接在微信里给 ClawBot 发消息即可，不必再跑命令。';
+                this.hint = '已登录。微信消息会进网页左侧「微信」文件夹，沿用网页默认模型。';
                 this.startRun();
                 return;
             }
@@ -139,9 +150,9 @@ export class WeixinChannel {
         if (this.runChild !== undefined && this.runChild.exitCode === null)
             return;
         this.phase = 'listening';
-        this.hint = '微信通道已在后台听着。在微信里发消息就会进本机 dsh。';
+        this.hint = '微信通道已在后台听着。消息会进网页「微信」文件夹的同一会话，模型跟网页默认（例如 Kimi）。';
         const child = spawn('npx', ['-y', 'dsh-wechat-bridge', 'run', '--data-dir', DATA_DIR], {
-            env: process.env,
+            env: weixinRunEnv(),
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         this.runChild = child;

package/lib/index.js

@@ -4,7 +4,7 @@ export const name = 'rez-wechat';
 export const inject = ['systemPrompt', 'webServer', 'rezSso'];
 const GUIDANCE = [
     '企业微信群发送走官方 dsh-mcp-client + wecom-mcp（mcp__wechat__*），密钥 REZ_WECHAT_WEBHOOK。未配置时不拉起 wecom-mcp。Webhook 在 设置 → 插件 → ReZ-TI 里填。',
-    '个人微信是 QClaw 同款 ClawBot 通道：在 Rez 面板「微信」页扫码一次，然后直接在微信里说话，dsh 会自动回。不要再跑 npx weixin-mcp login，也不要调用 mcp__weixin__*。',
+    '个人微信是 QClaw 同款 ClawBot 通道：在 Rez 面板「微信」页扫码一次，然后直接在微信里说话。消息进入网页左侧「微信」文件夹并延续同一会话，模型跟网页默认（在网页里选了 Kimi 就会走 Kimi）。不要再跑 npx weixin-mcp login，也不要调用 mcp__weixin__*。网页端必须开着。',
     '这是 ClawBot 客服会话，不是用个人微信号管好友/群。对外发消息必须先征得用户批准。',
 ].join('');
 function isLoopbackRequest(request) {

package/lib/web-shim-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/web-shim-cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * Executable stand-in for `dsh`. dsh-wechat-bridge spawns:
+ *   $DSH_BRIDGE_DSH --profile headless <task>
+ * stdout is the WeChat reply; logs go to stderr.
+ */
+import { parseHeadlessArgv, runHeadlessViaWeb } from './web-shim.js';
+const parsed = parseHeadlessArgv(process.argv.slice(1));
+if ('error' in parsed) {
+    process.stderr.write(`dsh-web-shim: ${parsed.error}\n`);
+    process.stdout.write('本机微信桥启动参数不对。请从 Rez 面板重新打开微信通道。\n');
+    process.exit(0);
+}
+try {
+    const reply = await runHeadlessViaWeb({ task: parsed.task, cwd: process.cwd() });
+    process.stdout.write(reply.endsWith('\n') ? reply : `${reply}\n`);
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`dsh-web-shim: ${message}\n`);
+    process.stdout.write(`${message}\n`);
+}

package/lib/web-shim.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Pretend to be `dsh --profile headless <task>` so dsh-wechat-bridge stays
+ * unchanged, but actually drive the running `dsh web` over loopback RPC.
+ *
+ * Headless always mints a fresh Agent (DeepSeek default, Ungrouped cwd hash).
+ * Web RPC reuses one session under ~/.dsh/workspaces/微信 so the sidebar
+ * folder is named 微信, turns continue, and the model follows the web default
+ * (Kimi if that is what the user selected).
+ */
+export declare const WECHAT_WORKSPACE_NAME = "\u5FAE\u4FE1";
+export declare const DEFAULT_WEB_URL = "http://127.0.0.1:3080";
+export interface ModelRef {
+    provider?: string;
+    model: string;
+}
+export interface SessionStore {
+    sessions: Record<string, {
+        sessionId: string;
+        updatedAt: number;
+    }>;
+}
+export interface RpcFn {
+    (method: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export declare function parseHeadlessArgv(argv: string[]): {
+    task: string;
+} | {
+    error: string;
+};
+export declare function isFreshBridgeTurn(task: string): boolean;
+export declare function extractLatestUserText(task: string): string;
+export declare function dshHomeDir(env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function wechatWorkspaceDir(env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function sessionStorePath(env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function webBaseUrl(env?: NodeJS.ProcessEnv): string;
+export declare function loadSessionStore(path: string): SessionStore;
+export declare function saveSessionStore(path: string, store: SessionStore): void;
+export declare function unwrapRpc(body: unknown): unknown;
+export declare function rpcErrorMessage(body: unknown): string | undefined;
+export declare function extractSessionId(body: unknown): string | undefined;
+export declare function historyEvents(body: unknown): unknown[];
+export declare function lastAssistantText(events: unknown[]): string;
+export declare function turnIsIdle(events: unknown[]): boolean;
+export declare function pickWechatModel(models: unknown, env?: NodeJS.ProcessEnv): ModelRef | undefined;
+export declare function selectModelPayloads(sessionId: string, ref: ModelRef): Array<Record<string, unknown>>;
+export declare function writeWeixinDshLauncher(opts: {
+    dataDir: string;
+    shimScript: string;
+    nodePath: string;
+    platform?: NodeJS.Platform;
+}): string;
+export declare function weixinBridgeEnv(opts: {
+    env?: NodeJS.ProcessEnv;
+    dataDir: string;
+    launcherPath: string;
+    shimScript: string;
+}): NodeJS.ProcessEnv;
+export declare function postRpc(baseUrl: string, method: string, params: Record<string, unknown>): Promise<unknown>;
+export declare function runHeadlessViaWeb(opts: {
+    task: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    rpc?: RpcFn;
+    timeoutMs?: number;
+}): Promise<string>;

package/lib/web-shim.js

@@ -0,0 +1,433 @@
+/**
+ * Pretend to be `dsh --profile headless <task>` so dsh-wechat-bridge stays
+ * unchanged, but actually drive the running `dsh web` over loopback RPC.
+ *
+ * Headless always mints a fresh Agent (DeepSeek default, Ungrouped cwd hash).
+ * Web RPC reuses one session under ~/.dsh/workspaces/微信 so the sidebar
+ * folder is named 微信, turns continue, and the model follows the web default
+ * (Kimi if that is what the user selected).
+ */
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+export const WECHAT_WORKSPACE_NAME = '微信';
+export const DEFAULT_WEB_URL = 'http://127.0.0.1:3080';
+export function parseHeadlessArgv(argv) {
+    const args = argv[0]?.endsWith('node') || argv[0]?.includes('node.exe') ? argv.slice(1) : argv;
+    const start = args[0]?.endsWith('.js') || args[0]?.endsWith('.mjs') || args[0]?.endsWith('.cjs') ? 1 : 0;
+    const rest = args.slice(start).filter(item => item !== '--');
+    const profileAt = rest.findIndex((item, index) => item === '--profile' && rest[index + 1] === 'headless');
+    const taskParts = profileAt >= 0 ? rest.slice(profileAt + 2) : rest.filter(item => item !== '--profile' && item !== 'headless');
+    const task = taskParts.join(' ').trim();
+    if (task.length === 0)
+        return { error: 'missing headless task' };
+    return { task };
+}
+export function isFreshBridgeTurn(task) {
+    return !task.includes('【桥接上下文】');
+}
+export function extractLatestUserText(task) {
+    if (!task.includes('【桥接上下文】'))
+        return task.trim();
+    let last = '';
+    for (const line of task.split('\n')) {
+        if (line.startsWith('[用户] '))
+            last = line.slice('[用户] '.length);
+    }
+    return last.trim() || task.trim();
+}
+export function dshHomeDir(env = process.env, home = homedir()) {
+    return env.DSH_HOME !== undefined && env.DSH_HOME !== '' ? env.DSH_HOME : join(home, '.dsh');
+}
+export function wechatWorkspaceDir(env = process.env, home = homedir()) {
+    if (env.REZ_WECHAT_WORKSPACE !== undefined && env.REZ_WECHAT_WORKSPACE !== '')
+        return env.REZ_WECHAT_WORKSPACE;
+    return join(dshHomeDir(env, home), 'workspaces', WECHAT_WORKSPACE_NAME);
+}
+export function sessionStorePath(env = process.env, home = homedir()) {
+    if (env.REZ_WECHAT_SESSION_STORE !== undefined && env.REZ_WECHAT_SESSION_STORE !== '')
+        return env.REZ_WECHAT_SESSION_STORE;
+    return join(dshHomeDir(env, home), 'dsh-rez-weixin', 'web-sessions.json');
+}
+export function webBaseUrl(env = process.env) {
+    return (env.REZ_DSH_WEB_URL ?? DEFAULT_WEB_URL).replace(/\/$/, '');
+}
+export function loadSessionStore(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (typeof parsed === 'object' && parsed !== null && 'sessions' in parsed) {
+            const sessions = parsed.sessions;
+            if (typeof sessions === 'object' && sessions !== null)
+                return { sessions };
+        }
+    }
+    catch {
+        // missing or corrupt store → start empty
+    }
+    return { sessions: {} };
+}
+export function saveSessionStore(path, store) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(store, null, 2), 'utf8');
+}
+export function unwrapRpc(body) {
+    if (typeof body !== 'object' || body === null)
+        return body;
+    const rec = body;
+    if (rec.error !== undefined)
+        return rec;
+    if (typeof rec.result === 'object' && rec.result !== null)
+        return rec.result;
+    if (typeof rec.data === 'object' && rec.data !== null && rec.sessionId === undefined)
+        return rec.data;
+    return body;
+}
+export function rpcErrorMessage(body) {
+    if (typeof body !== 'object' || body === null)
+        return undefined;
+    const rec = body;
+    if (typeof rec.error === 'string')
+        return rec.error;
+    if (typeof rec.error === 'object' && rec.error !== null) {
+        const err = rec.error;
+        if (typeof err.message === 'string')
+            return err.message;
+        if (typeof err.code === 'string')
+            return err.code;
+    }
+    return undefined;
+}
+export function extractSessionId(body) {
+    if (typeof body === 'string' && body.startsWith('session'))
+        return body;
+    if (typeof body !== 'object' || body === null)
+        return undefined;
+    const rec = body;
+    if (typeof rec.sessionId === 'string')
+        return rec.sessionId;
+    if (typeof rec.id === 'string')
+        return rec.id;
+    if (typeof rec.session === 'object' && rec.session !== null) {
+        const nested = rec.session;
+        if (typeof nested.id === 'string')
+            return nested.id;
+        if (typeof nested.sessionId === 'string')
+            return nested.sessionId;
+    }
+    return undefined;
+}
+function flattenText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map(block => {
+        if (typeof block === 'string')
+            return block;
+        if (typeof block !== 'object' || block === null)
+            return '';
+        const rec = block;
+        if (typeof rec.text === 'string')
+            return rec.text;
+        return '';
+    })
+        .join('');
+}
+export function historyEvents(body) {
+    const unwrapped = unwrapRpc(body);
+    if (Array.isArray(unwrapped))
+        return unwrapped;
+    if (typeof unwrapped !== 'object' || unwrapped === null)
+        return [];
+    const rec = unwrapped;
+    if (Array.isArray(rec.events))
+        return rec.events;
+    if (Array.isArray(rec.messages))
+        return rec.messages;
+    if (Array.isArray(rec.items))
+        return rec.items;
+    if (Array.isArray(rec.log))
+        return rec.log;
+    return [];
+}
+export function lastAssistantText(events) {
+    let text = '';
+    for (const event of events) {
+        if (typeof event !== 'object' || event === null)
+            continue;
+        const rec = event;
+        const type = typeof rec.type === 'string' ? rec.type : '';
+        const role = typeof rec.role === 'string' ? rec.role : '';
+        const isAssistant = type === 'assistant/message' || role === 'assistant';
+        if (!isAssistant)
+            continue;
+        const data = typeof rec.data === 'object' && rec.data !== null ? rec.data : rec;
+        const message = typeof data.message === 'object' && data.message !== null ? data.message : data;
+        const chunk = flattenText(message.content ?? data.content ?? rec.content) || (typeof rec.text === 'string' ? rec.text : '');
+        if (chunk.trim() !== '')
+            text = chunk;
+    }
+    return text.trim();
+}
+export function turnIsIdle(events) {
+    let open = 0;
+    for (const event of events) {
+        if (typeof event !== 'object' || event === null)
+            continue;
+        const type = event.type;
+        if (type === 'turn/start')
+            open += 1;
+        if (type === 'turn/end')
+            open = Math.max(0, open - 1);
+    }
+    return open === 0;
+}
+function looksLikeKimi(value) {
+    return /kimi|moonshot/i.test(value);
+}
+function collectModelRows(input, out, depth = 0, inheritedProvider) {
+    if (depth > 8 || input === null || input === undefined)
+        return;
+    if (Array.isArray(input)) {
+        for (const item of input)
+            collectModelRows(item, out, depth + 1, inheritedProvider);
+        return;
+    }
+    if (typeof input !== 'object')
+        return;
+    const rec = input;
+    const provider = typeof rec.provider === 'string' ? rec.provider
+        : typeof rec.providerID === 'string' ? rec.providerID
+            : typeof rec.adapter === 'string' ? rec.adapter
+                : inheritedProvider;
+    const model = typeof rec.model === 'string' ? rec.model
+        : typeof rec.id === 'string' && !rec.id.startsWith('session') ? rec.id
+            : undefined;
+    if (model !== undefined)
+        out.push(provider !== undefined ? { provider, model } : { model });
+    for (const value of Object.values(rec)) {
+        if (typeof value === 'object')
+            collectModelRows(value, out, depth + 1, provider);
+    }
+}
+function currentModelRef(models) {
+    if (typeof models !== 'object' || models === null)
+        return undefined;
+    const rec = models;
+    const current = rec.current ?? rec.selection;
+    if (typeof current === 'string' && current !== '')
+        return { model: current };
+    if (typeof current === 'object' && current !== null) {
+        const row = current;
+        const model = typeof row.model === 'string' ? row.model : typeof row.id === 'string' ? row.id : undefined;
+        if (model === undefined)
+            return undefined;
+        const provider = typeof row.provider === 'string' ? row.provider
+            : typeof row.providerID === 'string' ? row.providerID
+                : undefined;
+        return provider !== undefined ? { provider, model } : { model };
+    }
+    return undefined;
+}
+export function pickWechatModel(models, env = process.env) {
+    const forced = env.REZ_WECHAT_MODEL?.trim();
+    if (forced !== undefined && forced !== '') {
+        const provider = env.REZ_WECHAT_PROVIDER?.trim();
+        return provider !== undefined && provider !== '' ? { provider, model: forced } : { model: forced };
+    }
+    if (env.REZ_WECHAT_PREFER_KIMI === '0')
+        return undefined;
+    const current = currentModelRef(models);
+    if (current !== undefined && looksLikeKimi(`${current.provider ?? ''} ${current.model}`))
+        return undefined;
+    const rows = [];
+    collectModelRows(models, rows);
+    const kimi = rows.filter(row => looksLikeKimi(`${row.provider ?? ''} ${row.model}`));
+    if (kimi.length === 0)
+        return undefined;
+    const coding = kimi.find(row => /coding|kimi-code|kimi\.code/i.test(row.model));
+    return coding ?? kimi[0];
+}
+export function selectModelPayloads(sessionId, ref) {
+    const payloads = [
+        { sessionId, model: ref.model, ...(ref.provider !== undefined ? { provider: ref.provider } : {}) },
+        { sessionId, selection: ref },
+        { sessionId, model: ref },
+    ];
+    return payloads;
+}
+export function writeWeixinDshLauncher(opts) {
+    mkdirSync(opts.dataDir, { recursive: true });
+    const platform = opts.platform ?? process.platform;
+    if (platform === 'win32') {
+        const path = join(opts.dataDir, 'dsh-web-shim.cmd');
+        writeFileSync(path, `@echo off\r\n"${opts.nodePath}" "${opts.shimScript}" %*\r\n`);
+        return path;
+    }
+    const path = join(opts.dataDir, 'dsh-web-shim');
+    writeFileSync(path, `#!/bin/sh\nexec "${opts.nodePath}" "${opts.shimScript}" "$@"\n`, { mode: 0o755 });
+    chmodSync(path, 0o755);
+    return path;
+}
+export function weixinBridgeEnv(opts) {
+    const env = { ...(opts.env ?? process.env) };
+    env.DSH_BRIDGE_DSH = opts.launcherPath;
+    env.REZ_WECHAT_SESSION_STORE = env.REZ_WECHAT_SESSION_STORE ?? join(opts.dataDir, 'web-sessions.json');
+    env.REZ_WECHAT_WORKSPACE = env.REZ_WECHAT_WORKSPACE ?? wechatWorkspaceDir(env);
+    env.REZ_DSH_WEB_URL = env.REZ_DSH_WEB_URL ?? DEFAULT_WEB_URL;
+    return env;
+}
+async function sleep(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function postRpc(baseUrl, method, params) {
+    const url = `${baseUrl.replace(/\/$/, '')}/api/${method}`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(params),
+        });
+    }
+    catch (error) {
+        const why = error instanceof Error ? error.message : String(error);
+        throw new Error(`连不上本机 dsh web（${baseUrl}）：${why}。请保持网页端开着。`);
+    }
+    const raw = await response.text();
+    let parsed;
+    try {
+        parsed = raw === '' ? {} : JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`dsh web ${method} 返回非 JSON (${response.status}): ${raw.slice(0, 240)}`);
+    }
+    const body = unwrapRpc(parsed);
+    const err = rpcErrorMessage(parsed) ?? rpcErrorMessage(body);
+    if (!response.ok || err !== undefined) {
+        throw new Error(`dsh web ${method} 失败：${err ?? `HTTP ${response.status}`}`);
+    }
+    return body;
+}
+async function ensureWorkspace(rpc, cwd) {
+    mkdirSync(cwd, { recursive: true });
+    await rpc('workspace.create', { path: cwd, title: WECHAT_WORKSPACE_NAME });
+}
+async function createSession(rpc, cwd) {
+    const created = await rpc('session.create', { cwd });
+    const id = extractSessionId(created);
+    if (id === undefined)
+        throw new Error('session.create 没有返回 sessionId');
+    return id;
+}
+async function maybeSelectModel(rpc, sessionId, env) {
+    let models;
+    try {
+        models = await rpc('session.models', { sessionId });
+    }
+    catch {
+        models = undefined;
+    }
+    const ref = pickWechatModel(models ?? {}, env);
+    if (ref === undefined)
+        return;
+    for (const payload of selectModelPayloads(sessionId, ref)) {
+        try {
+            await rpc('session.selectModel', payload);
+            return;
+        }
+        catch {
+            // try the next payload shape
+        }
+    }
+}
+async function sessionAlive(rpc, sessionId) {
+    try {
+        await rpc('session.history', { sessionId, maxMessages: 1 });
+        return true;
+    }
+    catch {
+        try {
+            await rpc('session.get', { sessionId });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+async function waitForAssistant(rpc, sessionId, beforeText, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let last = '';
+    let idleOnce = false;
+    while (Date.now() < deadline) {
+        let events = [];
+        try {
+            events = historyEvents(await rpc('session.history', { sessionId, maxMessages: 40 }));
+        }
+        catch {
+            try {
+                events = historyEvents(await rpc('session.get', { sessionId }));
+            }
+            catch {
+                events = [];
+            }
+        }
+        const text = lastAssistantText(events);
+        if (text !== '')
+            last = text;
+        const idle = turnIsIdle(events);
+        if (idle)
+            idleOnce = true;
+        if (idle && text !== '' && text !== beforeText)
+            return text;
+        if (idleOnce && text !== '' && text !== beforeText)
+            return text;
+        await sleep(400);
+    }
+    if (last !== '' && last !== beforeText)
+        return last;
+    throw new Error('等待 dsh web 回复超时。请看网页左侧「微信」文件夹里的会话。');
+}
+export async function runHeadlessViaWeb(opts) {
+    const env = opts.env ?? process.env;
+    const text = extractLatestUserText(opts.task);
+    if (text.length === 0)
+        return '(空消息)';
+    const workspace = wechatWorkspaceDir(env);
+    const storeFile = sessionStorePath(env);
+    const key = basename(opts.cwd ?? process.cwd()) || 'default';
+    const rpc = opts.rpc ?? ((method, params) => postRpc(webBaseUrl(env), method, params));
+    const timeoutMs = opts.timeoutMs ?? Number(env.DSH_BRIDGE_TIMEOUT_MS ?? 10 * 60 * 1000);
+    await ensureWorkspace(rpc, workspace);
+    const store = loadSessionStore(storeFile);
+    let sessionId = store.sessions[key]?.sessionId;
+    const fresh = isFreshBridgeTurn(opts.task);
+    if (sessionId !== undefined && !fresh) {
+        const alive = await sessionAlive(rpc, sessionId);
+        if (!alive)
+            sessionId = undefined;
+    }
+    else {
+        sessionId = undefined;
+    }
+    if (sessionId === undefined) {
+        sessionId = await createSession(rpc, workspace);
+        await maybeSelectModel(rpc, sessionId, env);
+    }
+    store.sessions[key] = { sessionId, updatedAt: Date.now() };
+    saveSessionStore(storeFile, store);
+    let before = '';
+    try {
+        before = lastAssistantText(historyEvents(await rpc('session.history', { sessionId, maxMessages: 40 })));
+    }
+    catch {
+        before = '';
+    }
+    await rpc('session.prompt', {
+        sessionId,
+        content: [{ type: 'text', text }],
+    });
+    return await waitForAssistant(rpc, sessionId, before, timeoutMs);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rezti/dsh-rez-wechat",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "ReZ-TI WeChat/WeCom bridges. Personal WeChat is QClaw/ClawBot scan-and-chat via dsh-wechat-bridge; WeCom group send uses wecom-mcp.",
   "type": "module",
   "engines": {