@xmanrui/dsh-im 4.21.1 → 4.22.0

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

@@ -1,4 +1,5 @@
 import { validateBotAlias, withBotAlias } from './bot-alias.mjs';
+import { defaultImWorkspace, sameWorkspacePath } from './default-workspace.mjs';
 import {
   mkdir,
   readFile,
@@ -52,15 +53,6 @@ async function canonicalWorkspacePath(value) {
   return resolve(await realpath(value));
 }
 
-async function sameWorkspacePath(left, right) {
-  if (left === right) return true;
-  try {
-    return await canonicalWorkspacePath(left) === await canonicalWorkspacePath(right);
-  } catch {
-    return false;
-  }
-}
-
 function botIdOf(value) {
   if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) {
     throw new TypeError('Invalid bot id');
@@ -420,7 +412,7 @@ export class BotWorkspaceStore {
   #writeQueue = Promise.resolve();
   #botQueues = new Map();
 
-  constructor(path, { defaultWorkspace = process.cwd() } = {}) {
+  constructor(path, { defaultWorkspace = defaultImWorkspace() } = {}) {
     if (typeof path !== 'string' || !path) throw new TypeError('workspace store path is required');
     this.#path = path;
     this.#defaultWorkspace = resolve(defaultWorkspace);
@@ -1597,6 +1589,7 @@ export function createBotWorkspaceScope(
     if (!sessionId) return true;
     let sessionWorkspace = sessionGenerations.get(sessionId)?.workspace;
     let matches = false;
+    let unregistered = true;
     if (!sessionWorkspace && typeof harness.rpc === 'function') {
       // Read registration metadata only: adopting a Session is not a lookup.
       // Resolve by id before comparing real paths so symlink pins remain valid.
@@ -1609,7 +1602,11 @@ export function createBotWorkspaceScope(
       if (owners.length === 1 && typeof owners[0].path === 'string' && isAbsolute(owners[0].path)) {
         sessionWorkspace = owners[0].path;
       }
-    } else if (!sessionWorkspace && typeof harness.listWorkspaceSessions === 'function') {
+      unregistered = owners.length === 0;
+    }
+    if (!sessionWorkspace && unregistered && typeof harness.listWorkspaceSessions === 'function') {
+      // After a restart, default IM sessions have no registry owner. Reuse
+      // the read-only list, which also recognizes ungrouped default sessions.
       const listed = await harness.listWorkspaceSessions(await canonicalWorkspacePath(workspace));
       if (!Array.isArray(listed?.sessions)) {
         throw new TypeError('Harness returned an invalid workspace session list');

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

@@ -0,0 +1,28 @@
+import { mkdir, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+
+export function defaultImWorkspace(config = {}) {
+  const dshHome = config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh');
+  return resolve(dshHome, 'im');
+}
+
+export async function sameWorkspacePath(left, right) {
+  if (typeof left !== 'string' || typeof right !== 'string'
+    || !isAbsolute(left) || !isAbsolute(right)) return false;
+  if (resolve(left) === resolve(right)) return true;
+  try {
+    return resolve(await realpath(left)) === resolve(await realpath(right));
+  } catch {
+    return false;
+  }
+}
+
+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 };
+}

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

@@ -1,8 +1,10 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
 import { isAbsolute } from 'node:path';
 
 import { adoptRegisteredWorkspaceSession } from './harness-session-binding.mjs';
+import { sameWorkspacePath } from './default-workspace.mjs';
 import {
   appendInboundFilesToPrompt,
   InboundFileError,
@@ -717,6 +719,7 @@ export class HarnessClient {
   #baseUrl;
   #apiProxy;
   #workspace;
+  #ungroupedWorkspace;
   #agentPreset;
   #autostart;
   #dshBin;
@@ -740,6 +743,7 @@ export class HarnessClient {
     apiProxy,
     interactionScope = apiProxy,
     workspace,
+    ungroupedWorkspace,
     agentPreset,
     autostart = false,
     dshBin = 'dsh',
@@ -788,6 +792,8 @@ export class HarnessClient {
       throw new TypeError('interactionScope must identify the current Host');
     }
     this.#workspace = workspace;
+    // Only the reserved IM directory bypasses grouping, even after /ws switches.
+    this.#ungroupedWorkspace = ungroupedWorkspace;
     // Keep an omitted preset absent so session.create resolves the Host's current default.
     this.#agentPreset = agentPreset ?? undefined;
     this.#autostart = Boolean(this.#baseUrl && autostart);
@@ -921,6 +927,38 @@ export class HarnessClient {
     await this.ensureRunning(options);
     const workspaceList = await this.rpc('workspace.list', {}, 30_000, options);
     const workspace = workspaceFromList(workspacePath, workspaceList);
+    if (await this.isUngroupedWorkspace(workspacePath)) {
+      const sessionList = await this.rpc('session.list', {}, 30_000, options);
+      if (!Array.isArray(sessionList?.items)) {
+        throw new Error('Harness returned an invalid response for session.list');
+      }
+      const registered = new Set();
+      const selected = new Set();
+      for (const item of workspaceList.items) {
+        if (!Array.isArray(item?.sessionIds)
+          || item.sessionIds.some((id) => typeof id !== 'string' || !id)) {
+          throw new Error('Harness returned invalid session IDs for workspace.list');
+        }
+        for (const id of item.sessionIds) registered.add(id);
+        if (await sameWorkspacePath(item.path, workspacePath)) {
+          for (const id of item.sessionIds) selected.add(id);
+        }
+      }
+      for (const item of sessionList.items) {
+        if (typeof item?.sessionId !== 'string' || !item.sessionId) {
+          throw new Error('Harness returned an invalid response for session.list');
+        }
+        // A matching cwd never overrides an explicit group assignment.
+        if (!registered.has(item.sessionId) && await this.isUngroupedWorkspace(item.cwd)) {
+          selected.add(item.sessionId);
+        }
+      }
+      return workspaceSessions(
+        { path: workspacePath, sessionIds: [...selected] },
+        workspaceList.archivedSessionIds,
+        sessionList,
+      );
+    }
     if (!workspace) return { workspace: workspacePath, sessions: [] };
     const sessionList = await this.rpc('session.list', {}, 30_000, options);
     return workspaceSessions(workspace, workspaceList.archivedSessionIds, sessionList);
@@ -988,6 +1026,10 @@ export class HarnessClient {
     return adoptRegisteredWorkspaceSession(this, value, options);
   }
 
+  async isUngroupedWorkspace(workspace) {
+    return sameWorkspacePath(workspace, this.#ungroupedWorkspace);
+  }
+
   async workspaceId(options = {}) {
     const { workspace = this.#workspace, ...rpcOptions } = options;
     const { items } = await this.rpc('workspace.list', {}, 30_000, rpcOptions);
@@ -999,9 +1041,13 @@ export class HarnessClient {
 
   async createSession(options = {}) {
     const { agentPreset: requestedPreset, ...rpcOptions } = options;
+    const workspace = rpcOptions.workspace ?? this.#workspace;
+    const ungrouped = await this.isUngroupedWorkspace(workspace);
+    if (ungrouped) await mkdir(workspace, { recursive: true });
     await this.ensureRunning(rpcOptions);
-    const workspaceId = await this.workspaceId(rpcOptions);
-    const payload = { workspaceId };
+    const payload = ungrouped
+      ? { cwd: workspace }
+      : { workspaceId: await this.workspaceId(rpcOptions) };
     const agentPreset = requestedPreset !== undefined ? requestedPreset : this.#agentPreset;
     if (agentPreset != null) payload.agentPreset = agentPreset;
     const created = await this.rpc('session.create', payload, 30_000, rpcOptions);

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

@@ -37,16 +37,13 @@ function sessionWorkspace(sessionId, value) {
     }
   }
 
-  if (owners.length === 0) {
-    throw bindingError('session-not-registered', 'The session is not registered to a Harness workspace');
-  }
-  if (owners.length !== 1) {
+  if (owners.length > 1) {
     throw bindingError(
       'session-workspace-ambiguous',
       'The session is registered to more than one Harness workspace',
     );
   }
-  if (UNSAFE_WORKSPACE_PATH.test(owners[0].path)) {
+  if (owners.length && UNSAFE_WORKSPACE_PATH.test(owners[0].path)) {
     throw new Error('Harness returned an unsafe workspace path for the session');
   }
   return {
@@ -82,20 +79,28 @@ function sessionSummary(sessionId, value) {
   if (title !== undefined && title !== null && typeof title !== 'string') {
     throw new Error('Harness returned an invalid session title for session.list');
   }
-  return { title: typeof title === 'string' ? title : null };
+  return { cwd: summary.cwd, title: typeof title === 'string' ? title : null };
 }
 
 export async function adoptRegisteredWorkspaceSession(client, value, options = {}, timeoutMs = 30_000) {
   const sessionId = validatedSessionId(value);
   await client.ensureRunning(options);
   const workspaceList = await client.rpc('workspace.list', {}, timeoutMs, options);
-  const { workspace, archived } = sessionWorkspace(sessionId, workspaceList);
+  let { workspace, archived } = sessionWorkspace(sessionId, workspaceList);
   const summary = sessionSummary(
     sessionId,
     await client.rpc('session.list', {}, timeoutMs, options),
   );
+  if (!workspace) {
+    if (typeof summary.cwd !== 'string' || !isAbsolute(summary.cwd)
+      || UNSAFE_WORKSPACE_PATH.test(summary.cwd)
+      || !await client.isUngroupedWorkspace?.(summary.cwd)) {
+      throw bindingError('session-not-registered', 'The session is not registered to a Harness workspace');
+    }
+    workspace = { path: summary.cwd };
+  }
   const adopted = await client.rpc('session.create', {
-    workspaceId: workspace.workspaceId,
+    ...(workspace.workspaceId ? { workspaceId: workspace.workspaceId } : { cwd: workspace.path }),
     sessionId,
   }, timeoutMs, options);
   if (!adopted || adopted.sessionId !== sessionId) {