@agou/dsh-worktrees 0.0.0-stage → 1.0.0

package/lib/snapshot.js

@@ -0,0 +1,211 @@
+import * as fs from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { canonical, commitAt, digest, exists, fail, git, inside, nulRecords, safeChild, samePath, treeEntries } from './git.js';
+
+const MAX_FILES = 100_000;
+const MAX_FILE_BYTES = 64 * 1024 * 1024;
+
+/** Walk without following links, including ignored directories so embedded repositories cannot be destroyed. */
+async function scan(root, signal) {
+  const directories = [root];
+  let count = 0;
+  while (directories.length) {
+    signal?.throwIfAborted();
+    const directory = directories.pop();
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const names = new Set(entries.map(entry => entry.name.toLowerCase()));
+    if (!samePath(root, directory) && (names.has('.git') || (names.has('head') && names.has('objects') && names.has('refs')))) {
+      fail('NESTED_REPOSITORY', `An initialized submodule or embedded repository exists at ${directory}.`);
+    }
+    for (const entry of entries) {
+      if (samePath(root, directory) && entry.name === '.git') continue;
+      if (++count > MAX_FILES) fail('FILE_LIMIT', 'The checkout contains too many entries to snapshot safely.');
+      if (entry.isDirectory()) directories.push(path.join(directory, entry.name));
+      else if (!entry.isFile() && !entry.isSymbolicLink()) fail('SPECIAL_FILE', `Cannot snapshot the special filesystem entry ${path.join(directory, entry.name)}.`);
+    }
+  }
+}
+
+async function indexDigest(record) {
+  const target = path.join(record.gitDir, 'index');
+  const stat = await exists(target);
+  if (!stat) return null;
+  if (!stat.isFile() || stat.isSymbolicLink()) fail('UNSAFE_INDEX', 'The checkout index is not an ordinary file.');
+  return digest(await fs.readFile(target));
+}
+
+async function fileBytes(target, stat) {
+  if (stat.isSymbolicLink()) return fs.readlink(target, { encoding: 'buffer' });
+  if (!stat.isFile()) fail('SPECIAL_FILE', `Cannot snapshot the special filesystem entry ${target}.`);
+  if (stat.size > MAX_FILE_BYTES) fail('FILE_LIMIT', `The file exceeds the ${MAX_FILE_BYTES} byte snapshot limit: ${target}.`);
+  const handle = await fs.open(target, 'r');
+  try {
+    const opened = await handle.stat();
+    if (opened.dev !== stat.dev || opened.ino !== stat.ino || opened.size !== stat.size) fail('CHECKOUT_CHANGED', `The file changed while snapshotting: ${target}.`);
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+
+async function assertParents(root, target) {
+  let directory = path.dirname(target);
+  while (!samePath(directory, root)) {
+    if (!inside(root, directory)) fail('UNSAFE_TREE', 'A snapshot path escapes its checkout.');
+    const stat = await fs.lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) fail('UNSAFE_TREE', `A snapshot path traverses a link: ${directory}.`);
+    directory = path.dirname(directory);
+  }
+}
+
+async function currentTree(record, temporaryIndex, signal) {
+  await scan(record.path, signal);
+  const entries = treeEntries((await git(record.path, ['ls-tree', '-r', '-z', '--full-tree', 'HEAD'], { signal })).bytes);
+  const known = new Map(entries.map(entry => [entry.name, entry]));
+  const index = await git(record.path, ['ls-files', '--stage', '-z'], { signal });
+  for (const line of nulRecords(index.bytes)) {
+    const match = /^(\d{6}) ([a-f0-9]{40}|[a-f0-9]{64}) ([0-3])\t([\s\S]+)$/.exec(line);
+    if (!match) fail('INVALID_INDEX', 'Git returned an invalid index entry.');
+    const name = match[4];
+    if (match[1] === '160000' && match[3] !== '0') fail('SUBMODULE_CONFLICT', 'A conflicted submodule cannot be snapshotted safely.');
+    if (!known.has(name) || match[3] === '0') known.set(name, { name, mode: match[1], oid: match[2] });
+  }
+  const untracked = await git(record.path, ['ls-files', '--others', '--exclude-standard', '-z'], { signal });
+  for (const name of nulRecords(untracked.bytes)) if (!known.has(name)) known.set(name, { name, mode: '100644' });
+  if (known.size > MAX_FILES) fail('FILE_LIMIT', 'The checkout contains too many files to snapshot safely.');
+  const output = [];
+  for (const item of [...known.values()].sort((a, b) => Buffer.compare(Buffer.from(a.name), Buffer.from(b.name)))) {
+    signal?.throwIfAborted();
+    const target = safeChild(record.path, item.name);
+    const stat = await exists(target);
+    if (!stat) continue;
+    await assertParents(record.path, target);
+    if (item.mode === '160000') {
+      if (!stat.isDirectory() || (await fs.readdir(target)).length) fail('INITIALIZED_SUBMODULE', `The submodule at ${target} is initialized or contains files.`);
+      output.push(`160000 ${item.oid}\t${item.name}\0`);
+      continue;
+    }
+    if (stat.isDirectory()) continue;
+    const bytes = await fileBytes(target, stat);
+    const after = await fs.lstat(target);
+    if (after.dev !== stat.dev || after.ino !== stat.ino || after.size !== stat.size || after.mtimeMs !== stat.mtimeMs || after.mode !== stat.mode) {
+      fail('CHECKOUT_CHANGED', `The file changed while snapshotting: ${target}.`);
+    }
+    const mode = stat.isSymbolicLink() ? '120000' : process.platform === 'win32'
+      ? (item.mode === '100755' ? '100755' : '100644')
+      : (stat.mode & 0o111 ? '100755' : '100644');
+    const oid = (await git(record.path, ['hash-object', '-w', '--no-filters', '--stdin'], { signal, input: bytes })).stdout.trim();
+    output.push(`${mode} ${oid}\t${item.name}\0`);
+  }
+  const env = { GIT_INDEX_FILE: temporaryIndex };
+  await git(record.path, ['read-tree', '--empty'], { signal, env });
+  if (output.length) await git(record.path, ['update-index', '-z', '--index-info'], { signal, env, input: Buffer.from(output.join('')) });
+  return (await git(record.path, ['write-tree'], { signal, env })).stdout.trim();
+}
+
+async function withTemporaryIndex(callback) {
+  const parent = await canonical(tmpdir());
+  const directory = await fs.mkdtemp(path.join(parent, 'dsh-worktrees-index-'));
+  const index = path.join(directory, 'index');
+  try {
+    return await callback(index);
+  } finally {
+    if (!path.isAbsolute(directory) || !samePath(path.dirname(directory), parent) || !path.basename(directory).startsWith('dsh-worktrees-index-')) {
+      fail('UNSAFE_TEMP', 'Refusing to clean an unverified temporary index directory.');
+    }
+    for (const file of [index, `${index}.lock`]) {
+      const stat = await exists(file);
+      if (stat && stat.isFile() && !stat.isSymbolicLink()) await fs.unlink(file);
+    }
+    await fs.rmdir(directory);
+  }
+}
+
+/** Build objects without Git filters and never write to the checkout's index or stash. */
+export async function makeSnapshot(record, signal) {
+  const head = await commitAt(record.path, 'HEAD', signal);
+  const originalIndex = await indexDigest(record);
+  const tree = await withTemporaryIndex(index => currentTree(record, index, signal));
+  if (await commitAt(record.path, 'HEAD', signal) !== head || await indexDigest(record) !== originalIndex) {
+    fail('CHECKOUT_CHANGED', 'HEAD or the user index changed while creating the snapshot.');
+  }
+  const headTree = (await git(record.path, ['rev-parse', '--verify', 'HEAD^{tree}'], { signal })).stdout.trim();
+  let commit = head;
+  if (tree !== headTree) {
+    commit = (await git(record.path, ['-c', 'commit.gpgSign=false', 'commit-tree', tree, '-p', head], {
+      signal,
+      input: Buffer.from(`DSH worktree snapshot ${record.id}\n`),
+      env: {
+        GIT_AUTHOR_NAME: 'DSH Worktrees', GIT_AUTHOR_EMAIL: 'worktrees@localhost',
+        GIT_COMMITTER_NAME: 'DSH Worktrees', GIT_COMMITTER_EMAIL: 'worktrees@localhost',
+      },
+    })).stdout.trim();
+  }
+  return { commit, head, tree, index: originalIndex };
+}
+
+export async function assertSnapshotUnchanged(record, snapshot, signal) {
+  if (await commitAt(record.path, 'HEAD', signal) !== snapshot.head || await indexDigest(record) !== snapshot.index) {
+    fail('CHECKOUT_CHANGED', 'HEAD or the user index changed after creating the snapshot.');
+  }
+  const tree = await withTemporaryIndex(index => currentTree(record, index, signal));
+  if (tree !== snapshot.tree || await commitAt(record.path, 'HEAD', signal) !== snapshot.head || await indexDigest(record) !== snapshot.index) {
+    fail('CHECKOUT_CHANGED', 'Files, HEAD, or the user index changed after creating the snapshot. The checkout was kept.');
+  }
+}
+
+/** Materialize raw blobs so .gitattributes cannot rewrite saved bytes during restoration. */
+export async function materialize(record, commit, signal) {
+  const entries = treeEntries((await git(record.path, ['ls-tree', '-r', '-z', '--full-tree', commit], { signal })).bytes);
+  const allowed = new Set();
+  for (const entry of entries) {
+    safeChild(record.path, entry.name);
+    let name = entry.name;
+    while (name.includes('/')) {
+      name = name.slice(0, name.lastIndexOf('/'));
+      allowed.add(name);
+    }
+    allowed.add(entry.name);
+  }
+  const directories = [{ target: record.path, relative: '' }];
+  while (directories.length) {
+    signal?.throwIfAborted();
+    const { target, relative } = directories.pop();
+    for (const entry of await fs.readdir(target, { withFileTypes: true })) {
+      if (!relative && entry.name === '.git') continue;
+      const name = relative ? `${relative}/${entry.name}` : entry.name;
+      if (!allowed.has(name)) fail('OCCUPIED_PATH', `The incomplete checkout contains an unexpected entry: ${name}.`);
+      if (entry.isDirectory()) directories.push({ target: path.join(target, entry.name), relative: name });
+    }
+  }
+  for (const entry of entries) {
+    signal?.throwIfAborted();
+    const target = safeChild(record.path, entry.name);
+    const parentParts = entry.name.split('/').slice(0, -1);
+    let parent = record.path;
+    for (const part of parentParts) {
+      parent = path.join(parent, part);
+      const stat = await exists(parent);
+      if (stat && (!stat.isDirectory() || stat.isSymbolicLink())) fail('OCCUPIED_PATH', `A checkout directory is occupied: ${parent}.`);
+      if (!stat) await fs.mkdir(parent);
+    }
+    const stat = await exists(target);
+    if (entry.mode === '160000') {
+      if (stat && (!stat.isDirectory() || (await fs.readdir(target)).length)) fail('INITIALIZED_SUBMODULE', `The submodule path is occupied: ${target}.`);
+      if (!stat) await fs.mkdir(target);
+      continue;
+    }
+    const bytes = (await git(record.path, ['cat-file', 'blob', entry.oid], { signal })).bytes;
+    if (stat) {
+      if (entry.mode === '120000' ? !stat.isSymbolicLink() : !stat.isFile() || stat.isSymbolicLink()) fail('OCCUPIED_PATH', `The checkout path has changed type: ${target}.`);
+      if (!(await fileBytes(target, stat)).equals(bytes)) fail('OCCUPIED_PATH', `The incomplete checkout contains changed bytes: ${target}.`);
+      continue;
+    }
+    if (entry.mode === '120000') {
+      const linkTarget = process.platform === 'win32' ? new TextDecoder('utf-8', { fatal: true }).decode(bytes) : bytes;
+      await fs.symlink(linkTarget, target);
+    } else await fs.writeFile(target, bytes, { flag: 'wx', mode: entry.mode === '100755' ? 0o755 : 0o644 });
+  }
+  await git(record.path, ['read-tree', commit], { signal });
+}

package/lib/state.js

@@ -0,0 +1,97 @@
+import path from 'node:path';
+import { samePath } from './git.js';
+
+export function createInitialState() {
+  return { version: 1, worktrees: {}, bindings: {}, preferences: {}, accepted: {} };
+}
+
+function check(condition, message) {
+  if (!condition) throw new TypeError(`Invalid worktree state: ${message}`);
+}
+
+function object(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+}
+
+function text(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 8192 && !value.includes('\0');
+}
+
+function identifier(value) {
+  return text(value) && !['__proto__', 'prototype', 'constructor'].includes(value);
+}
+
+function timestamp(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function absolute(value) {
+  return text(value) && path.isAbsolute(value);
+}
+
+function choice(value) {
+  return object(value) && ['local', 'new'].includes(value.mode) && (value.mode === 'local' ? value.baseRef === undefined || text(value.baseRef) : text(value.baseRef));
+}
+
+function nullableText(value) {
+  return value === null || text(value);
+}
+
+export function freeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    for (const item of Object.values(value)) freeze(item);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/** Validate a complete aggregate before loading or persisting it; callers receive an independent value. */
+export function validateState(value) {
+  check(object(value) && value.version === 1, 'unsupported version');
+  for (const name of ['worktrees', 'bindings', 'preferences', 'accepted']) check(object(value[name]), `${name} must be a map`);
+  const statuses = ['creating', 'ready', 'snapshotting', 'removing', 'removed', 'restoring', 'missing', 'error'];
+  for (const [id, record] of Object.entries(value.worktrees)) {
+    check(object(record) && /^[a-f0-9-]{36}$/.test(id) && record.id === id, 'invalid worktree id');
+    check(identifier(record.workspaceId) && typeof record.workspaceTitle === 'string', `invalid workspace for ${id}`);
+    for (const name of ['sourceRoot', 'commonDir', 'managedRoot', 'path', 'originalPath']) check(absolute(record[name]), `invalid ${name} for ${id}`);
+    check(samePath(record.path, record.originalPath), `changed original path for ${id}`);
+    check(samePath(path.dirname(record.path), record.managedRoot) && path.basename(record.path) === `dsh-${id}`, `unsafe managed path for ${id}`);
+    check(record.gitDir === null || (absolute(record.gitDir) && samePath(path.dirname(record.gitDir), path.join(record.commonDir, 'worktrees'))), `invalid Git admin directory for ${id}`);
+    check(text(record.baseRef) && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(record.baseCommit), `invalid base for ${id}`);
+    check(/^[a-f0-9]{64}$/.test(record.token), `invalid ownership token for ${id}`);
+    check(timestamp(record.createdAt) && timestamp(record.lastUsedAt) && (record.ownerlessAt === null || timestamp(record.ownerlessAt)), `invalid timestamp for ${id}`);
+    check(statuses.includes(record.status) && nullableText(record.error), `invalid lifecycle for ${id}`);
+    check(record.currentBranch === undefined || nullableText(record.currentBranch), `invalid current branch for ${id}`);
+    check(record.snapshotRef === `refs/dsh-worktrees/snapshots/${id}`, `invalid snapshot ref for ${id}`);
+    for (const name of ['snapshotCommit', 'snapshotPendingCommit']) check(record[name] === null || /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(record[name]), `invalid ${name} for ${id}`);
+    check(Array.isArray(record.sessionIds) && record.sessionIds.every(identifier) && new Set(record.sessionIds).size === record.sessionIds.length, `invalid sessions for ${id}`);
+    check(typeof record.materialized === 'boolean' && typeof record.archivePending === 'boolean', `invalid operation state for ${id}`);
+    check(record.operationId === null || text(record.operationId), `invalid operation id for ${id}`);
+    check(identifier(record.ownerSessionId), `invalid owner for ${id}`);
+  }
+  for (const [sessionId, binding] of Object.entries(value.bindings)) {
+    check(identifier(sessionId) && object(binding) && binding.sessionId === sessionId && choice(binding), 'invalid binding');
+    check(identifier(binding.workspaceId) && absolute(binding.workspacePath) && absolute(binding.path) && typeof binding.workspaceTitle === 'string', `invalid binding workspace for ${sessionId}`);
+    check(timestamp(binding.preparedAt) && (binding.acceptedAt === null || timestamp(binding.acceptedAt)), `invalid binding time for ${sessionId}`);
+    check(['pending', 'ready', 'error'].includes(binding.status) && nullableText(binding.error), `invalid binding status for ${sessionId}`);
+    if (binding.mode === 'new') {
+      const record = value.worktrees[binding.worktreeId];
+      check(record && samePath(binding.path, record.path) && record.sessionIds.includes(sessionId), `missing worktree for ${sessionId}`);
+    } else {
+      check(binding.worktreeId === null && samePath(binding.path, binding.workspacePath), `invalid local binding for ${sessionId}`);
+    }
+  }
+  for (const [workspaceId, preference] of Object.entries(value.preferences)) {
+    check(identifier(workspaceId) && choice(preference) && timestamp(preference.acceptedAt) && identifier(preference.sessionId) && text(preference.requestId), 'invalid preference');
+  }
+  for (const [key, accepted] of Object.entries(value.accepted)) {
+    check(object(accepted) && identifier(accepted.sessionId) && text(accepted.requestId) && timestamp(accepted.acceptedAt), 'invalid accepted request');
+    check(key === JSON.stringify([accepted.sessionId, accepted.requestId]), 'invalid accepted request key');
+  }
+  return structuredClone(value);
+}
+
+export function requireIdentifier(value, name) {
+  if (!identifier(value)) throw new TypeError(`${name} must be a nonempty identifier.`);
+  return value;
+}

package/locale/en.json

@@ -0,0 +1,67 @@
+{
+  "meta": {
+    "title": "Worktrees",
+    "description": "Choose a Git branch or a new local worktree for each conversation, with recoverable background cleanup."
+  },
+  "ui": {
+    "nav": "Worktrees",
+    "worktree": "Worktree",
+    "branch": "Branch",
+    "local": "Local",
+    "new": "New local worktree",
+    "loading": "Loading…",
+    "detached": "Detached HEAD",
+    "noGit": "This workspace is not a Git repository.",
+    "noBranches": "No branches are available.",
+    "noCommit": "Create a commit in this repository before creating a worktree.",
+    "gitUnavailable": "Git is unavailable. Local sessions can still use this workspace.",
+    "locked": "This session will continue in its prepared directory.",
+    "snapshotHelp": "Git-ignored files are not included. Restored changes are recorded in a snapshot commit.",
+    "localHint": "Use the source directory. Choosing a branch checks it out immediately.",
+    "newHint": "Create a local worktree when the first message is sent.",
+    "baseHint": "Choose the base branch for the new worktree.",
+    "directory": "Worktree directory",
+    "directoryHelp": "Applies to newly created worktrees. Existing worktrees keep their paths.",
+    "chooseDirectory": "Choose folder",
+    "maxRetained": "Maximum retained worktrees",
+    "retentionHelp": "Eligible worktrees above this limit are snapshotted before cleanup. Pinned sessions and active work are protected, so the total can exceed the limit.",
+    "invalidMaximum": "Enter a whole number of at least 1.",
+    "directoryRequired": "Enter a worktree directory.",
+    "managed": "Managed worktrees",
+    "refresh": "Refresh",
+    "empty": "No managed worktrees.",
+    "untitled": "Untitled session",
+    "openSessions": "Open session",
+    "archived": "Archived",
+    "basedOn": "Based on {branch}",
+    "rowWorktree": "Worktree",
+    "hoverPath": "Worktree path: {path}",
+    "hoverBranch": "Worktree branch: {branch}",
+    "ready": "Ready",
+    "active": "Active",
+    "pinned": "Pinned",
+    "protected": "Protected",
+    "creating": "Creating",
+    "snapshotting": "Saving snapshot",
+    "removing": "Cleaning up",
+    "removed": "Cleaned up",
+    "missing": "Directory missing",
+    "restoring": "Restoring",
+    "error": "Error",
+    "restore": "Restore",
+    "delete": "Delete",
+    "cancel": "Cancel",
+    "close": "Close",
+    "restoreTitle": "Restore worktree?",
+    "restoreBody": "This worktree has been cleaned up. Restore its saved snapshot to continue in a detached worktree.",
+    "deleteTitle": "Delete worktree?",
+    "deleteBody": "This removes the worktree directory and archives its associated chats. A saved snapshot remains available for restoration.",
+    "deleteProtected": "Active worktrees and worktrees with pinned sessions cannot be deleted.",
+    "actionError": "Worktree operation failed",
+    "checkoutError": "Could not switch branch",
+    "archivedHelp": "Unarchive this session in the sidebar to open it.",
+    "invalidResponse": "The worktree service returned an invalid response.",
+    "notReady": "The worktree is not ready. Refresh and try again.",
+    "adapterUnavailable": "This DSH version does not expose the supported conversation send method."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,67 @@
+{
+  "meta": {
+    "title": "工作树",
+    "description": "为会话选择 Git 分支或新建本地工作树，支持保存快照后自动清理和恢复。"
+  },
+  "ui": {
+    "nav": "工作树",
+    "worktree": "工作树",
+    "branch": "分支",
+    "local": "本地",
+    "new": "新建本地工作树",
+    "loading": "正在加载…",
+    "detached": "分离的 HEAD",
+    "noGit": "此工作区不是 Git 仓库。",
+    "noBranches": "没有可用的分支。",
+    "noCommit": "请先在仓库中创建提交，再新建工作树。",
+    "gitUnavailable": "Git 不可用，此工作区仍可用于本地会话。",
+    "locked": "此会话将在已经准备好的目录中继续。",
+    "snapshotHelp": "快照不包含被 Git 忽略的文件。恢复后的修改会记录为一次快照提交。",
+    "localHint": "使用源目录。选择分支会立即切换源目录的分支。",
+    "newHint": "发送第一条消息时创建本地工作树。",
+    "baseHint": "选择新工作树的基础分支。",
+    "directory": "工作树目录",
+    "directoryHelp": "仅影响新建的工作树，现有工作树的路径保持不变。",
+    "chooseDirectory": "选择文件夹",
+    "maxRetained": "最多保留工作树数量",
+    "retentionHelp": "超过此数量的可清理工作树会先保存快照，再清理目录。置顶会话和正在运行的工作树受到保护，因此总数可能超过此限制。",
+    "invalidMaximum": "请输入不小于 1 的整数。",
+    "directoryRequired": "请输入工作树目录。",
+    "managed": "管理工作树",
+    "refresh": "刷新",
+    "empty": "暂无托管工作树。",
+    "untitled": "未命名会话",
+    "openSessions": "打开会话",
+    "archived": "已归档",
+    "basedOn": "基于 {branch}",
+    "rowWorktree": "工作树",
+    "hoverPath": "工作树路径：{path}",
+    "hoverBranch": "工作树分支：{branch}",
+    "ready": "就绪",
+    "active": "运行中",
+    "pinned": "已置顶",
+    "protected": "受到保护",
+    "creating": "正在创建",
+    "snapshotting": "正在保存快照",
+    "removing": "正在清理",
+    "removed": "已清理",
+    "missing": "目录缺失",
+    "restoring": "正在恢复",
+    "error": "错误",
+    "restore": "恢复",
+    "delete": "删除",
+    "cancel": "取消",
+    "close": "关闭",
+    "restoreTitle": "恢复工作树？",
+    "restoreBody": "此工作树已经清理。恢复保存的快照后，将在分离的工作树中继续工作。",
+    "deleteTitle": "删除工作树？",
+    "deleteBody": "这会删除工作树目录，并归档关联会话。保存的快照仍可用于恢复。",
+    "deleteProtected": "正在运行的工作树和包含置顶会话的工作树不能删除。",
+    "actionError": "工作树操作失败",
+    "checkoutError": "无法切换分支",
+    "archivedHelp": "请先在侧边栏取消归档，再打开此会话。",
+    "invalidResponse": "工作树服务返回了无效结果。",
+    "notReady": "工作树尚未就绪，请刷新后重试。",
+    "adapterUnavailable": "此 DSH 版本没有提供受支持的会话发送方法。"
+  }
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@agou/dsh-worktrees",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Creates detached worktrees from chat, remembers workspace choices, and manages recoverable background cleanup.",
+  "type": "module",
+  "license": "MIT",
+  "author": "agoudbg",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agoudbg/agou-dsh-plugins.git",
+    "directory": "packages/dsh-worktrees"
+  },
+  "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "git", "worktree", "web-ui"],
+  "engines": { "node": ">=22", "dsh": "0.2.1-rc.5" },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "scripts": {
+    "test": "node --test",
+    "locales": "node scripts/sync-locales.mjs",
+    "locales:check": "node scripts/sync-locales.mjs --check"
+  },
+  "files": ["index.js", "host.js", "transport.js", "discovery.js", "client.js", "lib/*.js", "cordis.patch.yml", "locale/*.json", "icon.svg", "README.md", "LICENSE"],
+  "dependencies": {
+    "@deepseek-ai/schemastery": "3.18.5",
+    "zod": "^4.6.7"
+  },
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-settings-general"
+      ]
+    }
+  }
+}

package/transport.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { RPC_ENDPOINTS } from './host.js';
+
+/** Register exact authenticated routes on the existing Connection transport. */
+export function registerTransport(ctx, host) {
+  for (const endpoint of RPC_ENDPOINTS) {
+    const method = `dsh-worktrees/${endpoint}`;
+    const envelope = z.object({
+      type: z.literal('client-request'),
+      rpcId: z.string(),
+      method: z.literal(method),
+      payload: z.unknown(),
+    });
+    ctx.effect(() => ctx.connection.fetch.register({
+      path: `/api/${method}`,
+      methods: ['POST'],
+      requestBody: 'buffered',
+      async fetch(request) {
+        const admission = ctx.connection.admit(request);
+        if ('rejection' in admission) return new Response('unauthorized', { status: admission.rejection });
+        if (request.headers.get('content-type')?.split(';', 1)[0]?.trim().toLowerCase() !== 'application/json') return new Response('content type must be application/json', { status: 415 });
+        let message;
+        try { message = envelope.parse(await request.json()); }
+        catch { return new Response('invalid worktree request envelope', { status: 400 }); }
+        const result = await host.rpc(endpoint, message.payload, request.signal, admission.peer);
+        return Response.json({ type: 'server-response', rpcId: message.rpcId, result });
+      },
+    }));
+  }
+}