@xmanrui/dsh-im 4.18.0 → 4.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.18.0",
+  "version": "4.18.1",
   "description": "把十一种 IM 渠道和公网 AI Office 接入本机 DeepSeek Harness。 Connect eleven IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",
@@ -48,6 +48,10 @@
     {
       "name": "cherryFloris",
       "url": "https://github.com/cherryFloris"
+    },
+    {
+      "name": "geekyfoxlab",
+      "url": "https://github.com/geekyfoxlab"
     }
   ],
   "license": "MIT",

package/plugin-src/host/rpc-authority.mjs

@@ -2,10 +2,11 @@ const RPC_AUTHORITIES = new Set(['loopback', 'trusted-host']);
 
 /**
  * Resolve the browser authority accepted by an IM management RPC channel.
- * The default keeps credential and bot-management operations on loopback.
+ * By default, use the browser authentication and Host/Origin trust checks
+ * already enforced by Harness before it dispatches a management Fetch route.
  */
 export function resolveRpcAuthority(value) {
-  if (value === undefined) return 'loopback';
+  if (value === undefined) return 'trusted-host';
   if (RPC_AUTHORITIES.has(value)) return value;
   throw new TypeError('dsh-im rpcAuthority must be "loopback" or "trusted-host"');
 }

package/scripts/verify-lan-management.mjs

@@ -0,0 +1,176 @@
+/** Run the built plugin through an original DSH CLI with an isolated, empty home. */
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { access, mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
+import { request as httpRequest } from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+const harnessRoot = process.argv[2];
+if (!harnessRoot || process.argv.includes('--help')) {
+  console.log('Usage: node scripts/verify-lan-management.mjs /path/to/built/deepseek-harness');
+  process.exit(harnessRoot ? 0 : 1);
+}
+const pluginRoot = resolve(import.meta.dirname, '..');
+const cli = resolve(harnessRoot, 'apps/cli/lib/bin.js');
+await access(cli);
+await access(join(pluginRoot, 'lib/index.js'));
+// DSH 0.1.5 CLI intentionally permits only loopback listening. Exercise its
+// real HTTP carrier with a trusted LAN authority, while keeping TCP local.
+const lanIp = '192.168.1.100';
+
+const directory = await mkdtemp(join(tmpdir(), 'dsh-im-lan-test-'));
+const home = join(directory, 'home');
+const profile = join(home, 'profiles/web');
+const results = [];
+let child;
+
+function request(url, { method = 'GET', headers = {}, body } = {}) {
+  return new Promise((resolveRequest, reject) => {
+    const req = httpRequest({
+      hostname: '127.0.0.1', port: url.port, path: `${url.pathname}${url.search}`,
+      method, headers: { host: url.host, ...headers },
+    }, res => {
+      let text = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { text += chunk; });
+      res.on('error', reject);
+      res.on('end', () => resolveRequest({ status: res.statusCode, headers: res.headers, body: text }));
+    });
+    req.on('error', reject);
+    req.setTimeout(10_000, () => req.destroy(new Error('HTTP request timed out')));
+    req.end(body);
+  });
+}
+
+function start() {
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => (
+    !/^DSH_/i.test(key) && !/(?:KEY|SECRET|TOKEN|PASSWORD|PROXY)/i.test(key)
+  )));
+  child = spawn(process.execPath, [cli, 'web', '--no-open', '--host', '127.0.0.1',
+    '--port', '0', '--trusted-host', lanIp], {
+    cwd: directory,
+    env: { ...env, DSH_HOME: home, DSH_AGENTS_HOME: join(directory, '.agents'),
+      DSH_TELEMETRY_DISABLED: '1', SSH_CONNECTION: '', SSH_TTY: '' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return new Promise((resolveStart, reject) => {
+    let output = '';
+    const timer = setTimeout(() => finish(new Error('DSH startup timed out')), 45_000);
+    let settled = false;
+    function finish(error, url) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) {
+        const safeOutput = output.replace(/([?&]token=)[^\s)]+/g, '$1<redacted>');
+        reject(new Error(`${error.message}\n${safeOutput}`));
+      } else resolveStart(new URL(url));
+    }
+    function append(chunk) {
+      output = `${output}${chunk}`.slice(-100_000);
+      const match = /dsh web: (http:\/\/[^\s]+)/.exec(output);
+      if (match) finish(null, match[1]);
+    }
+    child.stdout.on('data', append);
+    child.stderr.on('data', append);
+    child.once('error', error => finish(error));
+    child.once('exit', code => finish(new Error(`DSH exited before readiness: ${code}`)));
+  });
+}
+
+async function stop() {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  const stopped = new Promise(resolveStop => child.once('exit', resolveStop));
+  child.kill('SIGTERM');
+  const timer = setTimeout(() => child.kill('SIGKILL'), 10_000);
+  try { await stopped; } finally { clearTimeout(timer); }
+}
+
+async function login(launchUrl, hostname) {
+  const url = new URL(launchUrl);
+  url.hostname = hostname;
+  const response = await request(url);
+  assert.equal(response.status, 303, 'Harness must exchange its launch token for a browser cookie');
+  const cookie = response.headers['set-cookie']?.map(value => value.split(';', 1)[0]).join('; ');
+  assert.ok(cookie, 'Harness did not issue a browser cookie');
+  return { origin: url.origin, cookie };
+}
+
+function rpc(browser, channel = 'feishu', method = 'connection.status', headers = {}, payload = {}) {
+  return request(new URL(`/api/dsh-im/${channel}`, browser.origin), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', origin: browser.origin,
+      ...(browser.cookie ? { cookie: browser.cookie } : {}), ...headers },
+    body: JSON.stringify({ type: 'client-request', rpcId: 'lan-test',
+      method: `dsh-im/${channel}`, payload: { method, payload } }),
+  });
+}
+
+function expectStatus(name, response, expected, businessOk = false) {
+  assert.equal(response.status, expected, `${name}: ${response.body.slice(0, 300)}`);
+  if (businessOk) {
+    const envelope = JSON.parse(response.body);
+    assert.equal(envelope.type, 'server-response', name);
+    assert.equal(envelope.rpcId, 'lan-test', name);
+    assert.equal(envelope.result.ok, true, `${name}: ${response.body.slice(0, 300)}`);
+  }
+  results.push({ check: name, status: response.status, result: 'PASS' });
+}
+
+try {
+  await mkdir(profile, { recursive: true });
+  const packages = {
+    '@deepseek-ai/dsh-base': resolve(harnessRoot, 'packages/bundle/base'),
+    '@deepseek-ai/dsh-web-app': resolve(harnessRoot, 'packages/bundle/web-app'),
+    '@xmanrui/dsh-im': pluginRoot,
+  };
+  for (const [name, path] of Object.entries(packages)) {
+    const target = join(profile, 'node_modules', name);
+    await mkdir(dirname(target), { recursive: true });
+    await symlink(path, target, 'dir');
+  }
+  await writeFile(join(profile, 'cordis.yml'), '[]\n');
+  await writeFile(join(profile, 'package.json'), JSON.stringify({
+    name: 'dsh-im-lan-test', private: true,
+    dependencies: Object.fromEntries(Object.entries(packages).map(([name, path]) => [name, `link:${path}`])),
+    dsh: { profile: { bundles: Object.keys(packages) } },
+  }));
+
+  const launchUrl = await start();
+  const lanUrl = new URL(launchUrl);
+  lanUrl.hostname = lanIp;
+  const anonymous = { origin: lanUrl.origin };
+  expectStatus('LAN without login', await rpc(anonymous), 401);
+  const lan = await login(launchUrl, lanIp);
+  expectStatus('LAN authenticated web page', await request(new URL('/', lan.origin), {
+    headers: { cookie: lan.cookie },
+  }), 200);
+  for (const channel of ['feishu', 'weixin', 'dingtalk', 'wecom', 'wecom-app', 'qq',
+    'slack', 'telegram', 'discord', 'whatsapp', 'imessage', 'office']) {
+    expectStatus(`LAN default: ${channel}`, await rpc(lan, channel), 200, true);
+  }
+  const delivery = await rpc(lan, 'dsh-im-delivery', 'target.list', {}, { botId: 'bot_missing' });
+  expectStatus('LAN delivery reaches business handler', delivery, 200);
+  assert.equal(JSON.parse(delivery.body).result.error.code, 'unknown-bot');
+  expectStatus('LAN forged cookie', await rpc({ ...lan, cookie: 'invalid=invalid' }), 401);
+  expectStatus('Untrusted Host', await rpc(lan, 'feishu', 'connection.status', { host: 'untrusted.invalid' }), 403);
+  expectStatus('Cross-origin request', await rpc(lan, 'feishu', 'connection.status', { origin: 'https://untrusted.invalid' }), 403);
+  expectStatus('LAN update remains local-only', await rpc(lan, 'dsh-im', 'update.status'), 403);
+  expectStatus('LAN TTL remains local-only', await rpc(lan, 'dsh-im-settings', 'settings.inbound-ttl.get'), 403);
+  const local = await login(launchUrl, '127.0.0.1');
+  expectStatus('Loopback default: feishu', await rpc(local), 200, true);
+
+  await stop();
+  await writeFile(join(profile, 'cordis.patch.yml'), '- id: xmanrui-dsh-im\n  config:\n    rpcAuthority: loopback\n');
+  const restrictedUrl = await start();
+  expectStatus('Explicit loopback rejects LAN', await rpc(await login(restrictedUrl, lanIp)), 403);
+  expectStatus('Explicit loopback accepts localhost', await rpc(await login(restrictedUrl, '127.0.0.1')), 200, true);
+  console.table(results);
+  console.log(`Passed ${results.length} real HTTP checks using LAN Host/Origin ${lanIp}.`);
+  console.log('TCP connections stayed on loopback. This checks the original CLI, authentication and built plugin, not a second-device browser.');
+  console.log('The temporary profile contains no bot credentials and is removed after the server stops.');
+} finally {
+  await stop();
+  await rm(directory, { recursive: true, force: true });
+}

package/src/channels/shared/text-harness-bridge.mjs

@@ -144,6 +144,7 @@ export class TextHarnessBridge {
   #logger;
   #replyTimeoutMs;
   #signal;
+  #keepaliveIntervalMs;
   #queues = new Map();
   #pendingInteractions = new Map();
   #interactionKeys = new Map();
@@ -165,6 +166,7 @@ export class TextHarnessBridge {
     logger = console,
     replyTimeoutMs = 600_000,
     signal,
+    keepaliveIntervalMs = 4_000,
   }) {
     if (!descriptor?.key || !descriptor?.label) throw new TypeError('A channel descriptor is required');
     if (!bot || typeof bot.sendText !== 'function') throw new TypeError('A bot client is required');
@@ -179,6 +181,7 @@ export class TextHarnessBridge {
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#signal = signal;
+    this.#keepaliveIntervalMs = keepaliveIntervalMs;
     this.#deferred = createDeferredDeliveryCoordinator({ harness, state, signal, logger,
       deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
     });
@@ -586,6 +589,15 @@ export class TextHarnessBridge {
     const batchSubmission = message.batchSubmission;
     let stream = null;
     let semanticStream = false;
+    // A keepalive heartbeat keeps short-lived carriers (e.g. Telegram's
+    // private-chat Rich Draft) visible during long silent stretches such as a
+    // running tool call. Declared outside the try so every exit path (including
+    // pre-prompt failures like image parsing) clears the timer.
+    let keepaliveTimer = null;
+    const stopKeepalive = () => {
+      if (keepaliveTimer !== null) clearInterval(keepaliveTimer);
+      keepaliveTimer = null;
+    };
     try {
       this.#signal?.throwIfAborted();
       if (message.kind === 'group' && message.addressed !== true) {
@@ -685,6 +697,29 @@ export class TextHarnessBridge {
         }));
         contextEnhanced = content !== originalContent;
       }
+      // Start the keepalive only after the inbound payload is ready, so a
+      // pre-prompt failure (image parsing, context building) cannot leave the
+      // timer running; the outermost finally below clears it on every path.
+      if (stream && stream.keepalive === true && typeof stream.refresh === 'function') {
+        let refreshing = false;
+        keepaliveTimer = setInterval(async () => {
+          // Skip ticks while the previous heartbeat is pending so redundant
+          // refreshes cannot queue ahead of the final answer on a slow network.
+          if (refreshing) return;
+          refreshing = true;
+          try {
+            await Promise.allSettled([
+              this.#bot.sendTyping?.(target),
+              stream.refresh(),
+            ]);
+          } catch {
+            // Keepalive is best-effort, including synchronous adapter failures.
+          } finally {
+            refreshing = false;
+          }
+        }, this.#keepaliveIntervalMs);
+        keepaliveTimer.unref?.();
+      }
       const { answer, artifacts = [] } = await askInWorkspaceSession({
         deferredDelivery: () => ({ coordinator: this.#deferred, target: this.#descriptor.key === 'whatsapp' ? { jid: target.jid, selfChat: target.selfChat } : target }),
         harness: this.#harness,
@@ -719,6 +754,7 @@ export class TextHarnessBridge {
           files: message.files,
         },
       });
+      stopKeepalive();
       if (batchSubmission) {
         this.#batches.complete(conversationKey, batchSubmission.token);
       }
@@ -805,6 +841,7 @@ export class TextHarnessBridge {
       }
       return delivery.receipt;
     } catch (error) {
+      stopKeepalive();
       const turnStopped = error?.code === 'turn-stopped';
       if (batchSubmission && turnStopped) {
         this.#batches.complete(conversationKey, batchSubmission.token);
@@ -875,6 +912,7 @@ export class TextHarnessBridge {
       }
       return error.deliveryReceipt;
     } finally {
+      stopKeepalive();
       await Promise.allSettled([
         this.#cancelPendingInteraction(conversationKey),
         this.#approvals.closeRoute(conversationKey),

package/src/channels/telegram/telegram-runtime.mjs

@@ -325,48 +325,99 @@ class TelegramDeliveryStream {
   #providerMessageIds;
   #closed = false;
   #lastUpdate = null;
+  #lastBlock = null;
+  #keepalive = false;
+  #chain = Promise.resolve();
 
-  constructor({ update, finish, fail, providerMessageIds = [], presentation, logger }) {
+  constructor({
+    update,
+    finish,
+    fail,
+    providerMessageIds = [],
+    presentation,
+    logger,
+    keepalive = false,
+  }) {
     this.#update = update;
     this.#finish = finish;
     this.#fail = fail;
     this.#providerMessageIds = providerMessageIds;
     this.presentation = presentation;
     this.#logger = logger;
+    // Only short-lived carriers (e.g. the private-chat Rich Draft) need a
+    // keepalive refresh; editing a real placeholder message with identical
+    // content would be rejected by the platform.
+    this.#keepalive = keepalive === true;
   }
 
   get providerMessageIds() {
     return [...this.#providerMessageIds];
   }
 
-  async update(value) {
-    if (this.#closed) return undefined;
-    const block = createTextDeliveryBlock(value);
-    const key = `${block.format}:${block.text}`;
-    if (key === this.#lastUpdate) return undefined;
-    this.#lastUpdate = key;
-    try {
-      return await this.#update(block);
-    } catch (error) {
-      this.#logger.warn?.('[dsh-im:telegram] rich stream update failed:', error);
-      return undefined;
-    }
+  /** Whether this carrier is short-lived and wants a keepalive heartbeat. */
+  get keepalive() {
+    return this.#keepalive;
   }
 
-  async finish(value) {
-    if (this.#closed) throw new Error('Message stream is already closed');
-    this.#closed = true;
-    const result = await this.#finish(createTextDeliveryBlock(value));
-    this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
-    return result;
+  /** Serialize every write so an in-flight keepalive refresh can never land
+   *  after the final frame: finish()/fail() queue behind refresh()/update(). */
+  #enqueue(task) {
+    const run = this.#chain.then(task);
+    this.#chain = run.catch(() => undefined);
+    return run;
   }
 
-  async fail(text) {
-    if (this.#closed) return undefined;
-    this.#closed = true;
-    const result = await this.#fail(createTextDeliveryBlock(text, 'plain'));
-    this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
-    return result;
+  update(value) {
+    return this.#enqueue(async () => {
+      if (this.#closed) return undefined;
+      const block = createTextDeliveryBlock(value);
+      this.#lastBlock = block;
+      const key = `${block.format}:${block.text}`;
+      if (key === this.#lastUpdate) return undefined;
+      this.#lastUpdate = key;
+      try {
+        return await this.#update(block);
+      } catch (error) {
+        this.#logger.warn?.('[dsh-im:telegram] rich stream update failed:', error);
+        return undefined;
+      }
+    });
+  }
+
+  /** Re-send the most recent frame even when unchanged, to keep a short-lived
+   *  carrier (the private-chat Rich Draft) visible during long silent
+   *  stretches such as a running tool call. Serialized like update() so it
+   *  never overtakes a later finish(). No-op for carriers without keepalive. */
+  refresh() {
+    return this.#enqueue(async () => {
+      if (this.#closed || !this.#keepalive || !this.#lastBlock) return undefined;
+      try {
+        return await this.#update(this.#lastBlock);
+      } catch (error) {
+        this.#logger.warn?.('[dsh-im:telegram] rich stream refresh failed:', error);
+        return undefined;
+      }
+    });
+  }
+
+  finish(value) {
+    return this.#enqueue(async () => {
+      if (this.#closed) throw new Error('Message stream is already closed');
+      this.#closed = true;
+      const result = await this.#finish(createTextDeliveryBlock(value));
+      this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
+      return result;
+    });
+  }
+
+  fail(text) {
+    return this.#enqueue(async () => {
+      if (this.#closed) return undefined;
+      this.#closed = true;
+      const result = await this.#fail(createTextDeliveryBlock(text, 'plain'));
+      this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
+      return result;
+    });
   }
 
   cancel() {
@@ -663,6 +714,7 @@ export class TelegramBotClient {
         finish: (block) => this.#sendRich(target, block),
         fail: (block) => this.#sendPlain(target, block.text),
         presentation: 'telegram-rich-draft',
+        keepalive: true,
         logger: this.#logger,
       });
       await stream.update(createTextDeliveryBlock('正在处理…', 'plain'));