@paradow/ledge 0.3.3 → 0.5.0

package/dist/cli/chunk-Y4ODVTTN.js

@@ -0,0 +1,438 @@
+// ../protocol/src/messages.ts
+import { z as z7 } from "zod";
+
+// ../protocol/src/session.ts
+import { z } from "zod";
+var ToolSchema = z.enum(["claude", "codex", "cursor"]);
+var SessionStateSchema = z.enum(["starting", "working", "waiting_input", "waiting_permission", "idle", "exited", "error"]);
+var PendingSchema = z.object({
+  kind: z.enum(["question", "permission", "plan", "diff"]),
+  text: z.string(),
+  tool: z.string().optional(),
+  options: z.array(z.string()).optional(),
+  /** Each option's description, by index ('' when it has none); left out when no option has one. */
+  optionDetails: z.array(z.string()).optional(),
+  source: z.enum(["hook", "pane"]),
+  /** Set when the request comes from a helper (subagent): it is routed through its parent. */
+  helperId: z.string().optional(),
+  /** For a helper-routed request: the state the parent returns to once it is answered (main thread may stop meanwhile). */
+  parentState: SessionStateSchema.optional()
+});
+var ReplySchema = z.object({
+  text: z.string(),
+  at: z.string().datetime()
+});
+var HelperSchema = z.object({
+  id: z.string(),
+  kind: z.string(),
+  task: z.string(),
+  state: SessionStateSchema
+});
+var TopicSourceSchema = z.enum(["user", "pane", "prompt"]);
+var SessionSchema = z.object({
+  /** Origin is annotated by the overlay, never used as an unqualified session id on the wire. */
+  machineId: z.string().optional(),
+  machineName: z.string().optional(),
+  repoId: z.string().optional(),
+  id: z.string().min(1),
+  name: z.string().min(1),
+  tool: ToolSchema,
+  cwd: z.string(),
+  project: z.string(),
+  title: z.string(),
+  /** One line saying what the session is about (spec 2026-10-11 §3). */
+  topic: z.string().optional(),
+  topicSource: TopicSourceSchema.optional(),
+  /** The repository (its main worktree's folder name and absolute path), the checked-out branch, and whether `cwd` is a linked worktree (§4). */
+  repo: z.string().optional(),
+  repoPath: z.string().optional(),
+  branch: z.string().optional(),
+  worktree: z.boolean().optional(),
+  tmuxSession: z.string().nullable(),
+  state: SessionStateSchema,
+  pending: PendingSchema.optional(),
+  helpers: z.array(HelperSchema).default([]),
+  lastReply: ReplySchema.optional(),
+  startedAt: z.string().datetime(),
+  lastActivityAt: z.string().datetime(),
+  lastHookAt: z.string().datetime().optional(),
+  exitCode: z.number().int().nullable().optional(),
+  exitedAt: z.string().datetime().optional(),
+  lastError: z.string().optional(),
+  source: z.enum(["launcher", "hook_only"])
+});
+
+// ../protocol/src/chat.ts
+import { z as z2 } from "zod";
+var ChatStepSchema = z2.object({
+  kind: z2.enum(["sessions", "pane", "reply", "git", "repo"]),
+  id: z2.string().optional(),
+  name: z2.string().optional(),
+  path: z2.string().optional()
+});
+var ChatProposalSchema = z2.object({
+  cwd: z2.string().min(1),
+  project: z2.string(),
+  prompt: z2.string().optional(),
+  tool: ToolSchema,
+  launchedId: z2.string().optional(),
+  error: z2.string().optional()
+});
+var ChatRelaySchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string(),
+  tool: ToolSchema,
+  text: z2.string().min(1),
+  status: z2.enum(["queued", "sent"]).optional(),
+  sentAt: z2.string().datetime().optional(),
+  error: z2.string().optional()
+});
+var ChatTurnSchema = z2.object({
+  machineId: z2.string().optional(),
+  machineName: z2.string().optional(),
+  choices: z2.array(z2.object({ id: z2.string(), label: z2.string() })).optional(),
+  qid: z2.string().min(1),
+  question: z2.string(),
+  askedAt: z2.string().datetime(),
+  steps: z2.array(ChatStepSchema),
+  answer: z2.string().optional(),
+  answeredAt: z2.string().datetime().optional(),
+  error: z2.string().optional(),
+  proposal: ChatProposalSchema.optional(),
+  relay: ChatRelaySchema.optional()
+});
+
+// ../protocol/src/documents.ts
+import { z as z3 } from "zod";
+var DOCUMENT_MAX_BYTES = 1048576;
+var path = z3.string().min(1).max(4096);
+var requestId = z3.string().min(1);
+var DocumentReadSchema = z3.object({
+  type: z3.literal("document.read"),
+  requestId,
+  path,
+  machineId: z3.string().optional(),
+  sessionId: z3.string().min(1).optional(),
+  basePath: path.optional()
+});
+var DocumentContentSchema = z3.object({
+  type: z3.literal("document.content"),
+  requestId,
+  path,
+  text: z3.string(),
+  bytes: z3.number().int().nonnegative(),
+  modifiedAt: z3.string().datetime()
+});
+var DocumentErrorCodeSchema = z3.enum([
+  "not_found",
+  "not_file",
+  "unsupported_path",
+  "unsupported_type",
+  "permission_denied",
+  "too_large",
+  "invalid_utf8",
+  "ambiguous_path",
+  "session_missing",
+  "read_failed"
+]);
+var DocumentErrorSchema = z3.object({
+  type: z3.literal("document.error"),
+  requestId,
+  path,
+  code: DocumentErrorCodeSchema
+});
+
+// ../protocol/src/routing.ts
+import { z as z4 } from "zod";
+var MachineInventorySchema = z4.object({
+  id: z4.string().min(1).max(80),
+  label: z4.string().min(1).max(120),
+  online: z4.boolean(),
+  local: z4.boolean(),
+  sessions: z4.array(z4.object({ id: z4.string(), name: z4.string(), project: z4.string(), cwd: z4.string(), topic: z4.string().optional(), state: z4.string(), readOnly: z4.boolean() })).max(500),
+  folders: z4.array(z4.object({ project: z4.string(), cwd: z4.string() })).max(100)
+});
+var RoutingContextSchema = z4.object({
+  machines: z4.array(MachineInventorySchema).min(1).max(20),
+  history: z4.array(z4.object({ question: z4.string().max(2e4), answer: z4.string().max(2e4).optional(), machineId: z4.string().optional() })).max(50)
+});
+var RouteResultSchema = z4.object({
+  /** Null means an answer or a clarification, never an implicit local destination. */
+  machineId: z4.string().nullable(),
+  text: z4.string().min(1).max(2e4),
+  choices: z4.array(z4.string()).max(20).optional()
+});
+
+// ../protocol/src/ssh.ts
+import { z as z5 } from "zod";
+var SshAliasSchema = z5.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/);
+
+// ../protocol/src/thread.ts
+import { z as z6 } from "zod";
+var ToolStatusSchema = z6.enum(["running", "success", "failed", "unknown"]);
+var FileChangeSchema = z6.object({ path: z6.string().min(1), change: z6.enum(["add", "edit", "delete", "write"]), diff: z6.string().optional() });
+var base = { id: z6.string().min(1), at: z6.string().datetime(), turn: z6.number().int().nonnegative(), helperId: z6.string().optional() };
+var ThreadItemSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("prompt"), ...base, text: z6.string() }),
+  z6.object({ kind: z6.literal("message"), ...base, text: z6.string() }),
+  /** `id` is the harness's tool_use_id when it gives one, so the result updates the same row. */
+  z6.object({ kind: z6.literal("tool"), ...base, tool: z6.string(), label: z6.string(), input: z6.string().optional(), output: z6.string().optional(), error: z6.string().optional(), status: ToolStatusSchema, durationMs: z6.number().nonnegative().optional(), files: z6.array(FileChangeSchema).default([]) }),
+  /** `unknown`: answered in the terminal, the daemon only saw the prompt go away. */
+  z6.object({ kind: z6.literal("permission"), ...base, tool: z6.string(), text: z6.string(), decision: z6.enum(["accept", "deny", "unknown"]).optional() }),
+  z6.object({ kind: z6.literal("reply"), ...base, text: z6.string() }),
+  z6.object({ kind: z6.literal("helper"), ...base, task: z6.string(), agentType: z6.string().optional(), state: z6.enum(["working", "exited"]) })
+]);
+
+// ../protocol/src/messages.ts
+var PROTOCOL_PORT = 47831;
+var SessionEventSchema = z7.object({
+  name: z7.enum(["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Notification", "Stop", "SessionEnd", "PaneChanged", "PaneGone", "PanePrompt", "PaneIdle", "InjectFailed", "Decided", "PostToolUse", "PostToolUseFailure", "StopFailure", "SubagentStart", "SubagentStop", "PaneTitle", "Renamed"]),
+  at: z7.string().datetime(),
+  source: z7.enum(["hook", "pane", "daemon"]),
+  tool: z7.string().optional(),
+  text: z7.string().optional(),
+  options: z7.array(z7.string()).optional(),
+  /** Each option's description, by index ('' when it has none); left out when no option has one. */
+  optionDetails: z7.array(z7.string()).optional(),
+  kind: z7.enum(["question", "permission", "plan", "diff"]).optional(),
+  exitCode: z7.number().int().nullable().optional(),
+  helperId: z7.string().optional(),
+  /** The helper's description, once known (Claude Code: its `.meta.json`, written after SubagentStart). */
+  task: z7.string().optional(),
+  /** PostToolUseFailure: the user interrupted the turn (Esc); Claude then waits for input with no Stop. */
+  interrupt: z7.boolean().optional(),
+  /** Native tracking (spec 2026-10-13 §2): the harness's id of the tool call, so its result lands on the same row. */
+  toolUseId: z7.string().optional(),
+  /** The tool's input as the harness gave it, every string capped by the hook. */
+  toolInput: z7.record(z7.string(), z7.unknown()).optional(),
+  /** PostToolUse: the result as text; SubagentStop: nothing (the report travels in `text`). */
+  output: z7.string().optional(),
+  durationMs: z7.number().nonnegative().optional(),
+  /** PostToolUseFailure: the harness's error message. */
+  error: z7.string().optional(),
+  /** The session's transcript, or the helper's on SubagentStop; the daemon reads its tail for the agent's messages. */
+  transcriptPath: z7.string().optional(),
+  /** Decided: what was chosen when the daemon knows it. */
+  decision: z7.enum(["accept", "deny"]).optional()
+});
+var RecentSchema = z7.object({ cwd: z7.string().min(1), project: z7.string().min(1), lastAt: z7.string().datetime() });
+var SEMVER = /^\d+\.\d+\.\d+$/;
+var DaemonInfoSchema = z7.object({ version: z7.string(), install: z7.enum(["npm", "git", "unknown"]), systemd: z7.boolean(), manual: z7.string().optional(), routing: z7.boolean().optional() });
+var UpdateFailureSchema = z7.enum(["git-install", "no-systemd", "sessions-at-risk", "npm-failed", "busy"]);
+var ServerMessageSchema = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("chat.routed"), qid: z7.string(), result: RouteResultSchema }),
+  DocumentContentSchema,
+  DocumentErrorSchema,
+  /** `recents`: the folders of past sessions, most recent first. `launcher`: the command that runs `ledge` inside WSL
+   *  (`[node, cli]`), so the overlay can attach a terminal to a session with `<launcher> attach <id>`. `daemon`: absent
+   *  from daemons older than the auto-update. */
+  z7.object({ type: z7.literal("snapshot"), sessions: z7.array(SessionSchema), recents: z7.array(RecentSchema).optional(), launcher: z7.array(z7.string()).optional(), daemon: DaemonInfoSchema.optional(), sshAlias: SshAliasSchema.optional() }),
+  z7.object({ type: z7.literal("session.updated"), session: SessionSchema }),
+  z7.object({ type: z7.literal("session.removed"), id: z7.string() }),
+  z7.object({ type: z7.literal("session.preview"), id: z7.string(), lines: z7.array(z7.string()) }),
+  /** A session's thread, on request (spec 2026-10-13 §5); then each created or updated item, broadcast. */
+  z7.object({ type: z7.literal("session.thread"), id: z7.string(), items: z7.array(ThreadItemSchema) }),
+  z7.object({ type: z7.literal("session.thread.item"), id: z7.string(), item: ThreadItemSchema }),
+  /** Answer to the requester of a `session.launch`: the session exists (its `session.updated` is broadcast as usual). */
+  z7.object({ type: z7.literal("session.launched"), id: z7.string() }),
+  z7.object({ type: z7.literal("recents"), recents: z7.array(RecentSchema) }),
+  /** Answer to the requester of a `folder.list` or `folder.create`: `path` resolved (`~` expanded), `parent` null at the
+   *  root, `entries` its subfolders by name (hidden ones left out). A failure keeps the asked path and says why in `error`,
+   *  never in an `error` message, which the launch form reads as a failed launch. */
+  z7.object({ type: z7.literal("folder.listing"), path: z7.string(), parent: z7.string().nullable(), entries: z7.array(z7.string()), error: z7.string().optional() }),
+  /** The chat (spec 2026-10-11 §5): what Ledge reads, its words as they come, the final text, or why it stopped; the day's turns after each snapshot. */
+  z7.object({ type: z7.literal("chat.step"), qid: z7.string(), step: ChatStepSchema }),
+  z7.object({ type: z7.literal("chat.delta"), qid: z7.string(), text: z7.string() }),
+  z7.object({ type: z7.literal("chat.done"), qid: z7.string(), text: z7.string(), at: z7.string().datetime(), proposal: ChatProposalSchema.optional(), relay: ChatRelaySchema.optional() }),
+  z7.object({ type: z7.literal("chat.error"), qid: z7.string(), message: z7.string() }),
+  z7.object({ type: z7.literal("chat.history"), turns: z7.array(ChatTurnSchema) }),
+  /** The daemon updating itself: npm is running, then the service restarts (the socket closes right after). */
+  z7.object({ type: z7.literal("update.progress"), version: z7.string(), step: z7.enum(["installing", "restarting"]) }),
+  /** Nothing was changed. `detail`: the useful end of npm's output; `command`: what the person can run instead. */
+  z7.object({ type: z7.literal("update.failed"), version: z7.string(), reason: UpdateFailureSchema, detail: z7.string().optional(), command: z7.string().optional() }),
+  z7.object({ type: z7.literal("error"), message: z7.string(), id: z7.string().optional() })
+]);
+var ClientMessageSchema = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("chat.route"), qid: z7.string().min(1).max(100), text: z7.string().min(1).max(2e4), tool: ToolSchema.optional(), context: RoutingContextSchema }),
+  DocumentReadSchema,
+  /** The overlay starts a session: `cwd` is a WSL path (`~` allowed), `name` a preferred bot name (the daemon picks a
+   *  free one otherwise), `prompt` the agent's first instruction, `continue` resumes the folder's last conversation.
+   *  With `qid` it is the chat card of that turn: the daemon launches the turn's proposal and ignores the other fields. */
+  z7.object({ type: z7.literal("session.launch"), tool: ToolSchema, cwd: z7.string().min(1), name: z7.string().optional(), prompt: z7.string().optional(), continue: z7.boolean().optional(), qid: z7.string().min(1).optional() }),
+  /** The launch form's folder browser: list a folder's subfolders (home when no `path`), or make `name` inside `parent`
+   *  and list it. Both are answered with a `folder.listing`. */
+  z7.object({ type: z7.literal("folder.list"), path: z7.string().optional() }),
+  z7.object({ type: z7.literal("folder.create"), parent: z7.string().min(1), name: z7.string().min(1) }),
+  z7.object({ type: z7.literal("session.reply"), id: z7.string(), text: z7.string().min(1) }),
+  /** The chat card's instruction (spec 2026-10-12 relay §4): sent now if the session is free, else queued until it is. */
+  z7.object({ type: z7.literal("session.relay"), qid: z7.string().min(1) }),
+  /** Takes the card's queued instruction back out of the queue. */
+  z7.object({ type: z7.literal("session.relay.cancel"), qid: z7.string().min(1) }),
+  z7.object({ type: z7.literal("session.decide"), id: z7.string(), decision: z7.enum(["accept", "deny"]) }),
+  z7.object({ type: z7.literal("session.focus"), id: z7.string() }),
+  z7.object({ type: z7.literal("session.kill"), id: z7.string() }),
+  z7.object({ type: z7.literal("session.interrupt"), id: z7.string() }),
+  /** Removes a finished (exited) or read-only (hook_only) session from the list; refused for a live launcher session. */
+  z7.object({ type: z7.literal("session.dismiss"), id: z7.string() }),
+  /** The user names the session's topic from the overlay (500 characters at most, the hook's prompt cap); an empty topic hands back to the automatic sources. */
+  z7.object({ type: z7.literal("session.rename"), id: z7.string(), topic: z7.string().max(500) }),
+  z7.object({ type: z7.literal("session.thread"), id: z7.string() }),
+  z7.object({ type: z7.literal("session.register"), session: SessionSchema }),
+  /** `agent` and `cwd` describe the session when the daemon does not know it yet (a hook from an agent started without ledge). */
+  z7.object({ type: z7.literal("session.event"), id: z7.string(), event: SessionEventSchema, agent: ToolSchema.optional(), cwd: z7.string().optional() }),
+  z7.object({ type: z7.literal("session.unregister"), id: z7.string(), exitCode: z7.number().int().nullable() }),
+  z7.object({ type: z7.literal("snapshot.request") }),
+  z7.object({ type: z7.literal("chat.ask"), qid: z7.string().min(1), text: z7.string().min(1), tool: ToolSchema.optional() }),
+  z7.object({ type: z7.literal("chat.cancel"), qid: z7.string().min(1) }),
+  /** Starts a new conversation with Ledge: the day's turns are cleared and the next question opens a new harness session. */
+  z7.object({ type: z7.literal("chat.reset") }),
+  /** Installs `@paradow/ledge@version` and restarts the service (spec 2026-10-12 auto-update §6). */
+  z7.object({ type: z7.literal("update.daemon"), version: z7.string().regex(SEMVER) })
+]);
+function parseClientMessage(raw) {
+  return ClientMessageSchema.parse(raw);
+}
+function parseServerMessage(raw) {
+  return ServerMessageSchema.parse(raw);
+}
+
+// ../protocol/src/names.ts
+var NAMES = [
+  "Otto",
+  "Pim",
+  "Nova",
+  "Bix",
+  "Lu",
+  "Max",
+  "Ida",
+  "Rex",
+  "Zoe",
+  "Kit",
+  "Ari",
+  "Bo",
+  "Cal",
+  "Dee",
+  "Eli",
+  "Fay",
+  "Gus",
+  "Hal",
+  "Ivy",
+  "Jax",
+  "Kai",
+  "Lio",
+  "Mo",
+  "Nia",
+  "Oz",
+  "Pax",
+  "Quin",
+  "Rae",
+  "Sol",
+  "Tad",
+  "Uma",
+  "Vic",
+  "Wyn",
+  "Xen",
+  "Yan",
+  "Zia",
+  "Abe",
+  "Bea",
+  "Cy",
+  "Dot",
+  "Eva",
+  "Fin",
+  "Gil",
+  "Hen",
+  "Iro",
+  "Jo",
+  "Kip",
+  "Lex",
+  "Mia",
+  "Ned",
+  "Ola",
+  "Pat",
+  "Rio",
+  "Sam",
+  "Tia",
+  "Ulf",
+  "Val",
+  "Wes",
+  "Yui",
+  "Zed",
+  "Ash",
+  "Bry",
+  "Cleo",
+  "Dax"
+];
+var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+function pickName(taken, preferred) {
+  const used = new Set(taken);
+  const free = (n) => !used.has(n);
+  const wanted = preferred?.trim();
+  if (wanted) {
+    const base2 = cap(wanted);
+    if (free(base2)) return base2;
+    for (let i = 2; ; i++) if (free(`${base2}-${i}`)) return `${base2}-${i}`;
+  }
+  const first = NAMES.find(free);
+  if (first) return first;
+  for (let i = 2; ; i++) if (free(`${NAMES[0]}-${i}`)) return `${NAMES[0]}-${i}`;
+}
+
+// ../protocol/src/proposal.ts
+import { z as z8 } from "zod";
+var ProposalBlockSchema = z8.object({ cwd: z8.string().trim().min(1), prompt: z8.string().optional() });
+var RelayBlockSchema = z8.object({ session: z8.string().trim().min(1), text: z8.string().trim().min(1) });
+var BLOCK = /```ledge-(session|relay)[ \t]*\n?([\s\S]*?)(?:```|$)/g;
+function extractProposal(answer) {
+  const found = [];
+  const text = answer.replace(BLOCK, (_m, kind, body) => {
+    found.push({ kind, raw: body.trim() });
+    return "";
+  });
+  const last = found.at(-1);
+  return last ? { text: text.replace(/\n{3,}/g, "\n\n").trim(), kind: last.kind, raw: last.raw } : { text: answer, kind: null, raw: null };
+}
+function parseProposalBlock(raw) {
+  try {
+    const r = ProposalBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+function parseRelayBlock(raw) {
+  try {
+    const r = RelayBlockSchema.safeParse(JSON.parse(raw));
+    return r.success ? r.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../protocol/src/topic.ts
+var TOPIC_MAX = 80;
+function cleanTopic(text) {
+  const line = text.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+  const flat = line.replace(/\s+/g, " ");
+  return flat.length > TOPIC_MAX ? `${flat.slice(0, TOPIC_MAX - 1).trimEnd()}\u2026` : flat;
+}
+function sessionTitle(s) {
+  return `${s.name} \xB7 ${s.topic || s.project}`;
+}
+
+export {
+  SessionSchema,
+  DOCUMENT_MAX_BYTES,
+  RouteResultSchema,
+  SshAliasSchema,
+  PROTOCOL_PORT,
+  RecentSchema,
+  parseClientMessage,
+  parseServerMessage,
+  pickName,
+  extractProposal,
+  parseProposalBlock,
+  parseRelayBlock,
+  cleanTopic,
+  sessionTitle
+};