@paradow/ledge 0.34.0 → 0.35.0

package/dist/cli/chunk-UJ2WBGLW.js

@@ -1,305 +0,0 @@
-import {
-  run
-} from "./chunk-T547FLQN.js";
-import {
-  ensureLedgeDir,
-  paths
-} from "./chunk-53ISXX2R.js";
-
-// src/cli/setup.ts
-import { readFile as readFile2, writeFile, mkdir, rename, realpath, rm, stat, lstat, readlink } from "fs/promises";
-import { execFile } from "child_process";
-import { homedir, userInfo } from "os";
-import { join, dirname } from "path";
-
-// src/update/guard.ts
-import { readFile } from "fs/promises";
-var inDaemonService = (cgroup) => cgroup.split("\n").some((l) => l.split("/").includes(SERVICE));
-async function tmuxServerAtRisk(opts = {}) {
-  const runTmux = opts.runTmux ?? run;
-  const readCgroup = opts.readCgroup ?? ((pid2) => readFile(`/proc/${pid2}/cgroup`, "utf8"));
-  const r = await runTmux(["-L", opts.socket ?? "ledge", "list-sessions", "-F", "#{pid}"]);
-  if (r.code !== 0) return false;
-  const pid = r.stdout.split("\n").map((s) => s.trim()).find(Boolean);
-  if (!pid) return false;
-  try {
-    return inDaemonService(await readCgroup(pid));
-  } catch {
-    return true;
-  }
-}
-
-// src/cli/setup.ts
-var CLAUDE_EVENTS = [
-  "SessionStart",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PermissionRequest",
-  "Notification",
-  "Stop",
-  "SessionEnd",
-  "PostToolUse",
-  "PostToolUseFailure",
-  "StopFailure",
-  "SubagentStart",
-  "SubagentStop"
-];
-var CODEX_EVENTS = [
-  "SessionStart",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PermissionRequest",
-  "PostToolUse",
-  "Stop",
-  "SubagentStart",
-  "SubagentStop",
-  "Interrupt",
-  "SessionEnd"
-];
-function mergeHooks(settings, events, command, file) {
-  if (settings === void 0) settings = {};
-  if (!settings || typeof settings !== "object" || Array.isArray(settings)) throw new Error(`${file} root is not an object, not modified`);
-  const base = settings;
-  if (base.hooks !== void 0 && (!base.hooks || typeof base.hooks !== "object" || Array.isArray(base.hooks))) throw new Error(`${file} "hooks" is not an object, not modified`);
-  const hooks = { ...base.hooks ?? {} };
-  let changed = false;
-  for (const ev of events) {
-    if (hooks[ev] !== void 0 && !Array.isArray(hooks[ev])) throw new Error(`${file} hooks.${ev} is not an array, not modified`);
-    const list = [...hooks[ev] ?? []];
-    const mine = `${command} ${ev}`;
-    if (!list.some((e) => e.hooks?.some((h) => h.command === mine))) {
-      list.push({ hooks: [{ type: "command", command: mine, timeout: 5 }] });
-      changed = true;
-    }
-    hooks[ev] = list;
-  }
-  return { settings: { ...base, hooks }, changed };
-}
-function mergeClaudeHooks(settings, command = "ledge hook") {
-  return mergeHooks(settings, CLAUDE_EVENTS, command, "settings.json");
-}
-function mergeCodexHooks(hooks, command = "ledge hook codex") {
-  return mergeHooks(hooks, CODEX_EVENTS, command, "hooks.json");
-}
-var CURSOR_EVENTS = [
-  "sessionStart",
-  "beforeSubmitPrompt",
-  "preToolUse",
-  "postToolUse",
-  "postToolUseFailure",
-  "stop",
-  "afterAgentResponse",
-  "sessionEnd"
-];
-function mergeCursorHooks(config, command = "ledge hook cursor") {
-  if (config === void 0) config = {};
-  if (!config || typeof config !== "object" || Array.isArray(config)) throw new Error("hooks.json root is not an object, not modified");
-  const base = config;
-  if (base.hooks !== void 0 && (!base.hooks || typeof base.hooks !== "object" || Array.isArray(base.hooks))) throw new Error('hooks.json "hooks" is not an object, not modified');
-  const hooks = { ...base.hooks ?? {} };
-  let changed = base.version === void 0;
-  for (const ev of CURSOR_EVENTS) {
-    if (hooks[ev] !== void 0 && !Array.isArray(hooks[ev])) throw new Error(`hooks.json hooks.${ev} is not an array, not modified`);
-    const list = [...hooks[ev] ?? []];
-    const mine = `${command} ${ev}`;
-    if (!list.some((e) => e?.command === mine)) {
-      list.push({ command: mine, timeout: 5 });
-      changed = true;
-    }
-    hooks[ev] = list;
-  }
-  return { settings: { version: 1, ...base, hooks }, changed };
-}
-async function mergeJsonFile(path, merge, name) {
-  let raw = null;
-  try {
-    raw = await readFile2(path, "utf8");
-  } catch (e) {
-    if (e.code !== "ENOENT") throw e;
-  }
-  let current;
-  if (raw !== null) {
-    try {
-      current = JSON.parse(raw);
-    } catch {
-      throw new Error(`${name} is not valid JSON, not modified`);
-    }
-  }
-  const { settings, changed } = merge(current);
-  if (!changed) return false;
-  await mkdir(dirname(path), { recursive: true });
-  const tmp = `${path}.ledge-${process.pid}.tmp`;
-  await writeFile(tmp, JSON.stringify(settings, null, 2) + "\n");
-  await rename(tmp, path);
-  return true;
-}
-var SERVICE = "ledge-daemon.service";
-var execRunner = (cmd, args) => new Promise((resolve) => {
-  execFile(cmd, args, (err, stdout, stderr) => {
-    const code = err && typeof err.code === "number" ? err.code : err ? 1 : 0;
-    resolve({ code, stdout: String(stdout), stderr: String(stderr) });
-  });
-});
-function systemdUnit(opts) {
-  return `[Unit]
-Description=Ledge daemon (agent sessions for the Windows overlay)
-
-[Service]
-ExecStart=${opts.node} ${opts.script} daemon
-Restart=on-failure
-RestartSec=2
-
-[Install]
-WantedBy=default.target
-`;
-}
-async function writeIfChanged(path, content) {
-  let current = null;
-  try {
-    current = await readFile2(path, "utf8");
-  } catch (e) {
-    if (e.code !== "ENOENT") throw e;
-  }
-  if (current === content) return false;
-  await mkdir(dirname(path), { recursive: true });
-  const tmp = `${path}.ledge-${process.pid}.tmp`;
-  await writeFile(tmp, content);
-  await rename(tmp, path);
-  return true;
-}
-async function stopDetachedDaemon(pidFile) {
-  let pid;
-  try {
-    pid = Number((await readFile2(pidFile, "utf8")).trim());
-  } catch {
-    return null;
-  }
-  if (!Number.isInteger(pid) || pid <= 0) return null;
-  try {
-    process.kill(pid, 0);
-  } catch {
-    await rm(pidFile, { force: true });
-    return null;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {
-    return null;
-  }
-  const deadline = Date.now() + 3e3;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 50));
-    try {
-      process.kill(pid, 0);
-    } catch {
-      return pid;
-    }
-  }
-  return pid;
-}
-async function installService(opts = {}) {
-  const out = [];
-  const run2 = opts.run ?? execRunner;
-  const unitDir = opts.unitDir ?? join(homedir(), ".config", "systemd", "user");
-  const node = opts.node ?? await realpath(process.execPath);
-  const script = opts.script ?? await realpath(process.argv[1]);
-  const changed = await writeIfChanged(join(unitDir, SERVICE), systemdUnit({ node, script }));
-  const reload = await run2("systemctl", ["--user", "daemon-reload"]);
-  if (reload.code !== 0) throw new Error(`systemd user session unavailable (systemctl --user daemon-reload failed: ${reload.stderr.trim() || reload.code}); the daemon will still be started on demand by ledge claude`);
-  const active = (await run2("systemctl", ["--user", "is-active", SERVICE])).code === 0;
-  if (active && changed && await (opts.atRisk ?? tmuxServerAtRisk)()) {
-    out.push(`${SERVICE} unit updated but not restarted: the tmux server of your agents runs inside the service and would stop with it; close the sessions, then run ledge setup again (or systemctl --user restart ${SERVICE})`);
-  } else if (active && changed) {
-    const r = await run2("systemctl", ["--user", "restart", SERVICE]);
-    if (r.code !== 0) throw new Error(`systemctl --user restart ${SERVICE} failed: ${r.stderr.trim()}`);
-    out.push(`${SERVICE} updated and restarted`);
-  } else if (active) {
-    out.push(`${SERVICE} already running`);
-  } else {
-    const pid = await stopDetachedDaemon(paths().pid);
-    if (pid !== null) out.push(`detached daemon (pid ${pid}) stopped, the service takes over`);
-    const r = await run2("systemctl", ["--user", "enable", "--now", SERVICE]);
-    if (r.code !== 0) throw new Error(`systemctl --user enable --now ${SERVICE} failed: ${r.stderr.trim()}`);
-    out.push(`${SERVICE} installed and started (journalctl --user -u ${SERVICE} for its output)`);
-  }
-  const user = process.env.USER ?? userInfo().username;
-  const linger = await run2("loginctl", ["show-user", user, "-p", "Linger"]);
-  if (linger.code === 0 && /^Linger=yes/m.test(linger.stdout)) return out;
-  const enable = await run2("loginctl", ["enable-linger"]);
-  if (enable.code === 0) out.push("linger enabled: the daemon starts with WSL, before any shell is open");
-  else out.push(`linger not enabled (${enable.stderr.trim() || `exit ${enable.code}`}): the daemon starts with your first WSL shell; run \`sudo loginctl enable-linger ${user}\` to start it at WSL boot`);
-  return out;
-}
-async function isDir(path) {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-var BIN_MARK = "#!/bin/sh\n# Written by `ledge setup`";
-var shQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-async function writeBin(opts) {
-  const st = await lstat(opts.link).catch(() => null);
-  const was = st?.isSymbolicLink() ? await readlink(opts.link) : null;
-  if (was !== null && !was.endsWith("/dist/cli/index.js")) return null;
-  const current = st && was === null && st.isFile() ? await readFile2(opts.link, "utf8").catch(() => "") : "";
-  if (st && was === null && !current.startsWith(BIN_MARK)) return null;
-  const script = `${BIN_MARK}: the hooks run \`ledge\` wherever node is not on the PATH.
-exec ${shQuote(opts.node)} ${shQuote(opts.target)} "$@"
-`;
-  if (current === script) return null;
-  await mkdir(dirname(opts.link), { recursive: true });
-  const tmp = `${opts.link}.tmp`;
-  await writeFile(tmp, script, { mode: 493 });
-  await rename(tmp, opts.link);
-  return `${opts.link} runs ${opts.target} with ${opts.node}${was !== null ? ` (was a link to ${was})` : ""}`;
-}
-async function runSetup(opts = {}) {
-  const out = [];
-  await ensureLedgeDir();
-  out.push("~/.ledge ready (tmux.conf written if missing)");
-  const settingsPath = opts.settingsPath ?? join(homedir(), ".claude", "settings.json");
-  if (await mergeJsonFile(settingsPath, mergeClaudeHooks, "settings.json")) out.push(`Claude Code hooks added in ${settingsPath}`);
-  else out.push("Claude Code hooks already present");
-  const codexDir = opts.codexDir ?? process.env.CODEX_HOME ?? join(homedir(), ".codex");
-  if (!await isDir(codexDir)) out.push(`Codex not found (${codexDir} missing), Codex hooks skipped`);
-  else if (await mergeJsonFile(join(codexDir, "hooks.json"), mergeCodexHooks, "hooks.json")) {
-    out.push(`Codex hooks added in ${join(codexDir, "hooks.json")}; Codex asks to review them on its next start: trust them there or from Ledge`);
-  } else out.push("Codex hooks already present");
-  const cursorDir = opts.cursorDir ?? join(homedir(), ".cursor");
-  if (!await isDir(cursorDir)) out.push(`Cursor Agent not found (${cursorDir} missing), Cursor Agent hooks skipped`);
-  else if (await mergeJsonFile(join(cursorDir, "hooks.json"), mergeCursorHooks, "hooks.json")) out.push(`Cursor Agent hooks added in ${join(cursorDir, "hooks.json")}`);
-  else out.push("Cursor Agent hooks already present");
-  if (opts.service ?? true) {
-    const cli = opts.cli ?? process.argv[1] ?? "";
-    if (cli.endsWith(".ts")) out.push("systemd service skipped: run setup from the built CLI (pnpm --filter @paradow/ledge build, then ledge setup)");
-    else {
-      const script = await realpath(cli);
-      const line = await writeBin({ link: opts.link ?? join(homedir(), ".local", "bin", "ledge"), node: process.execPath, target: script });
-      if (line) out.push(line);
-      out.push(...await installService({ script, unitDir: opts.unitDir, run: opts.run }));
-    }
-  }
-  return out;
-}
-
-export {
-  CLAUDE_EVENTS,
-  CODEX_EVENTS,
-  mergeClaudeHooks,
-  mergeCodexHooks,
-  CURSOR_EVENTS,
-  mergeCursorHooks,
-  SERVICE,
-  execRunner,
-  systemdUnit,
-  stopDetachedDaemon,
-  installService,
-  isDir,
-  BIN_MARK,
-  writeBin,
-  runSetup,
-  inDaemonService,
-  tmuxServerAtRisk
-};

package/dist/cli/chunk-ULOMKEB6.js

@@ -1,85 +0,0 @@
-import {
-  CODEX_HOOK_VAR
-} from "./chunk-4TCSADFR.js";
-import {
-  connect
-} from "./chunk-7NHQGP6J.js";
-import {
-  SESSION_KEY_VAR,
-  actionById
-} from "./chunk-IWY7DSSO.js";
-
-// src/cli/action.ts
-import { randomUUID } from "crypto";
-var CLOSE_USAGE = "ledge close <session>\u2026 [--json]                 fermer proprement des sessions (leur conversation reste reprenable)";
-var DAEMON_DOWN = "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)";
-var RUN_MS = 6e4;
-function actionArgs(id, args) {
-  const parsed = actionById(id).args.safeParse(args);
-  return parsed.success ? args : void 0;
-}
-function callerOf(env) {
-  const by = env[CODEX_HOOK_VAR] || env.LEDGE_SESSION;
-  const key = env[SESSION_KEY_VAR];
-  return by ? { by, ...key ? { key } : {} } : void 0;
-}
-async function runOnClient(client, action, args, opts = {}) {
-  const rid = randomUUID();
-  const by = opts.by;
-  client.send({ type: "action.run", rid, action, args, ...by ? { by: by.by, ...by.key ? { key: by.key } : {} } : {}, ...opts.confirmed ? { confirmed: true } : {} });
-  const deadline = Date.now() + (opts.ms ?? RUN_MS);
-  for (; ; ) {
-    const { type: _t, rid: got, ...r } = await client.next("action.result", Math.max(0, deadline - Date.now()));
-    if (got === rid) return r;
-  }
-}
-var plain = (s) => s.replace(/\*\*/g, "");
-function resultLine(r, json = false) {
-  const ok = r.reason === void 0;
-  if (json) return { line: JSON.stringify({ ok, ...r }), code: ok ? 0 : 1 };
-  if (ok) return { line: `fait : ${plain(r.row?.summary ?? r.action)}`, code: 0 };
-  if (r.code === "confirm_required") return { line: `${plain(r.row?.summary ?? r.action)} : irr\xE9versible ; relance avec --yes pour confirmer`, code: 1 };
-  return { line: `${r.code === "failed" ? "\xE9chec" : "refus\xE9"} : ${r.reason}`, code: 1 };
-}
-function closeArgs(args) {
-  const json = args.includes("--json");
-  const sessions = args.filter((a) => a !== "--json");
-  if (!sessions.length || sessions.some((s) => s.startsWith("--") || !actionArgs("session.close", { session: s }))) return void 0;
-  return { sessions, ...json ? { json: true } : {} };
-}
-async function runClose(args, opts = {}) {
-  const parsed = closeArgs(args);
-  if (!parsed) return { line: CLOSE_USAGE, code: args.length ? 1 : 0 };
-  let client;
-  try {
-    client = await connect({ port: opts.port, timeoutMs: 1500 });
-  } catch {
-    return { line: DAEMON_DOWN, code: 1 };
-  }
-  const by = callerOf(opts.env ?? process.env);
-  const lines = [];
-  try {
-    for (const session of parsed.sessions) {
-      const r = resultLine(await runOnClient(client, "session.close", { session }, { by }), parsed.json);
-      lines.push(r.line);
-      if (r.code) return { line: lines.join("\n"), code: 1 };
-    }
-    return { line: lines.join("\n"), code: 0 };
-  } catch (e) {
-    return { line: [...lines, `pas de r\xE9ponse de Ledge : ${e.message}`].join("\n"), code: 1 };
-  } finally {
-    await client.close();
-  }
-}
-
-export {
-  CLOSE_USAGE,
-  DAEMON_DOWN,
-  RUN_MS,
-  actionArgs,
-  callerOf,
-  runOnClient,
-  resultLine,
-  closeArgs,
-  runClose
-};

package/dist/cli/chunk-V4XKKL6K.js

@@ -1,205 +0,0 @@
-import {
-  exitFile,
-  spawnSession
-} from "./chunk-4TCSADFR.js";
-import {
-  DaemonRefusedError,
-  connect
-} from "./chunk-7NHQGP6J.js";
-import {
-  PROTOCOL_PORT,
-  namesInUse
-} from "./chunk-IWY7DSSO.js";
-import {
-  realTmux
-} from "./chunk-T547FLQN.js";
-import {
-  log
-} from "./chunk-54KF5RBY.js";
-import {
-  ensureLedgeDir
-} from "./chunk-53ISXX2R.js";
-
-// src/cli/launch.ts
-import { spawn } from "child_process";
-import { readFile, rm } from "fs/promises";
-import { createConnection } from "net";
-var TMUX_SOCKET = "ledge";
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function parseLaunchArgs(argv) {
-  const args = [];
-  let name;
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (a === "--name") {
-      name = argv[++i];
-      continue;
-    }
-    if (a === "--") {
-      args.push(...argv.slice(i + 1));
-      break;
-    }
-    args.push(a);
-  }
-  return { name, args };
-}
-function portOpen(port) {
-  return new Promise((res) => {
-    const s = createConnection({ host: "127.0.0.1", port });
-    s.once("connect", () => {
-      s.end();
-      res(true);
-    });
-    s.once("error", () => res(false));
-  });
-}
-function spawnDetachedDaemon() {
-  const child = spawn(process.execPath, [process.argv[1], "daemon"], { detached: true, stdio: "ignore" });
-  child.unref();
-}
-var closeQuietly = (c) => Promise.race([c.close(), sleep(500)]);
-async function probe(port, timeoutMs) {
-  let client;
-  try {
-    client = await connect({ port, timeoutMs });
-  } catch (e) {
-    if (e instanceof DaemonRefusedError) return { client: null, state: "unauthorized" };
-    if (e.message === "connect timeout") return { client: null, state: "timeout" };
-    return { client: null, state: await portOpen(port) ? "foreign" : "refused" };
-  }
-  try {
-    await client.next("snapshot", timeoutMs);
-    return { client };
-  } catch {
-    void closeQuietly(client);
-    return { client: null, state: "foreign" };
-  }
-}
-async function ensureDaemon(opts = {}) {
-  await ensureLedgeDir();
-  const port = opts.port ?? PROTOCOL_PORT;
-  const timeoutMs = opts.timeoutMs ?? 2e3;
-  const first = await probe(port, timeoutMs);
-  if (first.client) return { client: first.client };
-  if (first.state === "foreign") {
-    log(`port ${port} is open but does not speak the Ledge protocol`);
-    return { client: null, reason: "foreign" };
-  }
-  if (first.state === "unauthorized") {
-    log(`the daemon on port ${port} refused this client's token`);
-    return { client: null, reason: "unauthorized" };
-  }
-  if (first.state === "timeout") {
-    log(`port ${port} accepted a connection but did not answer within ${timeoutMs} ms`);
-    return { client: null, reason: "unresponsive" };
-  }
-  (opts.spawnDaemon ?? spawnDetachedDaemon)();
-  for (let i = 0; i < 3; i++) {
-    await sleep(opts.retryDelayMs ?? 500);
-    const r = await probe(port, timeoutMs);
-    if (r.client) return { client: r.client };
-  }
-  return { client: null, reason: "unreachable" };
-}
-var DaemonError = class extends Error {
-};
-async function createSession(opts) {
-  const names = [];
-  const ids = [];
-  if (opts.client) {
-    let snap;
-    try {
-      opts.client.send({ type: "snapshot.request" });
-      snap = await opts.client.next("snapshot");
-    } catch (e) {
-      throw new DaemonError(`daemon did not answer: ${e.message}`);
-    }
-    names.push(...namesInUse(snap.sessions));
-    for (const s of snap.sessions) ids.push(s.id);
-  }
-  const session = await spawnSession({ ...opts, taken: { names, ids } });
-  try {
-    opts.client?.send({ type: "session.register", session });
-  } catch (e) {
-    log(`register failed for ${session.id}: ${e.message}`);
-  }
-  return session;
-}
-function attachEnv(env) {
-  const { TMUX: _ignored, ...rest } = env;
-  return rest;
-}
-function attachInherit(args, env) {
-  return new Promise((resolve) => {
-    const child = spawn("tmux", args, { stdio: "inherit", env });
-    child.on("error", () => resolve(1));
-    child.on("exit", (c) => resolve(c ?? 1));
-  });
-}
-async function readExitCode(id) {
-  const file = exitFile(id);
-  let raw = null;
-  try {
-    raw = await readFile(file, "utf8");
-  } catch {
-  }
-  await rm(file, { force: true });
-  const t = raw?.trim();
-  return t && /^\d+$/.test(t) ? Number(t) : null;
-}
-var UNTRACKED = {
-  foreign: (port) => `ledge: port ${port} is used by another program, session not tracked`,
-  unauthorized: () => "ledge: the daemon refused this client's token (missing or changed), session not tracked; restart the daemon: systemctl --user restart ledge-daemon",
-  unresponsive: () => "ledge: daemon not responding, session not tracked",
-  unreachable: () => "ledge: daemon not running, session not tracked"
-};
-async function launch(tool, argv, opts = {}) {
-  await ensureLedgeDir();
-  const { name, args } = parseLaunchArgs(argv);
-  const port = opts.port ?? PROTOCOL_PORT;
-  const socket = opts.tmuxSocket ?? TMUX_SOCKET;
-  const tmux = realTmux(socket);
-  const cwd = opts.cwd ?? process.cwd();
-  const daemon = await ensureDaemon({ port, spawnDaemon: opts.spawnDaemon, retryDelayMs: opts.retryDelayMs });
-  let client = daemon.client;
-  if (!daemon.client) console.error(UNTRACKED[daemon.reason](port));
-  const create = (c) => createSession({ tool, args, command: opts.command, recordExit: true, name, cwd, tmux, client: c });
-  let session;
-  try {
-    session = await create(client);
-  } catch (e) {
-    if (!(e instanceof DaemonError)) throw e;
-    log(e.message);
-    if (client) void closeQuietly(client);
-    client = null;
-    console.error(UNTRACKED.unresponsive(port));
-    session = await create(null);
-  }
-  if (client) await closeQuietly(client);
-  const tmuxName = session.tmuxSession;
-  if (process.stdout.isTTY) process.stdout.write(`\x1B]0;${session.title}\x07`);
-  const attachCode = await (opts.attach ?? attachInherit)(tmux.attachArgs(tmuxName), attachEnv(process.env));
-  if (await tmux.hasSession(tmuxName)) {
-    if (attachCode !== 0) console.error(`ledge: could not attach; ${session.name} keeps running in tmux session ${tmuxName} (tmux -L ${socket} attach -t ${tmuxName})`);
-    return attachCode;
-  }
-  const exitCode = await readExitCode(session.id);
-  if (client) {
-    try {
-      const c = await connect({ port, timeoutMs: 800 });
-      c.send({ type: "session.unregister", id: session.id, exitCode });
-      await closeQuietly(c);
-    } catch {
-    }
-  }
-  return exitCode ?? 1;
-}
-
-export {
-  parseLaunchArgs,
-  ensureDaemon,
-  DaemonError,
-  createSession,
-  attachEnv,
-  launch
-};