codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/claude-code-parallel.js

@@ -0,0 +1,221 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var claude_code_parallel_exports = {};
+__export(claude_code_parallel_exports, {
+  HOOK_TIMEOUT: () => HOOK_TIMEOUT,
+  SETTINGS_FILE: () => SETTINGS_FILE,
+  SKILL_FILE: () => SKILL_FILE,
+  SKILL_NAME: () => SKILL_NAME,
+  applyClaudeCode: () => applyClaudeCode,
+  claudeCodeDir: () => claudeCodeDir,
+  hookCommand: () => hookCommand,
+  planHook: () => planHook,
+  planSkill: () => planSkill,
+  previewClaudeCode: () => previewClaudeCode,
+  skillText: () => skillText,
+  thisMachine: () => thisMachine
+});
+module.exports = __toCommonJS(claude_code_parallel_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_skill_guide = require("../mcp/skill-guide");
+var import_command = require("../mcp/connector/command");
+var import_hook = require("../mcp/connector/hook");
+var import_claude_desktop_config = require("./claude-desktop-config");
+var import_confined_fs = require("./confined-fs");
+const SKILL_NAME = "codetrellis-parallel";
+const SKILL_FILE = `skills/${SKILL_NAME}/SKILL.md`;
+const SETTINGS_FILE = "settings.json";
+const HOOK_TIMEOUT = 10;
+function claudeCodeDir(w) {
+  const dir = w.env.CLAUDE_CONFIG_DIR?.trim() || import_node_path.default.join(w.home, ".claude");
+  return w.exists(dir) ? dir : null;
+}
+function skillText() {
+  const guide = (0, import_skill_guide.buildSkillGuide)("parallel").replace(/^# .*\n+/, "");
+  return [
+    "---",
+    `name: ${SKILL_NAME}`,
+    "description: Working alongside other AI agents in the same repository (other git worktrees, clones or branches), with CodeTrellis running. Use when starting work in a repository where other agents may be working, when planning changes to shared or exported code, or when CodeTrellis reports an overlap with other work.",
+    "---",
+    "",
+    "# Working in parallel, with CodeTrellis",
+    "",
+    "The tools below are the CodeTrellis MCP server's. In Claude Code they are named",
+    "`mcp__codetrellis__<tool>` (for example `mcp__codetrellis__get_awareness`). If they",
+    "are not available, CodeTrellis is not connected: say so rather than guessing.",
+    "",
+    "This skill is written by the CodeTrellis app (Settings \u2192 Connect an agent). The same",
+    "guide is served by the app as `codetrellis://skill/parallel`.",
+    "",
+    guide.trimEnd(),
+    ""
+  ].join("\n");
+}
+function hookCommand(connector) {
+  const env = Object.entries(connector.env).map(([k, v]) => `${k}=${(0, import_command.shellQuote)(v, "linux")}`);
+  return [...env, (0, import_command.shellQuote)(connector.command, "linux"), ...connector.args.map((a) => (0, import_command.shellQuote)(a, "linux")), import_hook.HOOK_FLAG, import_hook.HOOK_PRE_TOOL_USE].join(" ");
+}
+const isOurHook = (h) => !!h && typeof h === "object" && typeof h.command === "string" && /mcp-connector\.cjs/.test(h.command) && h.command.includes(`${import_hook.HOOK_FLAG} ${import_hook.HOOK_PRE_TOOL_USE}`);
+const planned = (before, after, existed) => {
+  const status = before === after ? "unchanged" : existed ? "update" : "add";
+  return { ok: true, status, before, after, diff: status === "unchanged" ? [] : (0, import_claude_desktop_config.lineDiff)(before, after) };
+};
+function planSkill(current) {
+  return planned(current ?? "", skillText(), current !== null);
+}
+function planHook(current, command) {
+  let doc = {};
+  if (current !== null && current.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(current);
+    } catch {
+      return { ok: false, reason: "Claude Code's settings.json is not valid JSON, so it was left alone. Fix it, then try again." };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, reason: "Claude Code's settings.json is not a JSON object, so it was left alone." };
+    }
+    doc = parsed;
+  }
+  const hooks = doc.hooks ?? {};
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    return { ok: false, reason: `Claude Code's settings have a "hooks" that is not an object, so they were left alone.` };
+  }
+  const pre = hooks.PreToolUse ?? [];
+  if (!Array.isArray(pre)) {
+    return { ok: false, reason: `Claude Code's settings have a "PreToolUse" that is not a list, so they were left alone.` };
+  }
+  const ours = { type: "command", command, timeout: HOOK_TIMEOUT };
+  let placed = false;
+  const kept = pre.flatMap((group) => {
+    const g = group;
+    if (!g || typeof g !== "object" || !Array.isArray(g.hooks) || !g.hooks.some(isOurHook)) return [group];
+    const others = g.hooks.filter((h) => !isOurHook(h));
+    const mine = placed ? [] : [{ matcher: import_hook.HOOK_MATCHER, hooks: [ours] }];
+    placed = true;
+    return [...mine, ...others.length ? [{ ...g, hooks: others }] : []];
+  });
+  const next = placed ? kept : [...kept, { matcher: import_hook.HOOK_MATCHER, hooks: [ours] }];
+  const merged = { ...doc, hooks: { ...hooks, PreToolUse: next } };
+  const before = current ?? "";
+  const unchanged = current !== null && JSON.stringify(JSON.parse(current || "{}")) === JSON.stringify(merged);
+  return planned(before, unchanged ? before : `${JSON.stringify(merged, null, 2)}
+`, current !== null);
+}
+function readCurrent(dir, rel, label) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(dir, rel))) return { text: null };
+  try {
+    return { text: (0, import_confined_fs.readTextWithin)(dir, rel, label) };
+  } catch {
+    return { error: `Claude Code's ${label} could not be read (it may be a link, which is not followed), so it was left alone.` };
+  }
+}
+const NO_DIR = "Claude Code's settings folder (~/.claude) was not found on this computer. Install Claude Code and run it once, then try again.";
+const NO_CONNECTOR = "The connector is not built in this checkout, so there is no hook to add yet (npm run build:connector).";
+function previewItem(dir, rel, label, plan) {
+  const current = readCurrent(dir, rel, label);
+  if ("error" in current) return current;
+  const p = plan(current.text);
+  if (!p.ok) return { error: p.reason };
+  return { path: import_node_path.default.join(dir, rel), status: p.status, diff: p.diff, beforeHash: (0, import_claude_desktop_config.hashOf)(current.text), exists: current.text !== null };
+}
+function previewClaudeCode(where, connector) {
+  const dir = claudeCodeDir(where);
+  if (!dir) return { ok: false, reason: NO_DIR };
+  const skill = previewItem(dir, SKILL_FILE, "skill file", planSkill);
+  if ("error" in skill) return { ok: false, reason: skill.error };
+  let hook;
+  if (!connector) hook = { unavailable: NO_CONNECTOR };
+  else {
+    const h = previewItem(dir, SETTINGS_FILE, "settings.json", (t) => planHook(t, hookCommand(connector)));
+    hook = "error" in h ? { unavailable: h.error } : { ...h, ...connector.caveat ? { caveat: connector.caveat } : {} };
+  }
+  return { ok: true, dir, skill, hook };
+}
+const stampOf = (now) => now.toISOString().replace(/[:.]/g, "-");
+function applyClaudeCode(where, connector, choice, now = /* @__PURE__ */ new Date()) {
+  const dir = claudeCodeDir(where);
+  if (!dir) return { ok: false, reason: NO_DIR };
+  if (!choice.skill && !choice.hook) return { ok: false, reason: "Choose the skill, the hook, or both." };
+  if (choice.hook && !connector) return { ok: false, reason: NO_CONNECTOR };
+  const items = [];
+  if (choice.skill) items.push({ key: "skill", rel: SKILL_FILE, label: "skill file", shown: choice.skill, plan: planSkill });
+  if (choice.hook) items.push({ key: "hook", rel: SETTINGS_FILE, label: "settings.json", shown: choice.hook, plan: (t) => planHook(t, hookCommand(connector)) });
+  const ready = [];
+  for (const it of items) {
+    const current = readCurrent(dir, it.rel, it.label);
+    if ("error" in current) return { ok: false, reason: current.error };
+    if ((0, import_claude_desktop_config.hashOf)(current.text) !== it.shown) {
+      return { ok: false, changed: true, reason: `Claude Code's ${it.label} changed after you looked at it. Here is the change again, against the file as it is now.` };
+    }
+    const plan = it.plan(current.text);
+    if (!plan.ok) return plan;
+    ready.push({ key: it.key, rel: it.rel, label: it.label, current: current.text, plan });
+  }
+  const out = {};
+  try {
+    for (const r of ready) {
+      const target = import_node_path.default.join(dir, r.rel);
+      if (r.plan.status === "unchanged") {
+        out[r.key] = { path: target, backupPath: null, status: "unchanged" };
+        continue;
+      }
+      let backupPath = null;
+      if (r.current !== null) {
+        const ext = import_node_path.default.extname(r.rel);
+        const backupRel = `${r.rel.slice(0, -ext.length)}.before-codetrellis-${stampOf(now)}${ext}`;
+        backupPath = (0, import_confined_fs.writeFileWithin)(dir, backupRel, r.current, `Claude Code ${r.label} backup`);
+      }
+      (0, import_confined_fs.writeFileWithin)(dir, r.rel, r.plan.after, `Claude Code ${r.label}`);
+      out[r.key] = { path: target, backupPath, status: r.plan.status };
+    }
+  } catch {
+    return { ok: false, reason: "Claude Code's files could not be written (a link at their place is not written through). Anything already written is listed by a fresh preview." };
+  }
+  return { ok: true, ...out };
+}
+function thisMachine() {
+  return { home: import_node_os.default.homedir(), env: process.env, exists: (p) => import_node_fs.default.existsSync(p) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HOOK_TIMEOUT,
+  SETTINGS_FILE,
+  SKILL_FILE,
+  SKILL_NAME,
+  applyClaudeCode,
+  claudeCodeDir,
+  hookCommand,
+  planHook,
+  planSkill,
+  previewClaudeCode,
+  skillText,
+  thisMachine
+});

package/src/backend/services/claude-desktop-config.js

@@ -0,0 +1,186 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var claude_desktop_config_exports = {};
+__export(claude_desktop_config_exports, {
+  CONFIG_NAME: () => CONFIG_NAME,
+  applyClaudeDesktop: () => applyClaudeDesktop,
+  claudeDesktopConfigDir: () => claudeDesktopConfigDir,
+  hashOf: () => hashOf,
+  lineDiff: () => lineDiff,
+  planMerge: () => planMerge,
+  previewClaudeDesktop: () => previewClaudeDesktop,
+  thisMachine: () => thisMachine
+});
+module.exports = __toCommonJS(claude_desktop_config_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_confined_fs = require("./confined-fs");
+const CONFIG_NAME = "claude_desktop_config.json";
+function claudeDesktopConfigDir(w) {
+  const candidates = [];
+  if (w.platform === "darwin") {
+    candidates.push(import_node_path.default.join(w.home, "Library", "Application Support", "Claude"));
+  } else if (w.platform === "win32") {
+    const appData = w.env.APPDATA ?? import_node_path.default.join(w.home, "AppData", "Roaming");
+    candidates.push(import_node_path.default.join(appData, "Claude"));
+    const local = w.env.LOCALAPPDATA ?? import_node_path.default.join(w.home, "AppData", "Local");
+    const packages = import_node_path.default.join(local, "Packages");
+    if (w.exists(packages)) {
+      for (const name of w.list(packages).filter((n) => /^Claude_/i.test(n)).sort()) {
+        candidates.push(import_node_path.default.join(packages, name, "LocalCache", "Roaming", "Claude"));
+      }
+    }
+  } else {
+    candidates.push(import_node_path.default.join(w.env.XDG_CONFIG_HOME || import_node_path.default.join(w.home, ".config"), "Claude"));
+  }
+  return candidates.find((d) => w.exists(d)) ?? null;
+}
+function lineDiff(before, after) {
+  const a = before === "" ? [] : before.replace(/\n$/, "").split("\n");
+  const b = after.replace(/\n$/, "").split("\n");
+  const n = a.length;
+  const m = b.length;
+  const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      out.push({ op: " ", text: a[i] });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) out.push({ op: "-", text: a[i++] });
+    else out.push({ op: "+", text: b[j++] });
+  }
+  while (i < n) out.push({ op: "-", text: a[i++] });
+  while (j < m) out.push({ op: "+", text: b[j++] });
+  return out;
+}
+function planMerge(current, entry) {
+  let doc = {};
+  if (current !== null && current.trim() !== "") {
+    let parsed;
+    try {
+      parsed = JSON.parse(current);
+    } catch {
+      return { ok: false, reason: "Claude Desktop's config file is not valid JSON, so it was left alone. Fix or remove it, then try again." };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false, reason: "Claude Desktop's config file is not a JSON object, so it was left alone." };
+    }
+    doc = parsed;
+  }
+  const servers = doc.mcpServers ?? {};
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    return { ok: false, reason: `Claude Desktop's config has an "mcpServers" that is not an object, so it was left alone.` };
+  }
+  const existing = servers.codetrellis;
+  const status = existing === void 0 ? "add" : JSON.stringify(existing) === JSON.stringify(entry) ? "unchanged" : "update";
+  const merged = { ...doc, mcpServers: { ...servers, codetrellis: entry } };
+  const before = current ?? "";
+  const after = status === "unchanged" ? before : `${JSON.stringify(merged, null, 2)}
+`;
+  return { ok: true, status, before, after, diff: status === "unchanged" ? [] : lineDiff(before, after) };
+}
+const hashOf = (text) => (0, import_node_crypto.createHash)("sha256").update(text ?? "\0absent").digest("hex");
+function readCurrent(dir) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(dir, CONFIG_NAME))) return { text: null };
+  try {
+    return { text: (0, import_confined_fs.readTextWithin)(dir, CONFIG_NAME, "Claude Desktop config") };
+  } catch {
+    return { error: "Claude Desktop's config file could not be read (it may be a link, which is not followed), so it was left alone." };
+  }
+}
+function previewClaudeDesktop(where, entry) {
+  if (!entry) return { ok: false, reason: "The connector is not built in this checkout, so there is nothing to add yet (npm run build:connector)." };
+  const dir = claudeDesktopConfigDir(where);
+  if (!dir) return { ok: false, reason: "Claude Desktop's settings folder was not found on this computer. Install Claude Desktop and open it once, then try again." };
+  const current = readCurrent(dir);
+  if ("error" in current) return { ok: false, reason: current.error };
+  const plan = planMerge(current.text, entry);
+  if (!plan.ok) return plan;
+  return { ok: true, path: import_node_path.default.join(dir, CONFIG_NAME), status: plan.status, diff: plan.diff, beforeHash: hashOf(current.text), exists: current.text !== null };
+}
+function applyClaudeDesktop(where, entry, shownHash, now = /* @__PURE__ */ new Date()) {
+  if (!entry) return { ok: false, reason: "The connector is not built in this checkout." };
+  const dir = claudeDesktopConfigDir(where);
+  if (!dir) return { ok: false, reason: "Claude Desktop's settings folder was not found on this computer." };
+  const current = readCurrent(dir);
+  if ("error" in current) return { ok: false, reason: current.error };
+  if (hashOf(current.text) !== shownHash) {
+    return { ok: false, changed: true, reason: "Claude Desktop's config changed after you looked at it. Here is the change again, against the file as it is now." };
+  }
+  const plan = planMerge(current.text, entry);
+  if (!plan.ok) return plan;
+  const target = import_node_path.default.join(dir, CONFIG_NAME);
+  if (plan.status === "unchanged") return { ok: true, path: target, backupPath: null, status: "unchanged" };
+  try {
+    let backupPath = null;
+    if (current.text !== null) {
+      const stamp = now.toISOString().replace(/[:.]/g, "-");
+      backupPath = (0, import_confined_fs.writeFileWithin)(dir, `claude_desktop_config.before-codetrellis-${stamp}.json`, current.text, "Claude Desktop config backup");
+    }
+    (0, import_confined_fs.writeFileWithin)(dir, CONFIG_NAME, plan.after, "Claude Desktop config");
+    return { ok: true, path: target, backupPath, status: plan.status };
+  } catch {
+    return { ok: false, reason: "Claude Desktop's config could not be written (a link at its place is not written through). Nothing was changed." };
+  }
+}
+function thisMachine() {
+  return {
+    platform: process.platform,
+    env: process.env,
+    home: import_node_os.default.homedir(),
+    exists: (p) => import_node_fs.default.existsSync(p),
+    list: (d) => {
+      try {
+        return import_node_fs.default.readdirSync(d);
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONFIG_NAME,
+  applyClaudeDesktop,
+  claudeDesktopConfigDir,
+  hashOf,
+  lineDiff,
+  planMerge,
+  previewClaudeDesktop,
+  thisMachine
+});

package/src/backend/services/cli-install.js

@@ -0,0 +1,249 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_install_exports = {};
+__export(cli_install_exports, {
+  LAUNCHER_MARK: () => LAUNCHER_MARK,
+  appImageLauncher: () => appImageLauncher,
+  applyCliInstall: () => applyCliInstall,
+  planCliInstall: () => planCliInstall,
+  refreshCliInstall: () => refreshCliInstall,
+  removeCliInstall: () => removeCliInstall,
+  thisCliMachine: () => thisCliMachine
+});
+module.exports = __toCommonJS(cli_install_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_command = require("../mcp/connector/command");
+const LAUNCHER_MARK = "Written by the CodeTrellis app";
+const join = (m, ...p) => m.platform === "win32" ? import_node_path.default.win32.join(...p) : import_node_path.default.posix.join(...p);
+function onPathOf(m, dir) {
+  const list = (m.env.PATH ?? "").split(m.platform === "win32" ? ";" : ":").map((d) => d.replace(/[\\/]+$/, ""));
+  return list.some((d) => m.platform === "win32" ? d.toLowerCase() === dir.toLowerCase() : d === dir);
+}
+function appImageLauncher(appImage) {
+  const q = `'${appImage.replace(/'/g, `'\\''`)}'`;
+  return [
+    "#!/bin/sh",
+    `# codetrellis: ${LAUNCHER_MARK} for the AppImage below; it rewrites this`,
+    "# file if the AppImage moves. Runs the CLI the app carries, in Node mode.",
+    // --no-sandbox last, after --: the AppImage's AppRun adds it as the first
+    // argument unless it is already there, and in Node mode that is a "bad
+    // option". As the connector's AppImage command does; app.cjs drops it.
+    `ELECTRON_RUN_AS_NODE=1 exec ${q} -e "require(require('path').join(process.resourcesPath, 'cli', 'bin', 'app.cjs'))" -- "$@" --no-sandbox`,
+    ""
+  ].join("\n");
+}
+function readLink(p) {
+  try {
+    return import_node_fs.default.readlinkSync(p);
+  } catch {
+    return null;
+  }
+}
+function readText(p) {
+  try {
+    return import_node_fs.default.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+function present(p) {
+  try {
+    import_node_fs.default.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function oursAt(p) {
+  const link = readLink(p);
+  if (link) return /[\\/]cli[\\/]bin[\\/]codetrellis$/.test(link);
+  return (readText(p) ?? "").includes(LAUNCHER_MARK);
+}
+function planCliInstall(m) {
+  if (!(0, import_command.isPackagedElectron)({ execPath: m.execPath, electronVersion: m.electronVersion }) || !m.resourcesPath) {
+    return { ok: false, reason: "Only the installed app can add the codetrellis command. From a checkout, run npm link; anywhere, npm install -g codetrellis." };
+  }
+  if (m.platform === "win32" && m.env.PORTABLE_EXECUTABLE_FILE) {
+    return { ok: false, reason: "The portable build unpacks to a temporary folder each time it starts, so a command on the PATH would stop working. Use the installer, or npm install -g codetrellis." };
+  }
+  const binDir = join(m, m.resourcesPath, "cli", "bin");
+  if (m.platform === "win32") {
+    const userPath = m.windowsUserPath?.() ?? "";
+    const has = userPath.split(";").some((d) => d.replace(/[\\/]+$/, "").toLowerCase() === binDir.toLowerCase());
+    return {
+      ok: true,
+      how: "path",
+      target: binDir,
+      source: join(m, binDir, "codetrellis.cmd"),
+      admin: false,
+      state: has ? "installed" : "missing",
+      onPath: onPathOf(m, binDir),
+      says: `Adds ${binDir} to your PATH. Open a new terminal afterwards.`
+    };
+  }
+  const localBin = import_node_path.default.posix.join(m.home, ".local", "bin");
+  const appImage = m.platform === "linux" && m.env.APPIMAGE && m.env.APPDIR && import_node_path.default.isAbsolute(m.env.APPIMAGE) && m.resourcesPath.startsWith(m.env.APPDIR) ? m.env.APPIMAGE : null;
+  const source = appImage ?? import_node_path.default.posix.join(binDir, "codetrellis");
+  const how = appImage ? "launcher" : "link";
+  const target = m.platform === "darwin" ? import_node_path.default.posix.join(m.macBin ?? "/usr/local/bin", "codetrellis") : import_node_path.default.posix.join(localBin, "codetrellis");
+  const dir = import_node_path.default.posix.dirname(target);
+  const admin = m.platform === "darwin" && !writable(dir);
+  let state = "missing";
+  let existing;
+  if (present(target)) {
+    const link = readLink(target);
+    if (how === "link" && link === source) state = "installed";
+    else if (how === "launcher" && readText(target) === appImageLauncher(appImage)) state = "installed";
+    else if (oursAt(target)) state = "stale";
+    else {
+      state = "other";
+      existing = link ? `a link to ${link}` : "a file CodeTrellis did not write";
+    }
+  }
+  const says = how === "launcher" ? `Writes ${target}, which runs this AppImage as the codetrellis command.` : `Links ${target} to the codetrellis command inside the app${admin ? ". macOS asks for your password to write there" : ""}.`;
+  return { ok: true, how, target, source, admin, state, existing, onPath: onPathOf(m, dir), says };
+}
+function writable(dir) {
+  try {
+    import_node_fs.default.accessSync(dir, import_node_fs.default.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const appleString = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+const runProgram = (command, args, env) => new Promise((resolve, reject) => {
+  (0, import_node_child_process.execFile)(command, args, { env: env ? { ...process.env, ...env } : process.env }, (err) => err ? reject(err) : resolve());
+});
+async function applyCliInstall(m, opts = {}, run = runProgram) {
+  const plan = planCliInstall(m);
+  if (!plan.ok) return plan;
+  if (plan.state === "installed") return { ok: true, target: plan.target, onPath: plan.onPath };
+  if (plan.state === "other" && !opts.replace) {
+    return { ok: false, reason: `${plan.target} is already ${plan.existing}. Choose Replace to put the app's command there instead.` };
+  }
+  try {
+    if (plan.how === "path") {
+      await run(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$p=[Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p='' }; $parts=@($p -split ';' | Where-Object { $_ -and ($_.TrimEnd('\\') -ne $env:CT_DIR.TrimEnd('\\')) }); [Environment]::SetEnvironmentVariable('Path', (($parts + $env:CT_DIR) -join ';'), 'User')"
+        ],
+        { CT_DIR: plan.target }
+      );
+    } else if (plan.how === "launcher") {
+      import_node_fs.default.mkdirSync(import_node_path.default.posix.dirname(plan.target), { recursive: true });
+      if (present(plan.target)) import_node_fs.default.rmSync(plan.target, { force: true });
+      import_node_fs.default.writeFileSync(plan.target, appImageLauncher(plan.source), { mode: 493 });
+    } else if (plan.admin) {
+      const dir = import_node_path.default.posix.dirname(plan.target);
+      const script = `do shell script "mkdir -p " & quoted form of ${appleString(dir)} & " && ln -sf " & quoted form of ${appleString(plan.source)} & " " & quoted form of ${appleString(plan.target)} with administrator privileges`;
+      await run("osascript", ["-e", script]);
+    } else {
+      import_node_fs.default.mkdirSync(import_node_path.default.posix.dirname(plan.target), { recursive: true });
+      if (present(plan.target)) import_node_fs.default.rmSync(plan.target, { force: true });
+      import_node_fs.default.symlinkSync(plan.source, plan.target);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: /User canceled|-128/.test(msg) ? "Cancelled: macOS did not get the password." : `Could not add the command: ${msg}` };
+  }
+  const after = planCliInstall(m);
+  if (!after.ok || after.state !== "installed") return { ok: false, reason: `The command was not added at ${plan.target}.` };
+  return { ok: true, target: after.target, onPath: after.onPath };
+}
+async function refreshCliInstall(m) {
+  const plan = planCliInstall(m);
+  if (!plan.ok || plan.state !== "stale" || plan.admin || plan.how === "path") return false;
+  return (await applyCliInstall(m)).ok;
+}
+async function removeCliInstall(m, run = runProgram) {
+  const plan = planCliInstall(m);
+  if (!plan.ok) return plan;
+  if (plan.state === "missing") return { ok: true, target: plan.target, onPath: plan.onPath };
+  if (plan.state === "other") return { ok: false, reason: `${plan.target} is not CodeTrellis's; it was left as it is.` };
+  try {
+    if (plan.how === "path") {
+      await run(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$p=[Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p='' }; [Environment]::SetEnvironmentVariable('Path', ((@($p -split ';' | Where-Object { $_ -and ($_.TrimEnd('\\') -ne $env:CT_DIR.TrimEnd('\\')) })) -join ';'), 'User')"
+        ],
+        { CT_DIR: plan.target }
+      );
+    } else if (plan.admin) {
+      await run("osascript", ["-e", `do shell script "rm -f " & quoted form of ${appleString(plan.target)} with administrator privileges`]);
+    } else {
+      import_node_fs.default.rmSync(plan.target, { force: true });
+    }
+  } catch (err) {
+    return { ok: false, reason: `Could not remove the command: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { ok: true, target: plan.target, onPath: plan.onPath };
+}
+function thisCliMachine() {
+  return {
+    platform: process.platform,
+    home: process.env.HOME || process.env.USERPROFILE || "",
+    execPath: process.execPath,
+    resourcesPath: process.resourcesPath,
+    electronVersion: process.versions.electron,
+    env: {
+      APPIMAGE: process.env.APPIMAGE,
+      APPDIR: process.env.APPDIR,
+      PORTABLE_EXECUTABLE_FILE: process.env.PORTABLE_EXECUTABLE_FILE,
+      PATH: process.env.PATH
+    },
+    windowsUserPath: () => {
+      try {
+        const out = (0, import_node_child_process.execFileSync)("reg", ["query", "HKCU\\Environment", "/v", "Path"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        return /Path\s+REG_(?:EXPAND_)?SZ\s+(.*)/i.exec(out)?.[1]?.trim() ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAUNCHER_MARK,
+  appImageLauncher,
+  applyCliInstall,
+  planCliInstall,
+  refreshCliInstall,
+  removeCliInstall,
+  thisCliMachine
+});