@launchsecure/launch-kit 0.0.29 → 0.0.31

package/dist/server/init-entry.js

@@ -317,26 +317,37 @@ var LAUNCH_KIT_TOOLS_GUIDE_STATIC_TAIL = `
   Open this repo in Claude Code; on first open you'll be prompted to install
   the "launch-secure" marketplace \u2014 accept to enable the commands above.
 `;
-function renderLsCommandsSection() {
-  const dir = path4.resolve(__dirname, "..", "..", "scaffolds", "ls-marketplace", "plugins", "kit", "commands");
-  if (!fs4.existsSync(dir)) {
-    return "\nLS slash commands: (scaffold dir not bundled \u2014 this is a packaging bug)\n";
-  }
-  const files = fs4.readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
-  if (files.length === 0) return "\nLS slash commands: (none defined)\n";
-  const lines = files.map((file) => {
-    const name = file.replace(/\.md$/, "");
-    const text = fs4.readFileSync(path4.join(dir, file), "utf-8");
+function listEntries(dir, kind) {
+  if (kind === "commands") {
+    return fs4.readdirSync(dir).filter((f) => f.endsWith(".md")).sort().map((f) => ({ name: f.replace(/\.md$/, ""), file: path4.join(dir, f) }));
+  }
+  return fs4.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && fs4.existsSync(path4.join(dir, e.name, "SKILL.md"))).map((e) => e.name).sort().map((name) => ({ name, file: path4.join(dir, name, "SKILL.md") }));
+}
+function renderEntries(dir, kind) {
+  if (!fs4.existsSync(dir)) return `
+LS slash ${kind}: (scaffold dir not bundled \u2014 this is a packaging bug)
+`;
+  const entries = listEntries(dir, kind);
+  if (entries.length === 0) return `
+LS slash ${kind}: (none defined)
+`;
+  const names = entries.map((e) => `/${PLUGIN_ID}:${e.name}`);
+  const colWidth = Math.max(26, ...names.map((n) => n.length + 2));
+  const lines = entries.map((entry, i) => {
+    const text = fs4.readFileSync(entry.file, "utf-8");
     const fmMatch = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     const desc = fmMatch?.[1].match(/^description:\s*(.+)$/m)?.[1]?.trim() ?? "";
-    const padded = `/${PLUGIN_ID}:${name}`.padEnd(26);
-    return `  ${padded} \u2014 ${desc}`;
+    return `  ${names[i].padEnd(colWidth)} \u2014 ${desc}`;
   });
   return `
-LS slash commands (run inside Claude Code in this project):
+LS slash ${kind} (run inside Claude Code in this project):
 ${lines.join("\n")}
 `;
 }
+function renderLsCommandsSection() {
+  const base = path4.resolve(__dirname, "..", "..", "scaffolds", "ls-marketplace", "plugins", "kit");
+  return renderEntries(path4.join(base, "commands"), "commands") + renderEntries(path4.join(base, "skills"), "skills");
+}
 function getLaunchKitToolsGuide() {
   return `${LAUNCH_KIT_TOOLS_GUIDE_STATIC_HEAD}${renderLsCommandsSection()}${LAUNCH_KIT_TOOLS_GUIDE_STATIC_TAIL}`;
 }

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: {} }
       },
       {