@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-X34PDRUH.mjs

@@ -0,0 +1,809 @@
+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 {
+  DaemonError,
+  MAIN_LOOP
+} from "./chunk-XNPZBLYL.mjs";
+import {
+  cjs
+} from "./chunk-SGUTYISF.mjs";
+import {
+  daemon_url_exports
+} from "./chunk-G426FACA.mjs";
+
+// src/main/tui/api/sse.ts
+var EventStream = class {
+  options;
+  fetchImpl;
+  controller = null;
+  closed = !1;
+  started = !1;
+  attempt = 0;
+  hasOpened = !1;
+  lastCursor;
+  seen = /* @__PURE__ */ new Set();
+  seenOrder = [];
+  idleTimer = null;
+  retryTimer = null;
+  info = { state: "idle", attempt: 0 };
+  constructor(options) {
+    this.options = options, this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis), this.lastCursor = options.since ?? -1;
+  }
+  get cursor() {
+    return this.lastCursor;
+  }
+  get connection() {
+    return this.info;
+  }
+  start() {
+    return this.started ? this : (this.started = !0, this.connect(), this);
+  }
+  close() {
+    this.closed = !0, this.retryTimer && clearTimeout(this.retryTimer), this.clearIdle(), this.controller?.abort(), this.setState({ state: "closed", attempt: this.attempt });
+  }
+  /** Drop the current connection and reconnect now (e.g. user-requested). */
+  reconnect() {
+    if (!this.closed) {
+      if (this.retryTimer) {
+        clearTimeout(this.retryTimer), this.retryTimer = null, this.connect();
+        return;
+      }
+      this.controller?.abort();
+    }
+  }
+  setState(info) {
+    this.info = info;
+    try {
+      this.options.onState?.(info);
+    } catch {
+    }
+  }
+  buildUrl() {
+    let params = new URLSearchParams();
+    this.options.agentId && params.set("agentId", this.options.agentId), this.lastCursor >= 0 ? params.set("since", String(this.lastCursor)) : this.options.replay || params.set("since", String(Number.MAX_SAFE_INTEGER));
+    let qs = params.toString();
+    return `${this.options.baseUrl}/events${qs ? `?${qs}` : ""}`;
+  }
+  async connect() {
+    if (this.closed) return;
+    this.retryTimer = null;
+    let resumed = this.hasOpened;
+    this.setState({ state: this.hasOpened || this.attempt > 0 ? "reconnecting" : "connecting", attempt: this.attempt });
+    let controller = new AbortController();
+    this.controller = controller;
+    let failure;
+    try {
+      let response = await this.fetchImpl(this.buildUrl(), {
+        headers: { Accept: "text/event-stream", ...typeof this.options.headers == "function" ? this.options.headers() : this.options.headers ?? {} },
+        signal: controller.signal
+      });
+      if (!response.ok || !response.body)
+        throw new Error(`HTTP ${response.status} ${response.statusText}`.trim());
+      this.attempt = 0, this.hasOpened = !0, this.setState({ state: "open", attempt: 0, resumed }), this.armIdle(), await this.read(response.body, controller), failure = "stream ended";
+    } catch (err) {
+      failure = controller.signal.aborted && this.closed ? void 0 : errorMessage(err);
+    } finally {
+      this.clearIdle();
+    }
+    if (this.closed) return;
+    this.attempt += 1;
+    let delay = this.backoff();
+    this.setState({ state: "reconnecting", attempt: this.attempt, error: failure, retryInMs: delay }), this.retryTimer = setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+  backoff() {
+    let min = this.options.minBackoffMs ?? 500, max = this.options.maxBackoffMs ?? 1e4, exp = Math.min(max, min * 2 ** Math.max(0, this.attempt - 1));
+    return Math.round(exp / 2 + Math.random() * (exp / 2));
+  }
+  armIdle() {
+    this.clearIdle();
+    let timeout = this.options.idleTimeoutMs ?? 75e3;
+    this.idleTimer = setTimeout(() => this.controller?.abort(new Error("idle timeout")), timeout);
+  }
+  clearIdle() {
+    this.idleTimer && clearTimeout(this.idleTimer), this.idleTimer = null;
+  }
+  async read(body, controller) {
+    let reader = body.getReader(), decoder = new TextDecoder(), buffer = "", abort = () => {
+      reader.cancel().catch(() => {
+      });
+    };
+    controller.signal.addEventListener("abort", abort, { once: !0 });
+    try {
+      for (; ; ) {
+        let { value, done } = await reader.read();
+        if (done) break;
+        this.armIdle(), buffer += decoder.decode(value, { stream: !0 }).replace(/\r\n?/g, `
+`);
+        let boundary = buffer.indexOf(`
+
+`);
+        for (; boundary >= 0; ) {
+          let block = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2), this.handleBlock(block), boundary = buffer.indexOf(`
+
+`);
+        }
+      }
+    } finally {
+      controller.signal.removeEventListener("abort", abort);
+    }
+    if (controller.signal.aborted) throw controller.signal.reason instanceof Error ? controller.signal.reason : new Error("aborted");
+  }
+  handleBlock(block) {
+    let data = [];
+    for (let line of block.split(`
+`)) {
+      if (!line || line.startsWith(":")) continue;
+      let colon = line.indexOf(":"), field = colon < 0 ? line : line.slice(0, colon), value = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
+      field === "data" && data.push(value);
+    }
+    if (data.length === 0) return;
+    let frame;
+    try {
+      frame = JSON.parse(data.join(`
+`));
+    } catch {
+      return;
+    }
+    if (!frame || typeof frame != "object" || !frame.event) return;
+    typeof frame.cursor == "number" && (frame.cursor < this.lastCursor && this.forgetCursorKeys(), this.lastCursor = frame.cursor);
+    let key = dedupeKey(frame);
+    if (key) {
+      if (this.seen.has(key)) return;
+      this.remember(key);
+    }
+    try {
+      this.options.onEvent(frame);
+    } catch {
+    }
+  }
+  remember(key) {
+    this.seen.add(key), this.seenOrder.push(key);
+    let cap = this.options.dedupeWindow ?? 5e3;
+    for (; this.seenOrder.length > cap; ) {
+      let old = this.seenOrder.shift();
+      old && this.seen.delete(old);
+    }
+  }
+  forgetCursorKeys() {
+    for (let i = this.seenOrder.length - 1; i >= 0; i--) {
+      let key = this.seenOrder[i];
+      key.startsWith("c:") && (this.seen.delete(key), this.seenOrder.splice(i, 1));
+    }
+  }
+};
+function dedupeKey(frame) {
+  let { event } = frame;
+  return event.agent_id && typeof event.seq == "number" && event.seq > 0 ? `a:${event.agent_id}:${event.seq}` : typeof frame.cursor == "number" ? `c:${frame.cursor}` : null;
+}
+function errorMessage(err) {
+  if (err instanceof Error) {
+    let cause = err.cause;
+    return cause instanceof Error && cause.message ? cause.message : err.message;
+  }
+  return String(err);
+}
+
+// src/main/tui/api/normalize.ts
+var obj = (v) => v && typeof v == "object" && !Array.isArray(v) ? v : {}, arr = (v) => Array.isArray(v) ? v : [], num = (v) => typeof v == "number" && Number.isFinite(v) ? v : 0;
+function normalizeRuntime(raw) {
+  let r = obj(raw), daemon = obj(r.daemon), providers = obj(r.providers), network = obj(r.network), mesh = obj(network.mesh), websocket = obj(network.websocket);
+  return {
+    ...r,
+    daemon: { ...daemon, pid: num(daemon.pid), uptime: num(daemon.uptime) },
+    settings: obj(r.settings),
+    providers: { ...providers, providers: arr(providers.providers) },
+    auth: obj(r.auth),
+    mcp: obj(r.mcp),
+    adapters: obj(r.adapters),
+    network: { ...network, mesh: { ...mesh, status: mesh.status ?? null }, agents: arr(network.agents), websocket: { ...websocket, activeConnections: num(websocket.activeConnections) } },
+    compute: r.compute && typeof r.compute == "object" ? r.compute : null,
+    agents: arr(r.agents)
+  };
+}
+
+// src/main/tui/api/client.ts
+var { localDaemonToken, resolveDaemonToken, resolveDaemonUrl } = cjs(daemon_url_exports), enc = encodeURIComponent;
+function sameOrigin(a, b) {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return !1;
+  }
+}
+var DaemonClient = class _DaemonClient {
+  baseUrl;
+  token;
+  fetchImpl;
+  timeoutMs;
+  options;
+  constructor(options = {}) {
+    this.baseUrl = resolveDaemonUrl(options.baseUrl), this.token = resolveDaemonToken(options.token, options.env ?? process.env, options.localToken ? this.baseUrl : void 0), this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis), this.timeoutMs = options.timeoutMs ?? 15e3, this.options = options;
+  }
+  /**
+   * Same transport (fetch, timeout) against another daemon. The current token
+   * is carried over only to the same origin; another origin gets `token`, or
+   * ADF_DAEMON_TOKEN, or none — never this daemon's bearer token.
+   */
+  withBaseUrl(baseUrl, token) {
+    let carried = sameOrigin(this.baseUrl, resolveDaemonUrl(baseUrl)) ? this.token : void 0;
+    return new _DaemonClient({ ...this.options, baseUrl, token: token ?? carried });
+  }
+  /** Whether requests carry a bearer token. */
+  get hasToken() {
+    return !!this.token;
+  }
+  // --- transport ------------------------------------------------------------
+  url(path, query) {
+    let qs = query ? buildQuery(query) : "";
+    return `${this.baseUrl}${path}${qs}`;
+  }
+  headers(extra = {}) {
+    return {
+      Accept: "application/json",
+      ...this.token ? { Authorization: `Bearer ${this.token}` } : {},
+      ...extra
+    };
+  }
+  /**
+   * The daemon answered 401: with `localToken` and no explicit token, pick up
+   * a token file that appeared or changed since (daemon first start). True
+   * when the token changed, so the request is worth one retry.
+   */
+  refreshLocalToken() {
+    if (!this.options.localToken || this.options.token) return !1;
+    let env = this.options.env ?? process.env;
+    if (env.ADF_DAEMON_TOKEN) return !1;
+    let fresh = localDaemonToken(this.baseUrl, env);
+    return !fresh || fresh === this.token ? !1 : (this.token = fresh, !0);
+  }
+  async request(method, path, options = {}, retried = !1) {
+    let controller = new AbortController(), timeoutMs = options.timeoutMs ?? this.timeoutMs, timer = setTimeout(() => controller.abort(new Error("timeout")), timeoutMs), onAbort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", onAbort, { once: !0 });
+    let response;
+    try {
+      response = await this.fetchImpl(this.url(path, options.query), {
+        method,
+        headers: this.headers(options.body !== void 0 ? { "Content-Type": "application/json" } : {}),
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (err) {
+      let reason = controller.signal.aborted && !options.signal?.aborted ? `timed out after ${timeoutMs}ms` : errorMessage2(err);
+      throw new DaemonError(`Cannot reach daemon at ${this.baseUrl}: ${reason}`, null);
+    } finally {
+      clearTimeout(timer), options.signal?.removeEventListener("abort", onAbort);
+    }
+    let text = await response.text(), body = null;
+    if (text.trim())
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = text;
+      }
+    if (!response.ok) {
+      if (response.status === 401 && !retried && this.refreshLocalToken()) return this.request(method, path, options, !0);
+      let message = isRecord(body) && typeof body.error == "string" ? body.error : `HTTP ${response.status} ${response.statusText}`;
+      throw new DaemonError(message, response.status, body);
+    }
+    return body;
+  }
+  get(path, query) {
+    return this.request("GET", path, { query });
+  }
+  post(path, body, query) {
+    return this.request("POST", path, { body, query });
+  }
+  put(path, body, query) {
+    return this.request("PUT", path, { body, query });
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, { body });
+  }
+  del(path, query) {
+    return this.request("DELETE", path, { query });
+  }
+  /** Live umbilical events (SSE) with auto-reconnect. Call `.start()` on the result. */
+  events(options) {
+    return new EventStream({ ...options, baseUrl: this.baseUrl, headers: () => this.headers({ Accept: "text/event-stream" }), fetch: this.fetchImpl });
+  }
+  // --- daemon ---------------------------------------------------------------
+  health() {
+    return this.get("/health");
+  }
+  /** GET /runtime, normalized: a partial or older daemon's response has every section the views read. */
+  async runtime() {
+    return normalizeRuntime(await this.get("/runtime"));
+  }
+  providers() {
+    return this.get("/runtime/providers");
+  }
+  authStatus() {
+    return this.get("/runtime/auth");
+  }
+  runtimeSettings() {
+    return this.get("/runtime/settings");
+  }
+  runtimeMcp() {
+    return this.get("/runtime/mcp");
+  }
+  runtimeAdapters() {
+    return this.get("/runtime/adapters");
+  }
+  network() {
+    return this.get("/runtime/network");
+  }
+  usage() {
+    return this.get("/runtime/usage");
+  }
+  models(provider, agentId) {
+    return this.get("/runtime/models", { provider, agentId });
+  }
+  settings() {
+    return this.get("/settings");
+  }
+  setting(key) {
+    return this.get(`/settings/${enc(key)}`);
+  }
+  putSetting(key, value) {
+    return this.put(`/settings/${enc(key)}`, { value });
+  }
+  /** Add an API-key provider. The key goes to the daemon secret store; the reply never carries it. */
+  addProvider(input) {
+    return this.post("/runtime/providers", input);
+  }
+  removeProvider(id) {
+    return this.del(`/runtime/providers/${enc(id)}`);
+  }
+  // --- compute (containers) and the mesh --------------------------------------
+  // Shapes are the daemon services' own; the Runtime view renders them as trees.
+  computeStatus() {
+    return this.get("/compute/status");
+  }
+  computeContainers() {
+    return this.get("/compute/containers");
+  }
+  meshStatus() {
+    return this.get("/network/mesh");
+  }
+  setMesh(enabled) {
+    return this.post(`/network/mesh/${enabled ? "enable" : "disable"}`);
+  }
+  meshServer() {
+    return this.get("/network/server");
+  }
+  meshServerAction(action) {
+    return this.post(`/network/server/${action}`);
+  }
+  /** `{ addresses: { hostname, addresses: [{ iface, address, family }] } }` (web/model `parseLan`). */
+  lanAddresses() {
+    return this.get("/network/mesh/lan-addresses");
+  }
+  // --- subscription provider sign-in (ChatGPT, Grok) ------------------------
+  // Sign-in flows themselves (browser, callback server, polling) live in
+  // cli/auth-flow.ts over `request`; these are the plain reads and sign-out.
+  subscriptionStatus(provider) {
+    return this.get(`/auth/${provider}/status`);
+  }
+  logoutSubscription(provider) {
+    return this.post(`/auth/${provider}/logout`);
+  }
+  // --- owner identity + agent creation --------------------------------------
+  // create / restore / unlock answer loopback callers only (403 loopback_only).
+  // Nothing here logs or keeps a request or response body.
+  identity() {
+    return this.get("/identity");
+  }
+  /** 201 with the 12 words, returned this once. `passphrase` only for file storage. */
+  createIdentity(passphrase) {
+    return this.post("/identity/create", passphrase ? { passphrase } : {});
+  }
+  restoreIdentity(mnemonic, passphrase) {
+    return this.post("/identity/restore", { mnemonic, ...passphrase ? { passphrase } : {} });
+  }
+  unlockIdentity(passphrase) {
+    return this.post("/identity/unlock", { passphrase });
+  }
+  lockIdentity() {
+    return this.post("/identity/lock");
+  }
+  confirmIdentityBackup() {
+    return this.post("/identity/confirm-backup");
+  }
+  templates() {
+    return this.get("/templates");
+  }
+  /** Studio's "new agent", headless. 409 identity_not_ready / name_taken, 422 template_*. */
+  createAgent(input = {}) {
+    return this.post("/agents/create", input);
+  }
+  // --- agents ---------------------------------------------------------------
+  agents() {
+    return this.get("/agents");
+  }
+  agent(agentId) {
+    return this.get(`/agents/${enc(agentId)}`);
+  }
+  status(agentId) {
+    return this.get(`/agents/${enc(agentId)}/status`);
+  }
+  agentUsage(agentId) {
+    return this.get(`/agents/${enc(agentId)}/usage`);
+  }
+  /** Load an .adf file from disk. Direct loads bypass review unless `requireReview`. */
+  load(filePath, requireReview = !1) {
+    return this.post("/agents/load", { filePath, requireReview });
+  }
+  review(filePath) {
+    return this.get("/agents/review", { filePath });
+  }
+  acceptReview(filePath) {
+    return this.post("/agents/review/accept", { filePath });
+  }
+  start(agentId) {
+    return this.post(`/agents/${enc(agentId)}/start`);
+  }
+  stop(agentId) {
+    return this.post(`/agents/${enc(agentId)}/stop`);
+  }
+  unload(agentId) {
+    return this.post(`/agents/${enc(agentId)}/unload`);
+  }
+  /**
+   * End one loop's running turn (default main) and leave it idle; the agent
+   * keeps accepting chats, triggers and timers. What Esc does.
+   */
+  interrupt(agentId, loop) {
+    return this.post(`/agents/${enc(agentId)}/interrupt`, void 0, loop && loop !== MAIN_LOOP ? { loop } : void 0);
+  }
+  /**
+   * Hard abort of one loop's turn (default main): the daemon leaves that
+   * executor stopped until the agent is reloaded. Prefer `interrupt`.
+   */
+  abort(agentId, loop) {
+    return this.post(`/agents/${enc(agentId)}/abort`, void 0, loop && loop !== MAIN_LOOP ? { loop } : void 0);
+  }
+  /** Scan directories and start every reviewed agent configured for autostart. */
+  autostart(trackedDirs, maxDepth) {
+    return this.post("/agents/autostart", { trackedDirs, ...maxDepth !== void 0 ? { maxDepth } : {} });
+  }
+  /** Compact one loop's history now. 409 while that loop is mid-turn. */
+  compact(agentId, loop) {
+    return this.post(`/agents/${enc(agentId)}/compact`, void 0, loop && loop !== MAIN_LOOP ? { loop } : void 0);
+  }
+  setState(agentId, state) {
+    return this.post(`/agents/${enc(agentId)}/state`, { state });
+  }
+  // --- conversation (loop-aware; absent loop = main) --------------------------
+  /** Owner chat into a loop. Unknown loop: 404, disabled loop: 409 — before any turn is queued. */
+  chat(agentId, text, loop) {
+    return this.post(`/agents/${enc(agentId)}/chat`, { text, ...loop && loop !== MAIN_LOOP ? { loop } : {} });
+  }
+  chatHistory(agentId, options = {}) {
+    return this.get(`/agents/${enc(agentId)}/chat`, { loop: options.loop, limit: options.limit });
+  }
+  clearChat(agentId, loop) {
+    return this.del(`/agents/${enc(agentId)}/chat`, { loop });
+  }
+  /** Raw persisted loop rows. Default page is the newest `limit` (50) rows. */
+  loopHistory(agentId, options = {}) {
+    return this.get(`/agents/${enc(agentId)}/loop`, { loop: options.loop, limit: options.limit, offset: options.offset });
+  }
+  trigger(agentId, dispatch) {
+    return this.post(`/agents/${enc(agentId)}/trigger`, dispatch);
+  }
+  // --- loops ----------------------------------------------------------------
+  loops(agentId) {
+    return this.get(`/agents/${enc(agentId)}/loops`);
+  }
+  loop(agentId, name) {
+    return this.get(`/agents/${enc(agentId)}/loops/${enc(name)}`);
+  }
+  createLoop(agentId, input) {
+    return this.post(`/agents/${enc(agentId)}/loops`, input);
+  }
+  updateLoop(agentId, name, patch) {
+    return this.patch(`/agents/${enc(agentId)}/loops/${enc(name)}`, patch);
+  }
+  setLoopEnabled(agentId, name, enabled) {
+    return this.updateLoop(agentId, name, { enabled });
+  }
+  /** Stops the loop, archives its stream to adf_audit, then removes it. */
+  deleteLoop(agentId, name) {
+    return this.del(`/agents/${enc(agentId)}/loops/${enc(name)}`);
+  }
+  // --- config / document / mind ---------------------------------------------
+  config(agentId) {
+    return this.get(`/agents/${enc(agentId)}/config`);
+  }
+  putConfig(agentId, config) {
+    return this.put(`/agents/${enc(agentId)}/config`, config);
+  }
+  document(agentId) {
+    return this.get(`/agents/${enc(agentId)}/document`);
+  }
+  putDocument(agentId, content) {
+    return this.put(`/agents/${enc(agentId)}/document`, { content });
+  }
+  mind(agentId) {
+    return this.get(`/agents/${enc(agentId)}/mind`);
+  }
+  putMind(agentId, content) {
+    return this.put(`/agents/${enc(agentId)}/mind`, { content });
+  }
+  // --- files ----------------------------------------------------------------
+  files(agentId) {
+    return this.get(`/agents/${enc(agentId)}/files`);
+  }
+  file(agentId, path) {
+    return this.get(`/agents/${enc(agentId)}/files/content`, { path });
+  }
+  writeFile(agentId, path, input) {
+    return this.put(`/agents/${enc(agentId)}/files/content`, input, { path });
+  }
+  deleteFile(agentId, path) {
+    return this.del(`/agents/${enc(agentId)}/files/content`, { path });
+  }
+  renameFile(agentId, oldPath, newPath) {
+    return this.post(`/agents/${enc(agentId)}/files/rename`, { oldPath, newPath });
+  }
+  renameFolder(agentId, oldPrefix, newPrefix) {
+    return this.post(`/agents/${enc(agentId)}/files/rename-folder`, { oldPrefix, newPrefix });
+  }
+  setFileProtection(agentId, path, protection) {
+    return this.patch(`/agents/${enc(agentId)}/files/protection`, { path, protection });
+  }
+  setFileAuthorized(agentId, path, authorized) {
+    return this.patch(`/agents/${enc(agentId)}/files/authorized`, { path, authorized });
+  }
+  // --- mesh messaging -------------------------------------------------------
+  inbox(agentId, status) {
+    return this.get(`/agents/${enc(agentId)}/inbox`, { status });
+  }
+  clearInbox(agentId) {
+    return this.del(`/agents/${enc(agentId)}/inbox`);
+  }
+  outbox(agentId, status) {
+    return this.get(`/agents/${enc(agentId)}/outbox`, { status });
+  }
+  // --- timers (a timer's `loop` is how an inner loop runs on a schedule) -----
+  timers(agentId) {
+    return this.get(`/agents/${enc(agentId)}/timers`);
+  }
+  createTimer(agentId, input) {
+    return this.post(`/agents/${enc(agentId)}/timers`, input);
+  }
+  /** `loop` present moves the timer to that loop (daemons before loop-aware timers ignore it). */
+  updateTimer(agentId, timerId, input) {
+    return this.put(`/agents/${enc(agentId)}/timers/${timerId}`, input);
+  }
+  deleteTimer(agentId, timerId) {
+    return this.del(`/agents/${enc(agentId)}/timers/${timerId}`);
+  }
+  // --- meta / identity (metadata only; secret values are never listed) ------
+  meta(agentId) {
+    return this.get(`/agents/${enc(agentId)}/meta`);
+  }
+  setMeta(agentId, key, value, protection) {
+    return this.put(`/agents/${enc(agentId)}/meta/${enc(key)}`, { value, ...protection ? { protection } : {} });
+  }
+  deleteMeta(agentId, key) {
+    return this.del(`/agents/${enc(agentId)}/meta/${enc(key)}`);
+  }
+  identities(agentId) {
+    return this.get(`/agents/${enc(agentId)}/identities`);
+  }
+  // --- logs / tables / umbilical replay -------------------------------------
+  logs(agentId, options = {}) {
+    return this.get(`/agents/${enc(agentId)}/logs`, options);
+  }
+  logsAfter(agentId, afterId) {
+    return this.get(`/agents/${enc(agentId)}/logs/after`, { afterId });
+  }
+  tables(agentId) {
+    return this.get(`/agents/${enc(agentId)}/tables`);
+  }
+  table(agentId, table, options = {}) {
+    return this.get(`/agents/${enc(agentId)}/tables/${enc(table)}`, options);
+  }
+  umbilicalReplay(agentId, options = {}) {
+    return this.get(`/agents/${enc(agentId)}/umbilical/events`, { since_seq: options.sinceSeq, limit: options.limit });
+  }
+  // --- HIL: tasks (approvals), asks, suspend --------------------------------
+  tasks(agentId, options = {}) {
+    return this.get(`/agents/${enc(agentId)}/tasks`, options);
+  }
+  task(agentId, taskId) {
+    return this.get(`/agents/${enc(agentId)}/tasks/${enc(taskId)}`);
+  }
+  resolveTask(agentId, taskId, input) {
+    return this.post(`/agents/${enc(agentId)}/tasks/${enc(taskId)}/resolve`, input);
+  }
+  /** Approve ▸ Always approve: un-restricts the pending request's tool on the
+   *  host config, then approves it. DaemonError status 409 when the request is
+   *  a protection override / one-shot approval / locked declaration. */
+  alwaysApproveTask(agentId, taskId) {
+    return this.post(`/agents/${enc(agentId)}/tasks/${enc(taskId)}/always-approve`, {});
+  }
+  /** Approve every pending gated approval (all loops, or just `loop`); protection overrides are skipped. */
+  approveAllTasks(agentId, loop) {
+    return this.post(`/agents/${enc(agentId)}/tasks/approve-all`, loop ? { loop } : {});
+  }
+  // --- tracked agent folders (Studio's tracked directories) -----------------
+  trackedDirs() {
+    return this.get("/tracked-dirs");
+  }
+  /** Track an absolute folder now and autostart its agents (review gate applies). 409 when already tracked. */
+  trackDir(path) {
+    return this.post("/tracked-dirs", { path });
+  }
+  /** Stop tracking (files are never deleted). `unload` also unloads the agents loaded from under it. */
+  untrackDir(path, options = {}) {
+    return this.del("/tracked-dirs", { path, unload: options.unload });
+  }
+  /** The agents in one tracked folder and where each stands (loaded, needs review, not autostart, stopped + load error). */
+  folderAgents(path) {
+    return this.get("/tracked-dirs/agents", { path });
+  }
+  /**
+   * Every tracked folder with its agents (GET /tracked-dirs/agents/all). On a
+   * daemon without that route: GET /tracked-dirs, then each folder's agents.
+   */
+  async trackedAgents() {
+    try {
+      return await this.get("/tracked-dirs/agents/all");
+    } catch (err) {
+      if (!(err instanceof DaemonError) || err.status !== 404) throw err;
+    }
+    let list = await this.trackedDirs(), folders = await Promise.all(list.directories.map(async (entry) => {
+      let agents = entry.exists ? await this.folderAgents(entry.path).then((r) => r.agents, () => []) : [];
+      return { ...entry, agents };
+    }));
+    return { maxDepth: list.maxDepth, folders };
+  }
+  asks(agentId) {
+    return this.get(`/agents/${enc(agentId)}/asks`);
+  }
+  /** `loop` picks the asking loop when request ids repeat across loops. */
+  answerAsk(agentId, requestId, answer, loop) {
+    return this.post(`/agents/${enc(agentId)}/asks/${enc(requestId)}/respond`, { answer, ...loop ? { loop } : {} });
+  }
+  respondSuspend(agentId, resume) {
+    return this.post(`/agents/${enc(agentId)}/suspend/respond`, { resume });
+  }
+  // --- per-agent runtime diagnostics ----------------------------------------
+  agentRuntime(agentId) {
+    return this.get(`/agents/${enc(agentId)}/runtime`);
+  }
+  agentTriggers(agentId) {
+    return this.get(`/agents/${enc(agentId)}/runtime/triggers`);
+  }
+  agentMcp(agentId) {
+    return this.get(`/agents/${enc(agentId)}/runtime/mcp`);
+  }
+  agentAdapters(agentId) {
+    return this.get(`/agents/${enc(agentId)}/runtime/adapters`);
+  }
+  // --- MCP servers (per agent) ------------------------------------------------
+  /** Add a server to the agent config (it connects on start, or with restartMcpServer now). */
+  attachMcpServer(agentId, server) {
+    return this.post(`/agents/${enc(agentId)}/mcp/servers`, { server });
+  }
+  /** Remove it and delete its stored credentials (`mcp:<namespace>:*`; the package, else the server name). */
+  detachMcpServer(agentId, serverName, credentialNamespace) {
+    return this.request("DELETE", `/agents/${enc(agentId)}/mcp/servers/${enc(serverName)}`, { query: { credentialNamespace } });
+  }
+  /** (Re)connect one server of a running agent now; the outcome carries tools found or the error. */
+  restartMcpServer(agentId, serverName) {
+    return this.request("POST", `/agents/${enc(agentId)}/mcp/servers/${enc(serverName)}/restart`, { timeoutMs: 18e4 });
+  }
+  /** Store one env value for an MCP server in the agent's identity store (`mcp:<namespace>:<key>`, sealed). */
+  setMcpCredential(agentId, namespace, envKey, value, opts = {}) {
+    return this.put(`/agents/${enc(agentId)}/mcp/credentials`, { npmPackage: namespace, envKey, value, ...opts.replace ? { replace: !0 } : {} });
+  }
+  /** What is stored for an MCP server's env keys: metadata only, never values. */
+  mcpCredentials(agentId, namespace) {
+    return this.get(`/agents/${enc(agentId)}/mcp/credentials`, { npmPackage: namespace });
+  }
+  /** Install an MCP server package on the daemon host (npm or Python). Synchronous: can take a minute. */
+  installMcpPackage(kind, pkg) {
+    return this.request("POST", `/admin/mcp/packages/${kind}`, { body: { package: pkg }, timeoutMs: 6e5 });
+  }
+  // --- messaging adapters (per agent) -----------------------------------------
+  /** Store one adapter credential in the agent's identity keystore (sealed under the owner identity). */
+  setAdapterCredential(agentId, adapterType, envKey, value, opts = {}) {
+    return this.put(`/agents/${enc(agentId)}/adapters/credentials`, { adapterType, envKey, value, ...opts.replace ? { replace: !0 } : {} });
+  }
+  /** What is stored for a channel's credentials: metadata only, never values. */
+  adapterCredentials(agentId, adapterType) {
+    return this.get(`/agents/${enc(agentId)}/adapters/credentials`, { adapterType });
+  }
+  /** Enable an adapter in the agent config; a running agent starts it. */
+  attachAdapter(agentId, adapterType, config) {
+    return this.post(`/agents/${enc(agentId)}/adapters`, { adapterType, config });
+  }
+  /** Remove the adapter from the config and delete its stored credentials. */
+  detachAdapter(agentId, adapterType) {
+    return this.del(`/agents/${enc(agentId)}/adapters/${enc(adapterType)}`);
+  }
+  agentWs(agentId) {
+    return this.get(`/agents/${enc(agentId)}/runtime/ws`);
+  }
+  // --- agent templates (/templates; the list is `templates()`) — owner: src/main/tui/templates ---
+  /** Summary + contents (config, seed files, extra files) + whether it is the default. */
+  templateDetail(id) {
+    return this.get(`/templates/${enc(id)}`);
+  }
+  /** Blank, or a duplicate of `fromId`. 201 `{ id, template }`. */
+  createTemplate(input) {
+    return this.post("/templates", input);
+  }
+  /** Rename and/or notes (`''` clears one). A rename moves the file: use the returned id. */
+  updateTemplate(id, patch) {
+    return this.patch(`/templates/${enc(id)}`, patch);
+  }
+  /** Moves the file to the daemon's templates-trash folder (never a hard delete). */
+  deleteTemplate(id) {
+    return this.del(`/templates/${enc(id)}`);
+  }
+  setDefaultTemplate(id) {
+    return this.post(`/templates/${enc(id)}/default`);
+  }
+  /** Shipped templates only: back to the shipped version. */
+  resetTemplate(id) {
+    return this.post(`/templates/${enc(id)}/reset`);
+  }
+  templateReview(id) {
+    return this.get(`/templates/${enc(id)}/review`);
+  }
+  /** Claims the file under this owner. 400 password_required / 403 wrong_password / 409 identity_not_ready. */
+  acceptTemplateReview(id, password) {
+    return this.post(`/templates/${enc(id)}/review/accept`, password ? { password } : {});
+  }
+  putTemplateConfig(id, config) {
+    return this.put(`/templates/${enc(id)}/config`, { config });
+  }
+  putTemplateFile(id, path, content) {
+    return this.put(`/templates/${enc(id)}/files`, { path, content });
+  }
+  removeTemplateFile(id, path) {
+    return this.del(`/templates/${enc(id)}/files`, { path });
+  }
+  // --- agent tool catalog (Inspect › Settings, /tools) -----------------------
+  /** Built-in + MCP + declared tools with declared state and descriptions (read-only; write via putConfig). */
+  agentTools(agentId) {
+    return this.get(`/agents/${enc(agentId)}/tools`);
+  }
+  // --- context usage (/context) ------------------------------------------------
+  /** One loop's context breakdown: categories (biggest `items` per category), compact threshold, total. */
+  agentContext(agentId, loop, items) {
+    return this.get(`/agents/${enc(agentId)}/context`, { loop: loop && loop !== MAIN_LOOP ? loop : void 0, items });
+  }
+};
+function buildQuery(query) {
+  let params = new URLSearchParams();
+  for (let [key, value] of Object.entries(query))
+    value == null || value === "" || params.set(key, String(value));
+  let qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+function isRecord(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage2(err) {
+  if (err instanceof Error) {
+    let cause = err.cause;
+    return cause instanceof Error && cause.message ? cause.message : err.message;
+  }
+  return String(err);
+}
+
+export {
+  DaemonClient
+};