@michengai/dsh-archive-manager 1.1.13 → 1.1.16

package/lib/explorer-path-policy.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+function isWindowsPath(p) {
+  return /^[a-zA-Z]:[\\/]/.test(p) || /^\\\\/.test(p) || process.platform === "win32";
+}
+function isPathAbsolute(p) {
+  return path.win32.isAbsolute(p) || path.posix.isAbsolute(p);
+}
+function normalizeComparable(target) {
+  const win = isWindowsPath(target);
+  const p = win ? path.win32 : path.posix;
+  const normalized = p.normalize(target).replace(/[\\/]+$/, "");
+  return win ? normalized.toLowerCase() : normalized;
+}
+function authorizeExplorerPath(targetPath, registeredPaths) {
+  if (typeof targetPath !== "string" || targetPath.trim() === "") return void 0;
+  const trimmed = targetPath.trim();
+  if (!isPathAbsolute(trimmed)) return void 0;
+  const targetComparable = normalizeComparable(trimmed);
+  for (const candidate of registeredPaths) {
+    if (typeof candidate !== "string" || candidate.trim() === "") continue;
+    if (normalizeComparable(candidate) === targetComparable) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+export {
+  authorizeExplorerPath
+};

package/lib/index.js

@@ -1,9 +1,12 @@
 import { getOnlineUpdate, getSidebarEntry, setOnlineUpdate, setSidebarEntry } from "./plugin-settings.js";
 import { isTrustedUpdateRequest, rawService, registerPluginUpdater, releaseUpdateRoute } from "./plugin-updater.js";
 import { apply as installHost, inject as hostInject } from "./host-install.js";
+import { authorizeExplorerPath } from "./explorer-path-policy.js";
+import { revealPathInSystem } from "./native-explorer.js";
 const inject = ["webServer", ...hostInject];
 const SIDEBAR_ENTRY_ENDPOINT = "/api/michengai/dsh-archive-manager/sidebar-entry";
 const ONLINE_UPDATE_ENDPOINT = "/api/michengai/dsh-archive-manager/online-update";
+const OPEN_IN_EXPLORER_ENDPOINT = "/api/michengai/dsh-archive-manager/open-in-explorer";
 function sendJson(response, statusCode, value) {
   response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
   response.end(JSON.stringify(value));
@@ -34,6 +37,7 @@ function registerSettingsRoutes(ctx, hostUpdateDisabled) {
   const server = rawService(ctx.webServer);
   releaseUpdateRoute(server, SIDEBAR_ENTRY_ENDPOINT);
   releaseUpdateRoute(server, ONLINE_UPDATE_ENDPOINT);
+  releaseUpdateRoute(server, OPEN_IN_EXPLORER_ENDPOINT);
   const disposeSidebar = ctx.webServer.register({
     kind: "exact",
     path: SIDEBAR_ENTRY_ENDPOINT,
@@ -92,6 +96,37 @@ function registerSettingsRoutes(ctx, hostUpdateDisabled) {
       response.end();
     }
   });
+  const disposeOpenExplorer = ctx.webServer.register({
+    kind: "exact",
+    path: OPEN_IN_EXPLORER_ENDPOINT,
+    handler: async (request, response) => {
+      if (request.method !== "POST") {
+        response.writeHead(405, { allow: "POST" });
+        response.end();
+        return;
+      }
+      if (!isTrustedUpdateRequest(request)) {
+        sendJson(response, 403, { ok: false, error: "\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u540C\u6E90\u8BF7\u6C42\u3002" });
+        return;
+      }
+      const body = await readJsonBody(request);
+      const path = typeof body?.path === "string" ? body.path : "";
+      const registry = ctx.get("workspaceRegistry");
+      const registeredPaths = typeof registry?.list === "function" ? registry.list().map((w) => w.path) : [];
+      const authorizedPath = authorizeExplorerPath(path, registeredPaths);
+      if (authorizedPath === void 0) {
+        sendJson(response, 403, { ok: false, error: "\u4EC5\u5141\u8BB8\u6253\u5F00\u5DF2\u6CE8\u518C\u7684\u5DE5\u4F5C\u533A\u76EE\u5F55\u3002" });
+        return;
+      }
+      try {
+        const result = await revealPathInSystem(authorizedPath);
+        sendJson(response, 200, { ok: true, opened: true, via: result.via });
+      } catch (error) {
+        ctx.logger?.warn?.(`open in explorer failed: ${String(error)}`);
+        sendJson(response, 500, { ok: false, error: "\u6253\u5F00\u7CFB\u7EDF\u8D44\u6E90\u7BA1\u7406\u5668\u5931\u8D25\u3002" });
+      }
+    }
+  });
   return () => {
     try {
       disposeSidebar();
@@ -101,6 +136,10 @@ function registerSettingsRoutes(ctx, hostUpdateDisabled) {
       disposeUpdate();
     } catch {
     }
+    try {
+      disposeOpenExplorer();
+    } catch {
+    }
   };
 }
 async function apply(ctx, config) {
@@ -142,6 +181,8 @@ async function apply(ctx, config) {
   };
 }
 export {
+  OPEN_IN_EXPLORER_ENDPOINT,
   apply,
-  inject
+  inject,
+  registerSettingsRoutes
 };

package/lib/native-explorer.js

@@ -0,0 +1,34 @@
+import { spawn } from "node:child_process";
+async function revealPathInSystem(targetPath, injectedModule, spawner) {
+  try {
+    const spec = "@deepseek-ai/dsh-native-command";
+    const mod = injectedModule ?? await import(spec).catch(() => ({}));
+    if (typeof mod.revealNativePath === "function") {
+      await mod.revealNativePath(targetPath);
+      return { ok: true, via: "native-command" };
+    }
+  } catch {
+  }
+  const spawnFn = spawner ?? ((file, args) => {
+    if (process.env.DSH_ARCHIVE_MANAGER_MOCK_EXPLORER === "1") {
+      return { unref() {
+      } };
+    }
+    return spawn(file, args, { detached: true, stdio: "ignore" });
+  });
+  const platform = process.platform;
+  if (platform === "win32") {
+    const cp = spawnFn("explorer.exe", [targetPath]);
+    cp.unref();
+  } else if (platform === "darwin") {
+    const cp = spawnFn("open", [targetPath]);
+    cp.unref();
+  } else {
+    const cp = spawnFn("xdg-open", [targetPath]);
+    cp.unref();
+  }
+  return { ok: true, via: "spawn" };
+}
+export {
+  revealPathInSystem
+};

package/lib/session-move.js

@@ -0,0 +1,346 @@
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import zlib from "node:zlib";
+const ZSTD_MAGIC = 4247762216;
+const CHECKSUM_OPTS = { params: { [zlib.constants.ZSTD_c_checksumFlag]: 1 } };
+function normalizePath(p) {
+  if (typeof p !== "string" || p.trim() === "") return void 0;
+  const norm = normalize(resolve(p)).replace(/[\\/]+$/, "");
+  return process.platform === "win32" ? norm.toLowerCase() : norm;
+}
+function rawWorkspaceSessionIds(ws) {
+  const raw = ws.record?.sessionIds;
+  return Array.isArray(raw) ? raw : Array.isArray(ws.sessionIds) ? ws.sessionIds : [];
+}
+function scanFirstZstdFrame(buf) {
+  if (buf.length < 4) throw new Error("\u4F1A\u8BDD\u5DE5\u4EF6\u6570\u636E\u8FC7\u77ED\uFF0C\u65E0\u6CD5\u8BFB\u53D6 zstd \u5934\u90E8");
+  if (buf.readUInt32LE(0) !== ZSTD_MAGIC) throw new Error("\u4F1A\u8BDD\u5DE5\u4EF6\u4E0D\u662F\u5408\u6CD5\u7684 zstd \u683C\u5F0F");
+  let offset = 4;
+  if (offset >= buf.length) throw new Error("\u4F1A\u8BDD\u5DE5\u4EF6 zstd \u5E27\u4E0D\u5B8C\u6574");
+  const descriptor = buf.readUInt8(offset++);
+  if ((descriptor & 24) !== 0) throw new Error("zstd \u5E27\u5305\u542B\u4FDD\u7559\u4F4D");
+  const contentSizeFlag = descriptor >>> 6;
+  const singleSegment = (descriptor & 32) !== 0;
+  const checksum = (descriptor & 4) !== 0;
+  const dictionaryFlag = descriptor & 3;
+  const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+  const contentSizeBytes = contentSizeFlag === 0 ? singleSegment ? 1 : 0 : 1 << contentSizeFlag;
+  const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+  if (buf.length - offset < remainingHeaderBytes) throw new Error("zstd \u5934\u90E8\u88AB\u622A\u65AD");
+  offset += remainingHeaderBytes;
+  for (; ; ) {
+    if (buf.length - offset < 3) throw new Error("zstd \u5757\u7ED3\u6784\u622A\u65AD");
+    const blockHeader = buf.readUIntLE(offset, 3);
+    offset += 3;
+    const lastBlock = (blockHeader & 1) !== 0;
+    const blockType = blockHeader >>> 1 & 3;
+    const blockSize = blockHeader >>> 3;
+    if (blockType === 3) throw new Error("zstd \u5305\u542B\u672A\u77E5\u4FDD\u7559\u5757\u7C7B\u578B");
+    const payloadBytes = blockType === 1 ? 1 : blockSize;
+    if (buf.length - offset < payloadBytes) throw new Error("zstd \u5757\u8D1F\u8F7D\u88AB\u622A\u65AD");
+    offset += payloadBytes;
+    if (lastBlock) break;
+  }
+  if (checksum) {
+    if (buf.length - offset < 4) throw new Error("zstd \u6821\u9A8C\u548C\u88AB\u622A\u65AD");
+    offset += 4;
+  }
+  return { start: 0, end: offset };
+}
+function rewriteSessionArtifactCwd(sourceBuffer, targetCwd, isZstd) {
+  if (isZstd) {
+    const frame0Boundary = scanFirstZstdFrame(sourceBuffer);
+    const frame0Bytes = sourceBuffer.subarray(0, frame0Boundary.end);
+    const decompressedHeader = zlib.zstdDecompressSync(frame0Bytes).toString("utf8");
+    const nlIndex = decompressedHeader.indexOf("\n");
+    const headerLine = nlIndex >= 0 ? decompressedHeader.slice(0, nlIndex) : decompressedHeader;
+    const headerObj = JSON.parse(headerLine);
+    headerObj.cwd = targetCwd;
+    const newFrame0 = zlib.zstdCompressSync(Buffer.from(JSON.stringify(headerObj) + "\n", "utf8"), CHECKSUM_OPTS);
+    const rest = sourceBuffer.subarray(frame0Boundary.end);
+    return Buffer.concat([newFrame0, rest]);
+  } else {
+    const text = sourceBuffer.toString("utf8");
+    const nlIndex = text.indexOf("\n");
+    const headerLine = nlIndex >= 0 ? text.slice(0, nlIndex) : text;
+    const headerObj = JSON.parse(headerLine);
+    headerObj.cwd = targetCwd;
+    const rest = nlIndex >= 0 ? text.slice(nlIndex + 1) : "";
+    return Buffer.from(JSON.stringify(headerObj) + "\n" + rest, "utf8");
+  }
+}
+async function moveSessionToWorkspace(ctx, sessionId, targetWorkspaceId) {
+  if (typeof sessionId !== "string" || sessionId.trim() === "") {
+    throw new TypeError("sessionId \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  if (typeof targetWorkspaceId !== "string" || targetWorkspaceId.trim() === "") {
+    throw new TypeError("targetWorkspaceId \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  const cleanSessionId = sessionId.trim();
+  const cleanTargetWsId = targetWorkspaceId.trim();
+  const registry = ctx.workspaceRegistry;
+  if (!registry || typeof registry.list !== "function") {
+    throw new Error("\u5DE5\u4F5C\u533A\u6CE8\u518C\u8868\u670D\u52A1\u4E0D\u53EF\u7528");
+  }
+  const targetWorkspace = registry.list().find((w) => w.id === cleanTargetWsId || w.workspaceId === cleanTargetWsId || w.path === cleanTargetWsId);
+  if (!targetWorkspace) {
+    throw new Error(`\u76EE\u6807\u5DE5\u4F5C\u533A\u4E0D\u5B58\u5728: ${cleanTargetWsId}`);
+  }
+  const targetPath = targetWorkspace.path ?? targetWorkspace.record?.path;
+  const liveSession = ctx.sessions?.get?.(cleanSessionId);
+  const agent = ctx.agents?.get?.(cleanSessionId);
+  const isExecuting = liveSession?.running === true || liveSession?.status === "running" || liveSession?.status === "ongoing" || agent?.busy === true || agent?.status === "running";
+  if (isExecuting) {
+    throw new Error("\u8BE5\u4F1A\u8BDD\u6B63\u5904\u4E8E\u6267\u884C\u6216\u8FD0\u884C\u72B6\u6001\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210\u540E\u518D\u79FB\u52A8\u3002");
+  }
+  let originalEntry;
+  if (liveSession !== void 0) {
+    if (typeof agent?.cancel === "function") {
+      try {
+        agent.cancel({ kind: "disposed" });
+        await agent.whenIdle?.();
+      } catch {
+      }
+    }
+    if (typeof ctx.sessions?.flush === "function") {
+      try {
+        await ctx.sessions.flush(liveSession);
+      } catch {
+      }
+    }
+    try {
+      await agent?.scope?.dispose?.();
+      ctx.agents?.store?.delete(cleanSessionId);
+    } catch {
+    }
+    originalEntry = ctx.sessions?.store?.get?.(cleanSessionId) ?? (typeof ctx.sessions?.liveEntryFor === "function" ? (() => {
+      try {
+        return ctx.sessions.liveEntryFor(liveSession);
+      } catch {
+        return void 0;
+      }
+    })() : void 0);
+    if (typeof originalEntry?.detach === "function") {
+      try {
+        originalEntry.detach();
+      } catch {
+      }
+    }
+  }
+  const persistence = ctx.sessionPersistence;
+  let header;
+  if (typeof registry.readSessionHeader === "function") {
+    header = await registry.readSessionHeader(cleanSessionId);
+  }
+  if (!header && persistence && typeof persistence.stat === "function") {
+    header = (await persistence.stat(cleanSessionId))?.header;
+  }
+  if (!header && persistence && typeof persistence.open === "function") {
+    try {
+      const readHandle = await persistence.open(cleanSessionId, "read");
+      header = readHandle.header;
+      await readHandle.close();
+    } catch {
+    }
+  }
+  if (!header) {
+    throw new Error(`\u65E0\u6CD5\u83B7\u53D6\u4F1A\u8BDD ${cleanSessionId} \u7684\u5143\u6570\u636E\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5\u3002`);
+  }
+  if (header.origin === "subagent") {
+    throw new Error("\u5B50\u4EE3\u7406\uFF08subagent\uFF09\u4F1A\u8BDD\u4E0D\u652F\u6301\u8DE8\u5DE5\u4F5C\u533A\u79FB\u52A8\u3002");
+  }
+  const currentNormalizedCwd = normalizePath(header.cwd);
+  const targetNormalizedCwd = normalizePath(targetPath);
+  const targetNorm = normalizePath(targetWorkspace.path);
+  const sourceWorkspaces = registry.list().filter((ws) => {
+    const wsNorm = normalizePath(ws.path);
+    const isOther = ws.id && targetWorkspace.id ? ws.id !== targetWorkspace.id : wsNorm !== targetNorm;
+    return isOther && rawWorkspaceSessionIds(ws).includes(cleanSessionId);
+  });
+  if (currentNormalizedCwd && targetNormalizedCwd && currentNormalizedCwd === targetNormalizedCwd) {
+    for (const ws of sourceWorkspaces) {
+      await ws.detachSession(cleanSessionId);
+    }
+    await targetWorkspace.attachSession(cleanSessionId);
+    registry.sessionPaths?.set(cleanSessionId, targetPath);
+    if (ctx.sessionProjectionCache && typeof ctx.sessionProjectionCache.coldSnapshot === "function") {
+      try {
+        if (ctx.sessionProjectionCache.coldSnapshot.length === 1) {
+          await ctx.sessionProjectionCache.coldSnapshot(cleanSessionId);
+        } else if (persistence && typeof persistence.open === "function") {
+          const readHandle = await persistence.open(cleanSessionId, "read");
+          try {
+            const { events } = typeof readHandle.read === "function" ? await readHandle.read(0) : { events: [] };
+            const coldMeta = readHandle.header ?? header;
+            const inherited = readHandle.inheritedEventCount ?? 0;
+            await ctx.sessionProjectionCache.coldSnapshot(
+              coldMeta,
+              inherited,
+              events ?? []
+            );
+          } finally {
+            await readHandle.close();
+          }
+        }
+      } catch (err) {
+        ctx.logger?.warn?.(`archive-manager: post-move coldSnapshot failed: ${String(err)}`);
+      }
+    }
+    return {
+      ok: true,
+      moved: true,
+      alreadyCwd: true,
+      sessionId: cleanSessionId,
+      toWorkspaceId: cleanTargetWsId,
+      toWorkspaceTitle: targetWorkspace.title || cleanTargetWsId,
+      toWorkspacePath: targetPath
+    };
+  }
+  if (!persistence || typeof persistence.locate !== "function") {
+    throw new Error("\u5F53\u524D\u6301\u4E45\u5316\u540E\u7AEF\u4E0D\u652F\u6301\u7269\u7406\u5B9A\u4F4D\uFF0C\u65E0\u6CD5\u8DE8\u5DE5\u4F5C\u533A\u79FB\u52A8\u4F1A\u8BDD\u3002");
+  }
+  const sourceLoc = persistence.locate({ id: cleanSessionId, cwd: header.cwd });
+  const targetLoc = persistence.locate({ id: cleanSessionId, cwd: targetPath });
+  if (!sourceLoc || !targetLoc || !sourceLoc.path || !targetLoc.path) {
+    throw new Error("\u6301\u4E45\u5316\u540E\u7AEF\u65E0\u6CD5\u5B9A\u4F4D\u4F1A\u8BDD\u5DE5\u4EF6\u8DEF\u5F84\u3002");
+  }
+  const sourceLogPath = sourceLoc.path;
+  const targetLogPath = targetLoc.path;
+  const sourceSessionDir = dirname(sourceLogPath);
+  const targetSessionDir = dirname(targetLogPath);
+  let targetOccupied = false;
+  try {
+    await stat(targetLogPath);
+    targetOccupied = true;
+  } catch {
+  }
+  if (targetOccupied) {
+    throw new Error(`\u76EE\u6807\u5DE5\u4F5C\u533A\u5DF2\u5B58\u5728\u540C\u540D\u4F1A\u8BDD\u5DE5\u4EF6\uFF0C\u62D2\u7EDD\u8986\u76D6: ${targetLogPath}`);
+  }
+  const persistenceRoot = persistence.root ?? persistence.config?.root;
+  const backupRoot = persistenceRoot ? join(dirname(resolve(persistenceRoot)), "dsham-move-backup") : join(dirname(sourceSessionDir), ".dsham-move-backup");
+  await mkdir(backupRoot, { recursive: true });
+  const safeSessionName = encodeURIComponent(cleanSessionId).replace(/%/g, "~");
+  const backupDir = join(backupRoot, `${safeSessionName}-${process.pid}-${Date.now()}`);
+  const isZstd = sourceLogPath.endsWith(".zstd");
+  const sourceBytes = await readFile(sourceLogPath);
+  const newBytes = rewriteSessionArtifactCwd(sourceBytes, targetPath, isZstd);
+  if (isZstd) {
+    const f0 = zlib.zstdDecompressSync(newBytes);
+    const f0Obj = JSON.parse(f0.toString("utf8").split("\n")[0]);
+    if (f0Obj.id !== cleanSessionId || f0Obj.cwd !== targetPath) {
+      throw new Error("\u8FC1\u79FB\u524D\u6821\u9A8C\u5931\u8D25\uFF1A\u6570\u636E\u6539\u5199\u9A8C\u8BC1\u672A\u901A\u8FC7\u3002");
+    }
+  }
+  const detachedWorkspaces = [];
+  let targetAttached = false;
+  let stageFile = null;
+  let sourceDirMoved = false;
+  try {
+    await rename(sourceSessionDir, backupDir);
+    sourceDirMoved = true;
+    await mkdir(targetSessionDir, { recursive: true });
+    stageFile = join(targetSessionDir, `.stage-${process.pid}-${Date.now()}`);
+    await writeFile(stageFile, newBytes);
+    await rename(stageFile, targetLogPath);
+    stageFile = null;
+    const readbackBytes = await readFile(targetLogPath);
+    if (readbackBytes.length === 0) throw new Error("\u76EE\u6807\u5199\u5165\u5DE5\u4EF6\u4E3A\u7A7A");
+    const targetHeader = { ...header, cwd: targetPath };
+    registry.sessionPaths?.set(cleanSessionId, targetPath);
+    registry.headers?.set(cleanSessionId, targetHeader);
+    registry.invalidSessionPaths?.delete(cleanSessionId);
+    if (liveSession !== void 0) {
+      try {
+        if ("header" in liveSession && liveSession.header) {
+          liveSession.header.cwd = targetPath;
+        }
+        if ("cwd" in liveSession) {
+          liveSession.cwd = targetPath;
+        }
+      } catch {
+      }
+    }
+    for (const ws of sourceWorkspaces) {
+      await ws.detachSession(cleanSessionId);
+      detachedWorkspaces.push(ws);
+    }
+    await targetWorkspace.attachSession(cleanSessionId);
+    targetAttached = true;
+    if (ctx.sessionProjectionCache && typeof ctx.sessionProjectionCache.coldSnapshot === "function") {
+      try {
+        if (ctx.sessionProjectionCache.coldSnapshot.length === 1) {
+          await ctx.sessionProjectionCache.coldSnapshot(cleanSessionId);
+        } else if (persistence && typeof persistence.open === "function") {
+          const readHandle = await persistence.open(cleanSessionId, "read");
+          try {
+            const { events } = typeof readHandle.read === "function" ? await readHandle.read(0) : { events: [] };
+            const coldMeta = readHandle.header ?? targetHeader;
+            const inherited = readHandle.inheritedEventCount ?? 0;
+            await ctx.sessionProjectionCache.coldSnapshot(
+              coldMeta,
+              inherited,
+              events ?? []
+            );
+          } finally {
+            await readHandle.close();
+          }
+        }
+      } catch (err) {
+        ctx.logger?.warn?.(`archive-manager: post-move coldSnapshot failed: ${String(err)}`);
+      }
+    }
+  } catch (error) {
+    if (header) {
+      registry.headers?.set(cleanSessionId, header);
+      if (header.cwd) registry.sessionPaths?.set(cleanSessionId, header.cwd);
+    }
+    if (liveSession !== void 0 && header) {
+      try {
+        if ("header" in liveSession && liveSession.header) {
+          liveSession.header.cwd = header.cwd;
+        }
+        if ("cwd" in liveSession && header.cwd) {
+          liveSession.cwd = header.cwd;
+        }
+      } catch {
+      }
+    }
+    if (stageFile) await rm(stageFile, { force: true }).catch(() => {
+    });
+    await rm(targetSessionDir, { recursive: true, force: true }).catch(() => {
+    });
+    if (sourceDirMoved) {
+      try {
+        await mkdir(dirname(sourceSessionDir), { recursive: true });
+        await rename(backupDir, sourceSessionDir);
+      } catch (restoreErr) {
+        throw new AggregateError([error, restoreErr], `\u79FB\u52A8\u5931\u8D25\u4E14\u539F\u5DE5\u4EF6\u56DE\u6EDA\u5F02\u5E38\uFF0C\u5907\u4EFD\u6682\u5B58\u4E8E: ${backupDir}`);
+      }
+    }
+    if (targetAttached) {
+      await targetWorkspace.detachSession(cleanSessionId).catch(() => {
+      });
+    }
+    for (const ws of detachedWorkspaces) {
+      await ws.attachSession(cleanSessionId).catch(() => {
+      });
+    }
+    throw error;
+  }
+  await rm(backupDir, { recursive: true, force: true }).catch(() => {
+  });
+  return {
+    ok: true,
+    moved: true,
+    alreadyCwd: false,
+    sessionId: cleanSessionId,
+    toWorkspaceId: cleanTargetWsId,
+    toWorkspaceTitle: targetWorkspace.title || cleanTargetWsId,
+    toWorkspacePath: targetPath
+  };
+}
+export {
+  moveSessionToWorkspace,
+  rewriteSessionArtifactCwd
+};

package/lib/workspace.js

@@ -10,6 +10,7 @@ import { bindTypertRemote, Remote } from "@deepseek-ai/dsh-typert-protocol";
 import { sessionDir } from "@deepseek-ai/dsh-spill-local";
 import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
 import { favoriteInputSchema, favoriteStateSchema, favoriteInvocations } from "./archive-organizer.js";
+import { moveSessionToWorkspace } from "./session-move.js";
 const favoriteDomainSpec = defineDomain({
   name: "archive_manager_favorites",
   version: 1,
@@ -105,7 +106,8 @@ const ARCHIVE_REMOTE_METHODS = [
   "diagnoseOrphanSubagents",
   "diagnoseSessionCaches",
   "rebuildSessionCaches",
-  "cleanOrphanSubagents"
+  "cleanOrphanSubagents",
+  "moveSessionToWorkspace"
 ];
 function markRemoteMethod(instance, method) {
   const context = {
@@ -212,6 +214,22 @@ const orphanCleanResultSchema = {
     return val;
   }
 };
+const sessionMoveInputSchema = {
+  parse(value) {
+    const val = record(value);
+    if (!val || typeof val.sessionId !== "string" || !val.sessionId || typeof val.targetWorkspaceId !== "string" || !val.targetWorkspaceId) {
+      throw new TypeError("sessionId and targetWorkspaceId must be non-empty strings");
+    }
+    return { sessionId: val.sessionId, targetWorkspaceId: val.targetWorkspaceId };
+  }
+};
+const sessionMoveResultSchema = {
+  parse(value) {
+    const val = record(value);
+    if (!val || val.ok !== true) throw new TypeError("session move result must be ok: true");
+    return val;
+  }
+};
 const ARCHIVE_MANAGER_INVOCATIONS = [
   ...cacheRebuildInvocations(),
   ...favoriteInvocations(),
@@ -338,6 +356,27 @@ const ARCHIVE_MANAGER_INVOCATIONS = [
       line: 1,
       column: 1
     }
+  },
+  {
+    id: "@michengai/dsh-archive-manager#workspaceRegistry/moveSessionToWorkspace",
+    service: "workspaceRegistry",
+    namespace: "workspaceRegistry",
+    method: "moveSessionToWorkspace",
+    invocation: { kind: "direct" },
+    parameters: [
+      {
+        name: "input",
+        wire: "input",
+        source: "json",
+        codec: strictCodec("@michengai/dsh-archive-manager/types#SessionMoveInput", sessionMoveInputSchema)
+      }
+    ],
+    result: strictCodec("@michengai/dsh-archive-manager/types#SessionMoveResult", sessionMoveResultSchema),
+    sourceLocation: {
+      file: "@michengai/dsh-archive-manager/lib/workspace.js",
+      line: 1,
+      column: 1
+    }
   }
 ];
 const ARCHIVE_MANAGER_TYPERT = {
@@ -1055,6 +1094,26 @@ var ArchiveWorkspaceRegistry = class extends WorkspaceRegistry {
       return { cleanedSessionIds, skippedSessionIds, failures };
     });
   }
+  /**
+   * 安全跨工作区会话移动：支持未分组归并及带备份的跨目录物理迁移。
+   */
+  async moveSessionToWorkspace(input) {
+    const { sessionId, targetWorkspaceId } = sessionMoveInputSchema.parse(input);
+    return this.enqueueOperation(async () => {
+      return moveSessionToWorkspace(
+        {
+          workspaceRegistry: this,
+          sessionPersistence: this.ctx.get("sessionPersistence"),
+          sessionProjectionCache: this.ctx.get("sessionProjectionCache"),
+          sessions: this.ctx.get("sessions"),
+          agents: this.ctx.get("agents"),
+          logger: this.ctx.logger
+        },
+        sessionId,
+        targetWorkspaceId
+      );
+    });
+  }
 };
 const workspaceOverlay = Symbol.for("dsh-archive-manager.workspace-overlay");
 const remoteMethodDescriptor = "@deepseek-ai/dsh-typert-protocol/remote-methods";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michengai/dsh-archive-manager",
-  "version": "1.1.13",
+  "version": "1.1.16",
   "description": "归档、恢复、收藏和永久删除会话，并诊断损坏的会话日志。 · Archive, restore, favorite, and permanently delete sessions, and diagnose damaged session logs.",
   "type": "module",
   "packageManager": "pnpm@11.22.0",