@launchsecure/launch-kit 0.0.28 → 0.0.30

package/dist/server/orbit-entry.js

@@ -41,6 +41,18 @@ function currentHeadRef(cwd) {
     return "HEAD";
   }
 }
+function isGitWorktreeTracked(path, projectRoot) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.split("\n").some((line) => line === `worktree ${path}`);
+  } catch {
+    return false;
+  }
+}
 var import_node_child_process, import_node_fs, import_node_path, gitWorktreeAdapter;
 var init_git_worktree = __esm({
   "src/server/orbit/adapters/git-worktree.ts"() {
@@ -86,6 +98,9 @@ var init_git_worktree = __esm({
       },
       async remove(input) {
         const { state, force, ctx } = input;
+        if (!isGitWorktreeTracked(state.path, ctx.projectRoot)) {
+          return;
+        }
         const args = ["worktree", "remove", state.path];
         if (force) args.push("--force");
         try {
@@ -1619,6 +1634,30 @@ async function create(opts) {
     };
     await registerWorktree(entry);
     opts.logger.ok(`registered ${slug}`);
+    try {
+      opts.logger.step(`generate chart graph for worktree`);
+      const chartEntry = (0, import_node_path7.join)(__dirname, "graph-mcp-entry.js");
+      const result = (0, import_node_child_process8.spawnSync)(
+        process.execPath,
+        [chartEntry, "generate"],
+        {
+          cwd: worktreeState.path,
+          stdio: "pipe",
+          encoding: "utf-8",
+          timeout: 6e4
+        }
+      );
+      if (result.status === 0) {
+        opts.logger.ok(`chart graph generated`);
+      } else {
+        const detail = (result.stderr || result.stdout || "").toString().trim().split("\n")[0]?.slice(0, 200) ?? "unknown";
+        opts.logger.warn(
+          `chart graph generation failed (${detail}). Re-run later with: launch-chart generate (from ${worktreeState.path})`
+        );
+      }
+    } catch (e) {
+      opts.logger.warn(`chart graph generation skipped: ${e.message}`);
+    }
     return {
       slug,
       branch: opts.branch,
@@ -1670,13 +1709,33 @@ async function drop(opts) {
     if (result.backupPath) backups[ref.name] = result.backupPath;
     freed[ref.name] = state.state;
   }
+  if ((0, import_node_fs10.existsSync)(entry.path)) {
+    const blockers = findBlockingPids(entry.path);
+    if (blockers.length > 0) {
+      opts.logger.warn(`${blockers.length} process(es) holding files in worktree \u2014 terminating:`);
+      for (const b of blockers) opts.logger.step(`  pid ${b.pid} (${b.cmd})`);
+      terminateProcesses(blockers.map((b) => b.pid), opts.logger);
+    }
+  }
   const worktreeAdapter = getWorktreeAdapter(manifest.worktree.adapter);
   opts.logger.step(`remove worktree via ${worktreeAdapter.id}`);
-  await worktreeAdapter.remove({
-    state: { path: entry.path, branch: entry.branch },
-    force: true,
-    ctx
-  });
+  try {
+    await worktreeAdapter.remove({
+      state: { path: entry.path, branch: entry.branch },
+      force: true,
+      ctx
+    });
+  } catch (e) {
+    opts.logger.warn(`worktree remove failed (continuing anyway): ${e.message}`);
+  }
+  if ((0, import_node_fs10.existsSync)(entry.path)) {
+    opts.logger.step(`remove leftover dir at ${entry.path}`);
+    try {
+      (0, import_node_fs10.rmSync)(entry.path, { recursive: true, force: true });
+    } catch (e) {
+      opts.logger.warn(`leftover dir cleanup failed: ${e.message}`);
+    }
+  }
   await deregisterWorktree(slug);
   opts.logger.ok(`dropped ${slug}`);
   return { slug, backups, freed };
@@ -1702,13 +1761,82 @@ function switchTo(opts) {
 }
 function doctor() {
   const issues = [];
+  const trackedByRoot = /* @__PURE__ */ new Map();
+  const tracked = (projectRoot) => {
+    let s = trackedByRoot.get(projectRoot);
+    if (s) return s;
+    s = /* @__PURE__ */ new Set();
+    try {
+      const out = (0, import_node_child_process8.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      for (const line of out.split("\n")) {
+        if (line.startsWith("worktree ")) s.add(line.slice("worktree ".length));
+      }
+    } catch {
+    }
+    trackedByRoot.set(projectRoot, s);
+    return s;
+  };
   for (const w of listWorktrees()) {
     if (!(0, import_node_fs10.existsSync)(w.path)) {
       issues.push({ kind: "missing-worktree", slug: w.slug, detail: `path ${w.path} does not exist` });
+      continue;
+    }
+    if (!tracked(w.projectRoot).has(w.path)) {
+      issues.push({
+        kind: "orphan-registration",
+        slug: w.slug,
+        detail: `${w.path} is in the orbit registry but not in \`git worktree list\` for ${w.projectRoot}. Run \`orbit drop ${w.branch}\` to reconcile.`
+      });
     }
   }
   return issues;
 }
+function findBlockingPids(path) {
+  let out;
+  try {
+    out = (0, import_node_child_process8.execFileSync)("lsof", ["-F", "pc", "+D", path], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return [];
+  }
+  const results = /* @__PURE__ */ new Map();
+  let currentPid = 0;
+  for (const line of out.split("\n")) {
+    if (line.startsWith("p")) {
+      currentPid = Number(line.slice(1));
+      if (!Number.isFinite(currentPid) || currentPid === process.pid) currentPid = 0;
+    } else if (line.startsWith("c") && currentPid && !results.has(currentPid)) {
+      results.set(currentPid, line.slice(1));
+    }
+  }
+  return [...results].map(([pid, cmd]) => ({ pid, cmd }));
+}
+function terminateProcesses(pids, logger) {
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const wakeUpAt = Date.now() + 750;
+  while (Date.now() < wakeUpAt) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+  }
+  for (const pid of pids) {
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, "SIGKILL");
+      logger.warn(`pid ${pid} did not respond to SIGTERM \u2014 sent SIGKILL`);
+    } catch {
+    }
+  }
+}
 async function checkMergeable(opts) {
   const start = Date.now();
   const slug = slugify(opts.branch);
@@ -2139,7 +2267,7 @@ var init_orbit_mcp = __esm({
       },
       {
         name: "orbit.drop",
-        description: "Tear down an orbit: backup the database (default true), drop the database, remove the worktree, deregister. Returns { slug, backups, freed }.",
+        description: "Tear down an orbit: backup the database (default true), drop the database, terminate any process holding files inside the worktree (chart/beacon MCPs, dev servers \u2014 via lsof+SIGTERM), remove the worktree, sweep any leftover on-disk dir, deregister. Idempotent: safe to retry on a partial state (e.g. git already removed the worktree but the registry still claims it). Returns { slug, backups, freed }.",
         inputSchema: {
           type: "object",
           properties: {
@@ -2151,7 +2279,7 @@ var init_orbit_mcp = __esm({
       },
       {
         name: "orbit.doctor",
-        description: "Report inconsistencies in the registry: orphan worktrees, missing paths, stale state, etc. Returns an array of issues.",
+        description: "Report inconsistencies in the registry. Detects: 'missing-worktree' (registered path doesn't exist on disk), 'orphan-registration' (path exists + registered, but git no longer tracks it \u2014 the partial-drop state). Returns an array of issues. Fix with `orbit drop <branch>` \u2014 drop is now idempotent and resolves both kinds.",
         inputSchema: { type: "object", properties: {} }
       },
       {