@agentproto/worktree 0.10.0 → 0.13.0

package/dist/{chunk-KRQFVJPK.mjs → chunk-MYH5XOX6.mjs}

@@ -1,12 +1,13 @@
-import { provisionWorktreeTool, cleanupWorktreeTool, runGateTool, runScriptTool, startServiceTool, stopServiceTool, listServicesTool } from './chunk-IKCBL2UN.mjs';
+import { provisionWorktreeTool, cleanupWorktreeTool, runGateTool, runScriptTool, startServiceTool, stopServiceTool, listServicesTool } from './chunk-3FZWPMLF.mjs';
 import { implementTool, defineDriver } from '@agentproto/driver';
 import { randomUUID } from 'crypto';
-import { lstat, mkdir, symlink, appendFile, writeFile, copyFile, readdir, stat, readFile } from 'fs/promises';
-import { resolve, join, dirname, posix, basename, sep } from 'path';
+import { lstat, mkdir, symlink, appendFile, writeFile, copyFile, readFile, rename, readdir, stat } from 'fs/promises';
+import { resolve, join, dirname, basename, posix, sep } from 'path';
 import { ToolError } from '@agentproto/tool';
 import { spawn } from 'child_process';
 import { z } from 'zod';
 import { homedir } from 'os';
+import { existsSync, mkdirSync, realpathSync, readdirSync } from 'fs';
 import { createServer } from 'net';
 
 /**
@@ -105,6 +106,53 @@ async function expandGlob(root, pattern) {
   const candidates = await walk(root, base);
   return candidates.filter((rel) => regex.test(rel));
 }
+var GlobTraversalError = class extends Error {
+  constructor(pattern) {
+    super(`glob pattern '${pattern}' escapes the repo root (path traversal)`);
+    this.name = "GlobTraversalError";
+  }
+};
+function assertNoTraversal(pattern) {
+  if (pattern.startsWith("/")) throw new GlobTraversalError(pattern);
+  if (pattern.split("/").some((seg) => seg === "..")) throw new GlobTraversalError(pattern);
+}
+async function expandCloneGlob(root, pattern) {
+  assertNoTraversal(pattern);
+  const segments = pattern.split("/").filter((seg) => seg.length > 0);
+  if (segments.length === 0) return [];
+  if (segments.includes("**")) {
+    throw new Error(
+      `cloneGlobs pattern '${pattern}' uses '**', which is not supported \u2014 name each path segment explicitly so a directory match clones as one unit.`
+    );
+  }
+  async function walkMatch(dirRel, idx) {
+    const seg = segments[idx];
+    const isLast = idx === segments.length - 1;
+    const abs = dirRel ? join(root, dirRel) : root;
+    let entries;
+    try {
+      entries = await readdir(abs, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const regex = new RegExp(`^${escapeSegment(seg)}$`);
+    const out = [];
+    for (const entry of entries) {
+      if (entry.name === ".git") continue;
+      if (!regex.test(entry.name)) continue;
+      const rel = dirRel ? posix.join(dirRel, entry.name) : entry.name;
+      if (isLast) {
+        out.push(rel);
+        continue;
+      }
+      if (entry.isDirectory()) {
+        out.push(...await walkMatch(rel, idx + 1));
+      }
+    }
+    return out;
+  }
+  return walkMatch("", 0);
+}
 var CONFIG_FILENAME = "agentproto.json";
 var hookSchema = z.union([z.string(), z.array(z.string())]);
 var scriptSchema = z.object({
@@ -181,6 +229,86 @@ async function loadConfigFromBase(repoRoot, base = "origin/main") {
   }
   return parseConfig(result.stdout);
 }
+var LOCAL_WORKTREE_CONFIG_REL = ".agentproto/worktree.json";
+var localWriteFileEntrySchema = z.object({
+  path: z.string().min(1, "writeFiles[].path must be non-empty"),
+  content: z.string(),
+  mode: z.enum(["create", "append"]).optional()
+});
+var localWorktreeConfigSchema = z.object({
+  copyGlobs: z.array(z.string()).optional(),
+  /** Gitignored dirs/files cloned (copy-on-write where the filesystem
+   *  supports it) from the source checkout into the worktree before
+   *  `depsCmd` runs — see `clone.ts`. */
+  cloneGlobs: z.array(z.string()).optional(),
+  writeFiles: z.array(localWriteFileEntrySchema).optional(),
+  depsCmd: z.string().optional(),
+  linkPaths: z.array(z.string()).optional()
+});
+function parseLocalWorktreeConfig(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(
+      `${LOCAL_WORKTREE_CONFIG_REL} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const result = localWorktreeConfigSchema.safeParse(json);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+    throw new ConfigError(`${LOCAL_WORKTREE_CONFIG_REL} failed validation: ${issues}`);
+  }
+  return result.data;
+}
+async function loadLocalWorktreeConfig(workspace) {
+  const path = resolve(workspace, LOCAL_WORKTREE_CONFIG_REL);
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  return parseLocalWorktreeConfig(raw);
+}
+var SLUG_PLACEHOLDER = /\{slug\}/g;
+function applySlugPlaceholder(text, slug) {
+  return text.replace(SLUG_PLACEHOLDER, slug);
+}
+function resolveLocalWriteFiles(files, slug) {
+  return (files ?? []).map((file) => ({
+    ...file,
+    path: applySlugPlaceholder(file.path, slug),
+    content: applySlugPlaceholder(file.content, slug)
+  }));
+}
+async function cloneEntry(src, dest) {
+  await mkdir(dirname(dest), { recursive: true });
+  const platform = process.platform;
+  const cloneArgs = platform === "darwin" ? ["-Rc", src, dest] : platform === "linux" ? ["-r", "--reflink=auto", src, dest] : null;
+  if (cloneArgs) {
+    const result = await execArgv("cp", cloneArgs, dirname(dest));
+    if (result.exitCode === 0) return;
+  }
+  const fallback = await execArgv("cp", ["-R", src, dest], dirname(dest));
+  if (fallback.exitCode !== 0) {
+    throw new Error(
+      `clone of '${src}' into '${dest}' failed: ${fallback.stderr || fallback.stdout}`
+    );
+  }
+}
+async function cloneEntries(repoRoot, cwd, patterns) {
+  for (const pattern of patterns) {
+    const matches = await expandCloneGlob(repoRoot, pattern);
+    for (const rel of matches) {
+      const dest = join(cwd, rel);
+      const existing = await lstat(dest).catch(() => null);
+      if (existing) continue;
+      await cloneEntry(join(repoRoot, rel), dest);
+    }
+  }
+}
 var ENV_VARS = {
   /** Absolute path to the original repo checkout the worktree was cut from. */
   sourceCheckoutPath: "AGENTPROTO_SOURCE_CHECKOUT_PATH",
@@ -232,38 +360,78 @@ function resolveWorktreesTurboCacheDir() {
 }
 
 // src/lifecycle.ts
+var NOISE_LINE_RES = [
+  /Failed to replace env in config: \$\{NODE_AUTH_TOKEN\}/,
+  /^\s*WARN\s+Issue while reading ".*\.npmrc"\.?\s*$/
+];
+function filteredTail(result) {
+  const combined = [result.stdout, result.stderr].filter(Boolean).join("\n");
+  const lines = combined.split("\n").filter((line) => !NOISE_LINE_RES.some((re) => re.test(line)));
+  const tail = lines.slice(-60).join("\n").trim();
+  return tail || "(no output captured)";
+}
 var HookError = class extends Error {
   command;
   result;
-  constructor(phase, run) {
+  /** Path to the full, unfiltered stdout+stderr log for this and every
+   *  other hook command in the same run, when the caller asked for one to
+   *  be persisted (see {@link runSetup}'s `opts.logPath`). */
+  logPath;
+  constructor(phase, run, logPath) {
     super(
       `worktree ${phase} hook failed (exit ${run.result.exitCode}): ${run.command}
-` + (run.result.stderr || run.result.stdout).trim()
+` + filteredTail(run.result) + (logPath ? `
+
+(full hook output: ${logPath})` : "")
     );
     this.name = "HookError";
     this.command = run.command;
     this.result = run.result;
+    if (logPath !== void 0) this.logPath = logPath;
   }
 };
-async function runSetup(config, ctx) {
+async function appendHookLog(logPath, command, result) {
+  if (!logPath) return;
+  try {
+    await mkdir(dirname(logPath), { recursive: true });
+    const parts = [
+      `$ ${command}`,
+      result.stdout,
+      result.stderr,
+      `(exit ${result.exitCode})`,
+      ""
+    ].filter(Boolean);
+    await appendFile(logPath, parts.join("\n") + "\n", "utf8");
+  } catch {
+  }
+}
+async function runSetup(config, ctx, opts = {}) {
   const commands = normalizeHook(config.worktree?.setup);
   const runs = [];
   const env = { ...hookEnv(ctx), TURBO_CACHE_DIR: resolveWorktreesTurboCacheDir() };
   for (const command of commands) {
-    const result = await execShell(command, ctx.worktreePath, { env });
-    const run = { command, result };
+    let result = await execShell(command, ctx.worktreePath, { env });
+    let run = { command, result };
     runs.push(run);
-    if (result.exitCode !== 0) throw new HookError("setup", run);
+    await appendHookLog(opts.logPath, command, result);
+    if (result.exitCode !== 0 && opts.retryOnFailure) {
+      result = await execShell(command, ctx.worktreePath, { env });
+      run = { command, result };
+      runs.push(run);
+      await appendHookLog(opts.logPath, `${command} (retry 1/1)`, result);
+    }
+    if (result.exitCode !== 0) throw new HookError("setup", run, opts.logPath);
   }
   return runs;
 }
-async function runTeardown(config, ctx) {
+async function runTeardown(config, ctx, opts = {}) {
   const commands = normalizeHook(config.worktree?.teardown);
   const runs = [];
   const env = hookEnv(ctx);
   for (const command of commands) {
     const result = await execShell(command, ctx.worktreePath, { env });
     runs.push({ command, result });
+    await appendHookLog(opts.logPath, command, result);
   }
   return runs;
 }
@@ -414,8 +582,12 @@ var provisionWorktreeBuiltin = implementTool(
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     const config = input.runSetup !== false ? await loadConfigFromBase(input.repoRoot, base) : null;
-    const linkPaths = input.linkPaths ?? config?.worktree?.linkPaths ?? [];
-    const depsCmd = input.depsCmd ?? config?.worktree?.depsCmd;
+    const localConfig = input.runSetup !== false ? await loadLocalWorktreeConfig(input.repoRoot) : null;
+    const linkPaths = input.linkPaths ?? localConfig?.linkPaths ?? config?.worktree?.linkPaths ?? [];
+    const depsCmd = input.depsCmd ?? localConfig?.depsCmd ?? config?.worktree?.depsCmd;
+    const copyGlobs = input.copyGlobs ?? localConfig?.copyGlobs ?? [];
+    const cloneGlobs = input.cloneGlobs ?? localConfig?.cloneGlobs ?? [];
+    const writeFiles = input.writeFiles ?? resolveLocalWriteFiles(localConfig?.writeFiles, input.slug);
     for (const rel of linkPaths) {
       const target = resolve(input.repoRoot, rel);
       const dest = join(cwd, rel);
@@ -424,7 +596,7 @@ var provisionWorktreeBuiltin = implementTool(
       await mkdir(dirname(dest), { recursive: true });
       await symlink(target, dest, "dir");
     }
-    for (const file of input.writeFiles ?? []) {
+    for (const file of writeFiles) {
       const dest = join(cwd, file.path);
       await mkdir(dirname(dest), { recursive: true });
       if (file.mode === "append") {
@@ -437,6 +609,16 @@ var provisionWorktreeBuiltin = implementTool(
         await writeFile(dest, file.content);
       }
     }
+    if (cloneGlobs.length > 0) {
+      try {
+        await cloneEntries(input.repoRoot, cwd, cloneGlobs);
+      } catch (err) {
+        throw new ToolError({
+          code: "execution_failed",
+          message: `cloneGlobs failed: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    }
     if (depsCmd) {
       const result = await execShell(depsCmd, cwd);
       if (result.exitCode !== 0) {
@@ -446,7 +628,7 @@ var provisionWorktreeBuiltin = implementTool(
         });
       }
     }
-    for (const pattern of input.copyGlobs ?? []) {
+    for (const pattern of copyGlobs) {
       const matches = await expandGlob(input.repoRoot, pattern);
       for (const rel of matches) {
         const dest = join(cwd, rel);
@@ -456,11 +638,18 @@ var provisionWorktreeBuiltin = implementTool(
     }
     if (config) {
       try {
-        await runSetup(config, {
-          sourceCheckoutPath: input.repoRoot,
-          worktreePath: cwd,
-          branchName: branch
-        });
+        await runSetup(
+          config,
+          {
+            sourceCheckoutPath: input.repoRoot,
+            worktreePath: cwd,
+            branchName: branch
+          },
+          {
+            ...input.setupLogPath ? { logPath: input.setupLogPath } : {},
+            ...input.retrySetupOnFailure ? { retryOnFailure: true } : {}
+          }
+        );
       } catch (err) {
         if (err instanceof HookError) {
           throw new ToolError({ code: "execution_failed", message: err.message });
@@ -471,25 +660,105 @@ var provisionWorktreeBuiltin = implementTool(
     return { cwd, branch };
   }
 );
+var WORKTREE_TRASH_DIRNAME = ".trash";
+function realOrResolved(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+async function removeWorktreeFast(repoRoot, path, options = {}) {
+  const force = options.force === true;
+  if (!force) {
+    const status = await execArgv(
+      "git",
+      ["-C", path, "status", "--porcelain=v2", "--ignored=matching"],
+      repoRoot
+    );
+    if (status.exitCode !== 0) {
+      throw new Error(
+        `git status failed in ${path} (exit ${status.exitCode}): ${status.stderr.trim() || status.stdout.trim()}`
+      );
+    }
+    if (status.stdout.trim().length > 0) {
+      const probe = await execArgv("git", ["-C", repoRoot, "worktree", "remove", path], repoRoot);
+      if (probe.exitCode !== 0) {
+        throw new Error(
+          `git worktree remove failed (exit ${probe.exitCode}): ${probe.stderr.trim() || probe.stdout.trim()}`
+        );
+      }
+      await execGit(repoRoot, ["worktree", "prune"]);
+      return;
+    }
+  }
+  const list = await execArgv("git", ["-C", repoRoot, "worktree", "list", "--porcelain"], repoRoot);
+  if (list.exitCode !== 0) {
+    throw new Error(
+      `git worktree list failed (exit ${list.exitCode}): ${list.stderr.trim() || list.stdout.trim()}`
+    );
+  }
+  const registered = new Set(
+    list.stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim())
+  );
+  const registeredReal = new Set([...registered].map(realOrResolved));
+  if (!registeredReal.has(realOrResolved(path))) {
+    throw new Error(`not a linked worktree of ${repoRoot}: ${path}`);
+  }
+  const poolDir = join(path, "..");
+  const stamp = (options.now ?? Date.now)();
+  const trashDir = join(poolDir, WORKTREE_TRASH_DIRNAME, `${basename(path)}-${stamp}`);
+  try {
+    if (!existsSync(join(poolDir, WORKTREE_TRASH_DIRNAME))) {
+      mkdirSync(join(poolDir, WORKTREE_TRASH_DIRNAME));
+    }
+    await rename(path, trashDir);
+  } catch {
+    await execGit(repoRoot, force ? ["worktree", "remove", "--force", path] : ["worktree", "remove", path]);
+    return;
+  }
+  await execGit(repoRoot, ["worktree", "prune"]);
+  if (options.spawnRemoval) {
+    options.spawnRemoval(trashDir);
+  } else {
+    spawn("rm", ["-rf", trashDir], { detached: true, stdio: "ignore" }).unref();
+  }
+}
+function sweepWorktreeTrash(root, options = {}) {
+  let names;
+  try {
+    names = readdirSync(join(root, WORKTREE_TRASH_DIRNAME));
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const trashDir = join(root, WORKTREE_TRASH_DIRNAME, name);
+    if (options.spawnRemoval) {
+      options.spawnRemoval(trashDir);
+    } else {
+      spawn("rm", ["-rf", trashDir], { detached: true, stdio: "ignore" }).unref();
+    }
+  }
+}
 function isPortFree(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer();
-    server.once("error", () => resolve5(false));
+    server.once("error", () => resolve6(false));
     server.once("listening", () => {
-      server.close(() => resolve5(true));
+      server.close(() => resolve6(true));
     });
     server.listen(port, "127.0.0.1");
   });
 }
 function ephemeralPort() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const server = createServer();
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
       if (address && typeof address === "object") {
         const port = address.port;
-        server.close(() => resolve5(port));
+        server.close(() => resolve6(port));
       } else {
         server.close(() => reject(new Error("could not determine an ephemeral port")));
       }
@@ -624,10 +893,10 @@ var ServiceSupervisor = class _ServiceSupervisor {
     this.opts.proxyTable?.delete(t.runtime.hostname);
     const child = t.child;
     if (!child || t.status !== "running") return false;
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const done = () => {
         t.status = "exited";
-        resolve5(true);
+        resolve6(true);
       };
       child.once("exit", done);
       child.kill("SIGTERM");
@@ -769,6 +1038,7 @@ async function computeTreeState(repoRoot, worktreePath, options = {}) {
     );
   }
   const noise = [];
+  const dirtyPaths = [];
   let modified = 0;
   let staged = 0;
   let untracked = 0;
@@ -779,6 +1049,7 @@ async function computeTreeState(repoRoot, worktreePath, options = {}) {
       noise.push(path);
       continue;
     }
+    if (path !== null) dirtyPaths.push(path);
     if (line.startsWith("? ")) {
       untracked++;
       continue;
@@ -790,12 +1061,14 @@ async function computeTreeState(repoRoot, worktreePath, options = {}) {
     }
   }
   if (modified === 0 && staged === 0 && untracked === 0) return noise.length > 0 ? { state: "clean", noise } : { state: "clean" };
+  const onlyUnder = dirtyPaths.length > 0 && dirtyPaths.every((p) => p.startsWith(".plans/")) ? ".plans/" : void 0;
   return {
     state: "dirty",
     modified,
     staged,
     untracked,
-    newestMtimeMs: await newestDirtyMtimeMs(repoRoot, worktreePath)
+    newestMtimeMs: await newestDirtyMtimeMs(repoRoot, worktreePath),
+    ...onlyUnder ? { onlyUnder } : {}
   };
 }
 async function newestDirtyMtimeMs(repoRoot, worktreePath) {
@@ -1062,6 +1335,7 @@ function classify(tree, integration, liveness, nowMs = Date.now()) {
   const idleOrUnreachable = liveness.state === "idle" || liveness.state === "daemon-unreachable";
   if ((merged || fresh) && clean && idleOrUnreachable) return { reclaimable: true, class: "reclaim" };
   if (merged && !clean) {
+    if (!idleOrUnreachable) return { reclaimable: false, class: "hold" };
     const writtenRecently = tree.state === "dirty" && typeof tree.newestMtimeMs === "number" && nowMs - tree.newestMtimeMs < RECENT_WRITE_HOLD_WINDOW_MS;
     if (writtenRecently) return { reclaimable: false, class: "hold" };
     return { reclaimable: false, class: "salvage" };
@@ -1189,13 +1463,13 @@ var cleanupWorktreeBuiltin = implementTool(
         if (tree.untracked > 0 && !discardUntracked) blocked.push("untracked");
         if ((tree.modified > 0 || tree.staged > 0) && !discardModified) blocked.push("modified");
         if (blocked.length > 0) throw new WorktreeNotRemovableError(input.cwd, blocked);
-        await execGit(input.repoRoot, ["worktree", "remove", "--force", input.cwd]);
+        await removeWorktreeFast(input.repoRoot, input.cwd, { force: true });
       } else {
-        await execGit(input.repoRoot, ["worktree", "remove", input.cwd]);
+        await removeWorktreeFast(input.repoRoot, input.cwd);
       }
     } else {
       try {
-        await execGit(input.repoRoot, ["worktree", "remove", input.cwd]);
+        await removeWorktreeFast(input.repoRoot, input.cwd);
       } catch (err) {
         throw new WorktreeNotRemovableError(input.cwd, [], err instanceof Error ? err.message : String(err));
       }
@@ -1287,6 +1561,6 @@ var worktreeProvider = defineDriver({
   ]
 });
 
-export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, HookError, InMemoryVerdictMemoStore, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WorktreeNotRemovableError, allocatePort, classify, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, normalizeHook, parseConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, repoLabel, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, worktreeProvider, writeWorktreeMarker };
-//# sourceMappingURL=chunk-KRQFVJPK.mjs.map
-//# sourceMappingURL=chunk-KRQFVJPK.mjs.map
+export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, GlobTraversalError, HookError, InMemoryVerdictMemoStore, LOCAL_WORKTREE_CONFIG_REL, ProxyTable, SESSIONS_BUCKETS_ROOT, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WORKTREES_TURBO_CACHE_DIR_ENV, WORKTREE_TRASH_DIRNAME, WorktreeNotRemovableError, allocatePort, applySlugPlaceholder, classify, cloneEntries, computeBaseDivergence, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandCloneGlob, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, loadLocalWorktreeConfig, normalizeHook, parseConfig, parseLocalWorktreeConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, removeWorktreeFast, repoLabel, resolveLocalWriteFiles, resolveSupervisor, resolveWorktreesTurboCacheDir, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, sweepWorktreeTrash, worktreeProvider, writeWorktreeMarker };
+//# sourceMappingURL=chunk-MYH5XOX6.mjs.map
+//# sourceMappingURL=chunk-MYH5XOX6.mjs.map