@shipers-dev/multi 0.17.0 → 0.18.0

package/dist/index.js

@@ -16073,7 +16073,7 @@ var StreamEventInputSchema = exports_external.object({
 });
 // src/worktree.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, symlinkSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, symlinkSync, rmSync } from "fs";
 import { dirname as dirname2, join as join3, resolve } from "path";
 async function run(cwd, cmd, args) {
   return await new Promise((resolve2) => {
@@ -16100,6 +16100,14 @@ async function branchExists(dir, branch) {
   const r = await run(dir, "git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
   return r.code === 0;
 }
+async function hasOriginRemote(dir) {
+  const r = await run(dir, "git", ["remote", "get-url", "origin"]);
+  return r.code === 0 && !!r.stdout;
+}
+async function isDirty(dir) {
+  const r = await run(dir, "git", ["status", "--porcelain"]);
+  return r.code === 0 && r.stdout.length > 0;
+}
 function ensureGitignoreEntry(workingDir, entry) {
   const gip = join3(workingDir, ".gitignore");
   let body = "";
@@ -16123,7 +16131,45 @@ function ensureGitignoreEntry(workingDir, entry) {
 function normalizeKey(issueKey) {
   return issueKey.toLowerCase().replace(/[^a-z0-9\-_\/]/g, "-");
 }
-async function ensureWorktree(workingDir, issueKey) {
+function indexPath(workingDir) {
+  return join3(workingDir, ".multi", "worktrees", "_index.json");
+}
+function readIndex(workingDir) {
+  try {
+    const p = indexPath(workingDir);
+    if (!existsSync2(p))
+      return {};
+    return JSON.parse(readFileSync2(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeIndex(workingDir, idx) {
+  try {
+    const p = indexPath(workingDir);
+    mkdirSync2(dirname2(p), { recursive: true });
+    writeFileSync2(p, JSON.stringify(idx, null, 2), "utf8");
+  } catch {}
+}
+function listWorktreeIndex(workingDir) {
+  const idx = readIndex(workingDir);
+  return Object.entries(idx).map(([key, issueId]) => ({ key, issueId }));
+}
+function removeWorktreeIndexEntry(workingDir, key) {
+  const idx = readIndex(workingDir);
+  if (key in idx) {
+    delete idx[key];
+    writeIndex(workingDir, idx);
+  }
+}
+function setWorktreeIndexEntry(workingDir, key, issueId) {
+  const idx = readIndex(workingDir);
+  if (idx[key] === issueId)
+    return;
+  idx[key] = issueId;
+  writeIndex(workingDir, idx);
+}
+async function ensureWorktree(workingDir, issueKey, issueId) {
   if (!await isGitRepo(workingDir)) {
     return { path: workingDir, branch: "", created: false };
   }
@@ -16133,6 +16179,8 @@ async function ensureWorktree(workingDir, issueKey) {
   const wtDir = join3(workingDir, ".multi", "worktrees");
   const wtPath = join3(wtDir, key);
   if (existsSync2(wtPath)) {
+    if (issueId)
+      setWorktreeIndexEntry(workingDir, key, issueId);
     return { path: wtPath, branch, created: false };
   }
   try {
@@ -16145,6 +16193,8 @@ async function ensureWorktree(workingDir, issueKey) {
     throw new Error(`git worktree add failed: ${r.stderr || r.stdout}`);
   }
   await linkIgnoredFiles(workingDir, wtPath);
+  if (issueId)
+    setWorktreeIndexEntry(workingDir, key, issueId);
   return { path: wtPath, branch, created: true };
 }
 async function linkIgnoredFiles(workingDir, wtPath) {
@@ -16177,9 +16227,61 @@ async function linkIgnoredFiles(workingDir, wtPath) {
     } catch {}
   }
 }
+async function removeWorktree(workingDir, issueKey, opts = {}) {
+  const result = { removedPath: false, pushed: false, skipped: null, errors: [] };
+  if (!await isGitRepo(workingDir)) {
+    result.skipped = "not_git";
+    return result;
+  }
+  const key = normalizeKey(issueKey);
+  const branch = `multi/${key}`;
+  const wtPath = join3(workingDir, ".multi", "worktrees", key);
+  if (existsSync2(wtPath)) {
+    const dirty = await isDirty(wtPath);
+    if (dirty && !opts.force) {
+      result.skipped = "dirty";
+      return result;
+    }
+  }
+  const noPush = opts.noPush || process.env.MULTI_GC_NO_PUSH === "1";
+  if (!noPush) {
+    if (await branchExists(workingDir, branch)) {
+      if (await hasOriginRemote(workingDir)) {
+        const push = await run(workingDir, "git", ["push", "--force-with-lease", "origin", `${branch}:${branch}`]);
+        if (push.code === 0) {
+          result.pushed = true;
+        } else {
+          result.errors.push(`push failed: ${push.stderr || push.stdout}`);
+        }
+      } else {
+        result.errors.push("no origin remote, skipped push");
+      }
+    }
+  }
+  await run(workingDir, "git", ["worktree", "prune"]);
+  if (existsSync2(wtPath)) {
+    const rm = await run(workingDir, "git", ["worktree", "remove", "--force", wtPath]);
+    if (rm.code === 0) {
+      result.removedPath = true;
+    } else {
+      result.errors.push(`worktree remove failed: ${rm.stderr || rm.stdout}`);
+      try {
+        rmSync(wtPath, { recursive: true, force: true });
+        result.removedPath = true;
+      } catch (e) {
+        result.errors.push(`fs rm failed: ${String(e)}`);
+      }
+    }
+    await run(workingDir, "git", ["worktree", "prune"]);
+  } else {
+    result.removedPath = true;
+  }
+  removeWorktreeIndexEntry(workingDir, key);
+  return result;
+}
 
 // src/materializer.ts
-import { mkdirSync as mkdirSync3, existsSync as existsSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync3, rmSync, symlinkSync as symlinkSync2, lstatSync } from "fs";
+import { mkdirSync as mkdirSync3, existsSync as existsSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync3, rmSync as rmSync2, symlinkSync as symlinkSync2, lstatSync } from "fs";
 import { join as join4, dirname as dirname3 } from "path";
 var HOME2 = process.env.HOME || process.env.USERPROFILE || ".";
 var MULTI_DIR = join4(HOME2, ".multi");
@@ -16210,17 +16312,17 @@ function safeRmManaged(path) {
   try {
     const st = lstatSync(path);
     if (st.isSymbolicLink()) {
-      rmSync(path);
+      rmSync2(path);
       return;
     }
     if (st.isDirectory() && existsSync3(join4(path, MARKER))) {
-      rmSync(path, { recursive: true, force: true });
+      rmSync2(path, { recursive: true, force: true });
       return;
     }
     if (st.isFile() && path.endsWith(".md")) {
       const head = readFileSync3(path, "utf8").slice(0, 200);
       if (head.includes("multi-managed: true"))
-        rmSync(path);
+        rmSync2(path);
     }
   } catch {}
 }
@@ -16324,7 +16426,7 @@ import { join as join5, dirname as dirname4 } from "path";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.17.0",
+  version: "0.18.0",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"
@@ -16365,7 +16467,8 @@ var COMMANDS = {
   stop: "Stop the running daemon",
   restart: "Stop and relaunch the daemon in background",
   logs: "View execution logs",
-  reset: "Reset acpx session for an issue (--issue <id>)"
+  reset: "Reset acpx session for an issue (--issue <id>)",
+  worktree: "Worktree maintenance (subcommands: gc)"
 };
 function ensureDirs() {
   for (const d of [MULTI_DIR2, join5(MULTI_DIR2, "logs"), SKILLS_DIR]) {
@@ -16396,7 +16499,10 @@ async function main() {
       workspace: { type: "string" },
       agent: { type: "string" },
       api: { type: "string" },
-      issue: { type: "string" }
+      issue: { type: "string" },
+      key: { type: "string" },
+      force: { type: "boolean", default: false },
+      "no-push": { type: "boolean", default: false }
     },
     allowPositionals: true,
     strict: false
@@ -16440,6 +16546,11 @@ async function main() {
     case "reset":
       await cmdReset(args.values.issue);
       break;
+    case "worktree": {
+      const sub = args.positionals.slice(3)[0] || "help";
+      await cmdWorktree(sub, { force: !!args.values.force, noPush: !!args.values["no-push"], key: args.values.key });
+      break;
+    }
     default:
       console.error(`Unknown command: ${command}`);
       printHelp();
@@ -16461,6 +16572,7 @@ Commands:
   restart   ${COMMANDS.restart}
   logs      ${COMMANDS.logs}
   reset     ${COMMANDS.reset}
+  worktree  ${COMMANDS.worktree}
 
 Options:
   --name <name>       Device name
@@ -16753,8 +16865,9 @@ async function cmdConnect(apiUrl, config2) {
                 try {
                   entry.child?.kill("SIGKILL");
                 } catch {}
-              }, 5000);
+              }, 1500);
             }
+            markStopped(apiUrl, issue_id, "user requested");
             return Response.json({ ok: true, state: "running-signalled" });
           } catch (e) {
             return Response.json({ error: String(e) }, { status: 400 });
@@ -17065,6 +17178,25 @@ async function markStopped(apiUrl, issueId, reason) {
   } catch {}
   await postStream(apiUrl, issueId, "stopped", { reason });
 }
+async function gcWorktreeAfterTerminal(baseWorkingDir, issueKey) {
+  try {
+    const res = await removeWorktree(baseWorkingDir, issueKey);
+    if (res.skipped === "dirty") {
+      log(`  \uD83D\uDEB1 worktree gc ${issueKey}: skipped (dirty \u2014 uncommitted changes preserved)`);
+      return;
+    }
+    if (res.skipped === "not_git")
+      return;
+    const errs = res.errors.length ? ` (warn: ${res.errors.join("; ")})` : "";
+    if (res.removedPath) {
+      log(`  \uD83E\uDDF9 worktree gc ${issueKey}: pushed=${res.pushed} removed=true (branch kept)${errs}`);
+    } else if (res.errors.length) {
+      log(`  \u26A0 worktree gc ${issueKey}: ${res.errors.join("; ")}`);
+    }
+  } catch (e) {
+    log(`  \u26A0 worktree gc ${issueKey} threw: ${fmtError(e)}`);
+  }
+}
 async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
   const issueId = task.issue_id;
   const isFollowup = !!task.followup;
@@ -17073,7 +17205,7 @@ async function handleRunTask(apiUrl, deviceId, task, detected, ctx) {
   let worktreeBranch = "";
   if (baseWorkingDir) {
     try {
-      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId);
+      const wt = await ensureWorktree(baseWorkingDir, task.key || issueId, issueId);
       workingDir = wt.path;
       worktreeBranch = wt.branch;
       await postStream(apiUrl, issueId, "worktree_created", { path: wt.path, branch: wt.branch, reused: !wt.created });
@@ -17539,9 +17671,13 @@ ${userPart}` : userPart;
     } else if (hadError) {
       await apiClient.post(`${apiUrl}/api/issues/${issueId}/fail`, {});
       log(`  \u2717 ${task.key} failed`);
+      if (baseWorkingDir)
+        await gcWorktreeAfterTerminal(baseWorkingDir, task.key || issueId);
     } else {
       await apiClient.post(`${apiUrl}/api/issues/${issueId}/complete`, {});
       log(`  \u2713 ${task.key} complete`);
+      if (baseWorkingDir)
+        await gcWorktreeAfterTerminal(baseWorkingDir, task.key || issueId);
     }
   } catch (e) {
     const msg = fmtError(e);
@@ -17594,7 +17730,7 @@ Issue actions:
 
 \`\`\`multi-plan
 {"actions":[
-  {"type":"create","title":"...","description":"...","assignee_type":"agent","assignee_id":"<agent id>"},
+  {"type":"create","title":"...","description":"... (required, non-empty: relays full task context to the assignee)","assignee_type":"agent","assignee_id":"<agent id>"},
   {"type":"update","id":"<issue id>","status":"done"},
   {"type":"delegate","id":"<issue id>","assignee_id":"<agent id>"}
 ]}
@@ -17713,6 +17849,11 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx) {
           continue;
         }
         lines.push(`- \u2713 updated ${res.data.key}`);
+        if ((a.status === "done" || a.status === "cancelled") && parentTask.working_dir && existsSync4(parentTask.working_dir)) {
+          const targetKey = res.data?.key;
+          if (targetKey)
+            await gcWorktreeAfterTerminal(parentTask.working_dir, targetKey);
+        }
       } else if (a.type === "delegate") {
         const res = await apiClient.post(`${apiUrl}/api/issues/agent/mutate`, { action: "update", id: a.id, assignee_type: "agent", assignee_id: a.assignee_id, status: "todo" }, { headers });
         if (!res.success) {
@@ -18227,6 +18368,40 @@ async function cmdReset(issueId) {
   }
   console.log(body);
 }
+async function cmdWorktree(sub, opts) {
+  const config2 = loadConfig();
+  const baseDir = process.cwd();
+  if (sub === "gc") {
+    const targets = opts.key ? [opts.key] : listWorktreeIndex(baseDir).map((e) => e.key);
+    if (!targets.length) {
+      console.log("No worktrees in index.");
+      return;
+    }
+    let kept = 0, gone = 0, dirty = 0;
+    for (const k of targets) {
+      const r = await removeWorktree(baseDir, k, { force: opts.force, noPush: opts.noPush });
+      if (r.skipped === "dirty") {
+        dirty++;
+        console.log(`  \uD83D\uDEB1 ${k}: skipped (dirty)`);
+        continue;
+      }
+      if (r.skipped === "not_git") {
+        console.log(`  \u26A0 ${k}: not a git repo`);
+        continue;
+      }
+      if (r.removedPath) {
+        gone++;
+        console.log(`  \uD83E\uDDF9 ${k}: pushed=${r.pushed} removed=true (branch kept)${r.errors.length ? " warn=" + r.errors.join("; ") : ""}`);
+      } else {
+        kept++;
+        console.log(`  \u26A0 ${k}: ${r.errors.join("; ") || "unchanged"}`);
+      }
+    }
+    console.log(`Done. removed=${gone} dirty=${dirty} kept=${kept}`);
+    return;
+  }
+  console.log("Usage: multi-agent worktree gc [--key <key>] [--force] [--no-push]");
+}
 async function cmdRestart(apiUrl) {
   if (existsSync4(PID_PATH)) {
     const pid = Number(readFileSync4(PID_PATH, "utf8").trim());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"