@agentdocumentformat/cli 0.7.2

package/dist/chunks/daemon-control-WDX7PMTC.mjs

@@ -0,0 +1,300 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  DEFAULT_DAEMON_URL,
+  resolveDaemonToken
+} from "./chunk-G426FACA.mjs";
+import {
+  defaultUserDataPath
+} from "./chunk-IHDDCZBS.mjs";
+import "./chunk-M2RX3S2T.mjs";
+
+// src/main/cli/daemon-control.ts
+import { spawn, execFileSync } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, readSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var DEFAULT_DAEMON_PORT = 7385, DEFAULT_MESH_PORT = 7295, START_TIMEOUT_MS = 9e4, STOP_TIMEOUT_MS = 3e4;
+function daemonTarget(url) {
+  let host = "127.0.0.1", port = DEFAULT_DAEMON_PORT;
+  try {
+    let parsed = new URL(url);
+    host = parsed.hostname.replace(/^\[|\]$/g, ""), port = parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+  } catch {
+  }
+  return { url: url.replace(/\/+$/, ""), host, port, loopback: isLoopbackHost(host) };
+}
+function isLoopbackHost(host) {
+  return host === "localhost" || host === "::1" || /^127\./.test(host);
+}
+function daemonPaths(port, env = process.env) {
+  let settingsFile = env.ADF_DAEMON_SETTINGS ?? join(defaultUserDataPath({ quiet: !0 }), "adf-settings.json"), dataDir = dirname(settingsFile), suffix = port === DEFAULT_DAEMON_PORT ? "" : `-${port}`;
+  return {
+    dataDir,
+    settingsFile,
+    pidFile: env.ADF_DAEMON_PIDFILE ?? join(dataDir, `adf-daemon${suffix}.pid`),
+    logFile: join(dataDir, "logs", `adf-daemon${suffix}.log`),
+    custom: !!(env.ADF_DAEMON_SETTINGS || env.ADF_USER_DATA_DIR)
+  };
+}
+async function isHealthy(url, fetchImpl = fetch, timeoutMs = 1500) {
+  try {
+    return (await fetchImpl(`${url}/health`, { signal: AbortSignal.timeout(timeoutMs) })).ok;
+  } catch {
+    return !1;
+  }
+}
+function readPidFile(file) {
+  try {
+    let raw = readFileSync(file, "utf-8").trim();
+    if (raw.startsWith("{")) {
+      let parsed = JSON.parse(raw);
+      return typeof parsed.pid == "number" ? { pid: parsed.pid, startedAt: typeof parsed.startedAt == "number" ? parsed.startedAt : void 0 } : null;
+    }
+    let pid = Number.parseInt(raw, 10);
+    return Number.isFinite(pid) && pid > 0 ? { pid } : null;
+  } catch {
+    return null;
+  }
+}
+function processAlive(pid) {
+  try {
+    return process.kill(pid, 0), !0;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function studioConflict(paths, env = process.env, fetchImpl = fetch) {
+  let settings = readJson(paths.settingsFile) ?? {}, meshPort = Number(env.MESH_PORT) || (typeof settings.meshPort == "number" ? settings.meshPort : DEFAULT_MESH_PORT), runtimeId = typeof settings.runtimeId == "string" ? settings.runtimeId : null;
+  if (runtimeId)
+    try {
+      let res = await fetchImpl(`http://127.0.0.1:${meshPort}/ping`, { signal: AbortSignal.timeout(800) });
+      if ((res.ok ? await res.json() : null)?.runtime_id === runtimeId)
+        return `Another ADF runtime on the same settings is already running (its mesh answers on 127.0.0.1:${meshPort}), most likely ADF Studio.`;
+    } catch {
+    }
+  return !paths.custom && studioProcessRunning() ? "ADF Studio is running." : null;
+}
+function studioProcessRunning() {
+  try {
+    if (process.platform === "win32") {
+      let out = execFileSync("tasklist", ["/FI", "IMAGENAME eq ADF Studio.exe", "/NH", "/FO", "CSV"], { encoding: "utf-8", windowsHide: !0, timeout: 4e3, stdio: ["ignore", "pipe", "ignore"] });
+      return /"ADF Studio\.exe"/i.test(out);
+    }
+    return process.platform === "darwin" ? (execFileSync("pgrep", ["-x", "ADF Studio"], { stdio: "ignore", timeout: 4e3 }), !0) : (execFileSync("pgrep", ["-f", "adf-studio"], { stdio: "ignore", timeout: 4e3 }), !0);
+  } catch {
+    return !1;
+  }
+}
+var STUDIO_ADVICE = [
+  "Studio and the daemon would run the same agents from the same files at once.",
+  "Quit ADF Studio, then run adf again. Or keep using Studio.",
+  "(Different data on purpose? Point the daemon elsewhere with ADF_DAEMON_SETTINGS, or override with: adf daemon start --force)"
+].join(`
+`);
+function daemonLaunch() {
+  let here = fileURLToPath(import.meta.url), source = /\.tsx?$/.test(here);
+  if (source) {
+    let root = resolve(dirname(here), "..", "..", "..");
+    return { command: process.execPath, args: [...process.execArgv, join(root, "src", "main", "cli", "bin.ts"), "daemon"], cwd: root, source, root };
+  }
+  let entry = process.argv[1];
+  return { command: process.execPath, args: [...process.execArgv, entry, "daemon"], cwd: homedir(), source };
+}
+var DaemonStartError = class extends Error {
+  constructor(message, advice) {
+    super(message);
+    this.advice = advice;
+  }
+  advice;
+};
+async function startDaemon(target, options = {}) {
+  let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, log = options.log ?? ((text) => process.stderr.write(text));
+  if (!target.loopback) throw new DaemonStartError(`${target.url} is not on this machine; start the daemon there.`);
+  let paths = daemonPaths(target.port, env);
+  if (!options.force) {
+    let conflict = await studioConflict(paths, env, fetchImpl);
+    if (conflict) throw new DaemonStartError(conflict, STUDIO_ADVICE);
+  }
+  let existing = readPidFile(paths.pidFile);
+  if (existing && processAlive(existing.pid) && !await isHealthy(target.url, fetchImpl))
+    return log(`Waiting for the ADF daemon starting as pid ${existing.pid}\u2026
+`), await waitHealthy(target.url, fetchImpl, START_TIMEOUT_MS, () => processAlive(existing.pid)), { pid: existing.pid, paths, ms: 0 };
+  mkdirSync(dirname(paths.logFile), { recursive: !0 });
+  let launch = daemonLaunch(), tty = process.stderr.isTTY, started = Date.now();
+  if (log(`Starting the ADF daemon on ${target.host}:${target.port}\u2026${tty ? "" : `
+`}`), launch.source && launch.root) {
+    let script = join(launch.root, "scripts", "rebuild-for-node.mjs");
+    if (existsSync(script)) {
+      let fd = openSync(paths.logFile, "a");
+      try {
+        execFileSync(process.execPath, [script], { cwd: launch.root, stdio: ["ignore", fd, fd], windowsHide: !0, timeout: 18e4 });
+      } catch {
+        throw closeSync(fd), new DaemonStartError("Could not prepare better-sqlite3 for this Node.js.", `Run: node scripts/rebuild-for-node.mjs (details in ${paths.logFile})`);
+      }
+      closeSync(fd);
+    }
+  }
+  let out = openSync(paths.logFile, "a"), childEnv = { ...env };
+  childEnv.ADF_NODE_ENV_DEFAULTED === "1" && (delete childEnv.NODE_ENV, delete childEnv.ADF_NODE_ENV_DEFAULTED);
+  let child = spawn(launch.command, launch.args, {
+    cwd: launch.cwd,
+    detached: !0,
+    windowsHide: !0,
+    stdio: ["ignore", out, out],
+    env: {
+      ...childEnv,
+      ADF_DAEMON_PORT: String(target.port),
+      ADF_DAEMON_HOST: target.host === "localhost" ? "127.0.0.1" : target.host,
+      ADF_DAEMON_PIDFILE: paths.pidFile,
+      ADF_DAEMON_SETTINGS: paths.settingsFile
+    }
+  });
+  closeSync(out);
+  let exited = null;
+  child.once("exit", (code) => {
+    exited = code ?? -1;
+  }), child.unref();
+  let pid = child.pid ?? -1, tick = tty ? setInterval(() => log("."), 1e3) : null;
+  try {
+    if (!await waitHealthy(target.url, fetchImpl, START_TIMEOUT_MS, () => exited === null)) {
+      let tail = tailLines(paths.logFile, 15);
+      throw new DaemonStartError(
+        exited !== null ? `The daemon exited during startup (code ${exited}).` : `The daemon did not answer ${target.url}/health within ${START_TIMEOUT_MS / 1e3}s.`,
+        `Log: ${paths.logFile}${tail ? `
+${tail}` : ""}`
+      );
+    }
+  } finally {
+    tick && clearInterval(tick), tty && log(`
+`);
+  }
+  let ms = Date.now() - started;
+  return log(`ADF daemon running in the background (pid ${pid}, ${(ms / 1e3).toFixed(1)}s) \xB7 log ${paths.logFile}
+`), { pid, paths, ms };
+}
+async function waitHealthy(url, fetchImpl, timeoutMs, alive) {
+  let deadline = Date.now() + timeoutMs;
+  for (; Date.now() < deadline; ) {
+    if (await isHealthy(url, fetchImpl, 1e3)) return !0;
+    if (!alive()) return !1;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return !1;
+}
+async function ensureDaemon(url, options = {}) {
+  let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, target = daemonTarget(url);
+  return await isHealthy(target.url, fetchImpl) || !target.loopback || options.disabled || env.ADF_NO_AUTOSTART === "1" ? null : await startDaemon(target, options);
+}
+async function stopDaemon(target, options = {}) {
+  let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, paths = daemonPaths(target.port, env), record = readPidFile(paths.pidFile), token = resolveDaemonToken(void 0, env, target.url);
+  if (!await isHealthy(target.url, fetchImpl))
+    return record && processAlive(record.pid) ? { stopped: !1, message: `No daemon answers ${target.url}, but pid ${record.pid} from ${paths.pidFile} is alive. It may be starting or stuck; see adf daemon logs.` } : { stopped: !0, message: `No daemon running at ${target.url}.` };
+  let accepted = !1;
+  try {
+    let res = await fetchImpl(`${target.url}/daemon/shutdown`, { method: "POST", headers: token ? { Authorization: `Bearer ${token}` } : {}, signal: AbortSignal.timeout(5e3) });
+    if (accepted = res.ok, !res.ok && res.status !== 404)
+      return { stopped: !1, message: `The daemon refused to stop: ${(await res.json().catch(() => null))?.error ?? `HTTP ${res.status}`}` };
+  } catch {
+  }
+  if (!accepted) {
+    if (record && process.platform !== "win32" && processAlive(record.pid))
+      try {
+        process.kill(record.pid, "SIGTERM"), accepted = !0;
+      } catch {
+      }
+    if (!accepted)
+      return { stopped: !1, message: "This daemon has no stop endpoint (older build). Stop it with Ctrl+C in its terminal, or update it." };
+  }
+  let deadline = Date.now() + (options.timeoutMs ?? STOP_TIMEOUT_MS);
+  for (; Date.now() < deadline; ) {
+    let up = await isHealthy(target.url, fetchImpl, 800), alive = record ? processAlive(record.pid) : !1;
+    if (!up && !alive) return { stopped: !0, message: "ADF daemon stopped." };
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return { stopped: !1, message: `The daemon is still shutting down after ${(options.timeoutMs ?? STOP_TIMEOUT_MS) / 1e3}s (unloading agents, stopping containers). Check adf daemon logs.` };
+}
+async function daemonStatus(target, options = {}) {
+  let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, paths = daemonPaths(target.port, env), running = await isHealthy(target.url, fetchImpl), record = readPidFile(paths.pidFile), lines = [`url       ${target.url}`, `status    ${running ? "running" : "not running"}`];
+  if (running)
+    try {
+      let token = resolveDaemonToken(void 0, env, target.url), body = await (await fetchImpl(`${target.url}/runtime`, { headers: token ? { Authorization: `Bearer ${token}` } : {}, signal: AbortSignal.timeout(3e3) })).json();
+      body.daemon?.pid && lines.push(`pid       ${body.daemon.pid}`), typeof body.daemon?.uptime == "number" && lines.push(`uptime    ${formatUptime(body.daemon.uptime)}`), body.daemon?.version && lines.push(`version   ${body.daemon.version}`), Array.isArray(body.agents) && lines.push(`agents    ${body.agents.length} loaded`);
+    } catch {
+    }
+  else record && processAlive(record.pid) && lines.push(`pid       ${record.pid} (alive, not answering: starting or stuck)`);
+  return target.loopback && (lines.push(`data      ${paths.dataDir}`), lines.push(`log       ${paths.logFile}${existsSync(paths.logFile) ? "" : " (none yet)"}`)), { running, lines };
+}
+function formatUptime(seconds) {
+  let s = Math.floor(seconds), h = Math.floor(s / 3600), m = Math.floor(s % 3600 / 60);
+  return h > 0 ? `${h}h ${m}m` : m > 0 ? `${m}m ${s % 60}s` : `${s}s`;
+}
+function tailLines(file, count) {
+  try {
+    let size = statSync(file).size, len = Math.min(size, 64 * 1024), fd = openSync(file, "r"), buf = Buffer.alloc(len);
+    return readSync(fd, buf, 0, len, size - len), closeSync(fd), buf.toString("utf-8").split(/\r?\n/).filter(Boolean).slice(-count).join(`
+`);
+  } catch {
+    return "";
+  }
+}
+async function followLog(file, options) {
+  let tail = tailLines(file, options.lines);
+  if (tail && options.write(`${tail}
+`), !options.follow) return;
+  let offset = existsSync(file) ? statSync(file).size : 0;
+  for (; !options.signal?.aborted; ) {
+    await new Promise((r) => setTimeout(r, 500));
+    let size = 0;
+    try {
+      size = statSync(file).size;
+    } catch {
+      continue;
+    }
+    if (size < offset && (offset = 0), size === offset) continue;
+    let fd = openSync(file, "r"), buf = Buffer.alloc(size - offset);
+    readSync(fd, buf, 0, buf.length, offset), closeSync(fd), offset = size, options.write(buf.toString("utf-8"));
+  }
+}
+function daemonUrlFrom(args, env = process.env) {
+  let url, port, rest = [];
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i];
+    arg === "--url" || arg === "-u" ? url = args[++i] : arg.startsWith("--url=") ? url = arg.slice(6) : arg === "--port" || arg === "-p" ? port = args[++i] : arg.startsWith("--port=") ? port = arg.slice(7) : rest.push(arg);
+  }
+  if (url) return { url: url.replace(/\/+$/, ""), rest };
+  let p = port ?? env.ADF_DAEMON_PORT;
+  return p ? { url: `http://127.0.0.1:${p}`, rest } : { url: (env.ADF_DAEMON_URL ?? DEFAULT_DAEMON_URL).replace(/\/+$/, ""), rest };
+}
+export {
+  DEFAULT_DAEMON_PORT,
+  DaemonStartError,
+  STUDIO_ADVICE,
+  daemonLaunch,
+  daemonPaths,
+  daemonStatus,
+  daemonTarget,
+  daemonUrlFrom,
+  ensureDaemon,
+  followLog,
+  isHealthy,
+  isLoopbackHost,
+  processAlive,
+  readPidFile,
+  startDaemon,
+  stopDaemon,
+  studioConflict,
+  tailLines
+};

package/dist/chunks/daemon-token-WRSULP7G.mjs

@@ -0,0 +1,23 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  DAEMON_TOKEN_FILENAME,
+  daemonSettingsDir,
+  daemonTokenPath,
+  ensureDaemonToken,
+  readDaemonToken,
+  tokensEqual
+} from "./chunk-IHDDCZBS.mjs";
+import "./chunk-M2RX3S2T.mjs";
+export {
+  DAEMON_TOKEN_FILENAME,
+  daemonSettingsDir,
+  daemonTokenPath,
+  ensureDaemonToken,
+  readDaemonToken,
+  tokensEqual
+};

package/dist/chunks/devtools-H7CI2ZVG.mjs

@@ -0,0 +1,85 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  wrapper_default
+} from "./chunk-F5ELW46V.mjs";
+import "./chunk-NGK6PVSF.mjs";
+import "./chunk-M2RX3S2T.mjs";
+
+// node_modules/ink/build/devtools-window-polyfill.js
+var customGlobal = globalThis;
+customGlobal.WebSocket ||= wrapper_default;
+customGlobal.window ||= globalThis;
+customGlobal.self ||= globalThis;
+customGlobal.window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ = [
+  {
+    // ComponentFilterElementType
+    type: 1,
+    // ElementTypeHostComponent
+    value: 7,
+    isEnabled: !0
+  },
+  {
+    // ComponentFilterDisplayName
+    type: 2,
+    value: "InternalApp",
+    isEnabled: !0,
+    isValid: !0
+  },
+  {
+    // ComponentFilterDisplayName
+    type: 2,
+    value: "InternalAppContext",
+    isEnabled: !0,
+    isValid: !0
+  },
+  {
+    // ComponentFilterDisplayName
+    type: 2,
+    value: "InternalStdoutContext",
+    isEnabled: !0,
+    isValid: !0
+  },
+  {
+    // ComponentFilterDisplayName
+    type: 2,
+    value: "InternalStderrContext",
+    isEnabled: !0,
+    isValid: !0
+  },
+  {
+    // ComponentFilterDisplayName
+    type: 2,
+    value: "InternalStdinContext",
+    isEnabled: !0,
+    isValid: !0
+  },
+  {
+    // ComponentFilterDisplayName
+    type: 2,
+    value: "InternalFocusContext",
+    isEnabled: !0,
+    isValid: !0
+  }
+];
+
+// node_modules/ink/build/devtools.js
+import devtools from "react-devtools-core";
+var isDevToolsReachable = async () => new Promise((resolve) => {
+  let socket = new wrapper_default("ws://localhost:8097"), timeout = setTimeout(() => {
+    socket.terminate(), resolve(!1);
+  }, 2e3);
+  timeout.unref(), socket.on("open", () => {
+    clearTimeout(timeout), socket.terminate(), resolve(!0);
+  }), socket.on("error", () => {
+    clearTimeout(timeout), socket.terminate(), resolve(!1);
+  });
+});
+await isDevToolsReachable() ? (devtools.initialize(), devtools.connectToDevTools()) : console.warn(`DEV is set to true, but the React DevTools server is not running. Start it with:
+
+$ npx react-devtools
+`);