@paradow/ledge 0.0.0-stage → 0.3.1

package/dist/cli/chunk-W5XAZ5IS.js

@@ -0,0 +1,77 @@
+import {
+  PROTOCOL_PORT,
+  parseServerMessage
+} from "./chunk-6GMDFIGB.js";
+
+// src/client.ts
+import WebSocket from "ws";
+function connect(opts = {}) {
+  const port = opts.port ?? PROTOCOL_PORT;
+  const host = opts.host ?? "127.0.0.1";
+  const ws = new WebSocket(`ws://${host}:${port}`);
+  const queue = [];
+  const MAX_QUEUED = 100;
+  const waiters = [];
+  ws.on("message", (data) => {
+    let msg;
+    try {
+      msg = parseServerMessage(JSON.parse(String(data)));
+    } catch {
+      return;
+    }
+    const i = waiters.findIndex((w) => w.type === msg.type);
+    if (i >= 0) waiters.splice(i, 1)[0].resolve(msg);
+    else {
+      queue.push(msg);
+      if (queue.length > MAX_QUEUED) queue.shift();
+    }
+  });
+  const client = {
+    send: (msg) => ws.send(JSON.stringify(msg)),
+    next(type, timeoutMs = 1500) {
+      const i = queue.findIndex((m) => m.type === type);
+      if (i >= 0) return Promise.resolve(queue.splice(i, 1)[0]);
+      return new Promise((resolve, reject) => {
+        const w = { type, resolve: (m) => {
+          clearTimeout(t);
+          resolve(m);
+        } };
+        const t = setTimeout(() => {
+          waiters.splice(waiters.indexOf(w), 1);
+          reject(new Error(`timeout waiting for ${type}`));
+        }, timeoutMs);
+        waiters.push(w);
+      });
+    },
+    close: () => new Promise((res) => {
+      if (ws.readyState === WebSocket.CLOSED) return res();
+      ws.once("close", () => res());
+      ws.close();
+    })
+  };
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      ws.terminate();
+      reject(new Error("connect timeout"));
+    }, opts.timeoutMs ?? 1e3);
+    ws.once("open", () => {
+      clearTimeout(t);
+      resolve(client);
+    });
+    let settled = false;
+    ws.once("open", () => {
+      settled = true;
+    });
+    ws.on("error", (e) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(t);
+        reject(e);
+      }
+    });
+  });
+}
+
+export {
+  connect
+};

package/dist/cli/chunk-XDRYMOVF.js

@@ -0,0 +1,267 @@
+import {
+  ensureLedgeDir,
+  paths
+} from "./chunk-6ZTCETRG.js";
+
+// src/cli/setup.ts
+import { readFile, writeFile, mkdir, rename, realpath, rm, stat, lstat, readlink, symlink, unlink } from "fs/promises";
+import { execFile } from "child_process";
+import { homedir, userInfo } from "os";
+import { join, dirname } from "path";
+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 readFile(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 readFile(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 readFile(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 run = 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 run("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 run("systemctl", ["--user", "is-active", SERVICE])).code === 0;
+  if (active && changed) {
+    const r = await run("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 run("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 run("loginctl", ["show-user", user, "-p", "Linger"]);
+  if (linger.code === 0 && /^Linger=yes/m.test(linger.stdout)) return out;
+  const enable = await run("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;
+  }
+}
+async function relinkBin(opts) {
+  const st = await lstat(opts.link).catch(() => null);
+  if (!st?.isSymbolicLink()) return null;
+  const current = await readlink(opts.link);
+  if (current === opts.target || !current.endsWith("/dist/cli/index.js")) return null;
+  await unlink(opts.link);
+  await symlink(opts.target, opts.link);
+  return `${opts.link} now points to ${opts.target} (was ${current})`;
+}
+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) && !process.argv[1]?.endsWith(".ts")) {
+    const line = await relinkBin({ link: join(homedir(), ".local", "bin", "ledge"), target: await realpath(process.argv[1]) });
+    if (line) out.push(line);
+  }
+  if (opts.service ?? true) {
+    if (process.argv[1]?.endsWith(".ts")) out.push("systemd service skipped: run setup from the built CLI (pnpm --filter @paradow/ledge build, then ledge setup)");
+    else out.push(...await installService());
+  }
+  return out;
+}
+
+export {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  mergeClaudeHooks,
+  mergeCodexHooks,
+  CURSOR_EVENTS,
+  mergeCursorHooks,
+  SERVICE,
+  execRunner,
+  systemdUnit,
+  stopDetachedDaemon,
+  installService,
+  isDir,
+  relinkBin,
+  runSetup
+};

package/dist/cli/chunk-Y44XZY6I.js

@@ -0,0 +1,197 @@
+import {
+  realTmux
+} from "./chunk-7ICDC2LK.js";
+import {
+  exitFile,
+  log,
+  spawnSession
+} from "./chunk-OUIDBDIH.js";
+import {
+  ensureLedgeDir
+} from "./chunk-6ZTCETRG.js";
+import {
+  connect
+} from "./chunk-W5XAZ5IS.js";
+import {
+  PROTOCOL_PORT
+} from "./chunk-6GMDFIGB.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.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 === "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}`);
+    }
+    for (const s of snap.sessions) {
+      names.push(s.name);
+      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`,
+  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
+};