@xmanrui/dsh-im 4.28.0 → 4.29.0

package/src/channels/shared/bot-workspace-store.mjs

@@ -1,7 +1,7 @@
 import { t } from './i18n.mjs';
 import { atConnectionStage, connectionStageError, extractConnectionEvidence } from './connection-error.mjs';
 import { validateBotAlias, withBotAlias } from './bot-alias.mjs';
-import { defaultImWorkspace, sameWorkspacePath } from './default-workspace.mjs';
+import { defaultImWorkspace, ensureImWorkspaceDirectory, sameWorkspacePath } from './default-workspace.mjs';
 import {
   mkdir,
   readFile,
@@ -367,13 +367,14 @@ async function writeStoredDocument(path, document) {
   await rename(temporary, path);
 }
 
-export async function validateWorkspacePath(value) {
+export async function validateWorkspacePath(value, { ungroupedWorkspace } = {}) {
   if (typeof value !== 'string' || !value.trim() || !isAbsolute(value.trim())) {
     const error = new Error('工作区必须是绝对路径。');
     error.code = 'workspace-not-absolute';
     throw error;
   }
   const workspace = resolve(value.trim());
+  await ensureImWorkspaceDirectory(workspace, ungroupedWorkspace);
   let info;
   try {
     info = await stat(workspace);
@@ -393,6 +394,7 @@ export async function validateWorkspacePath(value) {
 export class BotWorkspaceStore {
   #path;
   #defaultWorkspace;
+  #ungroupedWorkspace;
   #version = 1;
   #workspaces = {};
   #agentPresets = {};
@@ -414,10 +416,11 @@ export class BotWorkspaceStore {
   #writeQueue = Promise.resolve();
   #botQueues = new Map();
 
-  constructor(path, { defaultWorkspace = defaultImWorkspace() } = {}) {
+  constructor(path, { defaultWorkspace = defaultImWorkspace(), ungroupedWorkspace } = {}) {
     if (typeof path !== 'string' || !path) throw new TypeError('workspace store path is required');
     this.#path = path;
     this.#defaultWorkspace = resolve(defaultWorkspace);
+    this.#ungroupedWorkspace = ungroupedWorkspace;
   }
 
   async load() {
@@ -691,11 +694,20 @@ export class BotWorkspaceStore {
       const createsBot = !this.#workspaces[id];
       const initializesAccessPolicy = initialAccessPolicy !== undefined
         && !Object.hasOwn(this.#accessPolicies, id);
+      const accessPolicy = initializesAccessPolicy
+        ? validateAccessPolicy(initialAccessPolicy)
+        : undefined;
+      const agentPreset = createsBot ? validateAgentPresetId(defaultAgentPreset) : null;
+      // Resolve saved bot/conversation choices before preparing the shared IM
+      // directory. Merely loading a channel must not create an unused fallback.
+      const selectedWorkspaces = new Set([
+        this.#workspaces[id] ?? initialWorkspace,
+        ...Object.values(this.#conversationWorkspaces[id] ?? {}),
+      ]);
+      for (const selected of selectedWorkspaces) {
+        await ensureImWorkspaceDirectory(selected, this.#ungroupedWorkspace);
+      }
       if (createsBot || initializesAccessPolicy) {
-        const accessPolicy = initializesAccessPolicy
-          ? validateAccessPolicy(initialAccessPolicy)
-          : undefined;
-        const agentPreset = createsBot ? validateAgentPresetId(defaultAgentPreset) : null;
         const hadAgentPreset = Object.hasOwn(this.#agentPresets, id);
         const previousAgentPreset = this.#agentPresets[id];
         const nextAccessPolicies = initializesAccessPolicy
@@ -744,7 +756,7 @@ export class BotWorkspaceStore {
       error.code = 'workspace-bot-not-found';
       throw error;
     }
-    const workspace = await validateWorkspacePath(value);
+    const workspace = await validateWorkspacePath(value, { ungroupedWorkspace: this.#ungroupedWorkspace });
     return this.#enqueue(id, async () => {
       if (!this.has(id)
         || (incarnation !== undefined && incarnation !== this.incarnationFor(id))) {
@@ -965,7 +977,9 @@ export class BotWorkspaceStore {
     }
     // Validate before queueing so an invalid path fails without disturbing the
     // conversation's current workspace or its session.
-    const workspace = value === null ? null : await validateWorkspacePath(value);
+    const workspace = value === null ? null : await validateWorkspacePath(value, {
+      ungroupedWorkspace: this.#ungroupedWorkspace,
+    });
     return this.#enqueue(id, async () => {
       const assertCurrentSwitch = () => {
         if (!this.has(id)
@@ -981,6 +995,10 @@ export class BotWorkspaceStore {
         }
       };
       assertCurrentSwitch();
+      if (workspace === null) {
+        await ensureImWorkspaceDirectory(this.workspaceFor(id), this.#ungroupedWorkspace);
+        assertCurrentSwitch();
+      }
       const previousOverrides = this.#conversationWorkspaces[id];
       const previous = previousOverrides?.[key];
       const hadOverride = Boolean(previousOverrides)
@@ -1065,7 +1083,9 @@ export class BotWorkspaceStore {
         );
       }
     };
-    const workspace = await canonicalWorkspacePath(await validateWorkspacePath(value));
+    const workspace = await canonicalWorkspacePath(await validateWorkspacePath(value, {
+      ungroupedWorkspace: this.#ungroupedWorkspace,
+    }));
     return this.#enqueue(id, async () => {
       if (!this.has(id)
         || (incarnation !== undefined && incarnation !== this.incarnationFor(id))) {

package/src/channels/shared/default-workspace.mjs

@@ -21,8 +21,11 @@ export async function sameWorkspacePath(left, right) {
 export async function prepareBotWorkspace(config = {}) {
   const ungroupedWorkspace = defaultImWorkspace(config);
   const defaultWorkspace = resolve(config.workspace ?? ungroupedWorkspace);
-  if (await sameWorkspacePath(defaultWorkspace, ungroupedWorkspace)) {
-    await mkdir(defaultWorkspace, { recursive: true });
-  }
   return { defaultWorkspace, ungroupedWorkspace };
 }
+
+export async function ensureImWorkspaceDirectory(workspace, ungroupedWorkspace) {
+  if (await sameWorkspacePath(workspace, ungroupedWorkspace)) {
+    await mkdir(workspace, { recursive: true });
+  }
+}

package/src/channels/shared/harness-approval.mjs

@@ -272,6 +272,7 @@ export class HarnessApprovalQueue {
       requiresMention: context.requiresMention === true,
       send,
       render,
+      onResolved: typeof context.onResolved === 'function' ? context.onResolved : null,
       text,
       presented: false,
       presentationTask: null,
@@ -328,8 +329,7 @@ export class HarnessApprovalQueue {
         delivered = await presentationTask.then(() => true, () => false);
       }
       if (shouldNotify && delivered) {
-        pending.resolutionNotified = true;
-        await send(approvalOutcomeText(resolution.outcome)).catch(() => undefined);
+        await this.#notifyResolved(pending, resolution.outcome, send);
       }
     });
     return true;
@@ -347,16 +347,14 @@ export class HarnessApprovalQueue {
           { signal: AbortSignal.timeout(5_000) },
         );
         pending.closedOutcome = 'rejected';
-        if ((pending.presented || pending.deliveryCompleted) && !pending.resolutionNotified) {
-          pending.resolutionNotified = true;
-          await pending.send(approvalOutcomeText('rejected')).catch(() => undefined);
+        if (pending.presented || pending.deliveryCompleted) {
+          await this.#notifyResolved(pending, 'rejected');
         }
       } catch (error) {
         if (error?.code === 'interaction-not-pending') {
           pending.closedOutcome = 'resolved';
-          if ((pending.presented || pending.deliveryCompleted) && !pending.resolutionNotified) {
-            pending.resolutionNotified = true;
-            await pending.send(t(APPROVAL_RESOLVED_TEXT)).catch(() => undefined);
+          if (pending.presented || pending.deliveryCompleted) {
+            await this.#notifyResolved(pending, 'resolved');
           }
         } else {
           this.#logger.warn?.(`[dsh-im:${this.#label}] failed to reject a closing approval:`, error);
@@ -383,9 +381,8 @@ export class HarnessApprovalQueue {
       pending.deliveryCompleted = true;
       if (!pending.inactive) {
         pending.presented = true;
-      } else if (pending.closedOutcome && !pending.resolutionNotified) {
-        pending.resolutionNotified = true;
-        await pending.send(approvalOutcomeText(pending.closedOutcome)).catch(() => undefined);
+      } else if (pending.closedOutcome) {
+        await this.#notifyResolved(pending, pending.closedOutcome);
       }
     } finally {
       if (pending.presentationTask === task) pending.presentationTask = null;
@@ -401,9 +398,7 @@ export class HarnessApprovalQueue {
         const send = pending.send;
         const next = this.#remove(pending);
         await this.#transition(next, async () => {
-          if (!pending.resolutionNotified) {
-            await send(t(APPROVAL_RESOLVED_TEXT)).catch(() => undefined);
-          }
+          await this.#notifyResolved(pending, 'resolved', send);
         });
         return;
       }
@@ -417,12 +412,24 @@ export class HarnessApprovalQueue {
     const send = pending.send;
     const next = this.#remove(pending);
     await this.#transition(next, async () => {
-      if (!pending.resolutionNotified) {
-        await send(approvalOutcomeText(outcome)).catch(() => undefined);
-      }
+      await this.#notifyResolved(pending, outcome, send);
     });
   }
 
+  async #notifyResolved(pending, outcome, send = pending.send) {
+    if (pending.resolutionNotified) return;
+    // Claim notification before awaiting the channel, so a concurrent close or
+    // resolved event cannot replace the confirmed result or notify twice.
+    pending.resolutionNotified = true;
+    const text = approvalOutcomeText(outcome);
+    try {
+      await pending.onResolved?.(text);
+    } catch (error) {
+      this.#logger.warn?.(`[dsh-im:${this.#label}] failed to update a resolved approval:`, error);
+    }
+    await send(text).catch(() => undefined);
+  }
+
   async #transition(next, work) {
     let release;
     const barrier = new Promise((resolve) => { release = resolve; });

package/src/channels/shared/harness-session-binding.mjs

@@ -1,3 +1,4 @@
+import { mkdir } from 'node:fs/promises';
 import { isAbsolute } from 'node:path';
 
 const MAX_SESSION_ID_LENGTH = 256;
@@ -99,6 +100,9 @@ export async function adoptRegisteredWorkspaceSession(client, value, options = {
     }
     workspace = { path: summary.cwd };
   }
+  if (await client.isUngroupedWorkspace?.(workspace.path)) {
+    await mkdir(workspace.path, { recursive: true });
+  }
   const adopted = await client.rpc('session.create', {
     ...(workspace.workspaceId ? { workspaceId: workspace.workspaceId } : { cwd: workspace.path }),
     sessionId,

package/src/channels/weixin/weixin-api.mjs

@@ -504,8 +504,9 @@ function validateLoginResponse(value) {
   return value;
 }
 
-export function createWeixinApi({ fetchImpl = fetch } = {}) {
+export function createWeixinApi({ fetchImpl = fetch, uploadFetchImpl = fetchImpl } = {}) {
   if (typeof fetchImpl !== 'function') throw new TypeError('fetchImpl must be a function');
+  if (typeof uploadFetchImpl !== 'function') throw new TypeError('uploadFetchImpl must be a function');
 
   async function sendArtifact({
     baseUrl,
@@ -566,7 +567,7 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
     const ciphertextSize = aesEcbPaddedSize(file.bytes.byteLength);
     let downloadParam;
     try {
-      downloadParam = await uploadWeixinCdn(fetchImpl, uploadUrl, file.bytes, aesKey, { signal });
+      downloadParam = await uploadWeixinCdn(uploadFetchImpl, uploadUrl, file.bytes, aesKey, { signal });
     } catch (error) {
       if (signal?.aborted) throw abortError(signal);
       const status = Number(error?.status);