@agentdocumentformat/cli 0.7.8 → 0.8.1

package/dist/chunks/chunk-AEAJDCVK.mjs

@@ -0,0 +1,517 @@
+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 {
+  isLocalOnlyRoute,
+  openKeychainBackend,
+  readLocalProof,
+  testSeamsAllowed
+} from "./chunk-BS3USVEA.mjs";
+import {
+  daemonSettingsDir,
+  readDaemonToken
+} from "./chunk-WJGPNHGX.mjs";
+import {
+  writeSecretFileAtomic
+} from "./chunk-ZPB3HYM7.mjs";
+import {
+  __export
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/cli/remotes.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { link, open, readFile, rename, stat, unlink } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+
+// src/main/backend/daemon-secrets.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var TEST_KEYCHAIN_FILE_ENV = "ADF_TEST_KEYCHAIN_FILE", JsonFileKeychain = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  kind = "keychain";
+  read() {
+    if (!existsSync(this.filePath)) return {};
+    let parsed = JSON.parse(readFileSync(this.filePath, "utf-8"));
+    return parsed && typeof parsed == "object" && !Array.isArray(parsed) ? parsed : {};
+  }
+  write(values) {
+    mkdirSync(dirname(this.filePath), { recursive: !0 });
+    let tmp = `${this.filePath}.studio.tmp`;
+    writeFileSync(tmp, JSON.stringify(values, null, 2) + `
+`, { mode: 384 }), renameSync(tmp, this.filePath);
+  }
+  isUnlocked() {
+    return !0;
+  }
+  get(account2) {
+    return this.read()[account2] ?? null;
+  }
+  set(account2, value) {
+    this.write({ ...this.read(), [account2]: value });
+  }
+  delete(account2) {
+    let values = this.read();
+    account2 in values && (delete values[account2], this.write(values));
+  }
+};
+function openDaemonSecrets(env = process.env, opts = {}) {
+  if (env.ADF_SECRET_STORE === "file")
+    return { backend: null, unavailable: "the daemon keeps its secrets in its passphrase file (ADF_SECRET_STORE=file), which Studio cannot write" };
+  if (env.ADF_KEYCHAIN === "0" || env.ADF_KEYCHAIN === "off")
+    return { backend: null, unavailable: "the OS keychain is turned off (ADF_KEYCHAIN=0)" };
+  let fake = env[TEST_KEYCHAIN_FILE_ENV];
+  if (fake)
+    return !opts.packaged && testSeamsAllowed({ env }) ? { backend: new JsonFileKeychain(fake) } : { backend: null, unavailable: `${TEST_KEYCHAIN_FILE_ENV} is set without the test seams` };
+  let keychain = openKeychainBackend();
+  return keychain ? { backend: keychain } : { backend: null, unavailable: "no OS keychain is usable on this machine" };
+}
+
+// src/main/cli/remotes.ts
+var REMOTES_FILENAME = "cli-remotes.json", REMOTE_TOKENS_FILENAME = "cli-remote-tokens.json", REMOTE_ENV = "ADF_REMOTE";
+function remotesPath(env) {
+  return join(daemonSettingsDir(env), REMOTES_FILENAME);
+}
+function tokensPath(env) {
+  return join(daemonSettingsDir(env), REMOTE_TOKENS_FILENAME);
+}
+function isRecord(value) {
+  return !!value && typeof value == "object" && !Array.isArray(value);
+}
+var RemotesUnreadableError = class extends Error {
+  constructor(path, why) {
+    super(`${why}. Fix or remove it; nothing was changed.`);
+    this.path = path;
+    this.why = why;
+    this.name = "RemotesUnreadableError";
+  }
+  path;
+  why;
+};
+function emptyRemotes() {
+  return { v: 1, default: null, remotes: {} };
+}
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var rawOfRead = /* @__PURE__ */ new WeakMap();
+function readOf(path, text, readError) {
+  let none = (unreadable) => ({ file: emptyRemotes(), names: /* @__PURE__ */ new Set(), unreadable, malformed: [], malformedDefault: null });
+  if (text === null)
+    return readError?.code === "ENOENT" ? none(null) : none(`${path} cannot be read (${errorText(readError)})`);
+  let raw;
+  try {
+    raw = JSON.parse(stripBom(text));
+  } catch (err) {
+    return none(`${path} is not valid JSON (${errorText(err)})`);
+  }
+  if (!isRecord(raw) || raw.v !== 1 || !isRecord(raw.remotes)) return none(`${path} is not a saved-connections file (v 1)`);
+  let file = parseRemotes(text), order = Object.keys(raw.remotes), malformed = Object.fromEntries(Object.entries(raw.remotes).filter(([name]) => !file.remotes[name])), malformedDefault = typeof raw.default == "string" && raw.default in malformed ? raw.default : null, read = { file, names: new Set(order), unreadable: null, malformed: Object.keys(malformed), malformedDefault };
+  return rawOfRead.set(read, { malformed, order, default: raw.default ?? null }), read;
+}
+function rawOf(file, raw, malformed, parsedDefault) {
+  let remotes = {};
+  for (let name of raw.order)
+    file.remotes[name] ? remotes[name] = file.remotes[name] : name in malformed && (remotes[name] = malformed[name]);
+  for (let [name, remote] of Object.entries(file.remotes)) name in remotes || (remotes[name] = remote);
+  let keepRawDefault = file.default === parsedDefault && typeof raw.default == "string" && raw.default in malformed && raw.default in remotes;
+  return { ...file, default: keepRawDefault ? raw.default : file.default, remotes };
+}
+function readRemotes(env = process.env) {
+  let path = remotesPath(env);
+  try {
+    return readOf(path, readFileSync2(path, "utf-8"));
+  } catch (err) {
+    return readOf(path, null, err);
+  }
+}
+async function readRemotesAsync(env = process.env) {
+  let path = remotesPath(env), text;
+  try {
+    text = await readFile(path, "utf-8");
+  } catch (err) {
+    return readOf(path, null, err);
+  }
+  return readOf(path, text);
+}
+function loadRemotes(env = process.env) {
+  return readRemotes(env).file;
+}
+function parseRemotes(text) {
+  let empty = emptyRemotes();
+  try {
+    let raw = JSON.parse(stripBom(text));
+    if (!isRecord(raw) || raw.v !== 1 || !isRecord(raw.remotes)) return empty;
+    let remotes = {};
+    for (let [name, r] of Object.entries(raw.remotes))
+      isRecord(r) && typeof r.url == "string" && typeof r.fingerprint == "string" && typeof r.deviceId == "string" && (remotes[name] = {
+        url: r.url,
+        fingerprint: r.fingerprint,
+        deviceId: r.deviceId,
+        label: typeof r.label == "string" ? r.label : "",
+        pairedAt: typeof r.pairedAt == "string" ? r.pairedAt : "",
+        ...typeof r.hostName == "string" ? { hostName: r.hostName } : {}
+      });
+    return { v: 1, default: typeof raw.default == "string" && remotes[raw.default] ? raw.default : null, remotes };
+  } catch {
+    return empty;
+  }
+}
+function writeJson(path, value) {
+  writeSecretFileAtomic(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+var REMOTES_LOCK_STALE_MS = 1e4, REMOTES_LOCK_WAIT_MS = 5e3, RemotesLockedError = class extends Error {
+  constructor(path) {
+    super(`${path} is locked by another program; try again.`);
+    this.path = path;
+    this.name = "RemotesLockedError";
+  }
+  path;
+};
+function remotesFilePath(env = process.env) {
+  return remotesPath(env);
+}
+async function updateRemotes(env, mutate, opts = {}) {
+  let path = remotesPath(env), lock = `${path}.lock`, staleMs = opts.staleMs ?? REMOTES_LOCK_STALE_MS, deadline = Date.now() + (opts.waitMs ?? REMOTES_LOCK_WAIT_MS), openLock = opts.openLock ?? open, busy = (err) => {
+    let code = err?.code;
+    return code === "EEXIST" || (opts.platform ?? process.platform) === "win32" && code === "EPERM";
+  }, mine = `${process.pid} ${randomBytes(8).toString("hex")}`, ageOf = (file) => stat(file).then((s) => Date.now() - s.mtimeMs, () => null), takeOver = async () => {
+    let claim = `${lock}.claim`;
+    try {
+      await (await openLock(claim, "wx")).close();
+    } catch (err) {
+      if (!busy(err)) throw err;
+      let age = await ageOf(claim);
+      age !== null && age > staleMs && await unlink(claim).catch(() => {
+      });
+      return;
+    }
+    try {
+      let age = await ageOf(lock);
+      if (age === null || age <= staleMs) return;
+      let tomb = `${lock}.${process.pid}.${randomBytes(4).toString("hex")}.stale`;
+      try {
+        await rename(lock, tomb);
+      } catch {
+        return;
+      }
+      let tombAge = await ageOf(tomb);
+      tombAge !== null && tombAge <= staleMs && await link(tomb, lock).catch(() => {
+      }), await unlink(tomb).catch(() => {
+      });
+    } finally {
+      await unlink(claim).catch(() => {
+      });
+    }
+  };
+  for (await import("node:fs/promises").then((fs) => fs.mkdir(daemonSettingsDir(env), { recursive: !0 })); ; )
+    try {
+      let handle = await openLock(lock, "wx");
+      await handle.writeFile(`${mine}
+`), await handle.close();
+      break;
+    } catch (err) {
+      if (!busy(err)) throw err;
+      if (err.code === "EPERM") {
+        if (Date.now() > deadline) throw new RemotesLockedError(path);
+        await new Promise((r) => setTimeout(r, 25));
+        continue;
+      }
+      let age = await ageOf(lock);
+      if (age !== null && age > staleMs) {
+        await opts.onStaleSeen?.(), await takeOver();
+        continue;
+      }
+      if (Date.now() > deadline) throw new RemotesLockedError(path);
+      await new Promise((r) => setTimeout(r, 25));
+    }
+  try {
+    let read = await readRemotesAsync(env);
+    if (read.unreadable) throw new RemotesUnreadableError(path, read.unreadable);
+    let file = read.file;
+    read.malformedDefault && (file.default = read.malformedDefault);
+    let raw = rawOfRead.get(read) ?? { malformed: {}, order: [], default: null }, malformed = { ...raw.malformed }, parsedDefault = file.default, before = JSON.stringify([file, malformed]), result = await mutate(file, malformed);
+    if (JSON.stringify([file, malformed]) !== before) {
+      let out = rawOf(file, raw, malformed, parsedDefault);
+      for (; ; )
+        try {
+          writeJson(path, out);
+          break;
+        } catch (err) {
+          let code = err?.code;
+          if ((opts.platform ?? process.platform) !== "win32" || code !== "EPERM" && code !== "EBUSY" || Date.now() > deadline) throw err;
+          await new Promise((r) => setTimeout(r, 25));
+        }
+    }
+    return result;
+  } finally {
+    (await readFile(lock, "utf8").catch(() => null))?.trim() === mine && await unlink(lock).catch(() => {
+    });
+  }
+}
+var account = (fingerprint) => `remote-token:${fingerprint}`;
+function readTokenFile(env) {
+  try {
+    let raw = JSON.parse(readFileSync2(tokensPath(env), "utf-8"));
+    return isRecord(raw) ? Object.fromEntries(Object.entries(raw).filter((e) => typeof e[1] == "string")) : {};
+  } catch {
+    return {};
+  }
+}
+var KEYCHAIN_FILE_COPY = {
+  title: "Keychain unavailable",
+  message: "The token can be saved in a file only you can read.",
+  ok: "Save to file",
+  cancel: "Cancel",
+  prompt: "Save to file? [y/N] "
+}, TokenNotStoredError = class extends Error {
+  constructor(why) {
+    super(`The token was not saved (${why}).`);
+    this.why = why;
+    this.name = "TokenNotStoredError";
+  }
+  why;
+};
+async function storeRemoteToken(fingerprint, token, env, confirmFile) {
+  let secrets = openDaemonSecrets(env), why = secrets.unavailable ?? "no OS keychain";
+  if (secrets.backend)
+    try {
+      return secrets.backend.set(account(fingerprint), token), { where: "keychain", why: null, path: null };
+    } catch (err) {
+      why = `the OS keychain refused it: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  if (!confirmFile || !await confirmFile(why).catch(() => !1)) throw new TokenNotStoredError(why);
+  return storeInFile(fingerprint, token, env, why);
+}
+function storeInFile(fingerprint, token, env, why) {
+  let path = tokensPath(env);
+  return writeJson(path, { ...readTokenFile(env), [account(fingerprint)]: token }), { where: "file", why, path };
+}
+function readRemoteToken(fingerprint, env = process.env) {
+  let secrets = openDaemonSecrets(env);
+  if (secrets.backend)
+    try {
+      let value = secrets.backend.get(account(fingerprint));
+      if (value) return value;
+    } catch {
+    }
+  return readTokenFile(env)[account(fingerprint)] ?? null;
+}
+function deleteRemoteToken(fingerprint, env = process.env) {
+  let secrets = openDaemonSecrets(env);
+  try {
+    secrets.backend?.delete(account(fingerprint));
+  } catch {
+  }
+  let tokens = readTokenFile(env);
+  account(fingerprint) in tokens && (delete tokens[account(fingerprint)], writeJson(tokensPath(env), tokens));
+}
+function malformedRemoteSentence(path, name) {
+  return `"${name}" in ${path} is malformed and is not used; fix it, or remove it with: adf remotes forget ${name}`;
+}
+var RemoteMalformedError = class extends Error {
+  constructor(path, remoteName) {
+    super(malformedRemoteSentence(path, remoteName));
+    this.path = path;
+    this.remoteName = remoteName;
+    this.name = "RemoteMalformedError";
+  }
+  path;
+  remoteName;
+};
+async function forgetRemote(env, name) {
+  let removed = await updateRemotes(env, (file, malformed) => {
+    let remote = file.remotes[name];
+    if (!remote)
+      return name in malformed ? (delete malformed[name], file.default === name && (file.default = null), { remote: null, sharedWith: null }) : null;
+    delete file.remotes[name], file.default === name && (file.default = null);
+    let sharedWith = Object.entries(file.remotes).find(([, r]) => r.fingerprint === remote.fingerprint)?.[0] ?? Object.entries(malformed).find(([, r]) => isRecord(r) && r.fingerprint === remote.fingerprint)?.[0] ?? null;
+    return { remote, sharedWith };
+  });
+  if (!removed) return null;
+  let tokenError = null;
+  if (removed.remote && !removed.sharedWith)
+    try {
+      deleteRemoteToken(removed.remote.fingerprint, env);
+    } catch (err) {
+      tokenError = errorText(err);
+    }
+  return { ...removed, tokenError };
+}
+function selectedRemote(env = process.env) {
+  let chosen = env[REMOTE_ENV]?.trim();
+  if (chosen === "local" || !chosen && !existsSync2(remotesPath(env))) return null;
+  let read = readRemotes(env);
+  if (read.unreadable) throw new RemotesUnreadableError(remotesPath(env), read.unreadable);
+  let file = read.file;
+  if (chosen) {
+    let remote = file.remotes[chosen];
+    if (!remote && read.malformed.includes(chosen)) throw new RemoteMalformedError(remotesPath(env), chosen);
+    if (!remote) throw new Error(`No saved remote named "${chosen}". List them with: adf remotes`);
+    return { name: chosen, remote };
+  }
+  if (read.malformedDefault) throw new RemoteMalformedError(remotesPath(env), read.malformedDefault);
+  return file.default ? { name: file.default, remote: file.remotes[file.default] } : null;
+}
+function sameOrigin(a, b) {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return !1;
+  }
+}
+function savedRemoteToken(url, env = process.env) {
+  if (!existsSync2(remotesPath(env))) return;
+  let file = loadRemotes(env);
+  for (let remote of Object.values(file.remotes))
+    if (sameOrigin(remote.url, url)) return readRemoteToken(remote.fingerprint, env) ?? void 0;
+}
+function savedRemoteFor(url, env = process.env) {
+  if (!existsSync2(remotesPath(env))) return null;
+  for (let [name, remote] of Object.entries(loadRemotes(env).remotes))
+    if (sameOrigin(remote.url, url)) return { name, remote };
+  return null;
+}
+async function pinnedRemoteRefusal(url, env, fetchImpl, wait = {}) {
+  let saved = savedRemoteFor(url, env);
+  if (!saved) return null;
+  let token = readRemoteToken(saved.remote.fingerprint, env), { fetchHello, helloRefusal, rateLimitedSentence, verifyHello } = await import("./remote-hello-UFWUBDQI.mjs"), host = `"${saved.name}" (${saved.remote.hostName ?? saved.remote.url})`, ask = () => token ? verifyHello(url, token, { fetch: fetchImpl }) : fetchHello(url, fetchImpl).then((hello) => hello ? { kind: "verified", hello } : { kind: "none" }), check = await ask();
+  for (let attempt = 0; check.kind === "rate_limited"; attempt++) {
+    if (attempt >= (wait.retries ?? 0))
+      return wait.retries ? `${host} is rate-limiting connections; try again in ${Math.ceil(check.retryAfterMs / 1e3)} s.` : rateLimitedSentence(host);
+    wait.onWait?.(rateLimitedSentence(host)), await (wait.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(check.retryAfterMs), check = await ask();
+  }
+  return check.kind === "none" ? `${url} did not answer as ${host}: it is down, its remote access is off, or another program answers there. The saved token was not sent.` : check.kind !== "not_device_token" && check.hello.fingerprint !== saved.remote.fingerprint ? `The ADF daemon at ${url} is not ${host}: it shows fingerprint ${check.hello.fingerprint}, and ${saved.remote.fingerprint} was saved when you paired. The saved token was not sent. If that computer was set up again, pair it again: adf remotes forget ${saved.name}, then adf pair ${url}.` : helloRefusal(check, host, url);
+}
+function remoteNameFor(hostName, taken) {
+  let base = hostName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "remote", name = base;
+  for (let i = 2; taken[name]; i++) name = `${base}-${i}`;
+  return name;
+}
+
+// src/main/cli/daemon-url.ts
+var daemon_url_exports = {};
+__export(daemon_url_exports, {
+  DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT,
+  DEFAULT_DAEMON_URL: () => DEFAULT_DAEMON_URL,
+  daemonCredentials: () => daemonCredentials,
+  isLocalDaemonUrl: () => isLocalDaemonUrl,
+  isLocalOnlyRoute: () => isLocalOnlyRoute,
+  localDaemonToken: () => localDaemonToken,
+  localProofHeaders: () => localProofHeaders,
+  loopbackPort: () => loopbackPort,
+  resolveDaemonToken: () => resolveDaemonToken,
+  resolveDaemonUrl: () => resolveDaemonUrl,
+  tunnelTokenHint: () => tunnelTokenHint
+});
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+var DEFAULT_DAEMON_PORT = 7385, DEFAULT_DAEMON_URL = `http://127.0.0.1:${DEFAULT_DAEMON_PORT}`;
+function resolveDaemonUrl(explicit, env = process.env) {
+  return (explicit ?? env.ADF_DAEMON_URL ?? selectedRemote(env)?.remote.url ?? DEFAULT_DAEMON_URL).replace(/\/+$/, "");
+}
+function loopbackPort(url) {
+  try {
+    let parsed = new URL(url), host = parsed.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return host === "localhost" || host === "::1" || /^127\./.test(host) ? parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80 : null;
+  } catch {
+    return null;
+  }
+}
+function pidFileAlive(file) {
+  try {
+    let raw = readFileSync3(file, "utf-8").trim(), pid = raw.startsWith("{") ? JSON.parse(raw).pid : Number.parseInt(raw, 10);
+    if (typeof pid != "number" || !Number.isFinite(pid) || pid <= 0) return !1;
+    try {
+      return process.kill(pid, 0), !0;
+    } catch (err) {
+      return err?.code === "EPERM";
+    }
+  } catch {
+    return !1;
+  }
+}
+function isLocalDaemonUrl(url, env = process.env) {
+  let port = loopbackPort(url);
+  return port === null ? !1 : port === DEFAULT_DAEMON_PORT || port === Number(env.ADF_DAEMON_PORT) ? !0 : pidFileAlive(join2(daemonSettingsDir(env), `adf-daemon-${port}.pid`));
+}
+function localDaemonToken(url, env = process.env) {
+  if (isLocalDaemonUrl(url, env))
+    return readDaemonToken(daemonSettingsDir(env)) ?? void 0;
+}
+function tunnelTokenHint(url, explicit, env = process.env) {
+  return explicit || env.ADF_DAEMON_TOKEN || loopbackPort(url) === null || isLocalDaemonUrl(url, env) ? null : `${url} is not this machine's daemon port (${Number(env.ADF_DAEMON_PORT) || DEFAULT_DAEMON_PORT}; e.g. an SSH tunnel), so the local token is not sent there. Pass --token or set ADF_DAEMON_TOKEN to the remote daemon's token (print it on that host with: adf daemon token).`;
+}
+function resolveDaemonToken(explicit, env = process.env, url) {
+  let token = explicit ?? env.ADF_DAEMON_TOKEN;
+  if (token) return token;
+  if (url)
+    return savedRemoteToken(url, env) ?? localDaemonToken(url, env);
+}
+function localProofHeaders(url, path, env = process.env) {
+  if (!isLocalOnlyRoute(path) || !isLocalDaemonUrl(url, env)) return {};
+  let proof = readLocalProof(daemonSettingsDir(env), loopbackPort(url) ?? DEFAULT_DAEMON_PORT);
+  return proof ? { "X-ADF-Local-Proof": proof } : {};
+}
+function daemonCredentials(url, options = {}) {
+  let env = options.env ?? process.env, token = resolveDaemonToken(options.token, env, options.localToken ? url : void 0), pinned = !!options.localToken && !options.token && !env.ADF_DAEMON_TOKEN && savedRemoteFor(url, env) !== null, fetchImpl = options.fetch ?? fetch, proved = null;
+  return {
+    token: () => token,
+    ...pinned ? { ready: () => {
+      proved ??= pinnedRemoteRefusal(url, env, fetchImpl).then((refusal) => {
+        if (refusal) throw new Error(refusal);
+      });
+      let check = proved;
+      return check.catch((err) => {
+        throw proved === check && (proved = null), err;
+      });
+    }, dropped: () => {
+      proved = null;
+    } } : {},
+    // The daemon answered 401: pick up a token file that appeared or changed
+    // since (daemon first start). localDaemonToken is null for any URL that is
+    // not this machine's daemon, so a remote URL never gets the local token.
+    refresh: () => {
+      if (!options.localToken || options.token || env.ADF_DAEMON_TOKEN) return !1;
+      let fresh = localDaemonToken(url, env);
+      return !fresh || fresh === token ? !1 : (token = fresh, !0);
+    },
+    localProof: (path) => options.localToken ? localProofHeaders(url, path, env) : {}
+  };
+}
+
+export {
+  RemotesUnreadableError,
+  readRemotes,
+  remotesFilePath,
+  updateRemotes,
+  KEYCHAIN_FILE_COPY,
+  storeRemoteToken,
+  readRemoteToken,
+  deleteRemoteToken,
+  malformedRemoteSentence,
+  RemoteMalformedError,
+  forgetRemote,
+  pinnedRemoteRefusal,
+  remoteNameFor,
+  DEFAULT_DAEMON_PORT,
+  DEFAULT_DAEMON_URL,
+  resolveDaemonUrl,
+  loopbackPort,
+  isLocalDaemonUrl,
+  localDaemonToken,
+  tunnelTokenHint,
+  resolveDaemonToken,
+  localProofHeaders,
+  daemon_url_exports
+};

package/dist/chunks/{chunk-6VQEXLE2.mjs → chunk-BHY7QDCM.mjs}

@@ -17,19 +17,23 @@ __export(auth_flow_exports, {
   AUTH_POLL_INTERVAL_MS: () => AUTH_POLL_INTERVAL_MS,
   AUTH_PROVIDERS: () => AUTH_PROVIDERS,
   AUTH_PROVIDER_LABELS: () => AUTH_PROVIDER_LABELS,
+  CLAUDE_AUTH_TIMEOUT_MS: () => CLAUDE_AUTH_TIMEOUT_MS,
   RELAY_CALLBACK_TIMEOUT_MS: () => RELAY_CALLBACK_TIMEOUT_MS,
   browserLaunchCommand: () => browserLaunchCommand,
   daemonIsLocal: () => daemonIsLocal,
   loginChatGpt: () => loginChatGpt,
+  loginClaude: () => loginClaude,
   loginGrok: () => loginGrok,
   normalizeAuthProvider: () => normalizeAuthProvider,
   openBrowser: () => openBrowser,
+  submitClaudeCode: () => submitClaudeCode,
   waitForAuth: () => waitForAuth
 });
 import { spawn as nodeSpawn } from "child_process";
-var AUTH_PROVIDERS = ["chatgpt", "grok"], AUTH_PROVIDER_LABELS = {
+var AUTH_PROVIDERS = ["chatgpt", "grok", "claude"], AUTH_PROVIDER_LABELS = {
   chatgpt: "ChatGPT",
-  grok: "Grok"
+  grok: "Grok",
+  claude: "Claude"
 }, RELAY_CALLBACK_TIMEOUT_MS = 300 * 1e3, AUTH_POLL_INTERVAL_MS = 2e3, LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
 function normalizeAuthProvider(value) {
   switch (value?.toLowerCase()) {
@@ -40,6 +44,9 @@ function normalizeAuthProvider(value) {
     case "grok":
     case "xai":
       return "grok";
+    case "claude":
+    case "claude-code":
+      return "claude";
     default:
       return null;
   }
@@ -63,7 +70,7 @@ function openBrowser(url, deps = {}) {
   } catch {
   }
 }
-var CANCELLED = { ok: !1, error: "Sign-in cancelled", cancelled: !0 };
+var CLAUDE_AUTH_TIMEOUT_MS = 660 * 1e3, CANCELLED = { ok: !1, error: "Sign-in cancelled", cancelled: !0 };
 function isRecord(value) {
   return typeof value == "object" && value !== null && !Array.isArray(value);
 }
@@ -107,6 +114,35 @@ async function loginGrok(deps, opts) {
   let userCode = typeof data.userCode == "string" ? data.userCode : "", verificationUri = typeof data.verificationUriComplete == "string" && data.verificationUriComplete ? data.verificationUriComplete : typeof data.verificationUri == "string" ? data.verificationUri : "", expiresInSec = typeof data.expiresIn == "number" && data.expiresIn > 0 ? data.expiresIn : 900;
   return opts.onStart({ userCode, verificationUri, expiresInSec, raw: data }), deps.signal?.aborted ? CANCELLED : (verificationUri && (deps.openBrowser ?? openBrowser)(verificationUri), waitForAuth(deps, "grok", expiresInSec * 1e3));
 }
+async function loginClaude(deps, opts) {
+  let before = await deps.request("GET", "/auth/claude/status");
+  if (isRecord(before) && before.installed === !1) {
+    let installUrl = typeof before.installUrl == "string" ? before.installUrl : "";
+    return { ok: !1, error: `Claude Code is not installed on the daemon host.${installUrl ? ` Install it from ${installUrl}, then sign in again.` : ""}`, notInstalled: !0, installUrl };
+  }
+  let data = await deps.request("POST", "/auth/claude/start"), url = isRecord(data) && typeof data.url == "string" ? data.url : "";
+  if (opts.onStart({ url, raw: data }), opts.wait === !1 && !deps.signal?.aborted) return { ok: !1, error: "Sign-in started; not waiting for it", detached: !0 };
+  let outcome = deps.signal?.aborted ? CANCELLED : await waitForClaude(deps);
+  return !outcome.ok && (outcome.cancelled || outcome.timedOut) && await deps.request("POST", "/auth/claude/cancel").catch(() => {
+  }), outcome;
+}
+async function submitClaudeCode(deps, code) {
+  await deps.request("POST", "/auth/claude/code", { code: code.trim() });
+}
+async function waitForClaude(deps) {
+  let sleep = deps.sleep ?? ((ms) => abortableSleep(ms, deps.signal)), deadline = Date.now() + CLAUDE_AUTH_TIMEOUT_MS;
+  for (; Date.now() < deadline; ) {
+    if (await sleep(AUTH_POLL_INTERVAL_MS), deps.signal?.aborted) return CANCELLED;
+    let status = await deps.request("GET", "/auth/claude/status");
+    if (deps.signal?.aborted) return CANCELLED;
+    if (isRecord(status) && status.flowPending !== !0) {
+      if (typeof status.flowError == "string" && status.flowError) return { ok: !1, error: status.flowError };
+      if (status.authenticated === !0) return { ok: !0, email: typeof status.email == "string" ? status.email : void 0, raw: status };
+      if (status.installed === !1) return { ok: !1, error: "Claude Code is not installed on the daemon host." };
+    }
+  }
+  return { ok: !1, error: "Timed out waiting for Claude sign-in", timedOut: !0 };
+}
 async function waitForAuth(deps, provider, timeoutMs) {
   let sleep = deps.sleep ?? ((ms) => abortableSleep(ms, deps.signal)), deadline = Date.now() + timeoutMs;
   for (; Date.now() < deadline; ) {
@@ -140,5 +176,7 @@ export {
   openBrowser,
   loginChatGpt,
   loginGrok,
+  loginClaude,
+  submitClaudeCode,
   auth_flow_exports
 };

package/dist/chunks/{chunk-CD3ATSXE.mjs → chunk-BR3AD5QZ.mjs}

@@ -37,7 +37,11 @@ var START_IN_STATES = ["active", "idle", "hibernate"];
 function resolveStartInState(config) {
   return config.start_in_state ?? "active";
 }
-var DEFAULT_NEW_LOOP_TOOLS = ["loop_send", "loop_list", "sys_set_state"], LOOP_PROHIBITED_TOOLS = ["sys_update_config", "loop_manage", "sys_create_adf"];
+var DEFAULT_NEW_LOOP_TOOLS = ["loop_send", "loop_list", "sys_set_state"], MAX_SIDE_LOOPS = 16;
+function hasLoopGoal(loop) {
+  return !!loop.goal?.trim();
+}
+var LOOP_PROHIBITED_TOOLS = ["sys_update_config", "loop_manage", "sys_create_adf"];
 var META_PROTECTION_LEVELS = ["none", "readonly", "increment"], FILE_PROTECTION_LEVELS = ["read_only", "no_delete", "none"];
 var DEFAULT_TOOLS = [
   { name: "fs_read", enabled: !0, visible: !0 },
@@ -141,7 +145,6 @@ var AGENT_DEFAULTS = {
     provider: "",
     model_id: "",
     temperature: 0.7,
-    max_tokens: 4096,
     vision: !1
   },
   context: {
@@ -288,10 +291,13 @@ export {
   START_IN_STATES,
   resolveStartInState,
   DEFAULT_NEW_LOOP_TOOLS,
+  MAX_SIDE_LOOPS,
+  hasLoopGoal,
   LOOP_PROHIBITED_TOOLS,
   META_PROTECTION_LEVELS,
   FILE_PROTECTION_LEVELS,
   DEFAULT_TOOLS,
+  AUDIT_DEFAULTS,
   AGENT_DEFAULTS,
   getDefaultDocumentContent,
   DEFAULT_MIND_CONTENT,