@agentdocumentformat/cli 0.7.2

package/dist/chunks/cli-TCMBNZF6.mjs

@@ -0,0 +1,1030 @@
+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 {
+  AUTH_PROVIDER_LABELS,
+  loginChatGpt,
+  loginGrok,
+  normalizeAuthProvider,
+  openBrowser
+} from "./chunk-6VQEXLE2.mjs";
+import "./chunk-2NAP2ZF7.mjs";
+import {
+  DEFAULT_DAEMON_URL,
+  resolveDaemonToken,
+  resolveDaemonUrl
+} from "./chunk-G426FACA.mjs";
+import "./chunk-IHDDCZBS.mjs";
+import "./chunk-M2RX3S2T.mjs";
+
+// src/main/cli/index.ts
+var defaultIo = {
+  fetch: globalThis.fetch.bind(globalThis),
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text)
+}, TUI_FLAGS = /* @__PURE__ */ new Set(["--view", "--agent", "--loop", "--theme", "--mono", "--no-color", "--ascii", "--no-alt-screen", "--no-mouse", "--mouse", "--no-kitty"]);
+function tuiInvocation(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    let arg = argv[i];
+    if (arg === "--url" || arg === "-u" || arg === "--token") {
+      i++;
+      continue;
+    }
+    if (!(arg.startsWith("--url=") || arg.startsWith("--token=") || arg === "--json"))
+      return arg === "tui" || TUI_FLAGS.has(arg) || [...TUI_FLAGS].some((flag) => arg.startsWith(`${flag}=`)) ? argv.filter((a) => a !== "--json") : null;
+  }
+  return argv.filter((a) => a !== "--json");
+}
+async function defaultLaunchTui(argv) {
+  let { runTui } = await import("./tui-ODVYUIMT.mjs");
+  return await runTui(argv);
+}
+function urlFromArgv(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--url" || argv[i] === "-u") return resolveDaemonUrl(argv[i + 1]);
+    if (argv[i].startsWith("--url=")) return resolveDaemonUrl(argv[i].slice(6));
+  }
+  return resolveDaemonUrl(void 0);
+}
+async function daemonReady(io, url) {
+  if (!io.ensureDaemon) return { ok: !0, started: null };
+  try {
+    return { ok: !0, started: (await io.ensureDaemon(url))?.pid ?? null };
+  } catch (err) {
+    let advice = err.advice;
+    return io.stderr(`${err instanceof Error ? err.message : String(err)}
+${advice ? `${advice}
+` : ""}`), { ok: !1, started: null };
+  }
+}
+async function runCli(argv = process.argv.slice(2), io = defaultIo) {
+  let tuiArgv = tuiInvocation(argv);
+  if (tuiArgv) {
+    let ready = tuiArgv.includes("--help") || tuiArgv.includes("-h") ? { ok: !0, started: null } : await daemonReady(io, urlFromArgv(tuiArgv));
+    if (!ready.ok) return 1;
+    try {
+      let code = await (io.launchTui ?? defaultLaunchTui)(tuiArgv);
+      return ready.started && io.stdout(`The daemon (pid ${ready.started}) keeps running in the background. Stop it with: adf daemon stop
+`), code;
+    } catch (err) {
+      return io.stderr(`${err instanceof Error ? err.message : String(err)}
+`), 1;
+    }
+  }
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+  } catch (err) {
+    return io.stderr(`${err instanceof Error ? err.message : String(err)}
+
+${usage()}
+`), 2;
+  }
+  let { command, args, options } = parsed;
+  if (!["help", "--help", "-h"].includes(command) && !(await daemonReady(io, options.daemonUrl)).ok) return 1;
+  try {
+    switch (command) {
+      case "help":
+      case "--help":
+      case "-h":
+        return io.stdout(`${usage()}
+`), 0;
+      case "agents":
+        return await printGet(io, options, "/agents", formatAgents);
+      case "status":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/status`, formatStatus));
+      case "start":
+        return await controlAgent(io, options, args, "start");
+      case "stop":
+      case "unload":
+        return await controlAgent(io, options, args, "stop");
+      case "abort":
+        return await controlLoop(io, options, args, "abort");
+      case "interrupt":
+        return await controlLoop(io, options, args, "interrupt");
+      case "loops":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/loops`, formatLoops));
+      case "config":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/config`, formatJsonPretty));
+      case "providers":
+        return await printGet(io, options, "/runtime/providers", formatProviders);
+      case "auth":
+        return args[0] ? await authCommand(io, options, args) : await printGet(io, options, "/runtime/auth", formatAuth);
+      case "settings":
+        return await printGet(io, options, "/runtime/settings", formatJsonPretty);
+      case "network":
+        return args[0] ? await networkAdmin(io, options, args) : await printGet(io, options, "/runtime/network", formatNetwork);
+      case "usage":
+        return args[0] ? await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/usage`, formatUsage)) : await printGet(io, options, "/runtime/usage", formatUsage);
+      case "files":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/files`, formatFiles));
+      case "file":
+        return await withAgentAndValue(args, "file path", io, async (agent, path) => {
+          let data = await requestJson(io, options, `/agents/${enc(agent)}/files/content?path=${enc(path)}`);
+          return options.json ? io.stdout(`${JSON.stringify(data, null, 2)}
+`) : isRecord(data) && data.encoding === "utf-8" && typeof data.content == "string" ? io.stdout(data.content) : isRecord(data) && typeof data.content_base64 == "string" ? io.stdout(`${data.content_base64}
+`) : io.stdout(`${JSON.stringify(data, null, 2)}
+`), 0;
+        });
+      case "inbox":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/inbox`, formatMessages("inbox")));
+      case "outbox":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/outbox`, formatMessages("outbox")));
+      case "timers":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/timers`, formatTimers));
+      case "tasks":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/tasks`, formatTasks));
+      case "task":
+        return await withAgentAndValue(args, "task id", io, async (agent, taskId) => printGet(io, options, `/agents/${enc(agent)}/tasks/${enc(taskId)}`, formatJsonPretty));
+      case "approve":
+        return await resolveTask(io, options, args, "approve");
+      case "deny":
+        return await resolveTask(io, options, args, "deny");
+      case "asks":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/asks`, formatAsks));
+      case "answer":
+        return await answerAsk(io, options, args);
+      case "identities":
+        return await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/identities`, formatIdentities));
+      case "runtime":
+        return args[0] ? await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/runtime`, formatJsonPretty)) : await printGet(io, options, "/runtime", formatJsonPretty);
+      case "mcp":
+        return args[0] ? await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/runtime/mcp`, formatMcp)) : await printGet(io, options, "/runtime/mcp", formatGlobalMcp);
+      case "adapters":
+        return args[0] ? await withAgent(args, io, async (agent) => printGet(io, options, `/agents/${enc(agent)}/runtime/adapters`, formatAdapters)) : await printGet(io, options, "/runtime/adapters", formatGlobalAdapters);
+      case "events":
+        return await streamEvents(io, options, args);
+      case "chat":
+        return await sendChat(io, options, args);
+      case "identity":
+        return await identityCommand(io, options, args);
+      case "templates":
+        return await printGet(io, options, "/templates", formatTemplates);
+      case "new":
+        return await newAgent(io, options, args);
+      default:
+        return io.stderr(`Unknown command: ${command}
+
+${usage()}
+`), 2;
+    }
+  } catch (err) {
+    return io.stderr(`${err instanceof Error ? err.message : String(err)}
+`), 1;
+  }
+}
+function parseArgs(argv) {
+  let args = [...argv], daemonUrl = process.env.ADF_DAEMON_URL ?? DEFAULT_DAEMON_URL, json = !1, token, positional = [];
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i];
+    if (arg === "--json")
+      json = !0;
+    else if (arg === "--url" || arg === "-u") {
+      let value = args[++i];
+      if (!value) throw new Error(`${arg} requires a daemon URL`);
+      daemonUrl = value;
+    } else if (arg.startsWith("--url="))
+      daemonUrl = arg.slice(6);
+    else if (arg === "--token") {
+      let value = args[++i];
+      if (!value) throw new Error("--token requires a value");
+      token = value;
+    } else arg.startsWith("--token=") ? token = arg.slice(8) : positional.push(arg);
+  }
+  return {
+    command: positional[0] ?? "help",
+    args: positional.slice(1),
+    options: {
+      daemonUrl: daemonUrl.replace(/\/+$/, ""),
+      json,
+      ...token ? { token } : {}
+    }
+  };
+}
+async function printGet(io, options, path, formatter) {
+  let data = await requestJson(io, options, path);
+  return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : formatter(data)), 0;
+}
+function authHeader(options) {
+  let token = resolveDaemonToken(options.token, process.env, options.daemonUrl);
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function requestJson(io, options, path, init) {
+  let response;
+  try {
+    response = await io.fetch(`${options.daemonUrl}${path}`, {
+      ...init,
+      headers: {
+        ...init?.headers ?? {},
+        Accept: "application/json",
+        ...authHeader(options)
+      }
+    });
+  } catch (err) {
+    throw err instanceof TypeError ? new Error(`Cannot reach the ADF daemon at ${options.daemonUrl} (${err.message}). Start it with: adf daemon start`) : err;
+  }
+  let text = await response.text(), body = null;
+  if (text.trim())
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = text;
+    }
+  if (!response.ok) {
+    let message = isRecord(body) && typeof body.error == "string" ? body.error : `HTTP ${response.status} ${response.statusText}`;
+    throw new Error(message);
+  }
+  return body;
+}
+function takeLoop(args) {
+  let rest = [], loop;
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i];
+    if (arg === "--loop") {
+      if (loop = args[++i], !loop) throw new Error("--loop requires a loop name");
+    } else arg.startsWith("--loop=") ? loop = arg.slice(7) : rest.push(arg);
+  }
+  return { loop: loop && loop !== "main" ? loop : void 0, rest };
+}
+async function sendChat(io, options, args) {
+  let { loop, rest } = takeLoop(args), agent = rest[0], text = rest.slice(1).join(" ");
+  if (!agent || !text) throw new Error("Usage: adf chat <agent> [--loop <name>] <message>");
+  let data = await requestJson(io, options, `/agents/${enc(agent)}/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ text, ...loop ? { loop } : {} })
+  });
+  return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : formatChatAck(data)), 0;
+}
+async function controlLoop(io, options, args, action) {
+  let { loop, rest } = takeLoop(args), agent = rest[0];
+  if (!agent) throw new Error(`Usage: adf ${action} <agent> [--loop <name>]`);
+  let query = loop ? `?loop=${enc(loop)}` : "", data = await requestJson(io, options, `/agents/${enc(agent)}/${action}${query}`, { method: "POST" });
+  return options.json ? io.stdout(`${JSON.stringify(data, null, 2)}
+`) : action === "abort" ? io.stdout(formatAgentControl("abort", loop ? `${agent} (loop ${loop})` : agent, data)) : io.stdout(isRecord(data) && data.interrupted === !1 ? `Nothing running in ${agent} ${loop ?? "main"}
+` : `Interrupted ${agent} ${loop ?? "main"}: the loop is idle and keeps accepting work
+`), 0;
+}
+function formatLoops(value) {
+  let loops = isRecord(value) && Array.isArray(value.loops) ? value.loops.filter(isRecord) : [];
+  return loops.length === 0 ? `No loops
+` : table(["loop", "kind", "enabled", "status", "entries", "goal"], loops.map((loop) => [
+    String(loop.name ?? ""),
+    loop.isMain === !0 || loop.name === "main" ? "main" : "inner",
+    String(loop.enabled ?? !0),
+    String(loop.status ?? ""),
+    String(loop.entryCount ?? ""),
+    truncateCell(String(loop.goal ?? ""), 60)
+  ]));
+}
+function truncateCell(text, max) {
+  let line = text.replace(/\s+/g, " ").trim();
+  return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
+}
+async function resolveTask(io, options, args, action) {
+  let agent = args[0], taskId = args[1], reason = action === "deny" ? args.slice(2).join(" ") : void 0;
+  if (!agent || !taskId) throw new Error(`Usage: adf ${action} <agent> <taskId>${action === "deny" ? " [reason]" : ""}`);
+  let data = await requestJson(io, options, `/agents/${enc(agent)}/tasks/${enc(taskId)}/resolve`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ action, ...reason ? { reason } : {} })
+  });
+  return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : formatTaskResolution(action, taskId, data)), 0;
+}
+async function answerAsk(io, options, args) {
+  let agent = args[0], requestId = args[1], answer = args.slice(2).join(" ");
+  if (!agent || !requestId || !answer) throw new Error("Usage: adf answer <agent> <requestId> <answer>");
+  let data = await requestJson(io, options, `/agents/${enc(agent)}/asks/${enc(requestId)}/respond`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ answer })
+  });
+  return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : `Answered ${requestId}
+`), 0;
+}
+async function controlAgent(io, options, args, action) {
+  let agent = args[0];
+  if (!agent) throw new Error(`Usage: adf ${action} <agent>`);
+  let data = await requestJson(io, options, `/agents/${enc(agent)}/${action}`, { method: "POST" });
+  return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : formatAgentControl(action, agent, data)), 0;
+}
+function authDeps(io, options) {
+  return {
+    request: (method, path, body) => requestJson(io, options, path, body === void 0 ? { method } : { method, headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) }),
+    sleep: io.sleep,
+    openBrowser: io.openBrowser ?? openBrowser,
+    startCallbackServer: io.startCallbackServer
+  };
+}
+function requireAuthProvider(value) {
+  let provider = normalizeAuthProvider(value);
+  if (!provider) throw new Error("Specify a provider: chatgpt or grok");
+  return provider;
+}
+async function authCommand(io, options, args) {
+  let flags = new Set(args.filter((arg) => arg.startsWith("--"))), positional = args.filter((arg) => !arg.startsWith("--")), action = positional[0];
+  if (action === "status") return await printGet(io, options, "/runtime/auth", formatAuth);
+  if (action === "login")
+    return requireAuthProvider(positional[1]) === "chatgpt" ? await loginChatGptCli(io, options, flags) : await loginGrokCli(io, options);
+  if (action === "logout") {
+    let provider = requireAuthProvider(positional[1]), data = await requestJson(io, options, `/auth/${provider}/logout`, { method: "POST" });
+    return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : `Signed out of ${AUTH_PROVIDER_LABELS[provider]}.
+`), 0;
+  }
+  throw new Error("Usage: adf auth [status | login <chatgpt|grok> | logout <chatgpt|grok>]");
+}
+function reportAuth(io, provider, outcome) {
+  return outcome.ok ? (io.stdout(`Signed in to ${AUTH_PROVIDER_LABELS[provider]}${outcome.email ? ` as ${outcome.email}` : ""}.
+`), 0) : outcome.timedOut ? (io.stderr(`Timed out waiting for ${AUTH_PROVIDER_LABELS[provider]} sign-in. Run "adf auth" to check status.
+`), 1) : (io.stderr(`Sign-in failed: ${outcome.error}
+`), 1);
+}
+async function loginChatGptCli(io, options, flags) {
+  let stop = new AbortController(), printedStart = !1, outcome = await loginChatGpt({ ...authDeps(io, options), signal: stop.signal }, {
+    daemonUrl: options.daemonUrl,
+    mode: flags.has("--relay") ? "relay" : flags.has("--loopback") ? "loopback" : "auto",
+    onStart: (info) => {
+      if (options.json) {
+        info.mode === "loopback" && (io.stdout(`${JSON.stringify(info.raw, null, 2)}
+`), printedStart = !0, stop.abort());
+        return;
+      }
+      io.stdout(info.mode === "relay" ? `Open this URL to sign in to ChatGPT:
+
+  ${info.authUrl}
+
+Waiting for the callback on ${info.redirectUri} ...
+` : `Open this URL to sign in to ChatGPT:
+
+  ${info.authUrl}
+
+Waiting for sign-in to complete...
+`);
+    }
+  });
+  return printedStart ? 0 : options.json && outcome.ok ? (io.stdout(`${JSON.stringify(outcome.raw, null, 2)}
+`), 0) : reportAuth(io, "chatgpt", outcome);
+}
+async function loginGrokCli(io, options) {
+  let stop = new AbortController(), outcome = await loginGrok({ ...authDeps(io, options), signal: stop.signal }, {
+    onStart: (info) => {
+      if (options.json) {
+        io.stdout(`${JSON.stringify(info.raw, null, 2)}
+`), stop.abort();
+        return;
+      }
+      io.stdout(`Open this URL to sign in to Grok:
+
+  ${info.verificationUri}
+
+And enter the code: ${info.userCode}
+
+Waiting for approval...
+`);
+    }
+  });
+  return options.json ? 0 : reportAuth(io, "grok", outcome);
+}
+async function networkAdmin(io, options, args) {
+  let area = args[0], action = args[1];
+  if (area === "mesh") {
+    if (action === "enable" || action === "disable")
+      return await postAndPrint(io, options, `/network/mesh/${action}`, formatJsonPretty);
+    if (!action || action === "status") return await printGet(io, options, "/network/mesh", formatJsonPretty);
+  }
+  if (area === "server") {
+    if (action === "start" || action === "stop" || action === "restart")
+      return await postAndPrint(io, options, `/network/server/${action}`, formatJsonPretty);
+    if (!action || action === "status") return await printGet(io, options, "/network/server", formatJsonPretty);
+  }
+  if (area === "tools") return await printGet(io, options, "/network/mesh/recent-tools", formatJsonPretty);
+  if (area === "lan") return await printGet(io, options, "/network/mesh/lan-addresses", formatJsonPretty);
+  if (area === "runtimes") return await printGet(io, options, "/network/mesh/discovered-runtimes", formatJsonPretty);
+  throw new Error("Usage: adf network [mesh [status|enable|disable] | server [status|start|stop|restart] | tools | lan | runtimes]");
+}
+async function postAndPrint(io, options, path, formatter) {
+  let data = await requestJson(io, options, path, { method: "POST" });
+  return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
+` : formatter(data)), 0;
+}
+async function streamEvents(io, options, args) {
+  let agent = args[0], path = agent ? `/events?agentId=${enc(agent)}` : "/events", response = await io.fetch(`${options.daemonUrl}${path}`, {
+    headers: { Accept: "text/event-stream", ...authHeader(options) }
+  });
+  if (!response.ok || !response.body) {
+    let detail = await response.json().catch(() => null);
+    throw new Error(`Event stream failed: ${typeof detail?.error == "string" ? detail.error : `HTTP ${response.status} ${response.statusText}`}`);
+  }
+  let reader = response.body.getReader(), decoder = new TextDecoder(), buffer = "";
+  for (; ; ) {
+    let { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: !0 });
+    let parts = buffer.split(/\n\n/);
+    buffer = parts.pop() ?? "";
+    for (let part of parts) {
+      let dataLine = part.split(/\n/).find((line) => line.startsWith("data: "));
+      if (!dataLine) continue;
+      let payload = dataLine.slice(6);
+      if (options.json) io.stdout(`${payload}
+`);
+      else
+        try {
+          io.stdout(`${formatEvent(JSON.parse(payload))}
+`);
+        } catch {
+          io.stdout(`${payload}
+`);
+        }
+    }
+  }
+  return 0;
+}
+async function withAgent(args, io, run) {
+  let agent = args[0];
+  return agent ? await run(agent) : (io.stderr(`Missing agent id or handle.
+`), 2);
+}
+async function withAgentAndValue(args, label, io, run) {
+  let agent = args[0], value = args[1];
+  return !agent || !value ? (io.stderr(`Missing agent id/handle or ${label}.
+`), 2) : await run(agent, value);
+}
+var pipedLines = null, pipedLineIndex = 0;
+async function defaultPrompt(question, opts = {}) {
+  let { createInterface } = await import("readline");
+  if (!process.stdin.isTTY) {
+    if (pipedLines === null) {
+      let chunks = [];
+      for await (let chunk of process.stdin) chunks.push(Buffer.from(chunk));
+      pipedLines = Buffer.concat(chunks).toString("utf-8").split(/\r?\n/);
+    }
+    return pipedLines[pipedLineIndex++] ?? "";
+  }
+  let rl = createInterface({ input: process.stdin, output: process.stdout, terminal: !0, historySize: 0 }), internals = rl, muted = !1;
+  if (opts.hidden) {
+    let write = internals._writeToOutput.bind(rl);
+    internals._writeToOutput = (text) => {
+      muted || write(text);
+    };
+  }
+  try {
+    return await new Promise((resolve) => {
+      rl.question(question, resolve), muted = !!opts.hidden;
+    });
+  } finally {
+    rl.close(), opts.hidden && process.stdout.write(`
+`);
+  }
+}
+function ask(io, question, hidden = !1) {
+  return (io.prompt ?? defaultPrompt)(question, { hidden });
+}
+function postJson(io, options, path, body = {}) {
+  return requestJson(io, options, path, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+}
+async function passphraseIfNeeded(io, identity, confirmNew) {
+  if (!isRecord(identity) || identity.passphraseRequired !== !0) return;
+  io.stdout(`This machine has no usable OS keychain, so the owner identity is kept in a passphrase-protected file.
+`);
+  let passphrase = await ask(io, confirmNew ? "Choose a passphrase (8+ characters): " : "Passphrase: ", !0);
+  if (confirmNew && await ask(io, "Repeat the passphrase: ", !0) !== passphrase)
+    throw new Error("The passphrases do not match.");
+  return passphrase;
+}
+async function identityCommand(io, options, args) {
+  let action = args[0] ?? "status";
+  if (action === "status") return await printGet(io, options, "/identity", formatIdentity);
+  if (action === "new" || action === "create") {
+    let current = await requestJson(io, options, "/identity");
+    if (isRecord(current) && current.status !== "none")
+      return io.stdout(formatIdentity(current)), io.stderr(`An owner identity already exists here; nothing was created.
+`), 1;
+    let passphrase = await passphraseIfNeeded(io, current, !0), created = await postJson(io, options, "/identity/create", passphrase ? { passphrase } : {});
+    if (options.json)
+      return io.stdout(`${JSON.stringify(created, null, 2)}
+`), 0;
+    let words = isRecord(created) && Array.isArray(created.words) ? created.words.map(String) : [], identity = isRecord(created) && isRecord(created.identity) ? created.identity : {};
+    io.stdout(
+      `Owner identity created: ${String(identity.ownerDid ?? "")}
+
+Your seed phrase \u2014 write these 12 words down, in order, and keep them somewhere safe.
+Anyone with this phrase can act as you; without it, your owner identity cannot be
+recovered if this machine is lost. It will NOT be shown again.
+
+${formatWords(words)}
+
+Use the same phrase in ADF Studio (Settings \u2192 Import Identity) or \`adf identity restore\`
+on another machine to be the same owner there.
+
+`
+    );
+    let answer = (await ask(io, 'Type "yes" once you have written the words down: ')).trim().toLowerCase();
+    return answer === "yes" || answer === "y" ? (await postJson(io, options, "/identity/confirm-backup"), io.stdout(`Backup confirmed.
+`)) : io.stdout(`Backup not confirmed. The phrase cannot be shown again by the daemon; if you did not save it,
+you can reveal it in ADF Studio on this machine (Settings \u2192 Back Up Seed Phrase).
+`), 0;
+  }
+  if (action === "restore" || action === "import") {
+    let current = await requestJson(io, options, "/identity");
+    if (isRecord(current) && current.status === "ready")
+      return io.stdout(formatIdentity(current)), 0;
+    isRecord(current) && typeof current.ownerDid == "string" && current.ownerDid && io.stdout(`This machine's owner is ${current.ownerDid}; enter the seed phrase for that owner.
+`);
+    let mnemonic = (await ask(io, "Seed phrase (12 words, input hidden): ", !0)).trim();
+    if (!mnemonic) throw new Error("No seed phrase entered.");
+    let passphrase = await passphraseIfNeeded(io, current, isRecord(current) && current.status !== "locked"), restored = await postJson(io, options, "/identity/restore", { mnemonic, ...passphrase ? { passphrase } : {} }), identity = isRecord(restored) && isRecord(restored.identity) ? restored.identity : restored;
+    return io.stdout(options.json ? `${JSON.stringify(restored, null, 2)}
+` : `Owner identity restored.
+${formatIdentity(identity)}`), 0;
+  }
+  if (action === "unlock") {
+    let passphrase = await ask(io, "Passphrase: ", !0), unlocked = await postJson(io, options, "/identity/unlock", { passphrase }), identity = isRecord(unlocked) && isRecord(unlocked.identity) ? unlocked.identity : unlocked;
+    return io.stdout(options.json ? `${JSON.stringify(unlocked, null, 2)}
+` : formatIdentity(identity)), 0;
+  }
+  if (action === "lock") {
+    let locked = await postJson(io, options, "/identity/lock"), identity = isRecord(locked) && isRecord(locked.identity) ? locked.identity : locked;
+    return io.stdout(options.json ? `${JSON.stringify(locked, null, 2)}
+` : formatIdentity(identity)), 0;
+  }
+  throw new Error("Usage: adf identity [status | new | restore | unlock | lock]");
+}
+async function newAgent(io, options, args) {
+  let body = {}, valueFlags = {
+    "--template": "template",
+    "-t": "template",
+    "--provider": "provider",
+    "--model": "model",
+    "--dir": "directory",
+    "--directory": "directory"
+  }, positional = [];
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i], eq = arg.indexOf("="), flag = arg.startsWith("--") && eq > 0 ? arg.slice(0, eq) : arg;
+    if (flag === "--start") {
+      body.start = !0;
+      continue;
+    }
+    let key = valueFlags[flag];
+    if (key) {
+      let value = eq > 0 && flag !== arg ? arg.slice(eq + 1) : args[++i];
+      if (!value) throw new Error(`${flag} requires a value`);
+      body[key] = value;
+      continue;
+    }
+    if (arg.startsWith("-")) throw new Error(`Unknown option for adf new: ${arg}`);
+    positional.push(arg);
+  }
+  positional.length > 0 && (body.name = positional.join(" "));
+  let created = await postJson(io, options, "/agents/create", body);
+  if (options.json)
+    return io.stdout(`${JSON.stringify(created, null, 2)}
+`), 0;
+  let row = isRecord(created) ? created : {};
+  return io.stdout(table(["field", "value"], [
+    ["name", String(row.name ?? "")],
+    ["agentId", String(row.agentId ?? "")],
+    ["did", String(row.did ?? "")],
+    ["filePath", String(row.filePath ?? "")],
+    ["started", String(row.started ?? !1)]
+  ])), 0;
+}
+function formatWords(words) {
+  let cells = words.map((word, i) => `${String(i + 1).padStart(2)}. ${word}`.padEnd(16)), rows = [];
+  for (let i = 0; i < cells.length; i += 4) rows.push(`  ${cells.slice(i, i + 4).join(" ").trimEnd()}`);
+  return rows.join(`
+`);
+}
+function formatIdentity(value) {
+  return isRecord(value) ? `${table(["field", "value"], [
+    ["status", String(value.status ?? "")],
+    ["ownerDid", String(value.ownerDid ?? "")],
+    ["runtimeDid", String(value.runtimeDid ?? "")],
+    ["storage", String(value.storage ?? "")],
+    ["backupConfirmed", String(value.backupConfirmed ?? !1)]
+  ])}${typeof value.message == "string" ? `${value.message}
+` : ""}` : formatJsonPretty(value);
+}
+function formatTemplates(value) {
+  let templates = isRecord(value) && Array.isArray(value.templates) ? value.templates.filter(isRecord) : [];
+  if (templates.length === 0) return `No templates.
+`;
+  let defaultId = isRecord(value) ? String(value.defaultId ?? "") : "";
+  return table(["id", "name", "default", "model", "about"], templates.map((t) => [
+    String(t.id ?? ""),
+    String(t.name ?? ""),
+    t.id === defaultId ? "yes" : "",
+    [t.modelProvider, t.modelId].filter(Boolean).map(String).join("/"),
+    truncate(String(t.templateDescription ?? t.description ?? ""), 60)
+  ]));
+}
+function formatAgents(value) {
+  let rows = Array.isArray(value) ? value.filter(isRecord) : [];
+  return rows.length === 0 ? `No agents loaded.
+` : table(["id", "handle", "name", "autostart"], rows.map((row) => [
+    String(row.id ?? ""),
+    String(row.handle ?? ""),
+    String(row.name ?? ""),
+    String(row.autostart ?? !1)
+  ]));
+}
+function formatStatus(value) {
+  return isRecord(value) ? table(["field", "value"], [
+    ["id", String(value.id ?? "")],
+    ["handle", String(value.handle ?? "")],
+    ["name", String(value.name ?? "")],
+    ["runtimeState", String(value.runtimeState ?? "")],
+    ["targetState", String(value.targetState ?? "")],
+    ["loopCount", String(value.loopCount ?? "")],
+    ["filePath", String(value.filePath ?? "")]
+  ]) : formatJsonPretty(value);
+}
+function formatFiles(value) {
+  let files = isRecord(value) && Array.isArray(value.files) ? value.files.filter(isRecord) : [];
+  return files.length === 0 ? `No files.
+` : table(["path", "size", "mime", "protection"], files.map((file) => [
+    String(file.path ?? ""),
+    String(file.size ?? ""),
+    String(file.mime_type ?? ""),
+    String(file.protection ?? "")
+  ]));
+}
+function formatProviders(value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let providers = Array.isArray(value.providers) ? value.providers.filter(isRecord) : [], usage2 = Array.isArray(value.agentUsage) ? value.agentUsage.filter(isRecord) : [], providerTable = providers.length === 0 ? `Providers: none
+` : `Providers:
+${table(["id", "type", "name", "model", "key"], providers.map((provider) => [
+    String(provider.id ?? ""),
+    String(provider.type ?? ""),
+    String(provider.name ?? ""),
+    String(provider.defaultModel ?? ""),
+    String(provider.hasApiKey ?? !1)
+  ]))}`, usageTable = usage2.length === 0 ? `Agent usage: none
+` : `Agent usage:
+${table(["agent", "provider", "model", "source"], usage2.map((row) => [
+    String(row.handle ?? row.agentId ?? ""),
+    String(row.providerId ?? ""),
+    String(row.modelId ?? ""),
+    String(row.source ?? "")
+  ]))}`;
+  return `${providerTable}
+${usageTable}`;
+}
+function formatAuth(value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let chatgpt = isRecord(value.chatgpt) ? value.chatgpt : {}, grok = isRecord(value.grok) ? value.grok : {}, providers = Array.isArray(value.providers) ? value.providers.filter(isRecord) : [], chatgptTable = `ChatGPT:
+${table(["field", "value"], [
+    ["authenticated", String(chatgpt.authenticated ?? !1)],
+    ["email", String(chatgpt.email ?? "")]
+  ])}`, grokTable = `Grok:
+${table(["field", "value"], [
+    ["authenticated", String(grok.authenticated ?? !1)],
+    ["email", String(grok.email ?? "")]
+  ])}`, providersTable = providers.length === 0 ? `Provider credentials: none
+` : `Provider credentials:
+${table(["id", "type", "storage", "apiKey"], providers.map((provider) => [
+    String(provider.id ?? ""),
+    String(provider.type ?? ""),
+    String(provider.credentialStorage ?? ""),
+    String(provider.hasApiKey ?? !1)
+  ]))}`;
+  return `${chatgptTable}
+${grokTable}
+${providersTable}`;
+}
+function formatNetwork(value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let mesh = isRecord(value.mesh) ? value.mesh : {}, websocket = isRecord(value.websocket) ? value.websocket : {}, agents = Array.isArray(value.agents) ? value.agents.filter(isRecord) : [], summary = table(["field", "value"], [
+    ["meshEnabledSetting", String(mesh.enabledSetting ?? "")],
+    ["meshLan", String(mesh.lan ?? "")],
+    ["meshPort", String(mesh.port ?? "")],
+    ["wsActive", String(websocket.activeConnections ?? 0)],
+    ["wsInbound", String(websocket.inboundConnections ?? 0)],
+    ["wsOutbound", String(websocket.outboundConnections ?? 0)]
+  ]), agentTable = agents.length === 0 ? `Network agents: none
+` : `Network agents:
+${table(["agent", "receive", "mode", "ws", "routes"], agents.map((agent) => [
+    String(agent.handle ?? agent.agentId ?? ""),
+    String(agent.receive ?? !1),
+    String(agent.sendMode ?? ""),
+    String(agent.wsConnectionsConfigured ?? 0),
+    String(agent.servingRoutes ?? 0)
+  ]))}`;
+  return `${summary}
+${agentTable}`;
+}
+function formatUsage(value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let totals = isRecord(value.totals) ? value.totals : {}, summaryRows = [
+    ["source", String(value.source ?? "")],
+    ["input", formatNumber(totals.input)],
+    ["output", formatNumber(totals.output)],
+    ["cacheRead", formatNumber(totals.cacheRead)],
+    ["cacheWrite", formatNumber(totals.cacheWrite)],
+    ["total", formatNumber(totals.total)]
+  ];
+  value.agentId && summaryRows.unshift(["agentId", String(value.agentId)]), typeof value.loopRows == "number" && summaryRows.push(["loopRows", formatNumber(value.loopRows)]), typeof value.usageRows == "number" && summaryRows.push(["usageRows", formatNumber(value.usageRows)]);
+  let rows = Array.isArray(value.byModel) ? value.byModel.filter(isRecord).map((row) => [
+    String(row.provider ?? ""),
+    String(row.model ?? ""),
+    formatNumber(row.input),
+    formatNumber(row.output),
+    formatNumber(row.cacheRead),
+    formatNumber(row.cacheWrite),
+    formatNumber(row.total),
+    formatNumber(row.rows ?? row.days)
+  ]) : [], modelTable = rows.length === 0 ? `Models: none
+` : `Models:
+${table(["provider", "model", "input", "output", "cacheRead", "cacheWrite", "total", "rows/days"], rows)}`;
+  return `${table(["field", "value"], summaryRows)}
+${modelTable}`;
+}
+function formatMessages(label) {
+  return (value) => {
+    let messages = isRecord(value) && Array.isArray(value.messages) ? value.messages.filter(isRecord) : [];
+    return messages.length === 0 ? `No ${label} messages.
+` : table(["id", "status", label === "inbox" ? "from" : "to", "content"], messages.map((message) => [
+      String(message.id ?? ""),
+      String(message.status ?? ""),
+      String(label === "inbox" ? message.from ?? "" : message.to ?? ""),
+      truncate(String(message.content ?? ""), 80)
+    ]));
+  };
+}
+function formatTimers(value) {
+  let timers = isRecord(value) && Array.isArray(value.timers) ? value.timers.filter(isRecord) : [];
+  return timers.length === 0 ? `No timers.
+` : table(["id", "next_wake_at", "runs", "payload"], timers.map((timer) => [
+    String(timer.id ?? ""),
+    typeof timer.next_wake_at == "number" ? new Date(timer.next_wake_at).toISOString() : String(timer.next_wake_at ?? ""),
+    String(timer.run_count ?? ""),
+    truncate(String(timer.payload ?? ""), 80)
+  ]));
+}
+function formatTasks(value) {
+  let tasks = isRecord(value) && Array.isArray(value.tasks) ? value.tasks.filter(isRecord) : [];
+  return tasks.length === 0 ? `No tasks.
+` : table(["id", "status", "tool", "origin", "auth"], tasks.map((task) => [
+    String(task.id ?? ""),
+    String(task.status ?? ""),
+    String(task.tool ?? ""),
+    truncate(String(task.origin ?? ""), 32),
+    String(task.requires_authorization ?? !1)
+  ]));
+}
+function formatAsks(value) {
+  let asks = isRecord(value) && Array.isArray(value.asks) ? value.asks.filter(isRecord) : [];
+  return asks.length === 0 ? `No pending asks.
+` : table(["requestId", "question"], asks.map((ask2) => [
+    String(ask2.requestId ?? ""),
+    truncate(String(ask2.question ?? ""), 100)
+  ]));
+}
+function formatIdentities(value) {
+  let identities = isRecord(value) && Array.isArray(value.identities) ? value.identities.filter(isRecord) : [];
+  return identities.length === 0 ? `No identities.
+` : table(["purpose", "encrypted", "code_access"], identities.map((identity) => [
+    String(identity.purpose ?? ""),
+    String(identity.encrypted ?? !1),
+    String(identity.code_access ?? !1)
+  ]));
+}
+function formatMcp(value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let configured = Array.isArray(value.configured) ? value.configured.filter(isRecord) : [], states = Array.isArray(value.states) ? value.states.filter(isRecord) : [], configuredTable = configured.length === 0 ? `Configured MCP: none
+` : `Configured MCP:
+${table(["name", "transport", "tools"], configured.map((server) => [
+    String(server.name ?? ""),
+    String(server.transport ?? ""),
+    String(server.toolCount ?? "")
+  ]))}`, stateTable = states.length === 0 ? `Runtime MCP: none
+` : `Runtime MCP:
+${table(["name", "status", "tools", "error"], states.map((state) => [
+    String(state.name ?? ""),
+    String(state.status ?? ""),
+    String(state.toolCount ?? ""),
+    truncate(String(state.error ?? ""), 80)
+  ]))}`;
+  return `${configuredTable}
+${stateTable}`;
+}
+function formatGlobalMcp(value) {
+  let servers = isRecord(value) && Array.isArray(value.servers) ? value.servers.filter(isRecord) : [];
+  return servers.length === 0 ? `No daemon MCP servers registered.
+` : table(["id", "name", "type", "package", "storage", "env"], servers.map((server) => [
+    String(server.id ?? ""),
+    String(server.name ?? ""),
+    String(server.type ?? ""),
+    String(server.npmPackage ?? server.pypiPackage ?? server.command ?? server.url ?? ""),
+    String(server.credentialStorage ?? ""),
+    Array.isArray(server.env) ? String(server.env.length) : "0"
+  ]));
+}
+function formatAdapters(value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let configured = Array.isArray(value.configured) ? value.configured.filter(isRecord) : [], states = Array.isArray(value.states) ? value.states.filter(isRecord) : [], configuredTable = configured.length === 0 ? `Configured adapters: none
+` : `Configured adapters:
+${table(["type", "enabled"], configured.map((adapter) => [
+    String(adapter.type ?? ""),
+    String(adapter.enabled ?? !1)
+  ]))}`, stateTable = states.length === 0 ? `Runtime adapters: none
+` : `Runtime adapters:
+${table(["type", "status", "error"], states.map((state) => [
+    String(state.type ?? ""),
+    String(state.status ?? ""),
+    truncate(String(state.error ?? ""), 80)
+  ]))}`;
+  return `${configuredTable}
+${stateTable}`;
+}
+function formatGlobalAdapters(value) {
+  let adapters = isRecord(value) && Array.isArray(value.adapters) ? value.adapters.filter(isRecord) : [];
+  return adapters.length === 0 ? `No daemon adapters registered.
+` : table(["id", "type", "package"], adapters.map((adapter) => [
+    String(adapter.id ?? ""),
+    String(adapter.type ?? ""),
+    String(adapter.npmPackage ?? "")
+  ]));
+}
+function formatChatAck(value) {
+  return isRecord(value) ? value.accepted ? `Accepted turn ${String(value.turnId ?? "")}
+` : `${JSON.stringify(value, null, 2)}
+` : formatJsonPretty(value);
+}
+function formatAgentControl(action, agent, value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  if (value.success !== !0) return `${JSON.stringify(value, null, 2)}
+`;
+  if (action === "start") {
+    let details = [
+      value.loaded === !0 ? "loaded" : "",
+      value.startupTriggered === !1 ? "no startup trigger fired" : ""
+    ].filter(Boolean);
+    return `Started ${agent}${details.length > 0 ? ` (${details.join(", ")})` : ""}
+`;
+  }
+  return action === "abort" ? `Aborted current turn for ${agent}
+` : `Stopped ${agent}
+`;
+}
+function formatTaskResolution(action, taskId, value) {
+  if (!isRecord(value)) return formatJsonPretty(value);
+  let task = isRecord(value.task) ? value.task : {}, status = typeof task.status == "string" ? task.status : action === "approve" ? "approved" : "denied";
+  return `${action === "approve" ? "Approved" : "Denied"} ${taskId} (${status})
+`;
+}
+function formatEvent(value) {
+  if (!isRecord(value)) return JSON.stringify(value);
+  let envelope = isRecord(value.event) ? value.event : value, cursor = value.cursor ?? envelope.seq, seq = String(cursor ?? ""), type = String(envelope.event_type ?? ""), agent = envelope.agent_id ? ` ${String(envelope.agent_id)}` : "", payload = isRecord(envelope.payload) ? envelope.payload : {}, detail = typeof payload.message == "string" ? payload.message : typeof payload.type == "string" ? payload.type : "";
+  return `[${seq}] ${type}${agent}${detail ? ` ${detail}` : ""}`;
+}
+function formatJsonPretty(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function table(headers, rows) {
+  let widths = headers.map((header, i) => Math.max(header.length, ...rows.map((row) => (row[i] ?? "").length))), renderRow = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ");
+  return `${renderRow(headers)}
+${widths.map((width) => "-".repeat(width)).join("  ")}
+${rows.map(renderRow).join(`
+`)}
+`;
+}
+function truncate(value, max) {
+  return value.length <= max ? value : `${value.slice(0, max - 3)}...`;
+}
+function formatNumber(value) {
+  return typeof value == "number" && Number.isFinite(value) ? value.toLocaleString() : "";
+}
+function enc(value) {
+  return encodeURIComponent(value);
+}
+function isRecord(value) {
+  return !!value && typeof value == "object" && !Array.isArray(value);
+}
+function usage() {
+  return `ADF CLI: run and talk to your ADF agents from a terminal.
+
+Usage: adf [--url <daemon-url>] [--json] <command>
+       adf [tui] [--view <id>] [--agent <id>] [--loop <name>]
+       adf daemon [start|status|stop|restart|logs]
+
+With no command, adf opens the terminal app (see \`adf tui --help\`).
+When the daemon URL is on this machine and nothing answers there, adf
+starts the daemon in the background first (--no-daemon or
+ADF_NO_AUTOSTART=1 turn that off). Quitting leaves it running.
+
+Commands:
+  tui                            The terminal app (the default)
+  agents                         List loaded agents
+  status <agent>                 Show runtime status
+  start <agent>                  Start an agent and fire startup when applicable
+  stop <agent>                   Stop and unload an agent
+  unload <agent>                 Alias for stop
+  loops <agent>                  List the agent's loops: main plus its inner
+                                  (side) loops, parallel threads with their own
+                                  history, e.g. a memory consolidator on a timer
+  interrupt <agent> [--loop <name>]
+                                  End the running turn; the loop goes idle and
+                                  keeps accepting chats, timers and triggers
+  abort <agent> [--loop <name>]  Hard-abort the current turn without unloading;
+                                  that loop stays stopped until the agent is
+                                  reloaded (prefer interrupt)
+  runtime [agent]                Show daemon or agent runtime diagnostics
+  providers                      Show provider configuration and agent resolution
+  auth                           Show auth and credential presence
+  auth login <chatgpt|grok>      Sign in to a subscription provider
+                                  [--relay|--loopback] chooses where the
+                                  ChatGPT OAuth callback is served; defaults to
+                                  relay when --url points at a remote daemon
+  auth logout <chatgpt|grok>     Clear a subscription provider's tokens
+  settings                       Show sanitized daemon runtime settings
+  network                        Show mesh and WebSocket diagnostics
+  network mesh [enable|disable]  Control daemon mesh registration
+  network server [start|stop|restart]
+                                  Control the mesh HTTP server
+  network tools|lan|runtimes     Show mesh tools, LAN addresses, or peers
+  usage [agent]                  Show runtime or agent token usage
+  config <agent>                 Show agent config
+  files <agent>                  List agent files
+  file <agent> <path>            Print one agent file
+  inbox <agent>                  List inbox messages
+  outbox <agent>                 List outbox messages
+  timers <agent>                 List timers
+  tasks <agent>                  List tasks and pending approvals
+  task <agent> <taskId>          Show one task
+  approve <agent> <taskId>       Approve a pending task
+  deny <agent> <taskId> [reason] Deny a pending task
+  asks <agent>                   List pending ask requests
+  answer <agent> <requestId> <answer>
+                                  Answer a pending ask request
+  identities <agent>             List identity metadata without secret values
+  mcp [agent]                    Show daemon MCP registrations or agent MCP state
+  adapters [agent]               Show daemon adapter registrations or agent adapter state
+  events [agent]                 Follow daemon SSE events
+  chat <agent> [--loop <name>] <message>
+                                  Send chat (to main, or an inner loop) and
+                                  print the accepted turn id
+  identity                       Show the owner identity status
+  identity new                   Create an owner identity; shows the 12-word
+                                  seed phrase once \u2014 write it down
+  identity restore               Restore the owner identity from its seed
+                                  phrase (typed at a hidden prompt; the same
+                                  phrase as ADF Studio = the same owner)
+  identity unlock|lock           Unlock/lock a passphrase-protected identity
+                                  (machines without an OS keychain)
+  templates                      List agent templates
+  new [name] [--template <id>] [--provider <id>] [--model <id>]
+      [--dir <path>] [--start]   Create an agent from a template, sealed
+                                  with the owner identity (like Studio)
+
+Daemon:
+  daemon [--port <n>] [--host <h>] [--settings <file>]
+                                  Run the daemon in the foreground (Ctrl+C
+                                  stops it; also ADF_DAEMON_PORT,
+                                  ADF_DAEMON_HOST, ADF_DAEMON_SETTINGS,
+                                  ADF_USER_DATA_DIR)
+  daemon start [--port <n>] [--force]
+                                  Start it in the background (what adf does
+                                  on its own); --force skips the ADF Studio
+                                  check
+  daemon status                  Is it running: pid, uptime, version, log file
+  daemon stop                    Stop it gracefully (agents unloaded,
+                                  containers stopped)
+  daemon restart                 Stop, then start in the background
+  daemon logs [-f] [-n <lines>]  Show the background daemon's log (-f follows)
+  daemon token                   Print this machine's daemon access token (for
+                                  clients on other machines: --token or
+                                  ADF_DAEMON_TOKEN)
+
+Options:
+  --url, -u <url>                Daemon URL
+  --token <token>                Daemon access token (default: ADF_DAEMON_TOKEN,
+                                  else read automatically on the daemon's machine)
+  --json                         JSON output
+  --no-daemon                    Never start the daemon automatically
+  --version, -v                  Print the version
+
+Environment:
+  ADF_DAEMON_URL                 Defaults to ${DEFAULT_DAEMON_URL}
+  ADF_DAEMON_TOKEN               Daemon access token (overrides the local
+                                  <data dir>/daemon-token file)
+  ADF_NO_AUTOSTART=1             Same as --no-daemon`;
+}
+export {
+  runCli,
+  tuiInvocation
+};