@paradow/ledge 0.0.0-stage → 0.3.1

package/dist/cli/hook-HP23ZISG.js

@@ -0,0 +1,288 @@
+import {
+  QUESTION_TOOLS
+} from "./chunk-ZPF5I3LS.js";
+import {
+  CODEX_ENV_VAR,
+  CODEX_HOOK_VAR,
+  log
+} from "./chunk-OUIDBDIH.js";
+import "./chunk-6ZTCETRG.js";
+import {
+  connect
+} from "./chunk-W5XAZ5IS.js";
+import "./chunk-6GMDFIGB.js";
+
+// src/cli/hook.ts
+import { readFileSync, openSync, fstatSync, readSync, closeSync } from "fs";
+import { basename, join } from "path";
+var str = (v) => typeof v === "string" ? v : void 0;
+var PROMPT_MAX = 500;
+var promptText = (p) => {
+  const t = str(p.prompt)?.trim();
+  return t ? { text: t.slice(0, PROMPT_MAX) } : {};
+};
+function describeTool(tool, input) {
+  const i = input && typeof input === "object" ? input : {};
+  if (tool === "Bash") return str(i.command) ?? "";
+  if (tool === "Edit" || tool === "Write" || tool === "MultiEdit" || tool === "Read") return str(i.file_path) ?? "";
+  if (tool === "ExitPlanMode") return str(i.plan)?.split("\n")[0] ?? "plan";
+  if (tool === "apply_patch") {
+    const files = [...(str(i.command) ?? "").matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)].map((m) => m[1].trim());
+    return files.length ? files.join(", ") : "patch";
+  }
+  return str(i.description) ?? JSON.stringify(i).slice(0, 200);
+}
+var REPLY_MAX = 24e3;
+function lastReply(p) {
+  const text = str(p.last_assistant_message)?.trim();
+  if (!text) return void 0;
+  return text.length > REPLY_MAX ? `${text.slice(0, REPLY_MAX)}
+
+[\u2026]` : text;
+}
+var NON_TERMINAL_END_REASONS = /* @__PURE__ */ new Set(["clear", "resume"]);
+function mapClaudeHook(eventName, payload, at) {
+  return mapHook("claude", eventName, payload, at);
+}
+function underCodexDaemon(read = (p) => readFileSync(p, "utf8")) {
+  let pid = process.pid;
+  for (let depth = 0; depth < 8; depth++) {
+    try {
+      const stat = read(`/proc/${pid}/stat`);
+      pid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+      if (!pid || pid <= 1) return false;
+      if (read(`/proc/${pid}/cmdline`).split("\0").includes("app-server")) return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function codexLedgeId(env = process.env, daemon = underCodexDaemon) {
+  if (env[CODEX_HOOK_VAR]) return env[CODEX_HOOK_VAR];
+  if (env[CODEX_ENV_VAR] && !daemon()) return env[CODEX_ENV_VAR];
+  return void 0;
+}
+function mapHook(agent, eventName, payload, at) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const ledgeId = (agent === "codex" ? codexLedgeId() : process.env.LEDGE_SESSION) || void 0;
+  const launched = !!ledgeId;
+  const id = ledgeId || str(p.session_id);
+  if (!id) return null;
+  const cwd = str(p.cwd) || void 0;
+  const event = mapEvent(eventName, p, at, launched);
+  if (!event) return null;
+  const task = agent === "claude" && event.helperId ? helperDescription(str(p.transcript_path), event.helperId) : void 0;
+  return { id, event: task ? { ...event, task } : event, agent, ...cwd ? { cwd } : {} };
+}
+function helperDescription(transcriptPath, agentId) {
+  if (!transcriptPath?.endsWith(".jsonl") || !/^[\w-]+$/.test(agentId)) return void 0;
+  try {
+    const meta = JSON.parse(readFileSync(join(transcriptPath.slice(0, -".jsonl".length), "subagents", `agent-${agentId}.meta.json`), "utf8"));
+    return str(meta.description)?.split("\n")[0]?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function mapEvent(eventName, p, at, launched) {
+  const tool = str(p.tool_name);
+  const agentId = str(p.agent_id) || void 0;
+  const base = { at, source: "hook", ...agentId ? { helperId: agentId } : {} };
+  switch (eventName) {
+    case "SubagentStart":
+    case "SubagentStop": {
+      if (!agentId) return null;
+      const type = str(p.agent_type) || void 0;
+      const task = eventName === "SubagentStart" ? (str(p.description) || str(p.prompt))?.split("\n")[0] : void 0;
+      return { name: eventName, ...base, ...type ? { tool: type } : {}, ...task ? { text: task } : {} };
+    }
+    case "PostToolUse":
+      return { name: "PostToolUse", ...base, tool };
+    case "PostToolUseFailure":
+      return { name: "PostToolUseFailure", ...base, tool, ...p.is_interrupt === true ? { interrupt: true } : {} };
+    case "StopFailure": {
+      const error = str(p.error);
+      const details = str(p.error_details);
+      const text = [error, details].filter(Boolean).join(": ").slice(0, 300) || void 0;
+      return { name: "StopFailure", ...base, ...text ? { text } : {} };
+    }
+    // Codex: Esc on a running turn or on an approval. Like Claude's interrupted tool run, no Stop follows.
+    case "Interrupt":
+      return { name: "PostToolUseFailure", ...base, interrupt: true };
+    case "SessionStart":
+      return { name: "SessionStart", ...base };
+    case "UserPromptSubmit":
+      return { name: "UserPromptSubmit", ...base, ...promptText(p) };
+    case "Stop": {
+      const text = lastReply(p);
+      return { name: "Stop", ...base, ...text ? { text } : {} };
+    }
+    case "SessionEnd":
+      if (launched) return null;
+      if (NON_TERMINAL_END_REASONS.has(str(p.reason) ?? "")) return null;
+      return { name: "SessionEnd", ...base, exitCode: null };
+    case "PermissionRequest":
+      return { name: "PermissionRequest", ...base, tool, text: describeTool(tool, p.tool_input) };
+    case "PreToolUse": {
+      if (tool && QUESTION_TOOLS.has(tool)) {
+        const qs = p.tool_input?.questions ?? [];
+        const q = qs[0];
+        const options = (q?.options ?? []).map((o) => str(o.label) ?? "").filter(Boolean);
+        return { name: "PreToolUse", ...base, tool, text: str(q?.question) ?? "", options };
+      }
+      return { name: "PreToolUse", ...base, tool, text: describeTool(tool, p.tool_input) };
+    }
+    case "Notification": {
+      const type = str(p.notification_type) ?? "";
+      const message = str(p.message) ?? "";
+      const kind = type === "permission_prompt" || /permission/i.test(message) ? "permission" : void 0;
+      return { name: "Notification", ...base, kind, text: message };
+    }
+    default:
+      return null;
+  }
+}
+function describeCursorTool(input) {
+  const i = input && typeof input === "object" ? input : {};
+  return str(i.command) ?? str(i.file_path) ?? str(i.path) ?? str(i.description) ?? JSON.stringify(i).slice(0, 200);
+}
+function readTranscript(path, bytes = 512 * 1024) {
+  let raw;
+  try {
+    const fd = openSync(path, "r");
+    try {
+      const size = fstatSync(fd).size;
+      const len = Math.min(size, bytes);
+      const buf = Buffer.alloc(len);
+      readSync(fd, buf, 0, len, size - len);
+      raw = buf.toString("utf8");
+      if (len < size) raw = raw.slice(raw.indexOf("\n") + 1);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    try {
+      if (line.trim()) out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+var blocks = (e) => e.message?.content ?? [];
+var compact = (t) => t.replace(/\s+/g, "");
+function cursorReply(text, entries) {
+  let u = entries.length - 1;
+  while (u >= 0 && entries[u].role !== "user") u--;
+  const parts = entries.slice(u + 1).filter((e) => e.role === "assistant").flatMap(blocks).filter((b) => b.type === "text" && b.text && b.text !== "[REDACTED]").map((b) => b.text.trim()).filter(Boolean);
+  const joined = parts.join("\n\n");
+  return parts.length > 1 && compact(joined) === compact(text) ? joined : text;
+}
+function unwrapTool(name, input) {
+  const i = input && typeof input === "object" ? input : {};
+  if (name === "CallDynamicTool" && str(i.toolName)) return { name: str(i.toolName), input: i.arguments && typeof i.arguments === "object" ? i.arguments : {} };
+  return { name, input: i };
+}
+function mapCursorHook(eventName, payload, at, env = process.env) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const sessionId = str(p.session_id) || str(p.conversation_id);
+  if (!sessionId) return null;
+  const transcript = env.CURSOR_TRANSCRIPT_PATH || void 0;
+  const parentId = transcript ? basename(transcript, ".jsonl") : void 0;
+  const generation = str(p.generation_id);
+  const helper = parentId ? parentId !== sessionId : eventName !== "sessionStart" && generation === sessionId;
+  const id = env.LEDGE_SESSION || (helper ? parentId : sessionId);
+  if (!id) return null;
+  const roots = Array.isArray(p.workspace_roots) ? p.workspace_roots : [];
+  const cwd = str(roots[0]) || void 0;
+  const event = helper ? mapCursorHelperEvent(eventName, p, at, sessionId) : mapCursorEvent(eventName, p, at, !!env.LEDGE_SESSION, transcript);
+  return event ? { id, event, agent: "cursor", ...cwd ? { cwd } : {} } : null;
+}
+function mapCursorHelperEvent(eventName, p, at, helperId) {
+  const base = { at, source: "hook", helperId };
+  const tool = str(p.tool_name);
+  switch (eventName) {
+    case "preToolUse":
+      return { name: "SubagentStart", ...base };
+    case "postToolUse":
+      return { name: "PostToolUse", ...base, tool };
+    case "postToolUseFailure":
+      return { name: "PostToolUseFailure", ...base, tool };
+    default:
+      return null;
+  }
+}
+function mapCursorEvent(eventName, p, at, launched, transcript) {
+  const { name: tool, input } = unwrapTool(str(p.tool_name), p.tool_input);
+  const base = { at, source: "hook" };
+  switch (eventName) {
+    case "sessionStart":
+      return { name: "SessionStart", ...base };
+    case "beforeSubmitPrompt":
+      return { name: "UserPromptSubmit", ...base, ...promptText(p) };
+    case "preToolUse": {
+      if (tool === "Task") {
+        const callId = (str(p.tool_use_id) ?? "").split("\n")[0] || at;
+        const task = str(input.description) || str(input.prompt)?.split("\n")[0] || "";
+        return { name: "SubagentStart", ...base, helperId: `task:${callId}`, tool: str(input.subagent_type) || "subagent", ...task ? { text: task } : {} };
+      }
+      return { name: "PreToolUse", ...base, tool, text: describeCursorTool(input) };
+    }
+    case "postToolUse":
+      return { name: "PostToolUse", ...base, tool };
+    case "postToolUseFailure":
+      return { name: "PostToolUseFailure", ...base, tool, ...p.is_interrupt === true ? { interrupt: true } : {} };
+    case "stop":
+      if (str(p.status) === "error") return { name: "StopFailure", ...base };
+      return { name: "Stop", ...base };
+    case "afterAgentResponse": {
+      const raw = str(p.text) ?? "";
+      const text = lastReply({ last_assistant_message: raw && transcript ? cursorReply(raw, readTranscript(transcript)) : raw });
+      return { name: "Stop", ...base, ...text ? { text } : {} };
+    }
+    case "sessionEnd":
+      if (launched) return null;
+      return { name: "SessionEnd", ...base, exitCode: null };
+    default:
+      return null;
+  }
+}
+async function runHook(eventName, stdin, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 100;
+  const deadline = Date.now() + timeoutMs;
+  const agent = opts.tool ?? "claude";
+  const label = agent === "claude" ? eventName : `${agent} ${eventName}`;
+  if (process.env.LEDGE_CHAT === "1") {
+    log(`hook ${label} ignored: Ledge chat`);
+    return;
+  }
+  try {
+    const payload = JSON.parse(stdin || "{}");
+    const mapped = agent === "cursor" ? mapCursorHook(eventName, payload, (/* @__PURE__ */ new Date()).toISOString()) : mapHook(agent, eventName, payload, (/* @__PURE__ */ new Date()).toISOString());
+    if (!mapped) {
+      log(`hook ${label} ignored: unknown event, malformed payload, non-terminal SessionEnd or subagent event without a session of its own`);
+      return;
+    }
+    const client = await connect({ port: opts.port, timeoutMs });
+    client.send({ type: "session.event", id: mapped.id, event: mapped.event, agent: mapped.agent, ...mapped.cwd ? { cwd: mapped.cwd } : {} });
+    await Promise.race([client.close(), new Promise((r) => setTimeout(r, Math.max(0, deadline - Date.now())))]);
+  } catch (e) {
+    log(`hook ${label} dropped: ${e.message}`);
+  }
+}
+export {
+  REPLY_MAX,
+  codexLedgeId,
+  cursorReply,
+  mapClaudeHook,
+  mapCursorHook,
+  mapHook,
+  readTranscript,
+  runHook,
+  underCodexDaemon
+};

package/dist/cli/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+var USAGE = `ledge <claude|codex|cursor> [--name <bot>] [-- agent args]   start an agent in a tracked session
+ledge attach <id>                                            put this terminal on a running session
+ledge daemon                                                 run the daemon in the foreground
+ledge hook [codex|cursor] <Event>                            receive a hook (reads JSON on stdin)
+ledge setup                                                  install hooks and ~/.ledge
+ledge uninstall [--purge]                                    remove hooks, service and link (--purge: ~/.ledge too)
+ledge status                                                 list sessions
+ledge --version                                              print the installed version`;
+async function hookMain(args) {
+  const tool = args[0] === "codex" || args[0] === "cursor" ? args[0] : void 0;
+  const event = (tool ? args[1] : args[0]) ?? "";
+  try {
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    const { runHook } = await import("./hook-HP23ZISG.js");
+    await runHook(event, Buffer.concat(chunks).toString("utf8"), { tool });
+  } catch {
+  }
+  if (tool === "cursor") process.stdout.write("{}\n");
+}
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case "daemon": {
+      const { startDaemon } = await import("./daemon-6DDF7YZD.js");
+      await startDaemon();
+      await new Promise(() => {
+      });
+      return 0;
+    }
+    case "--version":
+    case "version": {
+      const { LEDGE_VERSION } = await import("./version-IBPGTVPF.js");
+      console.log(LEDGE_VERSION);
+      return 0;
+    }
+    case "setup": {
+      const { runSetup } = await import("./setup-KUWSQLVG.js");
+      for (const l of await runSetup()) console.log(l);
+      return 0;
+    }
+    case "uninstall": {
+      const { runUninstall } = await import("./uninstall-5GHUYN7P.js");
+      const r = await runUninstall({ purge: rest.includes("--purge") });
+      for (const l of r.lines) console.log(l);
+      return r.ok ? 0 : 1;
+    }
+    case "status": {
+      const { printStatus } = await import("./status-IW2FESH4.js");
+      console.log(await printStatus());
+      return 0;
+    }
+    case "claude":
+    case "codex":
+    case "cursor": {
+      const { launch } = await import("./launch-DFB54ANN.js");
+      return launch(cmd, rest);
+    }
+    case "attach": {
+      const { attach } = await import("./attach-YBGTDBQI.js");
+      return attach(rest[0] ?? "");
+    }
+    default:
+      console.log(USAGE);
+      return cmd ? 1 : 0;
+  }
+}
+if (process.argv[2] === "hook") {
+  hookMain(process.argv.slice(3)).then(() => process.exit(0), () => process.exit(0));
+} else {
+  main(process.argv.slice(2)).then((code) => process.exit(code), (e) => {
+    console.error(`ledge: ${e.message}`);
+    process.exit(1);
+  });
+}

package/dist/cli/launch-DFB54ANN.js

@@ -0,0 +1,26 @@
+import {
+  DaemonError,
+  attachEnv,
+  createSession,
+  ensureDaemon,
+  launch,
+  parseLaunchArgs
+} from "./chunk-Y44XZY6I.js";
+import "./chunk-7ICDC2LK.js";
+import {
+  agentEnv,
+  exitFile
+} from "./chunk-OUIDBDIH.js";
+import "./chunk-6ZTCETRG.js";
+import "./chunk-W5XAZ5IS.js";
+import "./chunk-6GMDFIGB.js";
+export {
+  DaemonError,
+  agentEnv,
+  attachEnv,
+  createSession,
+  ensureDaemon,
+  exitFile,
+  launch,
+  parseLaunchArgs
+};

package/dist/cli/setup-KUWSQLVG.js

@@ -0,0 +1,33 @@
+import {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  CURSOR_EVENTS,
+  SERVICE,
+  execRunner,
+  installService,
+  isDir,
+  mergeClaudeHooks,
+  mergeCodexHooks,
+  mergeCursorHooks,
+  relinkBin,
+  runSetup,
+  stopDetachedDaemon,
+  systemdUnit
+} from "./chunk-XDRYMOVF.js";
+import "./chunk-6ZTCETRG.js";
+export {
+  CLAUDE_EVENTS,
+  CODEX_EVENTS,
+  CURSOR_EVENTS,
+  SERVICE,
+  execRunner,
+  installService,
+  isDir,
+  mergeClaudeHooks,
+  mergeCodexHooks,
+  mergeCursorHooks,
+  relinkBin,
+  runSetup,
+  stopDetachedDaemon,
+  systemdUnit
+};

package/dist/cli/status-IW2FESH4.js

@@ -0,0 +1,26 @@
+import {
+  connect
+} from "./chunk-W5XAZ5IS.js";
+import "./chunk-6GMDFIGB.js";
+
+// src/cli/status.ts
+async function printStatus(opts = {}) {
+  let client;
+  try {
+    client = await connect({ port: opts.port, timeoutMs: 800 });
+  } catch {
+    return "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)";
+  }
+  const snap = await client.next("snapshot");
+  await client.close();
+  if (snap.sessions.length === 0) return "no sessions";
+  const rows = snap.sessions.map((s) => {
+    const age = Math.round((Date.now() - Date.parse(s.startedAt)) / 6e4);
+    const ask = s.pending ? ` \xB7 ${s.pending.kind}: ${s.pending.text}` : "";
+    return `${s.name.padEnd(8)} ${s.tool.padEnd(7)} ${s.state.padEnd(19)} ${s.project.padEnd(28)} ${age}m${ask}${s.source === "hook_only" ? " \xB7 read only" : ""}`;
+  });
+  return rows.join("\n");
+}
+export {
+  printStatus
+};

package/dist/cli/uninstall-5GHUYN7P.js

@@ -0,0 +1,154 @@
+import {
+  SERVICE,
+  execRunner,
+  stopDetachedDaemon
+} from "./chunk-XDRYMOVF.js";
+import {
+  paths
+} from "./chunk-6ZTCETRG.js";
+
+// src/cli/uninstall.ts
+import { readFile, writeFile, rename, rm, lstat, realpath } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var LEDGE_HOOK = /^ledge hook (?:(?:codex|cursor) )?[A-Za-z]+$/;
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function prune(config, file, keep) {
+  if (!isObject(config)) throw new Error(`${file} root is not an object, not modified`);
+  if (config.hooks === void 0) return { settings: config, removed: 0 };
+  if (!isObject(config.hooks)) throw new Error(`${file} "hooks" is not an object, not modified`);
+  const hooks = {};
+  let removed = 0;
+  for (const [ev, list] of Object.entries(config.hooks)) {
+    if (!Array.isArray(list)) throw new Error(`${file} hooks.${ev} is not an array, not modified`);
+    const kept = [];
+    for (const entry of list) {
+      const next = keep(entry);
+      if (next === null) removed++;
+      else {
+        if (next !== entry) removed++;
+        kept.push(next);
+      }
+    }
+    if (kept.length || !list.length) hooks[ev] = kept;
+  }
+  const { hooks: _drop, ...rest } = config;
+  return { settings: Object.keys(hooks).length ? { ...rest, hooks } : rest, removed };
+}
+function removeClaudeHooks(settings, file = "settings.json") {
+  return prune(settings, file, (entry) => {
+    if (!isObject(entry) || !Array.isArray(entry.hooks)) return entry;
+    const others = entry.hooks.filter((h) => !(isObject(h) && typeof h.command === "string" && LEDGE_HOOK.test(h.command)));
+    if (others.length === entry.hooks.length) return entry;
+    return others.length ? { ...entry, hooks: others } : null;
+  });
+}
+function removeCursorHooks(config) {
+  return prune(config, "hooks.json", (entry) => isObject(entry) && typeof entry.command === "string" && LEDGE_HOOK.test(entry.command) ? null : entry);
+}
+async function pruneJsonFile(path, remove, name) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+  let current;
+  try {
+    current = JSON.parse(raw);
+  } catch {
+    throw new Error(`${name} is not valid JSON, not modified`);
+  }
+  const { settings, removed } = remove(current);
+  if (!removed) return 0;
+  const tmp = `${path}.ledge-${process.pid}.tmp`;
+  await writeFile(tmp, JSON.stringify(settings, null, 2) + "\n");
+  await rename(tmp, path);
+  return removed;
+}
+async function removeService(opts = {}) {
+  const out = [];
+  const run = opts.run ?? execRunner;
+  const unit = join(opts.unitDir ?? join(homedir(), ".config", "systemd", "user"), SERVICE);
+  let present = true;
+  try {
+    await lstat(unit);
+  } catch {
+    present = false;
+  }
+  if (present) {
+    const r = await run("systemctl", ["--user", "disable", "--now", SERVICE]);
+    if (r.code !== 0) out.push(`systemctl --user disable --now ${SERVICE} failed (${r.stderr.trim() || `exit ${r.code}`}), removing the unit anyway`);
+    await rm(unit, { force: true });
+    await run("systemctl", ["--user", "daemon-reload"]);
+    out.push(`${SERVICE} stopped and removed`);
+  } else out.push(`${SERVICE} not installed`);
+  const pid = await stopDetachedDaemon(opts.pidFile ?? paths().pid);
+  if (pid !== null) out.push(`detached daemon (pid ${pid}) stopped`);
+  return out;
+}
+async function runningSessions(run, socket) {
+  const r = await run("tmux", ["-L", socket, "list-sessions", "-F", "#{session_name}"]);
+  return r.code === 0 ? r.stdout.split("\n").filter(Boolean).length : 0;
+}
+async function removeLink(link, script) {
+  try {
+    if (!(await lstat(link)).isSymbolicLink()) return false;
+    if (await realpath(link) !== await realpath(script)) return false;
+  } catch {
+    return false;
+  }
+  await rm(link, { force: true });
+  return true;
+}
+async function runUninstall(opts = {}) {
+  const lines = [];
+  let ok = true;
+  const step = async (f) => {
+    try {
+      await f();
+    } catch (e) {
+      ok = false;
+      lines.push(`error: ${e.message}`);
+    }
+  };
+  const run = opts.run ?? execRunner;
+  const files = [
+    ["Claude Code", opts.settingsPath ?? join(homedir(), ".claude", "settings.json"), (c) => removeClaudeHooks(c, "settings.json")],
+    ["Codex", join(opts.codexDir ?? process.env.CODEX_HOME ?? join(homedir(), ".codex"), "hooks.json"), (c) => removeClaudeHooks(c, "hooks.json")],
+    ["Cursor Agent", join(opts.cursorDir ?? join(homedir(), ".cursor"), "hooks.json"), removeCursorHooks]
+  ];
+  for (const [agent, path, remove] of files) {
+    await step(async () => {
+      const n = await pruneJsonFile(path, remove, `${agent} ${path}`);
+      lines.push(n === null ? `${agent}: ${path} missing, nothing to remove` : n ? `${agent}: ${n} Ledge hook${n > 1 ? "s" : ""} removed from ${path}` : `${agent}: no Ledge hook in ${path}`);
+    });
+  }
+  if (opts.service ?? true) await step(async () => {
+    lines.push(...await removeService({ unitDir: opts.unitDir, run }));
+  });
+  await step(async () => {
+    const n = await runningSessions(run, opts.tmuxSocket ?? "ledge");
+    if (n) lines.push(`${n} session${n > 1 ? "s" : ""} still running on Ledge's tmux server, left alone: \`tmux -L ${opts.tmuxSocket ?? "ledge"} kill-server\` ends ${n > 1 ? "them" : "it"}`);
+  });
+  const dir = paths().dir;
+  if (opts.purge) await step(async () => {
+    await rm(dir, { recursive: true, force: true });
+    lines.push(`${dir} removed`);
+  });
+  else lines.push(`${dir} kept (session journal and log): \`ledge uninstall --purge\` removes it`);
+  const script = opts.script ?? process.argv[1];
+  const link = opts.link ?? join(homedir(), ".local", "bin", "ledge");
+  if (script) await step(async () => {
+    if (await removeLink(link, script)) lines.push(`${link} removed`);
+  });
+  lines.push(ok ? "Ledge is uninstalled from WSL. On Windows: Settings > Apps > Installed apps > Ledge > Uninstall." : "Uninstall finished with errors, see above.");
+  return { lines, ok };
+}
+export {
+  removeClaudeHooks,
+  removeCursorHooks,
+  removeService,
+  runUninstall
+};

package/dist/cli/version-IBPGTVPF.js

@@ -0,0 +1,6 @@
+import {
+  LEDGE_VERSION
+} from "./chunk-ATG6CVVY.js";
+export {
+  LEDGE_VERSION
+};

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@paradow/ledge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.1",
+  "description": "Follow and answer your WSL agent sessions (Claude Code, Codex, Cursor Agent) from the Ledge island on Windows.",
+  "type": "module",
+  "bin": { "ledge": "dist/cli/index.js" },
+  "files": ["dist"],
+  "engines": { "node": ">=22" },
+  "repository": { "type": "git", "url": "git+https://github.com/Paradow-dev/ledge.git", "directory": "packages/ledge" },
+  "homepage": "https://github.com/Paradow-dev/ledge#readme",
+  "license": "UNLICENSED",
+  "publishConfig": { "access": "public", "provenance": true },
+  "scripts": {
+    "dev": "tsx src/cli/index.ts",
+    "build": "tsup",
+    "prepublishOnly": "pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@ledge/protocol": "workspace:*",
+    "@types/node": "^22.7.0",
+    "@types/ws": "^8.5.12",
+    "tsup": "^8.3.0"
+  }
+}