@paradow/ledge 0.33.0 → 0.35.0

package/dist/cli/decide-PFHHOCFZ.js

@@ -1,59 +0,0 @@
-import {
-  runOnClient
-} from "./chunk-XOZD4BP5.js";
-import {
-  CODEX_HOOK_VAR
-} from "./chunk-JEGPTNWV.js";
-import {
-  connect
-} from "./chunk-ASYAWVFW.js";
-import {
-  LEDGE_GIVER,
-  TASK_TEXT_MAX
-} from "./chunk-WXE2NOE5.js";
-import "./chunk-HOOHS3MX.js";
-import "./chunk-U67V476Y.js";
-
-// src/cli/decide.ts
-import { randomUUID } from "crypto";
-var DECIDE_USAGE = `ledge decide                       les d\xE9cisions que les sessions attendent de toi
-ledge decide <id> "<r\xE9ponse>"      y r\xE9pondre : la session qui l'a demand\xE9e reprend`;
-var ID = /^t[0-9a-f]{6}$/;
-var DECIDE_MS = 4e3;
-function decideArgs(args) {
-  if (!args.length) return { op: "list" };
-  const [id, text] = args;
-  return args.length === 2 && ID.test(id) && text.trim() && text.length <= TASK_TEXT_MAX ? { op: "done", task: id, text } : void 0;
-}
-async function runDecide(args, opts = {}) {
-  const op = decideArgs(args);
-  if (!op) return { line: DECIDE_USAGE, code: 1 };
-  const env = opts.env ?? process.env;
-  if (env.LEDGE_SESSION || env[CODEX_HOOK_VAR]) return { line: "refus\xE9 : ledge decide est la r\xE9ponse de l'utilisateur, pas celle d'une session", code: 1 };
-  let client;
-  try {
-    client = await connect({ port: opts.port, timeoutMs: DECIDE_MS });
-  } catch {
-    return { line: "daemon not running (start a session with `ledge claude`, or run `ledge daemon`)", code: 1 };
-  }
-  try {
-    if (op.op === "list") {
-      client.send({ type: "task.cmd", rid: randomUUID(), by: LEDGE_GIVER, op: "list" });
-      const asked = ((await client.next("task.result", DECIDE_MS)).tasks ?? []).filter((t) => t.owner === LEDGE_GIVER);
-      if (!asked.length) return { line: "aucune d\xE9cision en attente", code: 0 };
-      return { line: asked.map((t) => [`${t.id}  de ${t.giverName}  ${t.title}`, ...t.text ? t.text.split("\n").map((l) => `    ${l}`) : []].join("\n")).join("\n\n"), code: 0 };
-    }
-    const r = await runOnClient(client, "task.answer", { task: op.task, answer: op.text }, { confirmed: true, ms: DECIDE_MS });
-    if (r.reason !== void 0) return { line: `refus\xE9 : ${r.reason}`, code: 1 };
-    return { line: `r\xE9ponse envoy\xE9e \xE0 ${r.row?.vars?.session ?? "la session"}`, code: 0 };
-  } catch (e) {
-    return { line: `pas de r\xE9ponse de Ledge : ${e.message}`, code: 1 };
-  } finally {
-    await client.close();
-  }
-}
-export {
-  DECIDE_USAGE,
-  decideArgs,
-  runDecide
-};

package/dist/cli/handover-EMO6JT7O.js

@@ -1,17 +0,0 @@
-import {
-  HANDOVER_USAGE,
-  handoverArgs,
-  handoverOnClient,
-  runHandover
-} from "./chunk-CSLVBADC.js";
-import "./chunk-JEGPTNWV.js";
-import "./chunk-ASYAWVFW.js";
-import "./chunk-WXE2NOE5.js";
-import "./chunk-HOOHS3MX.js";
-import "./chunk-U67V476Y.js";
-export {
-  HANDOVER_USAGE,
-  handoverArgs,
-  handoverOnClient,
-  runHandover
-};

package/dist/cli/hook-W2BU74H5.js

@@ -1,523 +0,0 @@
-import {
-  QUESTION_TOOLS,
-  gitInfo,
-  messageNote,
-  readPeers,
-  resolveRoleAddress,
-  resolveTarget,
-  seatContext,
-  seatKey,
-  seatView,
-  takeImages,
-  teamChangeLine,
-  teammates
-} from "./chunk-3DB3VOMM.js";
-import {
-  findRole
-} from "./chunk-4VNKZOC2.js";
-import {
-  parseLedgeCommand,
-  readOnClient,
-  sendOnClient
-} from "./chunk-GXL3X7M7.js";
-import {
-  taskOnClient
-} from "./chunk-4HXJQEUN.js";
-import {
-  handoverOnClient
-} from "./chunk-CSLVBADC.js";
-import {
-  CODEX_ENV_VAR,
-  CODEX_HOOK_VAR,
-  codexPlan
-} from "./chunk-JEGPTNWV.js";
-import {
-  formatWho
-} from "./chunk-CCSUP5ZI.js";
-import {
-  connect,
-  sendMessageAndAwaitAck
-} from "./chunk-ASYAWVFW.js";
-import {
-  MESSAGE_MAX,
-  taskClosed
-} from "./chunk-WXE2NOE5.js";
-import {
-  log
-} from "./chunk-6IYPRUQG.js";
-import {
-  paths
-} from "./chunk-HOOHS3MX.js";
-import "./chunk-U67V476Y.js";
-
-// src/cli/hook.ts
-import { randomUUID } from "crypto";
-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 = MESSAGE_MAX;
-var promptText = (p) => {
-  const raw = str(p.prompt)?.trim();
-  if (!raw) return {};
-  const taken = takeImages(raw, paths().attachments);
-  const ids = taken.ids;
-  const t = ids.length ? taken.text : raw;
-  return { ...t ? { text: t.slice(0, PROMPT_MAX) } : {}, ...ids.length ? { attachments: ids } : {} };
-};
-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 === "SendMessage") return str(i.summary) || `\u2192 ${str(i.to) ?? ""}`;
-  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) {
-  return cap(str(p.last_assistant_message)?.trim());
-}
-function cap(text) {
-  if (!text) return void 0;
-  return text.length > REPLY_MAX ? `${text.slice(0, REPLY_MAX)}
-
-[\u2026]` : text;
-}
-var INPUT_MAX = 8e3;
-function trimInput(input, max = INPUT_MAX) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return void 0;
-  const trim = (v) => typeof v === "string" ? v.slice(0, max) : Array.isArray(v) ? v.map(trim) : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, trim(x)])) : v;
-  return trim(input);
-}
-function toolOutput(response) {
-  if (response === null || response === void 0) return void 0;
-  let text;
-  if (typeof response === "string") text = response;
-  else if (Array.isArray(response)) text = response.map((b) => str(b?.text) ?? "").filter(Boolean).join("\n");
-  else if (typeof response === "object" && ("stdout" in response || "stderr" in response)) {
-    const r = response;
-    text = [str(r.stdout), str(r.stderr)].filter(Boolean).join("\n");
-  } else {
-    try {
-      text = JSON.stringify(response);
-    } catch {
-      text = String(response);
-    }
-  }
-  return text.slice(0, REPLY_MAX);
-}
-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;
-  const agentSessionId = !event.helperId ? str(p.session_id) : void 0;
-  return { id, event: { ...event, ...task ? { task } : {}, ...agentSessionId ? { agentSessionId } : {} }, 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 } : {} };
-  const toolUseId = str(p.tool_use_id) || void 0;
-  const toolInput = trimInput(p.tool_input, tool === "ExitPlanMode" ? REPLY_MAX : INPUT_MAX);
-  const call = { ...toolUseId ? { toolUseId } : {}, ...toolInput ? { toolInput } : {} };
-  const transcript = str(p.transcript_path) ? { transcriptPath: str(p.transcript_path) } : {};
-  const duration = typeof p.duration_ms === "number" && p.duration_ms >= 0 ? { durationMs: p.duration_ms } : {};
-  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;
-      const report = eventName === "SubagentStop" ? lastReply(p) : void 0;
-      const agentTranscript = eventName === "SubagentStop" && str(p.agent_transcript_path) ? { transcriptPath: str(p.agent_transcript_path) } : {};
-      return { name: eventName, ...base, ...type ? { tool: type } : {}, ...task ? { text: task } : {}, ...report ? { text: report } : {}, ...agentTranscript };
-    }
-    case "PostToolUse": {
-      const output = toolOutput(p.tool_response);
-      return { name: "PostToolUse", ...base, tool, ...call, ...output !== void 0 ? { output } : {}, ...duration };
-    }
-    case "PostToolUseFailure": {
-      const error = str(p.error) || void 0;
-      return { name: "PostToolUseFailure", ...base, tool, ...call, ...error ? { error } : {}, ...duration, ...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), ...transcript };
-    case "Stop": {
-      const turnId = str(p.turn_id);
-      const path = str(p.transcript_path);
-      const said = lastReply(p);
-      const plan = said ? void 0 : turnId && path ? cap(codexPlan(path, turnId)) : void 0;
-      const text = said ?? plan;
-      return { name: "Stop", ...base, ...plan ? { kind: "plan" } : {}, ...text ? { text } : {}, ...transcript };
-    }
-    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), ...call, ...transcript };
-    case "PreToolUse": {
-      if (tool && QUESTION_TOOLS.has(tool)) {
-        const qs = p.tool_input?.questions ?? [];
-        const q = qs[0];
-        const opts = (q?.options ?? []).filter((o) => !!str(o.label));
-        const options = opts.map((o) => str(o.label));
-        const optionDetails = opts.map((o) => str(o.description)?.trim() ?? "");
-        return { name: "PreToolUse", ...base, tool, text: str(q?.question) ?? "", options, ...optionDetails.some(Boolean) ? { optionDetails } : {}, ...call, ...transcript };
-      }
-      return { name: "PreToolUse", ...base, tool, text: describeTool(tool, p.tool_input), ...call, ...transcript };
-    }
-    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: helper || event.helperId ? event : { ...event, agentSessionId: sessionId }, 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 toolInput = p.tool_input ? trimInput(input) : void 0;
-  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, ...toolInput ? { toolInput } : {} };
-    case "postToolUseFailure":
-      return { name: "PostToolUseFailure", ...base, tool, ...toolInput ? { toolInput } : {}, ...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;
-  }
-}
-var TASKS_TOLD = 10;
-var TASK_STATE = { open: "ouverte", taken: "prise", done: "termin\xE9e", refused: "refus\xE9e", dropped: "abandonn\xE9e" };
-function tasksContext(tasks) {
-  if (!tasks.length) return void 0;
-  const shown = tasks.slice(0, TASKS_TOLD);
-  return [
-    "Tes t\xE2ches en cours (elles sont gard\xE9es par Ledge, pas dans ta conversation) :",
-    ...shown.map((t) => `- ${t.id} \xB7 ${TASK_STATE[t.state]} \xB7 \xAB ${t.title} \xBB \xB7 confi\xE9e par ${t.giverName}`),
-    ...tasks.length > shown.length ? [`- et ${tasks.length - shown.length} autre(s) : ledge task list`] : [],
-    "Relis-en une avec `ledge task show <id>` avant de reprendre."
-  ].join("\n");
-}
-function identityContext(s) {
-  const where = [`projet ${s.repo ?? s.project}`, ...s.branch ? [`branche ${s.branch}`] : [], ...s.worktree ? [`worktree ${basename(s.cwd) || s.cwd}`] : []].join(", ");
-  return [
-    `Tu es ${s.name}, ${where} : une session lanc\xE9e par Ledge (${s.tool}). Les autres sessions Ledge te connaissent sous le nom ${s.name}.`,
-    "Pour voir les autres sessions (nom, outil, \xE9tat, projet, branche, sujet), lance `ledge who`.",
-    s.tool === "claude" ? "Pour \xE9crire \xE0 une autre session Ledge, Claude ou Codex, utilise son nom Ledge (donn\xE9 par `ledge who`) comme adresse SendMessage : Ledge le transmet. `ListAgents` montre les noms internes de Claude, pas les noms Ledge." : "Pour \xE9crire \xE0 une autre session Ledge, lance `ledge send <nom> \"<message>\"` (seul, sans && ni |). Ledge ex\xE9cute lui-m\xEAme `ledge send`, `ledge read`, `ledge task` et `ledge who` : leur r\xE9sultat t'arrive comme \xAB Command blocked by PreToolUse hook: \u2026 \xBB, c'est la r\xE9ponse, pas une erreur.",
-    "Un long message d'une autre session t'arrive en aper\xE7u avec son id : lance `ledge read <id>` pour le lire en entier. Une `<ledge-notice>` vient de Ledge : soit un de tes messages n'a pas pu \xEAtre remis, soit un changement te concerne (ta consigne de r\xF4le, ton \xE9quipe).",
-    'Un message sert \xE0 pr\xE9venir ; pour confier un travail qui ne doit pas se perdre, lance plut\xF4t `ledge task give <nom> "<titre>" "<d\xE9tail>"` (`ledge task` pour le reste). Une `<ledge-task>` t\'en confie une, ou te dit comment une des tiennes a fini : quand on t\'en confie une, prends-la (`ledge task take <id>`) et termine-la toujours (`ledge task done <id> "<r\xE9sultat>"`, ou `refuse`). Une d\xE9cision qui revient \xE0 l\'utilisateur se pose avec `ledge task give ledge "<question>" "<options, ta recommandation>"` : sa r\xE9ponse te r\xE9veille, inutile d\'attendre la fin pour la poser.',
-    ...s.seat ? [s.seat] : [],
-    ...s.relieves ? [`Tu as pris la rel\xE8ve de ${s.relieves.name}, dont le contexte \xE9tait plein : relis son bilan avec \`ledge handover show\`.`] : [],
-    ...s.tasks ? [tasksContext(s.tasks) ?? ""].filter(Boolean) : []
-  ].join("\n");
-}
-async function identity(agent, cwd, known, deadline, live = { sessions: [], teams: [] }) {
-  const name = known?.name ?? process.env.LEDGE_NAME;
-  const dir = known?.cwd ?? cwd;
-  if (!name || !dir) return void 0;
-  const git = known?.branch ? null : await Promise.race([gitInfo(dir).catch(() => null), new Promise((r) => setTimeout(() => r(null), Math.max(0, deadline - Date.now())))]);
-  return {
-    name,
-    tool: known?.tool ?? agent,
-    cwd: dir,
-    project: known?.project ?? (basename(dir) || dir),
-    ...known?.repo ?? git?.repo ? { repo: known?.repo ?? git.repo } : {},
-    ...known?.branch ?? git?.branch ? { branch: known?.branch ?? git.branch } : {},
-    ...known?.worktree ?? git?.worktree ? { worktree: true } : {},
-    ...seatOf(known, dir, live)
-  };
-}
-function seatOf(known, dir, live) {
-  const roleId = known?.role ?? process.env.LEDGE_ROLE;
-  if (!roleId) return {};
-  let role;
-  try {
-    role = findRole(roleId, dir);
-  } catch {
-    role = void 0;
-  }
-  const team = known?.team ? live.teams.find((t) => t.id === known.team && t.state !== "dissolved") : void 0;
-  const seat = seatContext({ ...role ? { role } : {}, roleId, roleLabel: known?.roleLabel, ...team ? { team: { name: team.name, members: teammates(team, live.sessions).filter((m) => m.name !== known?.name) } } : {} });
-  return seat ? { seat } : {};
-}
-var SEAT_REFRESH_MS = 500;
-async function seatChange(client, id, deadline) {
-  const left = () => Math.max(0, deadline - Date.now());
-  const snapshot = await client.next("snapshot", left()).catch(() => void 0);
-  const me = snapshot?.sessions.find((s) => s.id === id);
-  if (!snapshot || !me || !me.team && !me.teamSeen) return void 0;
-  const teams = me.team ? (await client.next("teams", left()).catch(() => void 0))?.teams : [];
-  if (!teams) return void 0;
-  const key = seatKey(seatView(id, snapshot.sessions, teams));
-  if (key === me.teamSeen) return void 0;
-  client.send({ type: "seat.seen", id, key });
-  return teamChangeLine(me.teamSeen, key);
-}
-var SEND_MESSAGE_MS = 1500;
-var deny = (reason) => JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } });
-async function relayMessage(client, from, toolUseId, input, deadline) {
-  if (!toolUseId) return void 0;
-  const left = () => Math.max(0, deadline - Date.now());
-  const to = input.to;
-  const snapshot = await client.next("snapshot", left());
-  const sender = snapshot.sessions.find((s) => s.id === from);
-  if (sender?.source !== "launcher") return void 0;
-  let address = to;
-  if (to.startsWith("@")) {
-    const teams = sender.team ? (await client.next("teams", left()).catch(() => void 0))?.teams ?? [] : [];
-    const role = resolveRoleAddress(to, from, snapshot.sessions, teams);
-    if ("reason" in role) return deny(`Ledge n'a pas pu transmettre le message \xE0 ${to} : ${role.reason}`);
-    address = role.to;
-  }
-  const r = resolveTarget(address, snapshot.sessions, readPeers());
-  if (r.outcome === "unknown") return void 0;
-  if (r.outcome === "refused") return deny(`Ledge n'a pas pu transmettre le message \xE0 ${to} : ${r.reason}`);
-  if (r.outcome === "native") {
-    const note = messageNote(sender.name, "claude");
-    const named = (text) => text.startsWith(note) ? text : `${note} ${text}`;
-    const updatedInput = { ...input, to: r.address, message: named(input.message), ...typeof input.content === "string" ? { content: named(input.content) } : {} };
-    return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput } });
-  }
-  const tool = r.target.tool;
-  const summary = str(input.summary);
-  const ack = await sendMessageAndAwaitAck(client, { type: "session.message", rid: toolUseId, from, to: address, text: input.message, ...summary ? { summary } : {}, intercept: true }, left());
-  const target = `${to} (${tool})`;
-  const reason = ack.outcome === "accepted" ? `Message transmis par Ledge \xE0 ${target} : il le re\xE7oit maintenant.` : ack.outcome === "queued" ? `Message transmis par Ledge \xE0 ${target} : il le recevra d\xE8s qu'il sera libre.` : ack.outcome === "refused" ? `Ledge n'a pas pu transmettre le message \xE0 ${to} : ${ack.reason ?? "raison inconnue"}` : void 0;
-  return reason ? deny(reason) : void 0;
-}
-async function runLedgeCommand(client, cmd, from, deadline) {
-  const left = () => Math.max(0, deadline - Date.now());
-  let line;
-  if (cmd.cmd === "who") line = formatWho((await client.next("snapshot", left())).sessions, from);
-  else if (cmd.cmd === "read") line = (await readOnClient(client, cmd.args, from, left())).line;
-  else if (cmd.cmd === "task") line = (await taskOnClient(client, cmd.args, from, left())).line;
-  else if (cmd.cmd === "handover") line = (await handoverOnClient(client, cmd.args, from, left())).line;
-  else line = (await sendOnClient(client, cmd.args, from, left())).line;
-  return deny(line);
-}
-async function runHook(eventName, stdin, opts = {}) {
-  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 void 0;
-  }
-  let mapped = null;
-  let identify = false;
-  let known;
-  let live = { sessions: [], teams: [] };
-  let deadline = Date.now() + (opts.timeoutMs ?? 100);
-  let relayed;
-  let seatLine;
-  let held = [];
-  try {
-    const payload = JSON.parse(stdin || "{}");
-    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 void 0;
-    }
-    const launchedId = agent === "codex" ? codexLedgeId() : agent === "claude" ? process.env.LEDGE_SESSION : void 0;
-    identify = eventName === "SessionStart" && !!launchedId && mapped.id === launchedId;
-    const refresh = eventName === "UserPromptSubmit" && agent !== "cursor" && !!launchedId && mapped.id === launchedId;
-    const input = payload.tool_input ?? {};
-    const intercept = agent === "claude" && eventName === "PreToolUse" && str(payload.tool_name) === "SendMessage" && typeof input.to === "string" && typeof input.message === "string" && !!input.message;
-    const command = agent === "codex" && eventName === "PreToolUse" && str(payload.tool_name) === "Bash" && typeof input.command === "string" ? parseLedgeCommand(input.command) : void 0;
-    const timeoutMs = opts.timeoutMs ?? (identify ? 1e3 : intercept || command ? SEND_MESSAGE_MS : refresh ? SEAT_REFRESH_MS : 100);
-    deadline = Date.now() + timeoutMs;
-    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 } : {} });
-    if (identify) {
-      const snapshot = await client.next("snapshot", Math.max(0, deadline - Date.now())).catch(() => void 0);
-      known = snapshot?.sessions.find((s) => s.id === mapped.id);
-      const teamList = known?.team ? (await client.next("teams", Math.max(0, deadline - Date.now())).catch(() => void 0))?.teams : void 0;
-      live = { sessions: snapshot?.sessions ?? [], teams: teamList ?? [] };
-      if (snapshot && known && (!known.team || teamList)) client.send({ type: "seat.seen", id: known.id, key: seatKey(seatView(known.id, live.sessions, live.teams)) });
-      client.send({ type: "task.cmd", rid: randomUUID(), by: mapped.id, op: "list" });
-      const listed = await client.next("task.result", Math.max(0, deadline - Date.now())).catch(() => void 0);
-      held = (listed?.tasks ?? []).filter((t) => t.owner === mapped.id && !taskClosed(t));
-    }
-    if (refresh) seatLine = await seatChange(client, mapped.id, deadline);
-    if (intercept) relayed = await relayMessage(client, mapped.id, str(payload.tool_use_id), input, deadline);
-    if (command) relayed = await runLedgeCommand(client, command, mapped.id, deadline);
-    await Promise.race([client.close(), new Promise((r) => setTimeout(r, Math.max(0, deadline - Date.now())))]);
-  } catch (e) {
-    log(`hook ${label} dropped: ${e.message}`);
-  }
-  if (relayed) return relayed;
-  if (seatLine) return JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: seatLine } });
-  if (!identify || !mapped) return void 0;
-  const found = await identity(agent, mapped.cwd, known, deadline, live);
-  const who = found ? { ...found, ...held.length ? { tasks: held } : {}, ...known?.relieves ? { relieves: known.relieves } : {} } : void 0;
-  return who ? JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: identityContext(who) } }) : void 0;
-}
-export {
-  INPUT_MAX,
-  REPLY_MAX,
-  codexLedgeId,
-  cursorReply,
-  identityContext,
-  mapClaudeHook,
-  mapCursorHook,
-  mapHook,
-  readTranscript,
-  runHook,
-  tasksContext,
-  toolOutput,
-  trimInput,
-  underCodexDaemon
-};

package/dist/cli/launch-LP7YJR5N.js

@@ -1,36 +0,0 @@
-import {
-  DaemonError,
-  attachEnv,
-  createSession,
-  ensureDaemon,
-  launch,
-  parseLaunchArgs,
-  roleArgs
-} from "./chunk-CPERVAPQ.js";
-import "./chunk-PZ3F4QH3.js";
-import "./chunk-OLLQBK6N.js";
-import "./chunk-NWIICISV.js";
-import "./chunk-3DB3VOMM.js";
-import "./chunk-4VNKZOC2.js";
-import {
-  agentEnv,
-  exitFile
-} from "./chunk-JEGPTNWV.js";
-import "./chunk-ASYAWVFW.js";
-import "./chunk-WXE2NOE5.js";
-import "./chunk-E3LXONBI.js";
-import "./chunk-NLL2EQJ2.js";
-import "./chunk-6IYPRUQG.js";
-import "./chunk-HOOHS3MX.js";
-import "./chunk-U67V476Y.js";
-export {
-  DaemonError,
-  agentEnv,
-  attachEnv,
-  createSession,
-  ensureDaemon,
-  exitFile,
-  launch,
-  parseLaunchArgs,
-  roleArgs
-};

package/dist/cli/send-NEI4X33R.js

@@ -1,19 +0,0 @@
-import {
-  parseLedgeCommand,
-  readMessage,
-  readOnClient,
-  sendMessage,
-  sendOnClient
-} from "./chunk-GXL3X7M7.js";
-import "./chunk-JEGPTNWV.js";
-import "./chunk-ASYAWVFW.js";
-import "./chunk-WXE2NOE5.js";
-import "./chunk-HOOHS3MX.js";
-import "./chunk-U67V476Y.js";
-export {
-  parseLedgeCommand,
-  readMessage,
-  readOnClient,
-  sendMessage,
-  sendOnClient
-};