@launchsecure/launch-kit 0.0.34 → 0.0.35

package/dist/server/orbit-entry.js

@@ -1530,6 +1530,73 @@ var init_manifest = __esm({
   }
 });
 
+// src/server/orbit/active.ts
+function anchorPaths(projectRoot) {
+  const dir = (0, import_node_path7.join)(projectRoot, LAUNCHSECURE_DIR, "orbit");
+  return { dir, current: (0, import_node_path7.join)(dir, "current"), activeJson: (0, import_node_path7.join)(dir, "active.json") };
+}
+function present(p) {
+  try {
+    (0, import_node_fs10.lstatSync)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setActiveOrbit(entry, envFileName) {
+  const paths = anchorPaths(entry.projectRoot);
+  (0, import_node_fs10.mkdirSync)(paths.dir, { recursive: true });
+  const tmpLink = `${paths.current}.tmp.${process.pid}`;
+  if (present(tmpLink)) (0, import_node_fs10.rmSync)(tmpLink, { force: true });
+  (0, import_node_fs10.symlinkSync)(entry.path, tmpLink);
+  (0, import_node_fs10.renameSync)(tmpLink, paths.current);
+  const active = {
+    slug: entry.slug,
+    branch: entry.branch,
+    path: entry.path,
+    envFile: (0, import_node_path7.join)(entry.path, envFileName),
+    projectRoot: entry.projectRoot,
+    anchor: paths.current,
+    switchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmpJson = `${paths.activeJson}.tmp.${process.pid}`;
+  (0, import_node_fs10.writeFileSync)(tmpJson, JSON.stringify(active, null, 2) + "\n", "utf-8");
+  (0, import_node_fs10.renameSync)(tmpJson, paths.activeJson);
+  return active;
+}
+function clearActiveOrbit(projectRoot) {
+  const paths = anchorPaths(projectRoot);
+  let cleared = false;
+  for (const p of [paths.current, paths.activeJson]) {
+    if (present(p)) {
+      try {
+        (0, import_node_fs10.rmSync)(p, { force: true });
+        cleared = true;
+      } catch {
+      }
+    }
+  }
+  return cleared;
+}
+function readActiveOrbit(projectRoot) {
+  const { activeJson } = anchorPaths(projectRoot);
+  if (!present(activeJson)) return null;
+  try {
+    return JSON.parse((0, import_node_fs10.readFileSync)(activeJson, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var import_node_fs10, import_node_path7;
+var init_active = __esm({
+  "src/server/orbit/active.ts"() {
+    "use strict";
+    import_node_fs10 = require("node:fs");
+    import_node_path7 = require("node:path");
+    init_launch_kit_paths();
+  }
+});
+
 // src/server/orbit/slug.ts
 function slugify(branch) {
   let s = branch.toLowerCase();
@@ -1556,7 +1623,7 @@ async function create(opts) {
   const envFileName = opts.envFileName ?? manifest.envFile ?? DEFAULT_ENV_FILE;
   const ctx = {
     projectRoot: opts.projectRoot,
-    manifestPath: (0, import_node_path7.join)(opts.projectRoot, "orbit.json"),
+    manifestPath: (0, import_node_path8.join)(opts.projectRoot, "orbit.json"),
     manifest,
     logger: opts.logger,
     envFileName
@@ -1610,13 +1677,13 @@ async function create(opts) {
         Object.assign(rewriteFns, adapter.envRewrites(state, ctx));
       }
     }
-    const srcEnv = (0, import_node_path7.join)(opts.projectRoot, envFileName);
-    const dstEnv = (0, import_node_path7.join)(worktreeState.path, envFileName);
-    if ((0, import_node_fs10.existsSync)(srcEnv) && !(0, import_node_fs10.existsSync)(dstEnv)) {
+    const srcEnv = (0, import_node_path8.join)(opts.projectRoot, envFileName);
+    const dstEnv = (0, import_node_path8.join)(worktreeState.path, envFileName);
+    if ((0, import_node_fs11.existsSync)(srcEnv) && !(0, import_node_fs11.existsSync)(dstEnv)) {
       opts.logger.step(`copy ${envFileName} into worktree`);
       copyEnvFile(srcEnv, dstEnv);
     }
-    if ((0, import_node_fs10.existsSync)(dstEnv) && Object.keys(rewriteFns).length > 0) {
+    if ((0, import_node_fs11.existsSync)(dstEnv) && Object.keys(rewriteFns).length > 0) {
       opts.logger.step(`rewrite ${envFileName} (${Object.keys(rewriteFns).join(", ")})`);
       const r = rewriteEnvFile(dstEnv, rewriteFns);
       if (r.missing.length > 0) {
@@ -1636,7 +1703,7 @@ async function create(opts) {
     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 chartEntry = (0, import_node_path8.join)(__dirname, "graph-mcp-entry.js");
       const result = (0, import_node_child_process8.spawnSync)(
         process.execPath,
         [chartEntry, "generate"],
@@ -1688,7 +1755,7 @@ async function drop(opts) {
   const manifest = loadManifestOrThrow(opts.projectRoot);
   const ctx = {
     projectRoot: opts.projectRoot,
-    manifestPath: (0, import_node_path7.join)(opts.projectRoot, "orbit.json"),
+    manifestPath: (0, import_node_path8.join)(opts.projectRoot, "orbit.json"),
     manifest,
     logger: opts.logger,
     envFileName: manifest.envFile ?? DEFAULT_ENV_FILE
@@ -1709,7 +1776,7 @@ 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)) {
+  if ((0, import_node_fs11.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:`);
@@ -1728,15 +1795,19 @@ async function drop(opts) {
   } catch (e) {
     opts.logger.warn(`worktree remove failed (continuing anyway): ${e.message}`);
   }
-  if ((0, import_node_fs10.existsSync)(entry.path)) {
+  if ((0, import_node_fs11.existsSync)(entry.path)) {
     opts.logger.step(`remove leftover dir at ${entry.path}`);
     try {
-      (0, import_node_fs10.rmSync)(entry.path, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(entry.path, { recursive: true, force: true });
     } catch (e) {
       opts.logger.warn(`leftover dir cleanup failed: ${e.message}`);
     }
   }
   await deregisterWorktree(slug);
+  if (readActiveOrbit(opts.projectRoot)?.slug === slug) {
+    clearActiveOrbit(opts.projectRoot);
+    opts.logger.step("cleared active-orbit anchor (current)");
+  }
   opts.logger.ok(`dropped ${slug}`);
   return { slug, backups, freed };
 }
@@ -1753,12 +1824,19 @@ function switchTo(opts) {
   const slug = slugify(opts.branch);
   const entry = lookupWorktree(slug);
   if (!entry) throw new Error(`no orbit registered for branch "${opts.branch}" (slug ${slug})`);
+  const active = setActiveOrbit(entry, DEFAULT_ENV_FILE);
   return {
     path: entry.path,
-    envFile: (0, import_node_path7.join)(entry.path, DEFAULT_ENV_FILE),
+    envFile: active.envFile,
+    anchor: active.anchor,
+    activeJson: anchorPaths(entry.projectRoot).activeJson,
+    nextAction: `cd "${active.anchor}"`,
     entry
   };
 }
+function deactivate(opts) {
+  return { cleared: clearActiveOrbit(opts.projectRoot), projectRoot: opts.projectRoot };
+}
 function doctor() {
   const issues = [];
   const trackedByRoot = /* @__PURE__ */ new Map();
@@ -1781,7 +1859,7 @@ function doctor() {
     return s;
   };
   for (const w of listWorktrees()) {
-    if (!(0, import_node_fs10.existsSync)(w.path)) {
+    if (!(0, import_node_fs11.existsSync)(w.path)) {
       issues.push({ kind: "missing-worktree", slug: w.slug, detail: `path ${w.path} does not exist` });
       continue;
     }
@@ -2018,18 +2096,19 @@ function formatAge(iso) {
   const d = Math.floor(h / 24);
   return `${d}d`;
 }
-var import_node_child_process8, import_node_fs10, import_node_path7, DEFAULT_ENV_FILE;
+var import_node_child_process8, import_node_fs11, import_node_path8, DEFAULT_ENV_FILE;
 var init_orchestrator = __esm({
   "src/server/orbit/orchestrator.ts"() {
     "use strict";
     import_node_child_process8 = require("node:child_process");
-    import_node_fs10 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_fs11 = require("node:fs");
+    import_node_path8 = require("node:path");
     init_adapter_registry();
     init_env_rewriter();
     init_gate_runner();
     init_manifest();
     init_registry();
+    init_active();
     init_slug();
     DEFAULT_ENV_FILE = ".env.local";
   }
@@ -2093,11 +2172,16 @@ async function handleTool(name, args) {
       const result = switchTo({ branch, projectRoot });
       return text({
         slug: result.entry.slug,
+        branch: result.entry.branch,
+        anchor: result.anchor,
         path: result.path,
         envFile: result.envFile,
-        nextAction: `cd ${result.path}`
+        nextAction: result.nextAction
       });
     }
+    case "orbit.deactivate": {
+      return text(deactivate({ projectRoot }));
+    }
     case "orbit.drop": {
       const branch = String(args.branch ?? "");
       if (!branch) return text({ error: "branch is required" });
@@ -2256,15 +2340,20 @@ var init_orbit_mcp = __esm({
       },
       {
         name: "orbit.switch",
-        description: "Look up the path + env file of an existing orbit by branch name. Does NOT change any shell \u2014 the caller is expected to `cd` into the returned path. Useful for agents that need to operate inside an already-created orbit.",
+        description: 'Activate an orbit by branch name. Atomically repoints the stable anchor <project>/.launchsecure/orbit/current at the orbit\'s worktree and records active.json, then returns `anchor` (the current/ path) + `nextAction`. AFTER calling this, operate on the anchor: Read/Edit/Write under `.launchsecure/orbit/current/<path>`, pass `project_root: ".launchsecure/orbit/current"` to chart, and run the returned `nextAction` (cd into current) so commands execute in the orbit. Switching to a different orbit just repoints the anchor; re-run nextAction afterwards.',
         inputSchema: {
           type: "object",
           properties: {
-            branch: { type: "string", description: "Branch name to look up." }
+            branch: { type: "string", description: "Branch name of the orbit to activate." }
           },
           required: ["branch"]
         }
       },
+      {
+        name: "orbit.deactivate",
+        description: "Clear the active-orbit anchor for this project \u2014 removes <project>/.launchsecure/orbit/current and active.json so no orbit is active. Use when you're done working in an orbit and want subsequent work to target the main checkout. No-op if nothing is active.",
+        inputSchema: { type: "object", properties: {} }
+      },
       {
         name: "orbit.drop",
         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 }.",
@@ -2326,8 +2415,8 @@ var init_orbit_mcp = __esm({
 });
 
 // src/server/orbit-entry.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path9 = require("node:path");
 init_orchestrator();
 init_logger();
 function parseFlags(argv) {
@@ -2413,14 +2502,22 @@ ${JSON.stringify(result, null, 2)}
         if (!branch) die("usage: launch-orbit switch <branch> [--emit-cd]");
         const result = switchTo({ branch, projectRoot });
         if (flags.emitCd) {
-          process.stdout.write(`cd ${result.path}
+          process.stdout.write(`cd ${result.anchor}
 `);
         } else {
-          process.stdout.write(`${JSON.stringify({ path: result.path, envFile: result.envFile, nextAction: `cd ${result.path}` }, null, 2)}
-`);
+          process.stdout.write(
+            `${JSON.stringify({ anchor: result.anchor, path: result.path, envFile: result.envFile, nextAction: result.nextAction }, null, 2)}
+`
+          );
         }
         return;
       }
+      case "deactivate": {
+        const result = deactivate({ projectRoot });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
       case "drop": {
         const branch = positional[0];
         if (!branch) die("usage: launch-orbit drop <branch> [--no-backup]");
@@ -2495,8 +2592,8 @@ ${JSON.stringify(result, null, 2)}
   }
 }
 function runInit(projectRoot) {
-  const path = (0, import_node_path8.join)(projectRoot, "orbit.json");
-  if ((0, import_node_fs11.existsSync)(path)) {
+  const path = (0, import_node_path9.join)(projectRoot, "orbit.json");
+  if ((0, import_node_fs12.existsSync)(path)) {
     process.stderr.write(`[launch-orbit] orbit.json already exists at ${path}
 `);
     process.exit(1);
@@ -2551,7 +2648,7 @@ function runInit(projectRoot) {
       full: { resources: ["db", "ports"] }
     }
   };
-  (0, import_node_fs11.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
+  (0, import_node_fs12.writeFileSync)(path, JSON.stringify(starter, null, 2) + "\n", "utf-8");
   process.stdout.write(`\u2713 wrote ${path}
 `);
 }

package/dist/server/radar-docker-init-entry.js

@@ -152,17 +152,26 @@ var SHORTHANDS = {
   sequencer: { port: 3517, bin: "launch-sequencer", args: [] },
   chart: { port: 52819, bin: "launch-chart", args: ["serve"] },
   deck: { port: 52829, bin: "launch-deck", args: ["serve"] },
-  council: { port: 52839, bin: "launch-council", args: ["serve"] }
+  council: { port: 52839, bin: "launch-council", args: ["serve"] },
+  // Claude web terminal — exposes a viewable/drivable `claude` session at
+  // `bot.<baseDomain>`. NOTE: no auth gate yet (tracked as a separate
+  // high-priority rover-security work item); ships behind a plain link first.
+  bot: { port: 52849, bin: "launch-bot", args: ["serve"] }
 };
 var DNS_NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 function defaultServices() {
   return [expandShorthand("radar")];
 }
 function expandShorthand(name) {
+  if (name === "preview") {
+    const raw = process.env.PREVIEW_PORT;
+    const port = raw && Number.isFinite(Number.parseInt(raw, 10)) ? Number.parseInt(raw, 10) : 3e3;
+    return { name: "preview", port, bin: "", args: [], skipSpawn: true };
+  }
   const def = SHORTHANDS[name];
   if (!def) {
     throw new Error(
-      `[launch-kit-services] unknown shorthand "${name}" \u2014 known: ${Object.keys(SHORTHANDS).join(", ")}. Use an object entry { name, port, bin, args } for custom services.`
+      `[launch-kit-services] unknown shorthand "${name}" \u2014 known: ${[...Object.keys(SHORTHANDS), "preview"].join(", ")}. Use an object entry { name, port, bin, args } for custom services.`
     );
   }
   return { name, port: def.port, bin: def.bin, args: [...def.args] };
@@ -243,7 +252,7 @@ function resolveServices(opts = {}) {
   }
   return validate(defaultServices());
 }
-var SHORTHAND_NAMES = Object.keys(SHORTHANDS);
+var SHORTHAND_NAMES = [...Object.keys(SHORTHANDS), "preview"];
 
 // src/server/cf-ingress.ts
 var import_node_fs2 = require("node:fs");
@@ -455,6 +464,23 @@ function setupClaudeCredentials() {
   cfg.lastOnboardingVersion = cfg.lastOnboardingVersion ?? "2.1.159";
   cfg.numStartups = (cfg.numStartups ?? 0) + 1;
   cfg.installMethod = cfg.installMethod ?? "global";
+  const PREAPPROVED_MCPS = [
+    "launch-secure",
+    "launch-chart",
+    "launch-deck",
+    "launch-orbit",
+    "launch-recall",
+    "launch-beacon",
+    "launch-sequencer"
+  ];
+  const projects = cfg.projects ?? {};
+  const wsKey = "/workspace";
+  const wsProject = projects[wsKey] ?? {};
+  const existingEnabled = Array.isArray(wsProject.enabledMcpjsonServers) ? wsProject.enabledMcpjsonServers : [];
+  const mergedEnabled = Array.from(/* @__PURE__ */ new Set([...existingEnabled, ...PREAPPROVED_MCPS]));
+  wsProject.enabledMcpjsonServers = mergedEnabled;
+  projects[wsKey] = wsProject;
+  cfg.projects = projects;
   (0, import_node_fs3.writeFileSync)(configPath, JSON.stringify(cfg, null, 2));
   (0, import_node_fs3.chmodSync)(configPath, 384);
 }
@@ -464,6 +490,27 @@ function setupGitAndGh() {
   const status = run("launch-kit", ["setup-git", `--identity=${name} <${email}>`]);
   if (status !== 0) fail(`[entrypoint] launch-kit setup-git failed (status ${status})`);
 }
+function detectAndSetPreviewPort() {
+  if (process.env.PREVIEW_PORT) return;
+  try {
+    const pkgPath = "/workspace/package.json";
+    if (!(0, import_node_fs3.existsSync)(pkgPath)) return;
+    const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf-8"));
+    const scripts = pkg.scripts ?? {};
+    const portRe = /(?:--port[= ]|-p\s+|\bPORT=)(\d{2,5})\b/;
+    for (const name of ["dev", "start", "serve"]) {
+      const script = scripts[name];
+      if (typeof script !== "string") continue;
+      const m = script.match(portRe);
+      if (m) {
+        process.env.PREVIEW_PORT = m[1];
+        console.log(`[entrypoint] preview port detected from package.json scripts.${name}: ${m[1]}`);
+        return;
+      }
+    }
+  } catch {
+  }
+}
 function initWorkspaceIfEmpty() {
   process.chdir("/workspace");
   if ((0, import_node_fs3.existsSync)(".git")) {
@@ -563,6 +610,10 @@ function spawnServiceGroup(services) {
     let exitedCount = 0;
     let firstFailure = null;
     for (const spec of services) {
+      if (spec.skipSpawn) {
+        console.log(`[entrypoint] ${spec.name} \u2192 ingress-only on port ${spec.port} (no spawn; user starts dev server here)`);
+        continue;
+      }
       const args = [...spec.args, "--port", String(spec.port)];
       console.log(`[entrypoint] starting ${spec.name}: ${spec.bin} ${args.join(" ")}`);
       const proc = (0, import_node_child_process.spawn)(spec.bin, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -599,6 +650,7 @@ async function main() {
   setupClaudeCredentials();
   setupGitAndGh();
   initWorkspaceIfEmpty();
+  detectAndSetPreviewPort();
   let services;
   try {
     services = resolveServices();