@paradow/ledge 0.34.0 → 0.36.0

package/dist/cli/chunk-ULOMKEB6.js

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

package/dist/cli/chunk-V4XKKL6K.js

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