dsh-scratch-workspace 0.1.1 → 0.1.2

package/lib/gc.js

@@ -127,9 +127,10 @@ export async function cleanOrphans({
         const info = await stat(dirPath)
         const ageMs = now - info.mtimeMs
 
-        // Case 1: Empty abandoned session folder past grace period
+        // Case 1: Empty abandoned session folder
         const empty = await isDirectoryEmpty(dirPath)
-        if (empty && ageMs >= emptyGraceMs) {
+        const hasSession = knownShortIds.has(folderShort)
+        if (empty && (!hasSession || ageMs >= emptyGraceMs)) {
           await removeSessionDir(dirPath)
           cleaned.push({ path: dirPath, reason: 'empty-abandoned' })
           logger?.info?.(`dsh-scratch-workspace gc: removed empty session dir ${dirPath}`)
@@ -137,7 +138,6 @@ export async function cleanOrphans({
         }
 
         // Case 2: Orphan session directory no longer associated with any session
-        const hasSession = knownShortIds.has(folderShort)
         if (!hasSession && ageMs > orphanTtlMs) {
           await removeSessionDir(dirPath)
           cleaned.push({ path: dirPath, reason: 'orphan-ttl' })
@@ -172,19 +172,22 @@ export function setupAutoGc(ctx, iso, {
     // Live sessions from registry
     const registry = ctx.root?.workspaceRegistry ?? ctx.workspaceRegistry
     const workspaces = registry?.list?.() ?? []
+    const archived = new Set(registry?.archivedSessionIds ?? [])
     for (const ws of workspaces) {
-      for (const id of ws.sessionIds ?? []) ids.add(id)
+      for (const id of ws.sessionIds ?? []) {
+        if (!archived.has(id)) ids.add(id)
+      }
     }
     // Live agents
     const agents = ctx.agents ?? ctx.root?.agents
     if (typeof agents?.list === 'function') {
-      for (const ag of agents.list() ?? []) if (ag?.id) ids.add(ag.id)
+      for (const ag of agents.list() ?? []) if (ag?.id && !archived.has(ag.id)) ids.add(ag.id)
     }
     // Stored headers if available
     try {
       const stored = await registry?.listStoredHeaders?.()
       if (Array.isArray(stored)) {
-        for (const h of stored) if (h?.id) ids.add(h.id)
+        for (const h of stored) if (h?.id && !archived.has(h.id)) ids.add(h.id)
       }
     } catch {}
 

package/lib/patch.js

@@ -15,6 +15,7 @@ import {
   allocateSessionDir,
   isMeaningfulTitle,
   sanitizeTitleForPath,
+  SESSION_DIR_PATTERN,
   SESSION_DIR_PREFIX,
   setIsolated,
 } from './isolate.js'
@@ -23,6 +24,51 @@ import { cleanOrphans, isDirectoryEmpty, removeSessionDir, shortSessionId } from
 /** The registry-internal host property. */
 const HOST_PROPERTY = 'host'
 
+/**
+ * Locate and remove a session's directory if it is empty.
+ * Uses 3-tier lookup: in-memory iso state -> registry index -> isolating roots scan by shortId.
+ * @param {string} sessionId
+ * @param {object} iso
+ * @param {object} [registry]
+ */
+export async function cleanEmptySessionDir(sessionId, iso, registry) {
+  if (!sessionId) return
+  let sessionDir = iso?.sessionPath?.(sessionId)
+  if (!sessionDir && typeof registry?.sessionPath === 'function') {
+    try { sessionDir = registry.sessionPath(sessionId) } catch {}
+  }
+  const short = shortSessionId(sessionId)
+  const candidateDirs = new Set()
+  if (sessionDir) candidateDirs.add(sessionDir)
+
+  if (short && typeof iso?.roots === 'function') {
+    for (const root of iso.roots()) {
+      try {
+        const entries = await readdir(root, { withFileTypes: true })
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue
+          const match = entry.name.match(SESSION_DIR_PATTERN)
+          if (match) {
+            const entryShort = (match[2] ?? match[1] ?? '').split('-')[0].toLowerCase()
+            if (entryShort === short) {
+              candidateDirs.add(join(root, entry.name))
+            }
+          }
+        }
+      } catch {}
+    }
+  }
+
+  iso?.forgetSession?.(sessionId)
+
+  for (const dir of candidateDirs) {
+    const empty = await isDirectoryEmpty(dir).catch(() => false)
+    if (empty) {
+      await removeSessionDir(dir).catch(() => {})
+    }
+  }
+}
+
 /**
  * Wrap the Workspace registry's session-path index so isolated sessions resolve
  * to the Workspace that owns their directory across all DSH versions.
@@ -81,29 +127,30 @@ export function patchRegistry(registry, iso) {
   }
 
   // Hook archiveSession to immediately clean empty session directories on archive
-  const originalArchive = registry?.archiveSession
+  const proto = registry ? Object.getPrototypeOf(registry) : null
+  const originalArchive = proto?.archiveSession ?? registry?.archiveSession
   if (typeof originalArchive === 'function') {
-    registry.archiveSession = async function archiveSession(sessionId, options) {
+    const wrappedArchive = async function archiveSession(sessionId, options) {
       const res = await originalArchive.call(this, sessionId, options)
-      if (sessionId) {
-        const sessionDir = iso.sessionPath(sessionId)
-        if (sessionDir) {
-          const empty = await isDirectoryEmpty(sessionDir).catch(() => false)
-          if (empty) {
-            iso.forgetSession(sessionId)
-            await removeSessionDir(sessionDir).catch(() => {})
-          }
-        }
-      }
+      await cleanEmptySessionDir(sessionId, iso, this).catch(() => {})
       return res
     }
+    registry.archiveSession = wrappedArchive
+    if (proto && typeof proto.archiveSession === 'function') {
+      proto.archiveSession = wrappedArchive
+    }
   }
 
   return () => {
     if (typeof originalMatches === 'function') target.candidateMatches = originalMatches
     if (typeof originalRemember === 'function') target.rememberSessionPath = originalRemember
     if (typeof originalPath === 'function') target.sessionPath = originalPath
-    if (typeof originalArchive === 'function') registry.archiveSession = originalArchive
+    if (typeof originalArchive === 'function') {
+      registry.archiveSession = originalArchive
+      if (proto && typeof proto.archiveSession === 'function') {
+        proto.archiveSession = originalArchive
+      }
+    }
   }
 }
 
@@ -180,32 +227,25 @@ export function patchSessionCreate(ctx, iso) {
 
     if (owner === undefined) return await originalCreate.call(this, request0)
 
-    // Check if request0.sessionId is an existing blank session.
-    // In an isolating workspace, if request0.sessionId already has a recorded cwd in DSH,
-    // or is already tracked in isolation, drop it so a fresh unique session is minted,
-    // avoiding ApiSessionCwdConflict and duplicate directory naming.
+    // Check if request0.sessionId is an existing blank session minted under parent workspace cwd.
+    // If so, it cannot be adopted for sandbox cwd; drop it and mint a fresh ID.
     let targetSessionId = request0.sessionId
     if (targetSessionId !== undefined) {
-      const trackedPath = typeof iso?.sessionPath === 'function' ? iso.sessionPath(targetSessionId) : undefined
-      if (trackedPath !== undefined) {
+      const sessions = typeof ctx.get === 'function' ? ctx.get('sessions', false) : ctx.sessions
+      const agents = typeof ctx.get === 'function' ? ctx.get('agents', false) : ctx.agents
+      const live = sessions?.get?.(targetSessionId) ?? agents?.get?.(targetSessionId)
+      const existingCwd = live?.session?.header?.cwd
+      if (existingCwd !== undefined && existingCwd === owner) {
         targetSessionId = undefined
       } else {
-        const sessions = typeof ctx.get === 'function' ? ctx.get('sessions', false) : ctx.sessions
-        const agents = typeof ctx.get === 'function' ? ctx.get('agents', false) : ctx.agents
-        const live = sessions?.get?.(targetSessionId) ?? agents?.get?.(targetSessionId)
-        const existingCwd = live?.session?.header?.cwd
-        if (existingCwd !== undefined) {
-          targetSessionId = undefined
-        } else {
-          const query = typeof ctx.get === 'function' ? ctx.get('sessionQuery', false) : ctx.sessionQuery
-          if (typeof query?.observeSession === 'function') {
-            try {
-              const obs = await query.observeSession(targetSessionId)
-              if (obs?.header?.cwd !== undefined) {
-                targetSessionId = undefined
-              }
-            } catch {}
-          }
+        const query = typeof ctx.get === 'function' ? ctx.get('sessionQuery', false) : ctx.sessionQuery
+        if (typeof query?.observeSession === 'function') {
+          try {
+            const obs = await query.observeSession(targetSessionId)
+            if (obs?.header?.cwd !== undefined && obs.header.cwd === owner) {
+              targetSessionId = undefined
+            }
+          } catch {}
         }
       }
     }
@@ -245,7 +285,6 @@ export function patchSessionCreate(ctx, iso) {
               if (!currentBase.includes(actualShort)) {
                 const correctDir = resolve(join(owner, `${SESSION_DIR_PREFIX}${actualShort}`))
                 await rename(fallbackCwd, correctDir).catch(() => {})
-                iso.recordRename?.(fallbackCwd, correctDir)
                 iso.recordSessionPath(created.sessionId, correctDir)
                 return created
               }
@@ -266,7 +305,6 @@ export function patchSessionCreate(ctx, iso) {
           const correctDir = resolve(join(owner, `${SESSION_DIR_PREFIX}${actualShort}`))
           try {
             await rename(cwd, correctDir)
-            iso.recordRename?.(cwd, correctDir)
             cwd = correctDir
           } catch {}
         }
@@ -299,60 +337,40 @@ export function patchSessionCreate(ctx, iso) {
   if (typeof originalDelete === 'function') {
     controller().delete = async function del(req) {
       const sessionId = req?.sessionId ?? (typeof req === 'string' ? req : undefined)
-      const sessionDir = sessionId ? iso.sessionPath(sessionId) : undefined
       try {
         return await originalDelete.call(this, req)
       } finally {
-        if (sessionDir) {
-          iso.forgetSession(sessionId)
-          await removeSessionDir(sessionDir)
+        if (sessionId) {
+          await cleanEmptySessionDir(sessionId, iso, registry())
         }
       }
     }
   }
 
+  // Hook workspaceController.archiveSession for frontend archive actions
+  const wsCtrl = ctx.root?.workspaceController ?? ctx.workspaceController
+  const originalWsArchive = wsCtrl?.archiveSession
+  if (typeof originalWsArchive === 'function') {
+    wsCtrl.archiveSession = async function archiveSession(request) {
+      const res = await originalWsArchive.call(this, request)
+      if (request?.sessionId) {
+        await cleanEmptySessionDir(request.sessionId, iso, registry())
+      }
+      return res
+    }
+  }
+
   return () => {
     controller().create = originalCreate
     if (typeof originalRename === 'function') controller().rename = originalRename
     if (typeof originalDelete === 'function') controller().delete = originalDelete
+    if (typeof originalWsArchive === 'function') wsCtrl.archiveSession = originalWsArchive
   }
 }
 
 /**
- * Helper to patch a method across an object and its entire prototype chain
- * up to Object.prototype, ensuring every Cordis service proxy, derived instance,
- * and caller shares the patched behavior.
- * @param {object} obj - target instance or service
- * @param {string} methodName - method to wrap
- * @param {Function} wrapper - function taking original method and returning new method
- * @returns {Function} disposer restoring all patched methods
- */
-function patchMethod(obj, methodName, wrapper) {
-  if (!obj) return () => {}
-  const targets = []
-  let curr = obj
-  while (curr && curr !== Object.prototype) {
-    if (Object.prototype.hasOwnProperty.call(curr, methodName) || typeof curr[methodName] === 'function') {
-      targets.push({ target: curr, original: curr[methodName] })
-    }
-    curr = Object.getPrototypeOf(curr)
-  }
-  if (!targets.some(t => t.target === obj) && typeof obj[methodName] === 'function') {
-    targets.push({ target: obj, original: obj[methodName] })
-  }
-  for (const item of targets) {
-    item.target[methodName] = wrapper(item.original)
-  }
-  return () => {
-    for (const item of targets) {
-      item.target[methodName] = item.original
-    }
-  }
-}
-
-/**
- * Wrap ctx.fs (resolve, stat, lstat) so tool operations (write, edit, read, etc.) automatically
- * translate pre-rename directory paths to their new renamed directory paths across all contexts.
+ * Wrap ctx.fs.resolve so tool operations (write, edit, read, etc.) automatically
+ * translate pre-rename directory paths to their new renamed directory paths.
  * @param ctx - Cordis context
  * @param iso - shared isolation state
  * @returns disposer
@@ -369,68 +387,25 @@ export function patchFs(ctx, iso) {
   }
 
   const fs = getFs()
-  if (!fs) return () => {}
-
-  const disposers = []
-
-  // Wrap fs.resolve
-  disposers.push(patchMethod(fs, 'resolve', (originalResolve) => {
-    if (typeof originalResolve !== 'function') return originalResolve
-    return async function resolve(path, options) {
-      const targetPath = typeof path === 'string' ? (iso.rewritePath?.(path) ?? path) : path
-      let targetOpts = options
-      if (options?.cwd && typeof options.cwd === 'string') {
-        const rewrittenCwd = iso.rewritePath?.(options.cwd) ?? options.cwd
-        if (rewrittenCwd !== options.cwd) {
-          targetOpts = { ...options, cwd: rewrittenCwd }
-        }
-      }
-      return await originalResolve.call(this, targetPath, targetOpts)
-    }
-  }))
-
-  // Wrap fs.stat
-  disposers.push(patchMethod(fs, 'stat', (originalStat) => {
-    if (typeof originalStat !== 'function') return originalStat
-    return async function stat(target, signal) {
-      let effectiveTarget = target
-      if (target && typeof target === 'object' && typeof target.targetKey === 'string') {
-        const rewritten = iso.rewritePath?.(target.targetKey)
-        if (rewritten && rewritten !== target.targetKey) {
-          effectiveTarget = { ...target, targetKey: rewritten }
-        }
-      } else if (typeof target === 'string') {
-        effectiveTarget = iso.rewritePath?.(target) ?? target
-      }
-      return await originalStat.call(this, effectiveTarget, signal)
-    }
-  }))
-
-  // Wrap fs.lstat
-  disposers.push(patchMethod(fs, 'lstat', (originalLstat) => {
-    if (typeof originalLstat !== 'function') return originalLstat
-    return async function lstat(path, opts, signal) {
-      const targetPath = typeof path === 'string' ? (iso.rewritePath?.(path) ?? path) : path
-      let targetOpts = opts
-      if (opts?.cwd && typeof opts.cwd === 'string') {
-        const rewrittenCwd = iso.rewritePath?.(opts.cwd) ?? opts.cwd
-        if (rewrittenCwd !== opts.cwd) {
-          targetOpts = { ...opts, cwd: rewrittenCwd }
-        }
-      }
-      return await originalLstat.call(this, targetPath, targetOpts, signal)
+  if (!fs || typeof fs.resolve !== 'function') return () => {}
+
+  const originalResolve = fs.resolve
+  fs.resolve = async function resolve(path, options) {
+    let target = path
+    if (typeof path === 'string') {
+      target = iso.rewritePath?.(path) ?? path
     }
-  }))
+    return await originalResolve.call(this, target, options)
+  }
 
   return () => {
-    for (const dispose of disposers) dispose()
+    fs.resolve = originalResolve
   }
 }
 
 /**
  * Wrap workingDirectory service so all tool executions (write, edit, bash, etc.)
  * immediately track renamed session working directories without throwing ENOENT.
- * Patches get, ensure, and directory across instance and prototype hierarchy.
  * @param ctx - Cordis context
  * @param iso - shared isolation state
  * @returns disposer
@@ -449,76 +424,48 @@ export function patchWorkingDirectory(ctx, iso) {
   const wd = getWd()
   if (!wd) return () => {}
 
-  const disposers = []
+  const originalGet = wd.get
+  const originalEnsure = wd.ensure
 
-  // Wrap wd.get
-  disposers.push(patchMethod(wd, 'get', (originalGet) => {
-    if (typeof originalGet !== 'function') return originalGet
-    return function get(session) {
+  if (typeof originalGet === 'function') {
+    wd.get = function get(session) {
       const sessionId = session?.id
       if (sessionId) {
         const isolated = iso.sessionPath(sessionId)
         if (isolated !== undefined) {
-          if (session?.header) session.header.cwd = isolated
           return isolated
         }
       }
-      if (session?.header?.cwd) {
-        const rewritten = iso.rewritePath?.(session.header.cwd)
-        if (rewritten && rewritten !== session.header.cwd) {
-          session.header.cwd = rewritten
-          return rewritten
-        }
-      }
-      const raw = originalGet.call(this, session)
-      return typeof raw === 'string' ? (iso.rewritePath?.(raw) ?? raw) : raw
+      return originalGet.call(this, session)
     }
-  }))
-
-  // Wrap wd.ensure
-  disposers.push(patchMethod(wd, 'ensure', (originalEnsure) => {
-    if (typeof originalEnsure !== 'function') return originalEnsure
-    return async function ensure(agent, signal) {
-      const sessionId = agent?.session?.id ?? agent?.id
-      let isolated = sessionId ? iso.sessionPath(sessionId) : undefined
-      if (!isolated && agent?.session?.header?.cwd) {
-        const rewritten = iso.rewritePath?.(agent.session.header.cwd)
-        if (rewritten && rewritten !== agent.session.header.cwd) {
-          isolated = rewritten
-        }
-      }
-      if (isolated !== undefined) {
-        const session = agent?.session
-        if (session) {
-          if (session.header) session.header.cwd = isolated
-          if (typeof session.append === 'function') {
-            try {
-              const handle = this.workingDirectoryProjectionHandle
+  }
+
+  if (typeof originalEnsure === 'function') {
+    wd.ensure = async function ensure(agent, signal) {
+      const sessionId = agent?.session?.id
+      if (sessionId) {
+        const isolated = iso.sessionPath(sessionId)
+        if (isolated !== undefined) {
+          const session = agent?.session
+          if (session) {
+            if (typeof session.append === 'function') {
+              const handle = wd.workingDirectoryProjectionHandle
               const currentProj = handle?.stateOf?.(session)
               if (currentProj !== isolated) {
                 session.append('working-directory/change', { cwd: isolated })
               }
-            } catch {}
+            }
           }
+          return isolated
         }
-        return isolated
       }
       return await originalEnsure.call(this, agent, signal)
     }
-  }))
-
-  // Wrap wd.directory
-  disposers.push(patchMethod(wd, 'directory', (originalDirectory) => {
-    if (typeof originalDirectory !== 'function') return originalDirectory
-    return async function directory(path, cwd, signal) {
-      const targetPath = typeof path === 'string' ? (iso.rewritePath?.(path) ?? path) : path
-      const targetCwd = typeof cwd === 'string' ? (iso.rewritePath?.(cwd) ?? cwd) : cwd
-      return await originalDirectory.call(this, targetPath, targetCwd, signal)
-    }
-  }))
+  }
 
   return () => {
-    for (const dispose of disposers) dispose()
+    if (typeof originalGet === 'function') wd.get = originalGet
+    if (typeof originalEnsure === 'function') wd.ensure = originalEnsure
   }
 }
 
@@ -581,14 +528,10 @@ export async function renameSessionDirToTitle(sessionId, title, iso, registry, c
       liveAgent?.session
 
     if (targetSession) {
-      if (targetSession.header) targetSession.header.cwd = targetDir
       if (typeof targetSession.append === 'function') {
         targetSession.append('working-directory/change', { cwd: targetDir })
       }
     }
-    if (liveAgent?.session?.header) {
-      liveAgent.session.header.cwd = targetDir
-    }
 
     // 6. Post-rename cleanup guard: If currentDir is ever re-created by an in-flight tool call,
     // merge files to targetDir and delete currentDir!
@@ -646,8 +589,11 @@ export function isolatedSessionsApi(ctx, iso) {
     async cleanOrphans(options = {}) {
       const registryInstance = registry()
       const known = new Set()
+      const archived = new Set(registryInstance?.archivedSessionIds ?? [])
       for (const ws of registryInstance?.list?.() ?? []) {
-        for (const id of ws.sessionIds ?? []) known.add(id)
+        for (const id of ws.sessionIds ?? []) {
+          if (!archived.has(id)) known.add(id)
+        }
       }
       return await cleanOrphans({
         roots: iso.roots(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-scratch-workspace",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "DeepSeek Harness 瞬态会话隔离与草稿清理插件 — 顺应官方原生工作区规范的会话沙箱隔离、侧边栏归集与磁盘生命周期自动清理",
   "author": "Mi Tom <6468993+MDX-Tom@users.noreply.github.com>",
   "license": "MIT",