@agentdocumentformat/cli 0.7.8 → 0.8.0

package/dist/chunks/{cli-NMFIAR7Z.mjs → cli-I47IFDHJ.mjs}

@@ -7,24 +7,511 @@ const __dirname = __adfDirname(__filename);
 import {
   AUTH_PROVIDER_LABELS,
   loginChatGpt,
+  loginClaude,
   loginGrok,
   normalizeAuthProvider,
-  openBrowser
-} from "./chunk-6VQEXLE2.mjs";
+  openBrowser,
+  submitClaudeCode
+} from "./chunk-BHY7QDCM.mjs";
+import {
+  MdnsService
+} from "./chunk-DDTTSKGG.mjs";
+import {
+  TailscaleClient,
+  defaultExec
+} from "./chunk-V3MM6PCH.mjs";
+import "./chunk-KDDVQKCG.mjs";
 import "./chunk-2NAP2ZF7.mjs";
 import {
+  UNSAFE_DISPLAY_CHARS,
+  cleanDisplayName,
+  fetchHello,
+  olderAdfSentence,
+  printable,
+  verifyHello,
+  verifyHelloWaiting
+} from "./chunk-M2F7C2UJ.mjs";
+import {
+  daemonPaths
+} from "./chunk-PRPTKMQW.mjs";
+import "./chunk-JVPZIMXW.mjs";
+import {
+  DEFAULT_DAEMON_PORT,
   DEFAULT_DAEMON_URL,
+  KEYCHAIN_FILE_COPY,
+  RemoteMalformedError,
+  RemotesUnreadableError,
+  deleteRemoteToken,
+  forgetRemote,
   isLocalDaemonUrl,
+  localDaemonToken,
   localProofHeaders,
   loopbackPort,
+  malformedRemoteSentence,
+  pinnedRemoteRefusal,
+  readRemoteToken,
+  readRemotes,
+  remoteNameFor,
+  remotesFilePath,
   resolveDaemonToken,
   resolveDaemonUrl,
-  tunnelTokenHint
-} from "./chunk-GKKCMXIZ.mjs";
-import "./chunk-UEZR2CNS.mjs";
-import "./chunk-IHDDCZBS.mjs";
+  storeRemoteToken,
+  tunnelTokenHint,
+  updateRemotes
+} from "./chunk-V2T6NZX2.mjs";
+import "./chunk-WVTPPOKK.mjs";
+import "./chunk-WJGPNHGX.mjs";
+import "./chunk-PAK5JCO2.mjs";
+import "./chunk-ZPB3HYM7.mjs";
+import "./chunk-LTX74NU6.mjs";
+import {
+  stdinPrompt
+} from "./chunk-PC63YFB7.mjs";
 import "./chunk-M2RX3S2T.mjs";
 
+// src/main/cli/index.ts
+import { createInterface } from "readline";
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+
+// src/main/cli/pair.ts
+import { hostname as hostname2 } from "node:os";
+
+// src/main/cli/daemon-discovery.ts
+import { randomBytes } from "node:crypto";
+function hostPart(address) {
+  return address.includes(":") ? `[${address}]` : address;
+}
+function daemonsOf(peers) {
+  return peers.flatMap((p) => p.remote ? [{ name: p.name, fingerprint: p.remote.fingerprint, url: p.remote.url, kind: p.remote.kind, pairingOpen: p.remote.pairingOpen, clash: p.remote.clash ?? null }] : []);
+}
+async function browseMdns(ms, createMdns = () => new MdnsService(), tailnet = async () => []) {
+  let service = createMdns();
+  try {
+    await service.start({ announce: !1, browse: !0, port: 0, runtimeId: `cli-browse-${randomBytes(6).toString("hex")}` });
+    let [found] = await Promise.all([tailnet().catch(() => []), new Promise((resolve) => setTimeout(resolve, ms))]);
+    for (let d of found)
+      try {
+        let url = new URL(d.url);
+        service.upsertTailnetDaemon({ fingerprint: d.fingerprint, name: d.name, address: url.hostname.replace(/^\[|\]$/g, ""), port: Number(url.port) || DEFAULT_DAEMON_PORT, pairingOpen: d.pairingOpen });
+      } catch {
+      }
+    return daemonsOf(service.peers());
+  } catch {
+    return [];
+  } finally {
+    await service.stop().catch(() => {
+    });
+  }
+}
+async function probeTailnet(opts = {}) {
+  let exec = opts.exec ?? defaultExec, client = new TailscaleClient(exec);
+  if ((await client.self()).state !== "running") return [];
+  let peers = [];
+  try {
+    let out = await exec(client.command ?? "tailscale", ["status", "--json"]);
+    peers = Object.values(JSON.parse(out).Peer ?? {});
+  } catch {
+    return [];
+  }
+  let port = opts.port ?? DEFAULT_DAEMON_PORT, probes = peers.filter((p) => p.Online === !0 && Array.isArray(p.TailscaleIPs) && typeof p.TailscaleIPs[0] == "string").map(async (p) => {
+    let ip = p.TailscaleIPs.find((a) => !a.includes(":")) ?? p.TailscaleIPs[0], url = `http://${hostPart(ip)}:${port}`, hello = await fetchHello(url, opts.fetch);
+    return hello ? { name: hello.name, fingerprint: hello.fingerprint, url, kind: "tailnet", pairingOpen: hello.pairingOpen } : null;
+  });
+  return (await Promise.all(probes)).filter((d) => d !== null);
+}
+function mergeDiscovered(lists) {
+  let byFp = /* @__PURE__ */ new Map();
+  for (let d of lists.flat()) {
+    let urls = byFp.get(d.fingerprint) ?? /* @__PURE__ */ new Map(), existing = urls.get(d.url);
+    urls.set(d.url, existing ? { ...existing, pairingOpen: existing.pairingOpen || d.pairingOpen, clash: existing.clash ?? d.clash ?? null } : { ...d }), byFp.set(d.fingerprint, urls);
+  }
+  let out = [];
+  for (let urls of byFp.values()) {
+    let all = [...urls.values()];
+    if (all.length > 1 || all.some((d) => (d.clash ?? 0) > 1)) {
+      for (let d of all) out.push({ ...d, clash: Math.max(all.length, d.clash ?? 0) });
+      continue;
+    }
+    out.push({ ...all[0], clash: null });
+  }
+  return out.sort((a, b) => Number(b.pairingOpen) - Number(a.pairingOpen) || a.name.localeCompare(b.name) || a.url.localeCompare(b.url));
+}
+async function peersFromDaemon(daemon, ms, fetchImpl = fetch, env = process.env) {
+  try {
+    let wait = Math.min(Math.max(ms, 0), 5e3), res = await fetchImpl(`${daemon.url.replace(/\/+$/, "")}/network/peers?wait=${wait}`, {
+      headers: { Authorization: `Bearer ${daemon.token}`, Accept: "application/json", ...localProofHeaders(daemon.url, "/network/peers", env) },
+      signal: AbortSignal.timeout(wait + 5e3)
+    });
+    if (!res.ok) return null;
+    let body = await res.json();
+    return Array.isArray(body.peers) ? body.peers : null;
+  } catch {
+    return null;
+  }
+}
+async function discoverDaemons(ms = 3e3, opts = {}) {
+  if (opts.localDaemon) {
+    let peers = await peersFromDaemon(opts.localDaemon, ms, opts.fetch, opts.env);
+    if (peers) return mergeDiscovered([daemonsOf(peers)]);
+  }
+  return mergeDiscovered([await browseMdns(ms, void 0, () => probeTailnet({ ...opts.fetch ? { fetch: opts.fetch } : {} }))]);
+}
+
+// src/main/backend/local-runtime-name.ts
+import { readFileSync, watch } from "node:fs";
+import { hostname } from "node:os";
+
+// src/shared/runtime-name.ts
+var LOCAL_LABEL = "Local";
+function localRuntimeName(name) {
+  let trimmed = typeof name == "string" ? name.trim() : "";
+  return trimmed ? `${trimmed} (${LOCAL_LABEL})` : LOCAL_LABEL;
+}
+
+// src/main/backend/local-runtime-name.ts
+function aliasOf(text) {
+  let alias = JSON.parse(text)?.runtimeAlias;
+  return cleanDisplayName(alias, 64);
+}
+function machineNameFromFile(settingsFile, host = hostname) {
+  if (settingsFile)
+    try {
+      let name = aliasOf(readFileSync(settingsFile, "utf-8"));
+      if (name) return name;
+    } catch {
+    }
+  return host().trim() || null;
+}
+
+// src/main/cli/pair.ts
+var PAIR_USAGE = `Usage: adf pair [<host>[:<port>] | <url>] [--name <this computer's name>] [--as <remote name>] [--yes] [--default | --no-default]
+
+Pairs this computer with another computer's ADF daemon. On that computer,
+open a pairing window first: ADF Studio \u2192 Settings \u2192 Connections \u2192 Add \u2192
+Share, or adf daemon pair. Type the 6-digit code it shows; it
+then asks whether to allow this computer.
+
+Without a host, adf lists the ADF computers it finds on this network and on
+your tailnet. The token adf receives is as powerful as that computer's owner
+seed phrase; it is saved in the OS keychain (or a file only you can read).`, REMOTES_USAGE = `Usage: adf remotes                 List saved remote daemons (* = default)
+       adf remotes use <name|local>  Talk to that daemon by default
+       adf remotes forget <name>     Delete its saved address and token`;
+function parsePairArgs(args) {
+  let out = { yes: !1, makeDefault: null };
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i], value = () => {
+      let v = args[++i];
+      if (v === void 0) throw new Error(`${arg} requires a value`);
+      return v;
+    };
+    if (arg === "--name") out.name = value();
+    else if (arg === "--as") out.as = value();
+    else if (arg === "--yes" || arg === "-y") out.yes = !0;
+    else if (arg === "--default") out.makeDefault = !0;
+    else if (arg === "--no-default") out.makeDefault = !1;
+    else {
+      if (arg === "--help" || arg === "-h") return PAIR_USAGE;
+      if (arg.startsWith("-")) return `Unknown option: ${arg}
+
+${PAIR_USAGE}`;
+      if (!out.host) out.host = arg;
+      else return `Too many arguments
+
+${PAIR_USAGE}`;
+    }
+  }
+  return out;
+}
+function hostToUrl(host) {
+  return /^https?:\/\//i.test(host) ? host.replace(/\/+$/, "") : /^\[.*\](:\d+)?$/.test(host) ? `http://${host.includes("]:") ? host : `${host}:${DEFAULT_DAEMON_PORT}`}` : host.includes(":") && host.split(":").length > 2 ? `http://[${host}]:${DEFAULT_DAEMON_PORT}` : `http://${/:\d+$/.test(host) ? host : `${host}:${DEFAULT_DAEMON_PORT}`}`;
+}
+function transportOf(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "plain";
+  }
+  if (parsed.protocol === "https:") return "https";
+  let host = parsed.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  return host === "localhost" || host === "::1" || /^127\./.test(host) ? "loopback" : /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(host) || /^fd7a:115c:a1e0:/.test(host) ? "tailnet" : "plain";
+}
+async function postJson(io, url, body) {
+  let res = await io.fetch(url, { method: "POST", headers: { "Content-Type": "application/json", Accept: "application/json" }, body: JSON.stringify(body), redirect: "manual" }), text = await res.text(), parsed = text ? JSON.parse(text) : {}, retry = Number(res.headers.get("retry-after"));
+  return { status: res.status, body: parsed, retryAfter: Number.isFinite(retry) && retry > 0 ? retry : null };
+}
+async function getJson(io, url, headers = {}) {
+  let res = await io.fetch(url, { headers: { Accept: "application/json", ...headers }, redirect: "manual" }), text = await res.text();
+  return { status: res.status, body: text ? JSON.parse(text) : {} };
+}
+function localDaemonOf(env) {
+  let url = `http://127.0.0.1:${Number(env.ADF_DAEMON_PORT) || DEFAULT_DAEMON_PORT}`, token = localDaemonToken(url, env);
+  return token ? { url, token } : null;
+}
+async function chooseDaemon(io) {
+  io.stderr(`Looking for ADF computers on this network and your tailnet\u2026
+`);
+  let found = await (io.discover ?? ((ms) => discoverDaemons(ms, { localDaemon: localDaemonOf(io.env ?? process.env), fetch: io.fetch, env: io.env ?? process.env })))(3e3);
+  if (found.length === 0)
+    return io.stderr(`No ADF computer found. On the other computer turn on remote access (Settings \u2192 Connections \u2192 Add \u2192 Share, or adf daemon remote on), then run adf pair <its address>.
+`), null;
+  found.forEach((d, i) => io.stderr(`  ${i + 1}. ${d.name}  ${d.fingerprint}  ${d.url}  (${d.kind === "tailnet" ? "tailnet" : "this network"}${d.pairingOpen ? ", ready to pair" : ""})
+`));
+  let answer = await io.prompt(found.length === 1 ? "Pair with 1? [Y/n] " : `Which one (1-${found.length})? `);
+  if (answer === null) return null;
+  let index = found.length === 1 && /^\s*(y|yes)?\s*$/i.test(answer) ? 0 : Number(answer.trim()) - 1, chosen = found[index];
+  if (!chosen)
+    return io.stderr(`No such entry.
+`), null;
+  let hello = await fetchHello(chosen.url, io.fetch);
+  return hello ? { url: chosen.url, hello } : (io.stderr(`${chosen.url} does not answer as an ADF daemon with remote access on.
+`), null);
+}
+async function bestUrl(io, used, urls, fingerprint, token, yes) {
+  if (transportOf(used) === "https") return used;
+  let view = null, { NO_TAILNET, TailscaleClient: TailscaleClient2, tailnetUrlAllowed } = await import("./tailscale-WLJATFMB.mjs");
+  for (let candidate of urls) {
+    if (candidate.url === used || candidate.kind !== "tailscale-https" && candidate.kind !== "tailnet" || (view ??= await (io.tailnetView ?? (() => new TailscaleClient2().tailnetView()))().catch(() => NO_TAILNET), !tailnetUrlAllowed(candidate.url, view))) continue;
+    let there = await verifyHello(candidate.url, token, { fetch: io.fetch });
+    if (there.kind !== "verified" || there.hello.fingerprint !== fingerprint) continue;
+    let hello = there.hello, answer = yes ? "y" : await io.prompt(`"${hello.name}" is also reachable at ${candidate.url}, encrypted by Tailscale. Save that address instead of ${used}? [Y/n] `);
+    return answer !== null && /^\s*(y|yes)?\s*$/i.test(answer) ? candidate.url : used;
+  }
+  return used;
+}
+function hostDeviceName(raw) {
+  let unsafe = new RegExp(UNSAFE_DISPLAY_CHARS.source, "gu"), name = [...raw.replace(unsafe, "").replace(/\s+/g, " ").trim()].slice(0, 64).join("").trim();
+  return cleanDisplayName(name, 64) ?? "ADF computer";
+}
+function terminalSafe(io) {
+  let prompt = io.prompt;
+  return {
+    ...io,
+    stdout: (text) => io.stdout(printable(text)),
+    stderr: (text) => io.stderr(printable(text)),
+    ...prompt ? { prompt: (question) => prompt(printable(question)) } : {}
+  };
+}
+async function runPair(args, rawIo) {
+  let io = terminalSafe(rawIo), env = io.env ?? process.env, sleep = io.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))), parsed;
+  try {
+    parsed = parsePairArgs(args);
+  } catch (err) {
+    return io.stderr(`${err instanceof Error ? err.message : String(err)}
+`), 2;
+  }
+  if (typeof parsed == "string")
+    return io.stdout(`${parsed}
+`), parsed === PAIR_USAGE ? 0 : 2;
+  let deviceName = parsed.name !== void 0 ? cleanDisplayName(parsed.name, 64) : hostDeviceName(hostname2());
+  if (!deviceName)
+    return io.stderr(`--name must be 1-64 characters without control or bidi characters.
+`), 2;
+  let remotes = readRemotes(env);
+  if (remotes.unreadable)
+    return io.stderr(`${new RemotesUnreadableError(remotesFilePath(env), remotes.unreadable).message}
+`), 1;
+  if (parsed.as !== void 0 && remotes.malformed.includes(parsed.as))
+    return io.stderr(`${malformedRemoteSentence(remotesFilePath(env), parsed.as)}; or pair under another name (--as <name>).
+`), 1;
+  let url, hello;
+  if (parsed.host) {
+    url = hostToUrl(parsed.host);
+    let h = await fetchHello(url, io.fetch);
+    if (!h)
+      return io.stderr(`${url} does not answer as an ADF daemon with remote access on. On that computer turn on remote access (Settings \u2192 Connections \u2192 Add \u2192 Share, or adf daemon remote on); an older ADF version cannot pair.
+`), 1;
+    hello = h;
+  } else {
+    let chosen = await chooseDaemon(io);
+    if (!chosen) return 1;
+    url = chosen.url, hello = chosen.hello;
+  }
+  if (hello.helloProof !== 1)
+    return io.stderr(`${olderAdfSentence(`"${hello.name}"`)}
+`), 1;
+  if (io.stderr(`Pairing with "${hello.name}" (fingerprint ${hello.fingerprint}) at ${url}. Check that it shows the same fingerprint.
+`), transportOf(url) === "plain" && (io.stderr(`This address uses plain http on this network: the token is sent unencrypted, and anyone who can see the traffic can take it. On a tailnet, pair with the tailnet address instead.
+`), !parsed.yes)) {
+    let ok = await io.prompt("I trust this network. Continue? [y/N] ");
+    if (!ok || !/^\s*y(es)?\s*$/i.test(ok))
+      return io.stderr(`Not paired.
+`), 1;
+  }
+  hello.pairingOpen || io.stderr(`No pairing window is open on "${hello.name}" yet. Open one there (Pair a computer, or adf daemon pair).
+`);
+  let accepted = null;
+  for (; !accepted; ) {
+    let answer = await io.prompt(`Code shown on "${hello.name}": `);
+    if (answer === null) return 1;
+    let code = answer.replace(/\s+/g, "");
+    if (!/^\d{6}$/.test(code)) {
+      io.stderr(`The code is 6 digits.
+`);
+      continue;
+    }
+    let res = await postJson(io, `${url}/pair/claim`, { code, deviceName, clientKind: "cli" });
+    if (res.status === 202) {
+      accepted = res.body;
+      break;
+    }
+    let message = res.body.error ?? `HTTP ${res.status}`;
+    if (res.body.code === "wrong_code" && (res.body.attemptsLeft ?? 0) > 0) {
+      io.stderr(`${message} ${res.body.attemptsLeft} attempt(s) left.
+`), await sleep(2100);
+      continue;
+    }
+    if (res.body.code === "rate_limited" && res.retryAfter) {
+      io.stderr(`${message} Waiting ${res.retryAfter} s.
+`), await sleep(res.retryAfter * 1e3);
+      continue;
+    }
+    return io.stderr(`${message}
+`), 1;
+  }
+  io.stderr(`Waiting for "${hello.name}" to allow this computer\u2026
+`);
+  let result = null;
+  for (; !result || result.state === "pending"; ) {
+    let res = await getJson(io, `${url}/pair/claims/${encodeURIComponent(accepted.claimId)}?wait=25`, { "X-ADF-Pair-Secret": accepted.collectSecret });
+    if (res.status !== 200)
+      return io.stderr(`${res.body.error ?? `HTTP ${res.status}`}
+`), 1;
+    result = res.body;
+  }
+  if (result.state === "denied")
+    return io.stderr(`"${hello.name}" did not allow this computer.
+`), 1;
+  let revokeHint = `"${result.daemon.name}" lists this computer as "${result.device.label}": remove it there (adf daemon devices revoke ${result.device.id}).`;
+  if (result.daemon.fingerprint !== hello.fingerprint)
+    return io.stderr(`Refused: the approval came from a computer with fingerprint ${result.daemon.fingerprint}, not ${hello.fingerprint} as "${hello.name}" showed. Nothing was saved. ${revokeHint}
+`), 1;
+  let read = readRemotes(env), file = read.file, sameHost = Object.entries(file.remotes).find(([, r]) => r.fingerprint === result.daemon.fingerprint), name = parsed.as ?? sameHost?.[0] ?? remoteNameFor(result.daemon.name, { ...Object.fromEntries(read.malformed.map((n) => [n, !0])), ...file.remotes }), previous = file.remotes[name];
+  if (previous && previous.fingerprint !== result.daemon.fingerprint)
+    return io.stderr(`Refused: the saved remote "${name}" is ${previous.hostName ?? previous.url} with fingerprint ${previous.fingerprint}, not this computer (${result.daemon.fingerprint}). Nothing was saved. Pair under another name (--as <name>), or forget it first (adf remotes forget ${name}). ${revokeHint}
+`), 1;
+  let saveUrl = await bestUrl(io, url, result.daemon.urls, result.daemon.fingerprint, result.token, parsed.yes), proved = await verifyHelloWaiting(saveUrl, result.token, { fetch: io.fetch, sleep, onWait: (ms) => io.stderr(`"${result.daemon.name}" is rate-limiting connections; retrying in ${Math.ceil(ms / 1e3)} s.
+`) });
+  if (proved.kind !== "verified" || proved.hello.fingerprint !== result.daemon.fingerprint) {
+    let why = proved.kind === "verified" ? `${saveUrl} answers with fingerprint ${proved.hello.fingerprint}, not ${result.daemon.fingerprint}` : proved.kind === "none" ? `${saveUrl} did not answer after "${result.daemon.name}" allowed this computer` : proved.kind === "rate_limited" ? `"${result.daemon.name}" kept rate-limiting connections` : proved.kind === "unsigned" ? `"${result.daemon.name}" runs an older ADF` : `${saveUrl} could not prove it is "${result.daemon.name}"`;
+    return io.stderr(`Refused: ${why}. Nothing was saved. ${revokeHint}
+`), 1;
+  }
+  if (previous) {
+    let changes = [previous.url !== saveUrl ? `its address (${previous.url} \u2192 ${saveUrl})` : null, "its token"].filter(Boolean).join(" and "), answer = parsed.yes ? "y" : await io.prompt(`"${name}" (${previous.hostName ?? previous.url}) is already saved. Replace ${changes}? [y/N] `);
+    if (!answer || !/^\s*y(es)?\s*$/i.test(answer))
+      return io.stderr(`Kept the saved "${name}" as it was. ${revokeHint}
+`), 1;
+  }
+  let previousToken = previous ? readRemoteToken(previous.fingerprint, env) : null, stored;
+  try {
+    stored = await storeRemoteToken(result.daemon.fingerprint, result.token, env, async (why) => {
+      if (parsed.yes) return !0;
+      io.stderr(`${KEYCHAIN_FILE_COPY.title}: ${KEYCHAIN_FILE_COPY.message} (${why})
+`);
+      let answer = await io.prompt(KEYCHAIN_FILE_COPY.prompt);
+      return !!answer && /^\s*y(es)?\s*$/i.test(answer);
+    });
+  } catch (err) {
+    return io.stderr(`The token was not saved: ${err instanceof Error ? err.message : String(err)}
+`), io.stderr(`"${result.daemon.name}" lists this computer as "${result.device.label}": remove it there (adf daemon devices revoke ${result.device.id}) and pair again once this is fixed.
+`), 1;
+  }
+  let entry = {
+    url: saveUrl,
+    fingerprint: result.daemon.fingerprint,
+    deviceId: result.device.id,
+    label: result.device.label,
+    pairedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    hostName: result.daemon.name
+  }, makeDefault = parsed.makeDefault;
+  if (makeDefault === null) {
+    let answer = await io.prompt("Use it by default for adf commands and the terminal app? [Y/n] ");
+    makeDefault = answer !== null && /^\s*(y|yes)?\s*$/i.test(answer);
+  }
+  try {
+    await updateRemotes(env, (latest, malformed) => {
+      let now = latest.remotes[name];
+      if (now && now.fingerprint !== entry.fingerprint) throw new Error(`the saved remote "${name}" changed to another computer (${now.fingerprint}) meanwhile`);
+      if (!now && name in malformed) throw new Error(`"${name}" became a malformed entry meanwhile; fix or forget it first`);
+      latest.remotes[name] = entry, makeDefault && (latest.default = name);
+    });
+  } catch (err) {
+    try {
+      previousToken ? await storeRemoteToken(result.daemon.fingerprint, previousToken, env, async () => !0) : deleteRemoteToken(result.daemon.fingerprint, env);
+    } catch {
+    }
+    return io.stderr(`The remote was not saved: ${err instanceof Error ? err.message : String(err)}
+${revokeHint}
+`), 1;
+  }
+  return io.stdout(`Paired with "${result.daemon.name}" as "${result.device.label}". Saved as remote "${name}" (${saveUrl})${makeDefault ? ", the default" : `; use it with --remote ${name}`}.
+`), io.stderr(stored.where === "keychain" ? `The token is in the OS keychain.
+` : `The token is in ${stored.path}, readable by you only (${stored.why}).
+`), transportOf(saveUrl) === "plain" && io.stderr(`This address is plain http: the token travels unencrypted with every request. Prefer https through tailscale serve or the tailnet address.
+`), 0;
+}
+function localRemoteName(env) {
+  return localRuntimeName(machineNameFromFile(daemonPaths(DEFAULT_DAEMON_PORT, env).settingsFile));
+}
+async function runRemotes(args, rawIo, json = !1) {
+  let io = terminalSafe(rawIo), env = io.env ?? process.env, [action, name] = args, read = readRemotes(env);
+  if (read.unreadable)
+    return io.stderr(`${new RemotesUnreadableError(remotesFilePath(env), read.unreadable).message}
+`), 1;
+  let file = read.file;
+  if (!action || action === "list") {
+    if (json)
+      return io.stdout(`${JSON.stringify(file, null, 2)}
+`), 0;
+    let rows = Object.entries(file.remotes);
+    io.stdout(`${file.default === null && !read.malformedDefault ? "*" : " "} local  ${printable(localRemoteName(env))}
+`);
+    for (let [n, r] of rows) io.stdout(`${file.default === n ? "*" : " "} ${n}  ${r.url}  ${r.hostName ?? ""}  ${r.fingerprint}  as "${r.label}"
+`);
+    for (let n of read.malformed) io.stderr(`${n === read.malformedDefault ? "* " : ""}${malformedRemoteSentence(remotesFilePath(env), n)}
+`);
+    return rows.length === 0 && read.malformed.length === 0 && io.stderr(`No saved remotes. Pair one with: adf pair
+`), 0;
+  }
+  if (action === "use")
+    return name ? name !== "local" && !file.remotes[name] ? (io.stderr(read.malformed.includes(name) ? `${malformedRemoteSentence(remotesFilePath(env), name)}
+` : `No saved remote named "${name}". List them with: adf remotes
+`), 1) : (await updateRemotes(env, (latest) => {
+      latest.default = name === "local" ? null : name;
+    }), io.stdout(name === "local" ? `adf now talks to this computer's daemon by default.
+` : `adf now talks to "${name}" (${file.remotes[name].url}) by default.
+`), 0) : (io.stderr(`${REMOTES_USAGE}
+`), 2);
+  if (action === "forget") {
+    if (!name || !file.remotes[name] && !read.malformed.includes(name))
+      return io.stderr(name ? `No saved remote named "${name}".
+` : `${REMOTES_USAGE}
+`), name ? 1 : 2;
+    let forgot;
+    try {
+      forgot = await forgetRemote(env, name);
+    } catch (err) {
+      return io.stderr(`"${name}" was not forgotten: ${err instanceof Error ? err.message : String(err)}
+`), 1;
+    }
+    if (!forgot)
+      return io.stderr(`No saved remote named "${name}".
+`), 1;
+    let remote = forgot.remote;
+    if (!remote)
+      return io.stdout(`Forgot "${name}".
+`), 0;
+    let what = forgot.sharedWith ? `"${name}"; its token stays for "${forgot.sharedWith}", the same computer` : `"${name}" and its token`;
+    return io.stdout(`Forgot ${what}. "${remote.hostName ?? remote.url}" still lists this computer: remove it there (adf daemon devices revoke ${remote.deviceId}).
+`), forgot.tokenError ? (io.stderr(`The token could not be removed: ${forgot.tokenError}
+`), 1) : 0;
+  }
+  return io.stderr(`${REMOTES_USAGE}
+`), 2;
+}
+
 // src/main/cli/index.ts
 var defaultIo = {
   fetch: globalThis.fetch.bind(globalThis),
@@ -44,15 +531,15 @@ function tuiInvocation(argv) {
   return argv.filter((a) => a !== "--json");
 }
 async function defaultLaunchTui(argv) {
-  let { runTui } = await import("./tui-UQJLK7XI.mjs");
+  let { runTui } = await import("./tui-SPSPDADM.mjs");
   return await runTui(argv);
 }
-function urlFromArgv(argv) {
+function urlFromArgv(argv, env) {
   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));
+    if (argv[i] === "--url" || argv[i] === "-u") return resolveDaemonUrl(argv[i + 1], env);
+    if (argv[i].startsWith("--url=")) return resolveDaemonUrl(argv[i].slice(6), env);
   }
-  return resolveDaemonUrl(void 0);
+  return resolveDaemonUrl(void 0, env);
 }
 async function daemonReady(io, url) {
   if (!io.ensureDaemon) return { ok: !0, started: null };
@@ -65,10 +552,26 @@ ${advice ? `${advice}
 ` : ""}`), { ok: !1, started: null };
   }
 }
+async function pinnedRemoteOk(io, url, explicitToken) {
+  let env = io.env ?? process.env;
+  if (explicitToken || env.ADF_DAEMON_TOKEN) return !0;
+  let refusal = await pinnedRemoteRefusal(url, env, io.fetch, { retries: 2, onWait: (sentence) => io.stderr(`${sentence}
+`), ...io.sleep ? { sleep: io.sleep } : {} });
+  return refusal && io.stderr(`${refusal}
+`), refusal === 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));
+    let wantsHelp = tuiArgv.includes("--help") || tuiArgv.includes("-h"), tuiUrl = "";
+    try {
+      wantsHelp || (tuiUrl = urlFromArgv(tuiArgv, io.env ?? process.env));
+    } catch (err) {
+      return io.stderr(`${err instanceof Error ? err.message : String(err)}
+`), 1;
+    }
+    if (!wantsHelp && !await pinnedRemoteOk(io, tuiUrl, tuiArgv.some((a) => a === "--token" || a.startsWith("--token=")))) return 1;
+    let ready = wantsHelp ? { ok: !0, started: null } : await daemonReady(io, tuiUrl);
     if (!ready.ok) return 1;
     try {
       let code = await (io.launchTui ?? defaultLaunchTui)(tuiArgv);
@@ -88,8 +591,18 @@ async function runCli(argv = process.argv.slice(2), io = defaultIo) {
 ${usage()}
 `), 2;
   }
-  let { command, args, options } = parsed;
-  if (!["help", "--help", "-h"].includes(command) && !(await daemonReady(io, options.daemonUrl)).ok) return 1;
+  let { command, args } = parsed, talksToDaemon = !["help", "--help", "-h", "pair", "remotes"].includes(command), options;
+  try {
+    let env = io.env ?? process.env;
+    options = { ...parsed.options, env, daemonUrl: talksToDaemon ? resolveDaemonUrl(parsed.explicitUrl ?? void 0, env) : "" };
+  } catch (err) {
+    return err instanceof RemotesUnreadableError || err instanceof RemoteMalformedError ? (io.stderr(`${err.message}
+`), 1) : (io.stderr(`${err instanceof Error ? err.message : String(err)}
+
+${usage()}
+`), 2);
+  }
+  if (talksToDaemon && !await pinnedRemoteOk(io, options.daemonUrl, !!options.token) || talksToDaemon && !(await daemonReady(io, options.daemonUrl)).ok) return 1;
   try {
     switch (command) {
       case "help":
@@ -170,6 +683,16 @@ ${usage()}
         return await printGet(io, options, "/templates", formatTemplates);
       case "new":
         return await newAgent(io, options, args);
+      case "pair": {
+        let prompt = io.prompt ? null : stdinPrompt();
+        try {
+          return await runPair(args, { fetch: io.fetch, stdout: io.stdout, stderr: io.stderr, prompt: io.prompt ? ((q) => io.prompt(q)) : ((q) => prompt.ask(q)), ...io.discover ? { discover: io.discover } : {}, ...io.sleep ? { sleep: io.sleep } : {}, ...io.env ? { env: io.env } : {} });
+        } finally {
+          prompt?.close();
+        }
+      }
+      case "remotes":
+        return await runRemotes(args, { stdout: io.stdout, stderr: io.stderr, ...io.env ? { env: io.env } : {} }, options.json);
       default:
         return io.stderr(`Unknown command: ${command}
 
@@ -182,7 +705,7 @@ ${usage()}
   }
 }
 function parseArgs(argv) {
-  let args = [...argv], daemonUrl = process.env.ADF_DAEMON_URL ?? DEFAULT_DAEMON_URL, json = !1, token, positional = [];
+  let args = [...argv], daemonUrl = null, json = !1, token, positional = [];
   for (let i = 0; i < args.length; i++) {
     let arg = args[i];
     if (arg === "--json")
@@ -203,10 +726,10 @@ function parseArgs(argv) {
     command: positional[0] ?? "help",
     args: positional.slice(1),
     options: {
-      daemonUrl: daemonUrl.replace(/\/+$/, ""),
       json,
       ...token ? { token } : {}
-    }
+    },
+    explicitUrl: daemonUrl
   };
 }
 async function printGet(io, options, path, formatter) {
@@ -215,7 +738,7 @@ async function printGet(io, options, path, formatter) {
 ` : formatter(data)), 0;
 }
 function authHeader(options) {
-  let token = resolveDaemonToken(options.token, process.env, options.daemonUrl);
+  let token = resolveDaemonToken(options.token, options.env, options.daemonUrl);
   return token ? { Authorization: `Bearer ${token}` } : {};
 }
 async function requestJson(io, options, path, init) {
@@ -227,12 +750,12 @@ async function requestJson(io, options, path, init) {
         ...init?.headers ?? {},
         Accept: "application/json",
         ...authHeader(options),
-        ...localProofHeaders(options.daemonUrl, path)
+        ...localProofHeaders(options.daemonUrl, path, options.env)
       }
     });
   } catch (err) {
     if (err instanceof TypeError) {
-      let forwarded = loopbackPort(options.daemonUrl) !== null && !isLocalDaemonUrl(options.daemonUrl);
+      let forwarded = loopbackPort(options.daemonUrl) !== null && !isLocalDaemonUrl(options.daemonUrl, options.env);
       throw new Error(`Cannot reach the ADF daemon at ${options.daemonUrl} (${err.message}). ${forwarded ? "That is not this machine's daemon port, so adf did not start one there: check the SSH tunnel, or start a daemon on it with: adf daemon start --port <n>" : "Start it with: adf daemon start"}`);
     }
     throw err;
@@ -245,12 +768,22 @@ async function requestJson(io, options, path, init) {
       body = text;
     }
   if (!response.ok) {
-    let message = isRecord(body) && typeof body.error == "string" ? body.error : `HTTP ${response.status} ${response.statusText}`, hint = response.status === 401 ? tunnelTokenHint(options.daemonUrl, options.token) : null;
-    throw new Error(hint ? `${message}
-${hint}` : message);
+    let message = isRecord(body) && typeof body.error == "string" ? body.error : `HTTP ${response.status} ${response.statusText}`, hint = response.status === 401 ? tunnelTokenHint(options.daemonUrl, options.token, options.env) : null;
+    throw new DaemonRequestError(hint ? `${message}
+${hint}` : message, response.status, isRecord(body) && typeof body.code == "string" ? body.code : null);
   }
   return body;
 }
+var DaemonRequestError = class extends Error {
+  constructor(message, status, apiCode) {
+    super(message);
+    this.status = status;
+    this.apiCode = apiCode;
+    this.name = "DaemonRequestError";
+  }
+  status;
+  apiCode;
+};
 function takeLoop(args) {
   let rest = [], loop;
   for (let i = 0; i < args.length; i++) {
@@ -261,13 +794,43 @@ function takeLoop(args) {
   }
   return { loop: loop && loop !== "main" ? loop : void 0, rest };
 }
+function takeAttachments(args) {
+  let rest = [], files = [];
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i];
+    if (arg === "--attach") {
+      let file = args[++i];
+      if (!file) throw new Error("--attach requires a file path");
+      files.push(file);
+    } else arg.startsWith("--attach=") ? files.push(arg.slice(9)) : rest.push(arg);
+  }
+  return { files, rest };
+}
+function uploadName(file) {
+  return `loop-upload/${basename(file).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+/, "") || "attachment"}`;
+}
 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`, {
+  let attached = takeAttachments(args), { loop, rest } = takeLoop(attached.rest), agent = rest[0], text = rest.slice(1).join(" ");
+  if (!agent || !text && attached.files.length === 0) throw new Error("Usage: adf chat <agent> [--loop <name>] [--attach <file>]... <message>");
+  let refs = [];
+  for (let file of attached.files) {
+    let bytes;
+    try {
+      bytes = readFileSync2(file);
+    } catch (err) {
+      throw new Error(`Cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let saved = await requestJson(io, options, `/agents/${enc(agent)}/files/raw?path=${enc(uploadName(file))}&unique=true`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: new Uint8Array(bytes)
+    }), path = isRecord(saved) && typeof saved.path == "string" ? saved.path : uploadName(file);
+    refs.push({ type: "file_ref", file_ref: { path, mime_type: "", size: bytes.length } });
+  }
+  let body = refs.length > 0 ? { content: [...text ? [{ type: "text", text }] : [], ...refs] } : { text }, data = await requestJson(io, options, `/agents/${enc(agent)}/chat`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ text, ...loop ? { loop } : {} })
+    body: JSON.stringify({ ...body, ...loop ? { loop } : {} })
   });
   return io.stdout(options.json ? `${JSON.stringify(data, null, 2)}
 ` : formatChatAck(data)), 0;
@@ -337,21 +900,23 @@ function authDeps(io, options) {
 }
 function requireAuthProvider(value) {
   let provider = normalizeAuthProvider(value);
-  if (!provider) throw new Error("Specify a provider: chatgpt or grok");
+  if (!provider) throw new Error("Specify a provider: chatgpt, grok or claude");
   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 === "login") {
+    let provider = requireAuthProvider(positional[1]);
+    return provider === "claude" ? await loginClaudeCli(io, options) : provider === "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>]");
+  throw new Error("Usage: adf auth [status | login <chatgpt|grok|claude> | logout <chatgpt|grok|claude>]");
 }
 function reportAuth(io, provider, outcome) {
   return outcome.ok ? (io.stdout(`Signed in to ${AUTH_PROVIDER_LABELS[provider]}${outcome.email ? ` as ${outcome.email}` : ""}.
@@ -405,6 +970,63 @@ Waiting for approval...
   });
   return options.json ? 0 : reportAuth(io, "grok", outcome);
 }
+async function loginClaudeCli(io, options) {
+  let stop = new AbortController(), deps = { ...authDeps(io, options), signal: stop.signal }, stopLines = () => {
+  }, stopInterrupt = (io.onInterrupt ?? defaultOnInterrupt)(() => stop.abort());
+  try {
+    let outcome = await loginClaude(deps, {
+      // --json hands out the start answer and stops waiting; the daemon's
+      // sign-in keeps running (only Ctrl-C cancels it), like ChatGPT/Grok.
+      wait: !options.json,
+      onStart: (info) => {
+        if (options.json) {
+          io.stdout(`${JSON.stringify(info.raw, null, 2)}
+`);
+          return;
+        }
+        io.stdout(`Opening Claude sign-in in your browser\u2026
+${info.url ? `If it does not open, visit:
+
+  ${info.url}
+
+` : `
+`}If the page shows a code, paste it here (or wait): `), stopLines = (io.readLines ?? defaultReadLines)((line) => {
+          let code = line.trim();
+          code && submitClaudeCode(deps, code).then(() => io.stdout(`Code sent. Waiting for Claude Code to finish...
+`)).catch((err) => io.stderr(`Could not send the code: ${err instanceof Error ? err.message : String(err)}
+`));
+        });
+      }
+    });
+    if (!outcome.ok && outcome.notInstalled)
+      return io.stderr(`${outcome.error}
+`), 1;
+    if (options.json) return outcome.ok || outcome.detached ? 0 : outcome.cancelled ? 130 : reportAuth(io, "claude", outcome);
+    if (io.stdout(`
+`), outcome.ok) {
+      let plan = isRecord(outcome.raw) && typeof outcome.raw.plan == "string" ? outcome.raw.plan : "";
+      return io.stdout(`Signed in to Claude${outcome.email ? ` as ${outcome.email}` : ""}${plan ? ` (${plan} plan)` : ""}.
+`), 0;
+    }
+    return outcome.cancelled ? (io.stderr(`Claude sign-in cancelled.
+`), 130) : reportAuth(io, "claude", outcome);
+  } finally {
+    stopLines(), stopInterrupt();
+  }
+}
+function defaultReadLines(onLine) {
+  if (!process.stdin.isTTY) return () => {
+  };
+  let rl = createInterface({ input: process.stdin, terminal: !1, historySize: 0 });
+  return rl.on("line", onLine), () => {
+    rl.close(), process.stdin.pause();
+  };
+}
+function defaultOnInterrupt(fn) {
+  return process.once("SIGINT", fn), () => {
+    process.removeListener("SIGINT", fn);
+  };
+}
 async function networkAdmin(io, options, args) {
   let area = args[0], action = args[1];
   if (area === "mesh") {
@@ -432,7 +1054,7 @@ async function streamEvents(io, options, args) {
     headers: { Accept: "text/event-stream", ...authHeader(options) }
   });
   if (!response.ok || !response.body) {
-    let detail = await response.json().catch(() => null), hint = response.status === 401 ? tunnelTokenHint(options.daemonUrl, options.token) : null;
+    let detail = await response.json().catch(() => null), hint = response.status === 401 ? tunnelTokenHint(options.daemonUrl, options.token, options.env) : null;
     throw new Error(`Event stream failed: ${typeof detail?.error == "string" ? detail.error : `HTTP ${response.status} ${response.statusText}`}${hint ? `
 ${hint}` : ""}`);
   }
@@ -485,7 +1107,7 @@ async function withAgentAndValue(args, label, io, run) {
 }
 var pipedLines = null, pipedLineIndex = 0;
 async function defaultPrompt(question, opts = {}) {
-  let { createInterface } = await import("readline");
+  let { createInterface: createInterface2 } = await import("readline");
   if (!process.stdin.isTTY) {
     if (pipedLines === null) {
       let chunks = [];
@@ -494,7 +1116,7 @@ async function defaultPrompt(question, opts = {}) {
     }
     return pipedLines[pipedLineIndex++] ?? "";
   }
-  let rl = createInterface({ input: process.stdin, output: process.stdout, terminal: !0, historySize: 0 }), internals = rl, muted = !1;
+  let rl = createInterface2({ 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) => {
@@ -513,7 +1135,7 @@ async function defaultPrompt(question, opts = {}) {
 function ask(io, question, hidden = !1) {
   return (io.prompt ?? defaultPrompt)(question, { hidden });
 }
-function postJson(io, options, path, body = {}) {
+function postJson2(io, options, path, body = {}) {
   return requestJson(io, options, path, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -537,7 +1159,7 @@ async function identityCommand(io, options, args) {
     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 } : {});
+    let passphrase = await passphraseIfNeeded(io, current, !0), created = await postJson2(io, options, "/identity/create", passphrase ? { passphrase } : {});
     if (options.json)
       return io.stdout(`${JSON.stringify(created, null, 2)}
 `), 0;
@@ -557,12 +1179,13 @@ 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.
+    return answer === "yes" || answer === "y" ? (await postJson2(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") {
+  if (action === "import") return await importIdentity(io, options, args.slice(1));
+  if (action === "restore") {
     let current = await requestJson(io, options, "/identity");
     if (isRecord(current) && current.status === "ready")
       return io.stdout(formatIdentity(current)), 0;
@@ -570,22 +1193,97 @@ you can reveal it in ADF Studio on this machine (Settings \u2192 Back Up Seed Ph
 `);
     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;
+    let passphrase = await passphraseIfNeeded(io, current, isRecord(current) && current.status !== "locked"), restored = await postJson2(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;
+    let passphrase = await ask(io, "Passphrase: ", !0), unlocked = await postJson2(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;
+    let locked = await postJson2(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]");
+  if (action === "trust-daemon") return await trustDaemon(io, options, args.slice(1));
+  if (action === "untrust-daemon") {
+    let answer = await postJson2(io, options, "/identity/untrust-daemon");
+    if (options.json)
+      return io.stdout(`${JSON.stringify(answer, null, 2)}
+`), 0;
+    let result = isRecord(answer) ? answer : {}, trust = isRecord(result.trust) ? result.trust : {};
+    return io.stdout(
+      `Revoked key ${String(result.retiredLabel ?? "")}: the daemon now uses a new key, and the old one no longer opens anything here.
+Slots removed from ${String(result.agentsUpdated ?? 0)} loaded agent(s); the tracked folders are swept in the background, and
+ADF Studio removes the slot from each agent it opens. A copy of an agent outside the tracked folders keeps the old slot
+until it is opened, and anyone holding a copy of the old key file can open that slot until then.
+${String(trust.message ?? "")}
+`
+    ), 0;
+  }
+  throw new Error("Usage: adf identity [status | new | restore | import | unlock | lock | trust-daemon | untrust-daemon]");
+}
+async function trustDaemon(io, options, args) {
+  for (let arg of args)
+    if (arg !== "--yes") throw new Error(`Unknown option for adf identity trust-daemon: ${arg}`);
+  let current = await requestJson(io, options, "/identity"), trust = isRecord(current) && isRecord(current.trust) ? current.trust : null;
+  if (trust?.state === "trusted")
+    return io.stdout(`${String(trust.message ?? "")}
+`), 0;
+  if (!args.includes("--yes") && (io.stdout(
+    `Trusting this daemon adds its key (the runtime-enc-key file next to the daemon settings) to
+trustedDaemonEncKeys. ADF Studio then wraps every agent's credentials to that key, so anyone who
+can read that file, or write the settings file, can unlock them without the owner passphrase.
+The grant is an entry in the settings file, not a signed statement.
+Revoke it with adf identity untrust-daemon.
+`
+  ), (await ask(io, 'Type "trust" to go ahead: ')).trim().toLowerCase() !== "trust"))
+    return io.stdout(`Nothing was changed.
+`), 1;
+  let answer = await postJson2(io, options, "/identity/trust-daemon", { confirm: !0 });
+  if (options.json)
+    return io.stdout(`${JSON.stringify(answer, null, 2)}
+`), 0;
+  let result = isRecord(answer) ? answer : {}, granted = isRecord(result.trust) ? result.trust : {};
+  return io.stdout(`${String(granted.message ?? "")}
+Slots added to ${String(result.agentsUpdated ?? 0)} loaded agent(s).
+`), 0;
+}
+async function importIdentity(io, options, args = []) {
+  for (let arg of args)
+    if (arg !== "--i-have-a-backup") throw new Error(`Unknown option for adf identity import: ${arg}`);
+  let haveBackup = args.includes("--i-have-a-backup"), current = await requestJson(io, options, "/identity");
+  isRecord(current) && typeof current.ownerDid == "string" && current.ownerDid && io.stdout(`This machine's owner is ${current.ownerDid}. A phrase of another owner replaces it.
+`);
+  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"), body = { mnemonic, ...passphrase ? { passphrase } : {}, ...haveBackup ? { previousOwnerBackupConfirmed: !0 } : {} }, imported;
+  try {
+    imported = await postJson2(io, options, "/identity/import", body);
+  } catch (err) {
+    if (!(err instanceof DaemonRequestError) || err.apiCode !== "switch_unconfirmed") throw err;
+    if (io.stdout(`${err.message}
+`), (await ask(io, 'Type "switch" to replace the owner: ')).trim().toLowerCase() !== "switch")
+      return io.stdout(`Nothing was changed.
+`), 1;
+    imported = await postJson2(io, options, "/identity/import", { ...body, switchOwner: !0 });
+  }
+  if (options.json)
+    return io.stdout(`${JSON.stringify(imported, null, 2)}
+`), 0;
+  let result = isRecord(imported) ? imported : {}, identity = isRecord(result.identity) ? result.identity : {}, restamp = isRecord(result.restamp) ? result.restamp : {}, failures = Array.isArray(restamp.failures) ? restamp.failures.map(String) : [], skipped = Array.isArray(restamp.skipped) ? restamp.skipped.map(String) : [], reloadFailures = Array.isArray(result.reloadFailures) ? result.reloadFailures.filter(isRecord) : [];
+  return io.stdout(
+    `${result.switched === !0 ? `Owner switched from ${String(result.previousOwnerDid ?? "")}.` : "Owner identity imported."}
+` + formatIdentity(identity) + `Restamped ${String(restamp.restamped ?? 0)} agent file(s), ${failures.length} failure(s).
+` + failures.map((f) => `  ${f}
+`).join("") + (skipped.length ? `Not restamped now, another runtime runs them (restamped when next opened):
+${skipped.map((f) => `  ${f}
+`).join("")}` : "") + reloadFailures.map((f) => `Could not reload ${String(f.name ?? "")} (${String(f.filePath ?? "")}): ${String(f.error ?? "")}
+`).join("")
+  ), failures.length > 0 || reloadFailures.length > 0 ? 1 : 0;
 }
 async function newAgent(io, options, args) {
   let body = {}, valueFlags = {
@@ -613,7 +1311,7 @@ async function newAgent(io, options, args) {
     positional.push(arg);
   }
   positional.length > 0 && (body.name = positional.join(" "));
-  let created = await postJson(io, options, "/agents/create", body);
+  let created = await postJson2(io, options, "/agents/create", body);
   if (options.json)
     return io.stdout(`${JSON.stringify(created, null, 2)}
 `), 0;
@@ -637,10 +1335,14 @@ function formatIdentity(value) {
     ["status", String(value.status ?? "")],
     ["ownerDid", String(value.ownerDid ?? "")],
     ["runtimeDid", String(value.runtimeDid ?? "")],
+    ...isRecord(value.runtime) ? [["runtime", `${String(value.runtime.source ?? "")} (${String(value.runtime.state ?? "")})`]] : [],
+    ...isRecord(value.trust) && value.trust.state !== "not-applicable" ? [["daemonKey", String(value.trust.state ?? "")]] : [],
     ["storage", String(value.storage ?? "")],
     ["backupConfirmed", String(value.backupConfirmed ?? !1)]
   ])}${typeof value.message == "string" ? `${value.message}
-` : ""}` : formatJsonPretty(value);
+` : ""}` + // Only the actionable case: a Studio runtime entry exists but was not used.
+  (isRecord(value.runtime) && value.runtime.state === "rejected" && typeof value.runtime.message == "string" ? `${value.runtime.message}
+` : "") : formatJsonPretty(value);
 }
 function formatTemplates(value) {
   let templates = isRecord(value) && Array.isArray(value.templates) ? value.templates.filter(isRecord) : [];
@@ -709,7 +1411,7 @@ ${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:
+  let chatgpt = isRecord(value.chatgpt) ? value.chatgpt : {}, grok = isRecord(value.grok) ? value.grok : {}, claude = isRecord(value.claude) ? value.claude : {}, providers = Array.isArray(value.providers) ? value.providers.filter(isRecord) : [], chatgptTable = `ChatGPT:
 ${table(["field", "value"], [
     ["authenticated", String(chatgpt.authenticated ?? !1)],
     ["email", String(chatgpt.email ?? "")]
@@ -717,7 +1419,14 @@ ${table(["field", "value"], [
 ${table(["field", "value"], [
     ["authenticated", String(grok.authenticated ?? !1)],
     ["email", String(grok.email ?? "")]
-  ])}`, providersTable = providers.length === 0 ? `Provider credentials: none
+  ])}`, claudeRows = claude.installed === !1 ? [["authenticated", "false"], ["claude code", `not installed (${String(claude.installUrl ?? "")})`]] : [
+    ["authenticated", String(claude.authenticated ?? !1)],
+    ["email", String(claude.email ?? "")],
+    ["plan", String(claude.plan ?? "")],
+    ["claude code", claude.updateRequired ? `${String(claude.version ?? "")} (update required: ADF needs ${String(claude.minVersion ?? "")} or newer)` : String(claude.version ?? "")],
+    ...typeof claude.flowError == "string" && claude.flowError ? [["error", claude.flowError]] : []
+  ], claudeTable = `Claude:
+${table(["field", "value"], claudeRows)}`, providersTable = providers.length === 0 ? `Provider credentials: none
 ` : `Provider credentials:
 ${table(["id", "type", "storage", "apiKey"], providers.map((provider) => [
     String(provider.id ?? ""),
@@ -727,6 +1436,7 @@ ${table(["id", "type", "storage", "apiKey"], providers.map((provider) => [
   ]))}`;
   return `${chatgptTable}
 ${grokTable}
+${claudeTable}
 ${providersTable}`;
 }
 function formatNetwork(value) {
@@ -972,11 +1682,16 @@ Commands:
   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
+  auth login <chatgpt|grok|claude>
+                                  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
+                                  relay when --url points at a remote daemon.
+                                  claude signs in through Claude Code on the
+                                  daemon host (ADF stores no Claude credentials)
+  auth logout <chatgpt|grok|claude>
+                                  Clear a subscription provider's tokens
+                                  (claude: signs Claude Code out on that host)
   settings                       Show sanitized daemon runtime settings
   network                        Show mesh and WebSocket diagnostics
   network mesh [enable|disable]  Control daemon mesh registration
@@ -1001,21 +1716,40 @@ Commands:
   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>
+  chat <agent> [--loop <name>] [--attach <file>]... <message>
                                   Send chat (to main, or an inner loop) and
-                                  print the accepted turn id
+                                  print the accepted turn id. --attach uploads
+                                  a file to the agent's loop-upload/ folder
+                                  and attaches it
   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
+  identity import [--i-have-a-backup]
+                                  Import an owner phrase like Studio's Import
+                                  identity: another owner's phrase replaces
+                                  this machine's owner (asks first; needs the
+                                  old phrase backed up) and restamps local
+                                  agents
+  identity unlock|lock          Unlock/lock a passphrase-protected identity
                                   (machines without an OS keychain)
+  identity trust-daemon [--yes]  No OS keychain: let ADF Studio wrap agent
+                                  credentials to this daemon's key file, so
+                                  they unlock without the passphrase (asks)
+  identity untrust-daemon        Revoke that trust
   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)
+  pair [<host>[:<port>]]
+      [--name <n>] [--yes]       Pair with another computer's daemon (its
+                                  6-digit code); without a host, lists the
+                                  ADF computers found on this network and
+                                  your tailnet. Saves the device token
+  remotes [use <name|local> | forget <name>]
+                                  Saved remote daemons; use picks the default
 
 Daemon:
   daemon [--port <n>] [--host <h>] [--settings <file>]
@@ -1032,12 +1766,18 @@ Daemon:
                                   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)
+  daemon token                   Print this machine's daemon access token
+                                  (this machine only; other computers get a
+                                  device token: daemon devices add / pair)
+  daemon remote on|off|status    Remote access (live, no restart); also
+                                  trust|untrust, serve on|off
+  daemon devices [list|add <label>|revoke <id|label>]
+                                  Computers with a device token
+  daemon pair                    Open a pairing window and show its code
 
 Options:
   --url, -u <url>                Daemon URL
+  --remote <name>                A daemon saved by adf pair (adf remotes)
   --token <token>                Daemon access token (default: ADF_DAEMON_TOKEN,
                                   else the local daemon's token file)
   --json                         JSON output
@@ -1048,7 +1788,8 @@ 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`;
+  ADF_NO_AUTOSTART=1             Same as --no-daemon
+  ADF_REMOTE                     Same as --remote (local = this computer)`;
 }
 export {
   runCli,