@reed-io/dsh-workspace-move 0.0.0-stage → 0.1.0

package/lib/registry-ops.js

@@ -0,0 +1,177 @@
+/**
+ * Registry-level primitives shared by plan, execute and undo: entity snapshots,
+ * session-header index updates, and the two structural writes the public
+ * registry API cannot express (retargeting one workspace's path, merging a
+ * moved session group back into its old registration).
+ *
+ * These helpers operate on the registry's own serialized operation queue so they
+ * never interleave with a concurrent create/delete/attach from other plugins.
+ * @module @reed-io/dsh-workspace-move
+ */
+import { samePath } from "./fsx.js";
+
+/**
+ * Serialize one operation behind the registry's own write queue.
+ * @param registry - workspace registry service.
+ * @param operation - work to run inside the queue.
+ * @returns the operation result.
+ */
+/**
+ * Reach the registry's durable record table.
+ * @param registry - workspace registry service.
+ * @returns the storage-domain table, or undefined when the registry is not ready.
+ */
+export function tableOf(registry) {
+  const table = registry?.table;
+  return typeof table === "function" ? table.call(registry) : table;
+}
+
+export function enqueue(registry, operation) {
+  if (typeof registry.enqueueOperation === "function") return registry.enqueueOperation(operation);
+  return operation();
+}
+
+/**
+ * Read one workspace's stored record without touching live entity state.
+ * @param registry - workspace registry service.
+ * @param id - workspace id.
+ * @returns the stored record, or undefined.
+ */
+export function recordOf(registry, id) {
+  const table = tableOf(registry);
+  return table?.get(id);
+}
+
+/**
+ * Snapshot one workspace registration for rollback and review.
+ * @param registry - workspace registry service.
+ * @param id - workspace id.
+ * @returns a plain snapshot.
+ */
+export function snapshotWorkspace(registry, id) {
+  const record = recordOf(registry, id);
+  if (record === undefined) return undefined;
+  return {
+    id,
+    path: record.path,
+    title: record.title,
+    sessionIds: [...record.sessionIds],
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+}
+
+/**
+ * Every session id the registry knows about, live or stored.
+ * @param registry - workspace registry service.
+ * @returns session ids.
+ */
+export function knownSessionIds(registry) {
+  return [...(registry.headers?.keys() ?? [])];
+}
+
+/**
+ * Make the live header index agree with a session whose header now carries `cwd`.
+ * @param registry - workspace registry service.
+ * @param id - session id.
+ * @param cwd - the working directory the stored header now records.
+ * @returns nothing.
+ */
+export function indexSessionAt(registry, id, cwd) {
+  const headers = registry.headers;
+  if (headers !== undefined) {
+    const current = headers.get(id);
+    if (current !== undefined) headers.set(id, { ...current, cwd });
+  }
+  registry.sessionPaths?.set(id, cwd);
+  registry.missingSessionPaths?.delete(id);
+  registry.invalidSessionPaths?.delete(id);
+}
+
+/**
+ * Drop one session from the live header index, mirroring an unmounted session.
+ * @param registry - workspace registry service.
+ * @param id - session id.
+ * @returns nothing.
+ */
+export function forgetSession(registry, id) {
+  registry.headers?.delete(id);
+  registry.sessionPaths?.delete(id);
+  registry.missingSessionPaths?.delete(id);
+  registry.invalidSessionPaths?.delete(id);
+}
+
+/**
+ * Retarget one existing registration to a new directory without recreating it:
+ * the record keeps its id, title, creation stamp and session order, and the
+ * entity cache is rebuilt in the registry's durable order.
+ * @param registry - workspace registry service.
+ * @param id - workspace id.
+ * @param path - canonical new path.
+ * @param options - pass `{ rebuild: false }` to skip the entity rebuild.
+ * @returns nothing.
+ */
+export async function retargetWorkspace(registry, id, path, options = {}) {
+  const write = async () => {
+    const record = recordOf(registry, id);
+    if (record === undefined) throw new Error(`workspace '${id}' is no longer registered`);
+    if (record.path !== path) {
+      await tableOf(registry).update(id, (current) => ({ ...current, path, updatedAt: new Date().toISOString() }));
+    }
+    for (const sessionId of record.sessionIds) indexSessionAt(registry, sessionId, path);
+    if (options.rebuild !== false) registry.rebuildEntities?.();
+  };
+  return write();
+}
+
+/**
+ * Detach one session from every other registration that still claims it.
+ * @param registry - workspace registry service.
+ * @param sessionId - session id.
+ * @param keepId - the registration that should keep it.
+ * @returns nothing.
+ */
+export async function detachFromOthers(registry, sessionId, keepId) {
+  for (const entity of registry.list()) {
+    if (entity.id === keepId) continue;
+    const ids = recordOf(registry, entity.id)?.sessionIds ?? [];
+    if (!ids.includes(sessionId)) continue;
+    await entity.detachSession(sessionId).catch(() => {});
+  }
+}
+
+/**
+ * Attach sessions to one registration, preserving their relative order.
+ * @param registry - workspace registry service.
+ * @param entity - target workspace entity.
+ * @param sessionIds - desired session order.
+ * @returns nothing.
+ */
+export async function attachOrdered(registry, entity, sessionIds) {
+  const existing = recordOf(registry, entity.id)?.sessionIds ?? [];
+  const missing = sessionIds.filter((id) => !existing.includes(id));
+  for (const sessionId of missing) await detachFromOthers(registry, sessionId, entity.id);
+  for (const sessionId of [...missing].reverse()) await entity.attachSession(sessionId);
+  const order = recordOf(registry, entity.id)?.sessionIds ?? [];
+  let previous;
+  for (const sessionId of order) {
+    if (!sessionIds.includes(sessionId)) continue;
+    if (previous !== undefined) await entity.insertSessionBefore(sessionId, previous);
+    previous = sessionId;
+  }
+}
+
+/**
+ * Report the workspace whose registration already owns a path, if any.
+ * @param registry - workspace registry service.
+ * @param path - canonical path.
+ * @param exceptId - registration to ignore.
+ * @returns the owning workspace id, or undefined.
+ */
+export function ownerOfPath(registry, path, exceptId) {
+  for (const entity of registry.list()) {
+    if (entity.id === exceptId) continue;
+    if (samePath(entity.path, path)) return entity.id;
+  }
+  return undefined;
+}

package/lib/sessions.js

@@ -0,0 +1,266 @@
+/**
+ * Per-session work of a move: locate a session's artifact, take it down before
+ * the workspace folder travels, and write it back at the path its new working
+ * directory implies.
+ *
+ * Taking every session down first is what makes a half-moved session impossible
+ * to observe: no live handle points at a folder that is being renamed, and no
+ * index entry can claim a path that has not been written yet.
+ * @module @reed-io/dsh-workspace-move
+ */
+import { copyFile, mkdir, readdir, rename, rm } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { copyArtifactWithCwd, isZstdFramed, readArtifactHeader, scanFrames, transcodeArtifactWithCwd } from "./artifact.js";
+import { exists } from "./fsx.js";
+import { logPath, projectDir, sessionDir } from "./paths.js";
+
+/**
+ * Resolve the persistence root and compression the backend uses.
+ * @param persistence - session persistence service.
+ * @returns the root directory and the raw compression setting.
+ */
+export function persistenceInfo(persistence) {
+  const root = persistence.root ?? persistence.config?.root;
+  if (typeof root !== "string" || root === "") throw new Error("session persistence root is unknown");
+  const raw = persistence.compression ?? persistence.config?.compression ?? "zstd";
+  return { root, compression: raw === "none" || raw === undefined ? "none" : "zstd" };
+}
+
+/**
+ * Compare two paths the way the running platform does.
+ * @param value - path to normalize.
+ * @returns a comparison key.
+ */
+function comparisonKey(value) {
+  const text = value.replace(/[\\/]+$/u, "");
+  return process.platform === "win32" ? text.toLowerCase() : text;
+}
+
+/**
+ * Whether one path is the parent itself or lives underneath it.
+ * @param child - candidate path.
+ * @param parent - containing path.
+ * @returns true when child is inside parent.
+ */
+export function isWithin(child, parent) {
+  const inner = comparisonKey(child);
+  const outer = comparisonKey(parent);
+  if (inner === outer) return true;
+  if (inner.startsWith(`${outer}\\`)) return true;
+  return inner.startsWith(`${outer}/`);
+}
+
+/**
+ * Locate one stored session: its artifact, the folder holding it, and its header.
+ * @param ctx - Host context.
+ * @param id - session id.
+ * @returns the location, or undefined when the session is not stored.
+ */
+export async function locateSession(ctx, id) {
+  const persistence = ctx.sessionPersistence;
+  if (persistence === undefined) return undefined;
+  const { root, compression } = persistenceInfo(persistence);
+  const snapshot = await persistence.stat(id).catch(() => undefined);
+  if (snapshot === undefined || snapshot.location === undefined) return undefined;
+  const header = snapshot.header;
+  const path = typeof snapshot.location.path === "string" ? snapshot.location.path : logPath(root, header.cwd, id, header.version ?? 4, compression);
+  if (!isWithin(path, root)) return undefined;
+  return { id, path, dir: dirname(path), header, root, compression };
+}
+
+/**
+ * Collect the sessions one move carries: the ones the workspace lists, plus any
+ * stored session whose header records a working directory inside the folder.
+ * @param ctx - Host context.
+ * @param workspace - the registry record being moved.
+ * @returns located sessions, listed ones first.
+ */
+export async function collectSessions(ctx, workspace) {
+  const located = [];
+  const seen = new Set();
+  for (const id of workspace.sessionIds) {
+    const found = await locateSession(ctx, id).catch(() => undefined);
+    if (found === undefined) continue;
+    located.push({ ...found, listed: true });
+    seen.add(id);
+  }
+  const persistence = ctx.sessionPersistence;
+  if (persistence !== undefined) {
+    const { root, compression } = persistenceInfo(persistence);
+    const snapshots = await persistence.list().catch(() => []);
+    for (const snapshot of snapshots) {
+      const header = snapshot.header;
+      const id = header?.id;
+      const cwd = header?.cwd;
+      if (typeof id !== "string" || typeof cwd !== "string" || seen.has(id)) continue;
+      if (!isWithin(cwd, workspace.path)) continue;
+      const path = logPath(root, cwd, id, header.version ?? 4, compression);
+      located.push({ id, path, dir: dirname(path), header, root, compression, listed: false });
+      seen.add(id);
+    }
+  }
+  return located;
+}
+
+/**
+ * Take one session down for the duration of the folder move: its folder is
+ * renamed into the plugin's backup area, so nothing can read a half-written log.
+ * @param backupRoot - plugin-owned backup directory.
+ * @param tag - unique label for this move.
+ * @param entry - located session.
+ * @returns where the archived folder now lives.
+ */
+export async function takeDownSession(backupRoot, tag, entry) {
+  const target = join(backupRoot, tag, basename(entry.dir));
+  await mkdir(dirname(target), { recursive: true });
+  await rename(entry.dir, target);
+  return target;
+}
+
+/**
+ * Delete the backup area of one move.
+ * @param backupRoot - plugin-owned backup directory.
+ * @param tag - unique label for this move.
+ * @returns nothing.
+ */
+export async function dropBackup(backupRoot, tag) {
+  await rm(join(backupRoot, tag), { recursive: true, force: true }).catch(() => {});
+}
+
+/**
+ * Find the log inside one archived session folder.
+ * @param folder - archived session folder.
+ * @returns the log path and the log filename.
+ */
+async function logIn(folder) {
+  const entries = await readdir(folder, { withFileTypes: true });
+  const log = entries.find((entry) => entry.isFile() && entry.name.startsWith("session.") && entry.name.includes(".jsonl"));
+  if (log === undefined) throw new Error(`archived session '${folder}' holds no log`);
+  return { path: join(folder, log.name), name: log.name };
+}
+
+/**
+ * Write one taken-down session at the path its new working directory implies,
+ * keeping every payload byte, then move any companion files next to it.
+ * @param entry - located session (original location).
+ * @param archived - archived session folder.
+ * @param cwd - the new working directory.
+ * @returns the log path at the new location.
+ */
+export async function writeBackSession(entry, archived, cwd) {
+  const log = await logIn(archived);
+  const targetDir = sessionDir(entry.root, cwd, entry.id);
+  await mkdir(targetDir, { recursive: true });
+  const target = join(targetDir, log.name);
+  await rm(target, { force: true }).catch(() => {});
+  await copyArtifactWithCwd(log.path, target, cwd, entry.id);
+  const companions = await readdir(archived, { withFileTypes: true });
+  for (const companion of companions) {
+    if (companion.name === log.name) continue;
+    const from = join(archived, companion.name);
+    const to = join(targetDir, companion.name);
+    await rm(to, { recursive: true, force: true }).catch(() => {});
+    await renameOrCopy(from, to);
+  }
+  const header = await readArtifactHeader(target);
+  if (header.cwd !== cwd) throw new Error(`session '${entry.id}' did not adopt cwd '${cwd}'`);
+  return target;
+}
+
+/**
+ * Rename a companion file or folder, falling back to a copy across devices.
+ * @param from - source path.
+ * @param to - destination path.
+ * @returns nothing.
+ */
+async function renameOrCopy(from, to) {
+  try {
+    await rename(from, to);
+  } catch (error) {
+    if (error?.code !== "EXDEV") throw error;
+    await mkdir(dirname(to), { recursive: true });
+    await moveAcrossDevices(from, to);
+  }
+}
+
+/**
+ * Copy one path tree across devices and drop the source.
+ * @param from - source path.
+ * @param to - destination path.
+ * @returns nothing.
+ */
+async function moveAcrossDevices(from, to) {
+  const stat = await (await import("node:fs/promises")).stat(from);
+  if (!stat.isDirectory()) {
+    await copyFile(from, to);
+    await rm(from, { force: true });
+    return;
+  }
+  await mkdir(to, { recursive: true });
+  for (const child of await readdir(from)) await moveAcrossDevices(join(from, child), join(to, child));
+  await rm(from, { recursive: true, force: true });
+}
+
+/**
+ * Put one session back exactly where it was, with its original working directory.
+ * Accepts both the original folder and the backup copy as the source.
+ * @param entry - located session describing the original location.
+ * @param cwd - the working directory to record in the header.
+ * @param fallbackFolder - backup folder holding the intact original, if any.
+ * @returns nothing.
+ */
+export async function restoreSession(entry, cwd, fallbackFolder) {
+  const usable = fallbackFolder !== undefined && (await exists(fallbackFolder)) && (await logIn(fallbackFolder).then(() => true).catch(() => false));
+  if (!usable) fallbackFolder = undefined;
+  if (fallbackFolder !== undefined) {
+    await rm(entry.dir, { recursive: true, force: true }).catch(() => {});
+    await mkdir(dirname(entry.dir), { recursive: true });
+    await renameOrCopy(fallbackFolder, entry.dir);
+  }
+  const log = await logIn(entry.dir);
+  await normalizeLog(log.path, cwd, entry.id);
+  return;
+}
+
+/**
+ * Rewrite one log's header in place, re-encoding every frame only when the log
+ * cannot be copied verbatim.
+ * @param path - log path.
+ * @param cwd - working directory to record.
+ * @param id - expected session id.
+ * @returns nothing.
+ */
+async function normalizeLog(path, cwd, id) {
+  const header = await readArtifactHeader(path);
+  if (header.cwd === cwd) return;
+  const bytes = await (await import("node:fs/promises")).readFile(path);
+  const frames = isZstdFramed(bytes) ? scanFrames(bytes).frames.length : 1;
+  const stage = join(dirname(path), `.dshwm-transcode-${process.pid}-${Date.now()}`);
+  if (frames <= 2) {
+    await copyArtifactWithCwd(path, stage, cwd, id);
+  } else {
+    await transcodeArtifactWithCwd(path, stage, cwd, id);
+  }
+  await rm(path, { force: true });
+  await rename(stage, path);
+}
+
+/**
+ * Every stored session folder whose working directory lives under one path.
+ * @param ctx - Host context.
+ * @param path - the folder about to move.
+ * @returns located sessions.
+ */
+export async function sessionsUnder(ctx, path) {
+  const persistence = ctx.sessionPersistence;
+  if (persistence === undefined) return [];
+  const snapshots = await persistence.list().catch(() => []);
+  const { root, compression } = persistenceInfo(persistence);
+  const found = [];
+  for (const snapshot of snapshots) {
+    const header = snapshot.header;
+    if (typeof header?.cwd !== "string" || !isWithin(header.cwd, path)) continue;
+    found.push({ id: header.id, header, cwd: header.cwd, root, compression, project: projectDir(root, header.cwd) });
+  }
+  return found;
+}

package/locale/en.json

@@ -0,0 +1,44 @@
+{
+  "meta": {
+    "meta": {
+      "title": "Workspace Move",
+      "description": "Move a workspace directory — its subfolders, nested workspaces and sessions — to a new location, with rename, rollback and undo."
+    }
+  },
+  "meta.title": "Workspace Move",
+  "meta.description": "Move a workspace directory — its subfolders, nested workspaces and sessions — to a new location, with rename, rollback and undo.",
+  "menu.move": "Move workspace…",
+  "menu.undo": "Undo last move",
+  "dialog.title": "Move workspace",
+  "dialog.source": "Current location",
+  "dialog.target": "Destination parent folder",
+  "dialog.folderName": "Folder name",
+  "dialog.folderHint": "The workspace lands in the chosen folder under this name. Changing the name renames the workspace.",
+  "dialog.destination": "New location",
+  "dialog.up": "Up",
+  "dialog.home": "Home",
+  "dialog.newFolder": "New folder",
+  "dialog.newFolderPrompt": "New folder name",
+  "dialog.pickHere": "Use this folder",
+  "dialog.confirm": "Move",
+  "dialog.cancel": "Cancel",
+  "dialog.moving": "Moving…",
+  "dialog.loading": "Loading…",
+  "dialog.emptyFolder": "No subfolders here",
+  "dialog.invalidName": "Enter a folder name without slashes.",
+  "dialog.targetExists": "That name already exists there and is not empty. Pick another name.",
+  "dialog.sameLocation": "The workspace is already there. Pick another place or change the name.",
+  "dialog.insideSelf": "A workspace cannot be moved inside its own folder.",
+  "dialog.ancestor": "That place is above the workspace's current path. Pick another one.",
+  "dialog.missingFolder": "That folder does not exist. Refresh and try again.",
+  "dialog.unknownWorkspace": "That workspace is no longer listed. Reopen the menu.",
+  "toast.moved": "Workspace moved.",
+  "toast.undone": "Move undone.",
+  "toast.failed": "The action failed.",
+  "running.title": "Stop these sessions first",
+  "running.hint": "Sessions with running work cannot be moved. Stop them and try again.",
+  "undo.title": "Undo last move",
+  "undo.body": "Restores the workspace and its sessions to the previous location.",
+  "undo.confirm": "Undo",
+  "undo.none": "Nothing to undo."
+}

package/locale/zh.json

@@ -0,0 +1,44 @@
+{
+  "meta": {
+    "meta": {
+      "title": "移动工作区",
+      "description": "把工作区目录、其子目录、其下的子工作区和其中的会话整体搬到新位置，支持重命名、失败回滚与撤销。"
+    }
+  },
+  "meta.title": "移动工作区",
+  "meta.description": "把工作区目录、其子目录、其下的子工作区和其中的会话整体搬到新位置，支持重命名、失败回滚与撤销。",
+  "menu.move": "移动工作区…",
+  "menu.undo": "撤销上次移动",
+  "dialog.title": "移动工作区",
+  "dialog.source": "当前位置",
+  "dialog.target": "目标上级文件夹",
+  "dialog.folderName": "文件夹名称",
+  "dialog.folderHint": "工作区会以此名称放进所选文件夹；改名即重命名工作区。",
+  "dialog.destination": "移动后位置",
+  "dialog.up": "上一层",
+  "dialog.home": "主目录",
+  "dialog.newFolder": "新建文件夹",
+  "dialog.newFolderPrompt": "新文件夹名称",
+  "dialog.pickHere": "选择此文件夹",
+  "dialog.confirm": "移动",
+  "dialog.cancel": "取消",
+  "dialog.moving": "正在移动…",
+  "dialog.loading": "加载中…",
+  "dialog.emptyFolder": "这里没有子文件夹",
+  "dialog.invalidName": "请填写不含斜杠的文件夹名称。",
+  "dialog.targetExists": "目标文件夹里已有同名项且非空，请换个名字。",
+  "dialog.sameLocation": "工作区已经在这个位置了，换个目标或改个名字。",
+  "dialog.insideSelf": "不能把工作区搬到它自己的文件夹里面。",
+  "dialog.ancestor": "目标在工作区当前路径的上层，请换一个位置。",
+  "dialog.missingFolder": "这个文件夹不存在，请刷新后重试。",
+  "dialog.unknownWorkspace": "这个工作区已经不在列表里了，请重新打开菜单。",
+  "toast.moved": "工作区已移动。",
+  "toast.undone": "已撤销移动。",
+  "toast.failed": "操作失败。",
+  "running.title": "请先停止这些会话",
+  "running.hint": "有正在运行的会话不能移动，停止后再试。",
+  "undo.title": "撤销上次移动",
+  "undo.body": "将把工作区及其会话恢复到原来的位置。",
+  "undo.confirm": "撤销",
+  "undo.none": "没有可撤销的移动。"
+}

package/package.json

@@ -1,6 +1,93 @@
 {
   "name": "@reed-io/dsh-workspace-move",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Move a DSH workspace — its folder tree, nested workspaces and sessions — to a new location from the sidebar, with rename, rollback and undo.",
+  "author": "reed-io",
+  "homepage": "https://github.com/ame-code/dsh-workspace-move#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ame-code/dsh-workspace-move.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ame-code/dsh-workspace-move/issues"
+  },
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./icon": "./icon/icon.svg",
+    "./icon/icon.svg": "./icon/icon.svg",
+    "./locale/*.json": "./locale/*.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src",
+    "locale",
+    "icon",
+    "cordis.patch.yml",
+    "CHANGELOG.md",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "workspace",
+    "move",
+    "session"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0",
+    "dsh": ">=0.2.0-rc.1 <0.3.0-0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1 <5.0.0",
+    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.1 <0.3.0-0",
+    "@deepseek-ai/dsh-workspace": ">=0.2.0-rc.1 <0.3.0-0",
+    "@deepseek-ai/dsh-session-persistence": ">=0.2.0-rc.1 <0.3.0-0",
+    "@deepseek-ai/dsh-host-webserver": ">=0.2.0-rc.1 <0.3.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-workspace": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-persistence": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-host-webserver": {
+      "optional": true
+    }
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": false,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build-client.mjs",
+    "check": "node scripts/build-client.mjs && node scripts/check-client.mjs",
+    "test": "node test/unit.mjs",
+    "prepack": "node scripts/build-client.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}