@xmanrui/dsh-im 3.0.8 → 3.1.1

package/plugin-src/host/update-service.mjs

@@ -0,0 +1,385 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+import semver from 'semver';
+
+import manifest from '../../package.json' with { type: 'json' };
+import { withSessionBindingLock } from '../../src/channels/shared/session-binding-lock.mjs';
+import { NPM_REGISTRY, PACKAGE_NAME } from './update-runtime.mjs';
+
+const ACTIVE_STATES = new Set(['installing', 'verifying']);
+const JOB_STATES = new Set([...ACTIVE_STATES, 'restart-required', 'completed', 'failed', 'interrupted']);
+const MAX_METADATA_BYTES = 256 * 1024;
+const SNAPSHOT_FILES = ['package.json', 'pnpm-lock.yaml', 'pnpm-workspace.yaml'];
+const NO_LOCK = Symbol('no update lock');
+
+export function updateError(code) {
+  return Object.assign(new Error(code), { code });
+}
+
+/** Read only the fixed npm package; neither RPC callers nor registry metadata choose a command. */
+export async function fetchNpmRelease(fetchImpl = globalThis.fetch, timeoutMs = 10_000) {
+  let response;
+  try {
+    response = await fetchImpl(`${NPM_REGISTRY}${encodeURIComponent(PACKAGE_NAME)}/latest`, {
+      headers: { accept: 'application/json' },
+      redirect: 'error',
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok) throw updateError('check-failed');
+    if (Number(response.headers.get('content-length')) > MAX_METADATA_BYTES) {
+      throw updateError('invalid-release');
+    }
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of response.body) {
+      length += chunk.byteLength;
+      if (length > MAX_METADATA_BYTES) throw updateError('invalid-release');
+      chunks.push(Buffer.from(chunk));
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const version = value.version;
+    if (value.name !== PACKAGE_NAME || typeof version !== 'string'
+      || semver.valid(version) !== version || semver.prerelease(version)) {
+      throw updateError('invalid-release');
+    }
+    const nodeRange = value.engines?.node;
+    if (nodeRange !== undefined && (typeof nodeRange !== 'string' || !semver.validRange(nodeRange))) {
+      throw updateError('invalid-release');
+    }
+    const tarball = new URL(value.dist?.tarball);
+    const integrity = value.dist?.integrity;
+    if (tarball.origin !== new URL(NPM_REGISTRY).origin || tarball.username || tarball.password
+      || tarball.search || tarball.hash
+      || tarball.pathname !== `/@xmanrui/dsh-im/-/dsh-im-${version}.tgz`
+      || typeof integrity !== 'string' || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(integrity)) {
+      throw updateError('invalid-release');
+    }
+    return { version, nodeRange: nodeRange ?? '*', integrity, tarball: tarball.href };
+  } catch (error) {
+    if (error?.code === 'invalid-release' || error instanceof SyntaxError || error instanceof TypeError && response?.ok) {
+      throw updateError('invalid-release');
+    }
+    throw updateError('check-failed');
+  }
+}
+
+function pathsFor(environment) {
+  if (!isAbsolute(environment.homeDir ?? '') || !isAbsolute(environment.profileDir ?? '')) return null;
+  const key = createHash('sha256').update(environment.profileDir).digest('hex').slice(0, 24);
+  const directory = join(environment.homeDir, 'updates', 'dsh-im', key);
+  return {
+    directory,
+    state: join(directory, 'state.json'),
+    lock: join(directory, 'install.lock'),
+    backup: join(directory, 'before.json'),
+  };
+}
+
+async function readJson(path, missing = null) {
+  try {
+    if ((await stat(path)).size > 10 * 1024 * 1024) throw updateError('state-unavailable');
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return missing;
+    throw updateError('state-unavailable');
+  }
+}
+
+async function writeJson(path, value) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+    await rename(temporary, path);
+  } catch {
+    throw updateError('state-unavailable');
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (error.code !== 'ENOENT') throw updateError('state-unavailable');
+    });
+  }
+}
+
+function processAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== 'ESRCH';
+  }
+}
+
+function publicJob(job) {
+  if (!job) return null;
+  const { id, state, targetVersion, message } = job;
+  return { id, state, targetVersion, message };
+}
+
+/** One update job per profile. Persist intent before starting pnpm, and never apply a restart here. */
+export function createUpdateService({
+  runtime,
+  runningVersion = manifest.version,
+  nodeVersion = process.versions.node,
+  fetchImpl = globalThis.fetch,
+  now = Date.now,
+  checkTimeoutMs = 10_000,
+  confirmationTtlMs = 10 * 60_000,
+  installTimeoutMs = 15 * 60_000,
+} = {}) {
+  const queue = {};
+  let checked = null;
+  let checking = null;
+  let lastCheckAt = -Infinity;
+  let activeJob = null;
+  let activeTask = null;
+  let abortController = null;
+  let unsavedJob = null;
+  let disposed = false;
+
+  function assertActive() {
+    if (disposed) throw updateError('disposed');
+  }
+
+  async function readJob(environment) {
+    const paths = pathsFor(environment);
+    if (!paths) return null;
+    // A failed final write must not make this Host display the old "installing"
+    // record forever. Keep the lock and expose the outcome we actually observed.
+    if (unsavedJob?.statePath === paths.state) return unsavedJob.job;
+    let job = await readJson(paths.state);
+    const lock = await readJson(paths.lock, NO_LOCK);
+    if (!job) {
+      if (lock !== NO_LOCK) {
+        return { id: 'locked', state: 'interrupted', message: 'recovery-required', targetVersion: null };
+      }
+      return null;
+    }
+    if (!JOB_STATES.has(job.state) || typeof job.id !== 'string' || !semver.valid(job.targetVersion)) {
+      throw updateError('state-unavailable');
+    }
+    if (ACTIVE_STATES.has(job.state) && job.id !== activeJob?.id) {
+      if (lock === NO_LOCK || lock?.id !== job.id || !processAlive(lock?.pid)) {
+        job = { ...job, state: 'interrupted', message: 'recovery-required' };
+      }
+    }
+    if (job.id !== activeJob?.id && !ACTIVE_STATES.has(job.state)) {
+      if (lock !== NO_LOCK) return { ...job, state: 'interrupted', message: 'recovery-required' };
+      // A later Host can retry after a verified manual repair. Never infer this
+      // from version equality while an old process lock is still present.
+      if (['failed', 'interrupted'].includes(job.state) && environment.packageValid === true
+        && environment.installedVersion === runningVersion && !environment.blockedReason) {
+        return job.targetVersion === runningVersion
+          ? { ...job, state: 'completed', message: 'recovered' }
+          : { ...job, recoverable: true };
+      }
+    }
+    if (job.state === 'restart-required' || job.state === 'completed') {
+      if (environment.installedVersion !== job.targetVersion || environment.packageValid !== true) {
+        return { ...job, state: 'interrupted', message: 'installation-changed' };
+      }
+      return { ...job, state: runningVersion === job.targetVersion ? 'completed' : 'restart-required' };
+    }
+    return job;
+  }
+
+  function snapshot(environment, job) {
+    let blockedReason = environment.blockedReason ?? checked?.blockedReason ?? null;
+    if (job?.state === 'interrupted' && !job.recoverable
+      || job?.state === 'failed' && environment.installedVersion !== runningVersion) {
+      blockedReason = 'recovery-required';
+    } else if (job?.state === 'restart-required' || environment.installedVersion && environment.installedVersion !== runningVersion) {
+      blockedReason = 'pending-restart';
+    }
+    const busy = ACTIVE_STATES.has(job?.state);
+    const canInstall = Boolean(environment.eligible && !blockedReason && !busy && checked?.checkId
+      && now() < checked.expiresAt && checked.installationKey === environment.installationKey
+      && semver.valid(runningVersion) && semver.gt(checked.release.version, runningVersion));
+    return {
+      runningVersion,
+      installedVersion: environment.installedVersion ?? null,
+      latestVersion: checked?.release.version ?? null,
+      profileName: environment.profileName ?? null,
+      environmentKind: environment.environmentKind ?? 'cli',
+      canInstall,
+      blockedReason,
+      checkedAt: checked?.checkedAt ?? null,
+      checkId: canInstall ? checked.checkId : null,
+      job: publicJob(job),
+    };
+  }
+
+  async function status() {
+    assertActive();
+    const environment = await runtime.inspect();
+    return snapshot(environment, await readJob(environment));
+  }
+
+  async function check() {
+    assertActive();
+    if (checking) return checking;
+    // Collapse double clicks without turning a failed request into a cached success.
+    if (checked?.checkId && now() - lastCheckAt < 2_000) return status();
+    lastCheckAt = now();
+    checking = (async () => {
+      try {
+        const environment = await runtime.inspect({ preflight: true });
+        const release = await fetchNpmRelease(fetchImpl, checkTimeoutMs);
+        assertActive();
+        checked = {
+          release,
+          checkId: randomUUID(),
+          checkedAt: now(),
+          expiresAt: now() + confirmationTtlMs,
+          installationKey: environment.installationKey,
+          profileDir: environment.profileDir,
+          blockedReason: environment.blockedReason
+            ?? (!semver.satisfies(nodeVersion, release.nodeRange) ? 'incompatible-node' : null),
+        };
+        return snapshot(environment, await readJob(environment));
+      } catch (error) {
+        if (checked) checked = { ...checked, checkId: null, expiresAt: 0 };
+        throw error;
+      } finally {
+        checking = null;
+      }
+    })();
+    return checking;
+  }
+
+  async function releaseLock(paths, id) {
+    const lock = await readJson(paths.lock);
+    if (lock?.id === id) await unlink(paths.lock);
+  }
+
+  async function backupProfile(environment, paths, job) {
+    const files = {};
+    for (const filename of SNAPSHOT_FILES) {
+      try {
+        const path = join(environment.profileDir, filename);
+        if ((await stat(path)).size > 3 * 1024 * 1024) throw updateError('state-unavailable');
+        files[filename] = await readFile(path, 'utf8');
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw updateError('state-unavailable');
+      }
+    }
+    // Keep only the previous attempt's small manifests, never credentials or the entire home.
+    await writeJson(paths.backup, { jobId: job.id, previousVersion: job.previousVersion, files });
+  }
+
+  function rememberUnsavedJob(paths) {
+    activeJob = { ...activeJob, state: 'interrupted', message: 'state-unavailable' };
+    unsavedJob = { statePath: paths.state, job: activeJob };
+  }
+
+  async function execute(paths, job, originalEnvironment) {
+    const deadline = AbortSignal.timeout(installTimeoutMs);
+    try {
+      await runtime.install(job.targetVersion, {
+        signal: AbortSignal.any([abortController.signal, deadline]),
+        expectedInstallationKey: originalEnvironment.installationKey,
+      });
+      if (disposed) throw updateError('interrupted');
+      activeJob = { ...activeJob, state: 'verifying', updatedAt: now() };
+      await writeJson(paths.state, activeJob);
+      const environment = await runtime.inspect();
+      if (environment.homeDir !== originalEnvironment.homeDir || environment.profileDir !== originalEnvironment.profileDir
+        || environment.profileName !== originalEnvironment.profileName || environment.blockedReason === 'installation-changed') {
+        throw updateError('installation-changed');
+      }
+      if (environment.installedVersion !== job.targetVersion || environment.packageValid !== true) {
+        throw updateError('verify-failed');
+      }
+      if (environment.blockedReason && environment.blockedReason !== 'pending-restart') throw updateError('verify-failed');
+      activeJob = { ...activeJob, state: 'restart-required', message: null, updatedAt: now() };
+      await writeJson(paths.state, activeJob);
+    } catch (error) {
+      const timedOut = deadline.aborted || error.code === 'install-timeout';
+      const interrupted = disposed || abortController.signal.aborted
+        || !timedOut && ['interrupted', 'install-interrupted'].includes(error.code);
+      activeJob = {
+        ...activeJob,
+        state: interrupted ? 'interrupted' : 'failed',
+        message: interrupted ? 'interrupted' : timedOut ? 'install-timeout'
+          : ['verify-failed', 'state-unavailable', 'installation-changed', 'registry-conflict'].includes(error.code)
+            ? error.code : 'install-failed',
+        updatedAt: now(),
+      };
+      try {
+        await writeJson(paths.state, activeJob);
+      } catch {
+        // Retain the lock when the final record cannot be saved; the next Host must inspect it.
+        rememberUnsavedJob(paths);
+        return;
+      }
+    }
+    await releaseLock(paths, job.id);
+  }
+
+  function install({ checkId, requestId }) {
+    return withSessionBindingLock(queue, 'install', async () => {
+      assertActive();
+      let environment = await runtime.inspect({ preflight: true });
+      const previous = await readJob(environment);
+      if (previous?.requestId === requestId) return snapshot(environment, previous);
+      if (ACTIVE_STATES.has(previous?.state) || previous?.state === 'restart-required') throw updateError('update-busy');
+      const confirmation = checked;
+      if (!confirmation || !checkId || confirmation.checkId !== checkId || now() >= confirmation.expiresAt) {
+        throw updateError('check-expired');
+      }
+      if (environment.profileDir !== confirmation.profileDir || environment.installationKey !== confirmation.installationKey) {
+        throw updateError('installation-changed');
+      }
+      if (!snapshot(environment, previous).canInstall) throw updateError(environment.blockedReason ?? 'update-busy');
+      const paths = pathsFor(environment);
+      if (!paths) throw updateError('state-unavailable');
+      const job = {
+        id: randomUUID(), requestId, state: 'installing', message: null,
+        targetVersion: confirmation.release.version, previousVersion: environment.installedVersion,
+        startedAt: now(), updatedAt: now(),
+      };
+      let locked = false;
+      try {
+        await mkdir(paths.directory, { recursive: true, mode: 0o700 });
+        const lock = await open(paths.lock, 'wx', 0o600);
+        locked = true;
+        try {
+          await lock.writeFile(JSON.stringify({ id: job.id, pid: process.pid, startedAt: now() }));
+        } finally {
+          await lock.close();
+        }
+        const currentRelease = await fetchNpmRelease(fetchImpl, checkTimeoutMs);
+        if (JSON.stringify(currentRelease) !== JSON.stringify(confirmation.release)) throw updateError('check-expired');
+        environment = await runtime.inspect({ preflight: true });
+        if (environment.profileDir !== confirmation.profileDir || environment.installationKey !== confirmation.installationKey) {
+          throw updateError('installation-changed');
+        }
+        if (!environment.eligible || environment.blockedReason) throw updateError(environment.blockedReason ?? 'update-busy');
+        assertActive();
+        await backupProfile(environment, paths, job);
+        await writeJson(paths.state, job);
+        assertActive();
+      } catch (error) {
+        if (locked) await releaseLock(paths, job.id);
+        if (error.code === 'EEXIST') throw updateError('update-busy');
+        if (error.code?.startsWith('E')) throw updateError('state-unavailable');
+        throw error;
+      }
+      activeJob = job;
+      abortController = new AbortController();
+      activeTask = execute(paths, job, environment).catch(() => {
+        // Keep unknown cleanup failures local and keep the on-disk lock for manual recovery.
+        rememberUnsavedJob(paths);
+      });
+      return snapshot(environment, job);
+    });
+  }
+
+  async function close() {
+    disposed = true;
+    abortController?.abort();
+    if (activeTask) await activeTask;
+  }
+
+  return Object.freeze({ status, check, install, close });
+}

package/scripts/verify-package.mjs

@@ -28,6 +28,10 @@ const required = [
   'plugin-src/client/channels/dingtalk/index.js',
   'plugin-src/client/channels/slack/index.js',
   'plugin-src/client/i18n.js',
+  'plugin-src/client/update-panel.js',
+  'plugin-src/host/update-service.mjs',
+  'plugin-src/host/update-runtime.mjs',
+  'plugin-src/host/update-rpc.mjs',
   'plugin-src/host/channels/feishu/index.mjs',
   'plugin-src/host/channels/weixin/index.mjs',
   'plugin-src/host/channels/dingtalk/index.mjs',
@@ -143,6 +147,14 @@ for (const marker of ['/feishu', '/weixin', '/dingtalk', '/wecom', '/qq', '/slac
     throw new Error(`host bundle does not contain the internal ${marker} RPC provider`);
   }
 }
+for (const marker of ['update.status', 'update.check', 'update.install']) {
+  if (!host.includes(marker) || !client.includes(marker)) {
+    throw new Error(`update RPC endpoint missing from Host or Client bundle: ${marker}`);
+  }
+}
+if (!host.includes('https://registry.npmjs.org/') || !host.includes('desktopPnpm')) {
+  throw new Error('host bundle is missing the npm updater or Desktop package-management adapter');
+}
 for (const marker of ['/session Session ID', 'bindWorkspaceSession', 'session-subagent-unsupported']) {
   if (!host.includes(marker)) {
     throw new Error(`host bundle does not contain the Session binding marker: ${marker}`);

package/src/channels/dingtalk/dingtalk-bridge.mjs

@@ -13,6 +13,7 @@ import {
 } from '../shared/harness-question.mjs';
 import { HarnessApprovalQueue } from '../shared/harness-approval.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import { isHistoryCommand, runHistoryCommand } from '../shared/history-command.mjs';
 import {
   isControlCommand,
   runControlCommand,
@@ -67,6 +68,7 @@ const HELP_TEXT_LINES = [
   '直接发送文字、图片或文件即可继续当前会话。',
   '/new  开启一个全新会话',
   '/compact  压缩当前会话的较早上下文',
+  '/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）',
   '/workspace 工作区绝对路径  切换工作区',
   '/workspacelist  列出工作区绝对路径',
   '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
@@ -522,7 +524,8 @@ export class DingtalkHarnessBridge {
         ));
       }
     }
-    const commandRunner = hasInboundFiles(promptMessage) ? null : isControlCommand(commandText)
+    const commandRunner = isHistoryCommand(commandText) ? runHistoryCommand
+      : hasInboundFiles(promptMessage) ? null : isControlCommand(commandText)
       ? runControlCommand
       : (isModelCommand(commandText)
           ? runModelCommand
@@ -789,6 +792,7 @@ export class DingtalkHarnessBridge {
       key,
       {
         signal: this.#signal,
+        isDirect: String(message.conversationType) === '1',
         hasImages: hasInboundImages(prompt),
         hasFiles: hasInboundFiles(prompt),
         pendingInteraction: this.#pendingInteractions.has(key)

package/src/channels/feishu/bridge.mjs

@@ -30,6 +30,7 @@ import {
   isBatchInputCommand,
 } from '../shared/batch-input.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import { isHistoryCommand, runHistoryCommand } from '../shared/history-command.mjs';
 import {
   isControlCommand,
   runControlCommand,
@@ -48,6 +49,7 @@ import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
 import {
   createDeliveryReceipt,
+  providerMessageIdsFor,
 } from '../shared/semantic/delivery.mjs';
 import {
   channelDeliveryFailure,
@@ -620,12 +622,15 @@ export class FeishuHarnessBridge {
         .finally(() => this.#acceptedMessageIds.delete(messageId));
       return processing;
     }
-    const commandRunner = hasInboundFiles(commandMessage) ? null : isControlCommand(commandText)
+    const commandRunner = isHistoryCommand(commandText) ? runHistoryCommand
+      : hasInboundFiles(commandMessage) ? null : isControlCommand(commandText)
       ? runControlCommand
       : (isModelCommand(commandText)
           ? runModelCommand
           : (isPresetCommand(commandText) ? runPresetCommand : null));
-    if (commandRunner && addressed) {
+    // In all-message group mode, history must still be refused locally rather
+    // than becoming a normal prompt when no mention is present.
+    if (commandRunner && (addressed || commandRunner === runHistoryCommand)) {
       const processing = this.#processFastCommand(
         event,
         messageId,
@@ -913,6 +918,7 @@ export class FeishuHarnessBridge {
       key,
       {
         signal: this.#signal,
+        isDirect: event.message.chat_type === 'p2p',
         hasImages: hasInboundImages(message),
         hasFiles: hasInboundFiles(message),
         pendingInteraction: this.#hasPendingInteraction(key),
@@ -2083,7 +2089,10 @@ export class FeishuHarnessBridge {
     try {
       const bound = await this.#harness.bindWorkspaceSession(key, sessionId);
       const title = String(bound?.title ?? '').replace(/\s+/gu, ' ').trim() || t('暂无标题');
-      await this.#send(chatId, t('已绑定会话「{title}」\nID：{id}', { title, id: bound?.sessionId ?? sessionId }));
+      await this.#send(chatId, [
+        t('已绑定会话「{title}」\nID：{id}', { title, id: bound?.sessionId ?? sessionId }),
+        t('发送 /history 查看最近对话。'),
+      ].join('\n'));
       await this.#sendMenuCard(key, chatId, { updateMessageId });
     } catch (error) {
       await this.#sendFailure(chatId, error, {
@@ -3307,7 +3316,7 @@ export class FeishuHarnessBridge {
       createDeliveryReceipt({
         deliveryId: messageId,
         presentation: 'feishu-cardkit',
-        providerMessageIds: stream?.messageId ? [stream.messageId] : [],
+        providerMessageIds: providerMessageIdsFor(stream),
       }),
     );
     this.#status.streamResponses = (this.#status.streamResponses ?? 0) + 1;

package/src/channels/feishu/feishu-cards.mjs

@@ -497,6 +497,7 @@ export function menuHelpText() {
     '/status  连接状态',
     '/version  查看插件版本',
     '/compact  压缩当前会话上下文',
+    '/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）',
     '/archived on/off  会话列表显示/隐藏归档',
     '',
     '👁 关注',
@@ -593,6 +594,7 @@ export function helpCard(extraTextLines = []) {
     { tag: 'div', text: markdown([
       t(HELP_TEXT_COMMANDS),
       t('`/version` — 查看插件版本'),
+      t('/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）'),
     ].join('\n') + extraText) },
     { tag: 'hr' },
     { tag: 'div', text: markdown(t(HELP_NUMBER_FALLBACK)) },