@agentdocumentformat/cli 0.8.2 → 0.8.4

package/dist/chunks/{daemon-control-MKN7G5M3.mjs → daemon-control-U4OGCAAJ.mjs}

@@ -24,12 +24,12 @@ import {
   stopDaemon,
   studioConflict,
   tailLines
-} from "./chunk-RHBGCOS3.mjs";
-import "./chunk-D7A77SNL.mjs";
+} from "./chunk-22ZGZFOV.mjs";
+import "./chunk-3FWPIWYM.mjs";
 import {
   DEFAULT_DAEMON_PORT
-} from "./chunk-AEAJDCVK.mjs";
-import "./chunk-BS3USVEA.mjs";
+} from "./chunk-IM5JKLXO.mjs";
+import "./chunk-P4G5ZEBI.mjs";
 import "./chunk-WJGPNHGX.mjs";
 import "./chunk-PAK5JCO2.mjs";
 import "./chunk-ZPB3HYM7.mjs";

package/dist/chunks/{devtools-H7CI2ZVG.mjs → devtools-AUZWFIPL.mjs}

@@ -6,7 +6,7 @@ const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
 import {
   wrapper_default
-} from "./chunk-F5ELW46V.mjs";
+} from "./chunk-GJYMGPH4.mjs";
 import "./chunk-NGK6PVSF.mjs";
 import "./chunk-M2RX3S2T.mjs";
 

package/dist/chunks/firewall-service-7RGJN4LD.mjs

@@ -0,0 +1,163 @@
+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 {
+  getLanAddresses
+} from "./chunk-A53XYNJL.mjs";
+import "./chunk-M2RX3S2T.mjs";
+
+// src/main/services/firewall-service.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile), FW_RULE_TCP = "ADF Mesh (LAN)", FW_RULE_UDP = "ADF mDNS (LAN)", MDNS_PORT = 5353;
+function firstLanIpv4() {
+  let isRfc1918 = (ip) => /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(ip);
+  for (let a of getLanAddresses().addresses)
+    if (a.family === "IPv4" && isRfc1918(a.address)) return a.address;
+  return null;
+}
+function buildWindowsCheckScript() {
+  return [
+    `$r = Get-NetFirewallRule -DisplayName '${FW_RULE_TCP}' -ErrorAction SilentlyContinue`,
+    "$ok = $false",
+    "if ($r) { $ok = @($r | Where-Object { $_.Enabled -eq 'True' -and $_.Direction -eq 'Inbound' -and $_.Action -eq 'Allow' }).Count -gt 0 }",
+    "[Console]::Out.Write((@{ ruleConfigured = [bool]$ok } | ConvertTo-Json -Compress))"
+  ].join("; ");
+}
+function psQuote(s) {
+  return `'${s.replace(/['‘’‚‛]/g, "$&$&")}'`;
+}
+function shQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function lanFirewallCommands(platform, port, exePath, manager) {
+  if (platform === "win32") {
+    let exe = psQuote(exePath), replace = (name) => `Get-NetFirewallRule -DisplayName ${psQuote(name)} -ErrorAction SilentlyContinue | Remove-NetFirewallRule; New-NetFirewallRule -DisplayName ${psQuote(name)}`;
+    return [
+      `${replace(FW_RULE_TCP)} -Direction Inbound -Action Allow -Protocol TCP -LocalPort ${port} -Program ${exe} -Profile Private,Domain`,
+      `${replace(FW_RULE_UDP)} -Direction Inbound -Action Allow -Protocol UDP -LocalPort ${MDNS_PORT} -Program ${exe} -Profile Private,Domain`
+    ];
+  }
+  if (platform === "darwin") {
+    let fw = "/usr/libexec/ApplicationFirewall/socketfilterfw";
+    return [`sudo ${fw} --add ${shQuote(exePath)}`, `sudo ${fw} --unblockapp ${shQuote(exePath)}`];
+  }
+  return platform === "linux" && manager ? buildLinuxApplyCommand(manager, port).split(" && ").map((c) => `sudo ${c}`) : [];
+}
+async function probeReachable(lanIp, port) {
+  try {
+    let ctrl = new AbortController(), t = setTimeout(() => ctrl.abort(), 2e3);
+    try {
+      return (await fetch(`http://${lanIp}:${port}/agents`, {
+        signal: ctrl.signal
+      })).ok;
+    } finally {
+      clearTimeout(t);
+    }
+  } catch {
+    return !1;
+  }
+}
+async function checkLanFirewall(port) {
+  let platform = process.platform, lanIp = firstLanIpv4(), reachable = lanIp ? await probeReachable(lanIp, port) : null;
+  if (platform === "win32")
+    try {
+      let { stdout } = await execFileAsync(
+        "powershell",
+        ["-NoProfile", "-NonInteractive", "-Command", buildWindowsCheckScript()],
+        { timeout: 15e3, windowsHide: !0 }
+      ), ruleConfigured = !!JSON.parse(stdout.trim() || "{}").ruleConfigured;
+      return {
+        platform,
+        supported: !0,
+        ruleConfigured,
+        reachable,
+        lanIp,
+        detail: ruleConfigured ? "Inbound firewall rule present." : "No inbound firewall rule: peers cannot fetch this runtime's agents.",
+        commands: ruleConfigured ? [] : lanFirewallCommands(platform, port, process.execPath)
+      };
+    } catch (err) {
+      return {
+        platform,
+        supported: !0,
+        ruleConfigured: null,
+        reachable,
+        lanIp,
+        detail: `Could not query Windows Firewall: ${err instanceof Error ? err.message : String(err)}`,
+        commands: lanFirewallCommands(platform, port, process.execPath)
+      };
+    }
+  return platform === "darwin" ? {
+    platform,
+    supported: !0,
+    ruleConfigured: null,
+    reachable,
+    lanIp,
+    detail: "The macOS application firewall is per app. If it is on, allow incoming connections for ADF Studio.",
+    commands: lanFirewallCommands(platform, port, process.execPath)
+  } : platform === "linux" ? checkLinuxFirewall(port, reachable, lanIp) : {
+    platform,
+    supported: !1,
+    ruleConfigured: null,
+    reachable,
+    lanIp,
+    detail: `Open TCP port ${port} and UDP port ${MDNS_PORT} for ADF Studio in this computer's firewall.`,
+    commands: []
+  };
+}
+async function tryExec(cmd, args) {
+  try {
+    let { stdout } = await execFileAsync(cmd, args, { timeout: 5e3, windowsHide: !0 });
+    return { code: 0, stdout: stdout.toString() };
+  } catch (err) {
+    let code = typeof err.code == "number" ? err.code : 1, stdout = err.stdout?.toString() ?? "";
+    return { code, stdout };
+  }
+}
+async function checkLinuxFirewall(port, reachable, lanIp) {
+  let base = { platform: "linux", reachable, lanIp }, fwState = await tryExec("firewall-cmd", ["--state"]);
+  if (fwState.code === 0 && /running/i.test(fwState.stdout)) {
+    let tcp = await tryExec("firewall-cmd", [`--query-port=${port}/tcp`]), udp = await tryExec("firewall-cmd", [`--query-port=${MDNS_PORT}/udp`]), ruleConfigured = tcp.code === 0 && udp.code === 0;
+    return {
+      ...base,
+      supported: !0,
+      manager: "firewalld",
+      ruleConfigured,
+      detail: ruleConfigured ? "firewalld is active and the ports are open." : "firewalld is active but the mesh ports are closed: peers cannot fetch this runtime's agents.",
+      commands: ruleConfigured ? [] : lanFirewallCommands("linux", port, "", "firewalld")
+    };
+  }
+  let ufwActive = await tryExec("systemctl", ["is-active", "ufw"]);
+  return ufwActive.code === 0 && /^active/.test(ufwActive.stdout.trim()) ? {
+    ...base,
+    supported: !0,
+    manager: "ufw",
+    ruleConfigured: null,
+    detail: "ufw is active. Allow the mesh ports so peers can fetch this runtime's agents.",
+    commands: lanFirewallCommands("linux", port, "", "ufw")
+  } : {
+    ...base,
+    supported: !0,
+    manager: null,
+    ruleConfigured: !0,
+    detail: "No active firewall detected: inbound LAN connections are open.",
+    commands: []
+  };
+}
+function buildLinuxApplyCommand(manager, port) {
+  return manager === "firewalld" ? `firewall-cmd --permanent --add-port=${port}/tcp --add-port=${MDNS_PORT}/udp && firewall-cmd --reload` : `ufw allow ${port}/tcp && ufw allow ${MDNS_PORT}/udp`;
+}
+export {
+  FW_RULE_TCP,
+  FW_RULE_UDP,
+  MDNS_PORT,
+  buildLinuxApplyCommand,
+  buildWindowsCheckScript,
+  checkLanFirewall,
+  firstLanIpv4,
+  lanFirewallCommands,
+  psQuote
+};

package/dist/chunks/{open-3OR6WT4T.mjs → open-T3VGLWGF.mjs}

@@ -12,14 +12,15 @@ import {
   openProviderAdd,
   openWelcome,
   secretStoreReady
-} from "./chunk-2Z7X3UUR.mjs";
-import "./chunk-O7XKQ6CH.mjs";
-import "./chunk-5QU5VY7N.mjs";
-import "./chunk-SOSPQPEN.mjs";
-import "./chunk-3AT7IIP7.mjs";
+} from "./chunk-DHO5Z6HP.mjs";
 import "./chunk-NZLEPJ5M.mjs";
 import "./chunk-7CV2SA3H.mjs";
 import "./chunk-SGUTYISF.mjs";
+import "./chunk-O7XKQ6CH.mjs";
+import "./chunk-5QU5VY7N.mjs";
+import "./chunk-TDRQG5UO.mjs";
+import "./chunk-HONGRUAE.mjs";
+import "./chunk-WZ6S3SQP.mjs";
 import "./chunk-6GJ4QHRI.mjs";
 import "./chunk-UYY5M2PB.mjs";
 import "./chunk-ZJKXHM4Q.mjs";

package/dist/chunks/{pipeline-executor-DRYEEFDR.mjs → pipeline-executor-MHRI7ODL.mjs}

@@ -7,13 +7,16 @@ const __dirname = __adfDirname(__filename);
 import {
   MAX_SHELL_DEPTH,
   executeNode
-} from "./chunk-F3WSCAJD.mjs";
+} from "./chunk-XP4U4A2W.mjs";
 import "./chunk-UZPDETEU.mjs";
 import "./chunk-ESP3VNMX.mjs";
-import "./chunk-LVF2DRBR.mjs";
-import "./chunk-E7LC6SHP.mjs";
+import "./chunk-TBMQOM7Y.mjs";
+import "./chunk-4T745GJA.mjs";
+import "./chunk-RIAB37IS.mjs";
 import "./chunk-3GNIDM53.mjs";
 import "./chunk-LKFHERRV.mjs";
+import "./chunk-ZECGH3LT.mjs";
+import "./chunk-26RK7T5L.mjs";
 import "./chunk-BR3AD5QZ.mjs";
 import "./chunk-M2RX3S2T.mjs";
 export {

package/dist/chunks/{remote-access-cli-GLEEP7DI.mjs → remote-access-cli-EFVCXFOY.mjs}

@@ -11,10 +11,10 @@ import {
 import {
   DEFAULT_DAEMON_PORT,
   loopbackPort
-} from "./chunk-AEAJDCVK.mjs";
+} from "./chunk-IM5JKLXO.mjs";
 import {
   readLocalProof
-} from "./chunk-BS3USVEA.mjs";
+} from "./chunk-P4G5ZEBI.mjs";
 import {
   readDaemonToken
 } from "./chunk-WJGPNHGX.mjs";
@@ -31,7 +31,7 @@ var REMOTE_USAGE = `Usage: adf daemon remote on [--name <name>] | off | status [
        adf daemon devices [list] [--json]
        adf daemon devices add <label>        Print a new device token (shown once)
        adf daemon devices revoke <id|label>  Disconnect that computer and void its token
-       adf daemon pair                       Open a pairing window and show its code
+       adf daemon pair                       Pair a browser or client; approve it in this terminal
 
 Remote access: devices you pair or add use this computer's ADF daemon (no
 restart; agents keep running). It listens only on private and Tailscale
@@ -214,11 +214,27 @@ async function pairCommand(io, target) {
 `), 1;
     throw err;
   }
-  let host = (await call(io, target, "GET", "/remote-access")).urls.find((u) => u.kind === "tailnet" || u.kind === "lan")?.url.replace(/^http:\/\//, "").replace(new RegExp(`:${DEFAULT_DAEMON_PORT}$`), "");
+  let status = await call(io, target, "GET", "/remote-access"), host = status.urls.find((u) => u.kind === "tailnet" || u.kind === "lan")?.url.replace(/^http:\/\//, "").replace(new RegExp(`:${DEFAULT_DAEMON_PORT}$`), "");
   io.stdout(`Pairing with "${window.name}" (fingerprint ${window.fingerprint}) is open for 2 minutes.
-`), io.stdout(`On the other computer: adf pair${host ? ` ${host}` : ""}, or pair with this computer in ADF Studio \u2192 Settings \u2192 Connections.
+`);
+  let browserUrls = /* @__PURE__ */ new Set();
+  for (let address of [...status.urls].sort((a, b) => Number(b.encrypted) - Number(a.encrypted)))
+    try {
+      let url = new URL(address.url);
+      (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && browserUrls.add(new URL("/studio/", url).href);
+    } catch {
+    }
+  if (browserUrls.size > 0) {
+    io.stdout(`In the other device\u2019s browser, open:
+`);
+    for (let url of browserUrls) io.stdout(`  ${url}
+`);
+    io.stdout(`Enter the code below and a browser name, then return to this terminal to approve the request. No desktop app is needed.
+`);
+  }
+  io.stdout(`On the other computer: adf pair${host ? ` ${host}` : ""}, or pair with this computer in ADF Studio \u2192 Settings \u2192 Connections.
 `), io.stdout(`Code: ${window.code.slice(0, 3)} ${window.code.slice(3)}
-`), io.stderr(`Waiting for the other computer\u2026 (Ctrl+C closes the window)
+`), io.stderr(`Waiting for a browser or client request to approve here\u2026 (Ctrl+C closes the window)
 `);
   let interrupted = !1, stop = io.onInterrupt?.(() => {
     interrupted = !0;

package/dist/chunks/{store-55CQSAOX.mjs → store-37YHXFJ6.mjs}

@@ -14,11 +14,12 @@ import {
   useClient,
   useStore,
   useTuiSelector
-} from "./chunk-RJDOVMM4.mjs";
-import "./chunk-75DC5EWN.mjs";
+} from "./chunk-TPA2ITKV.mjs";
 import "./chunk-7CV2SA3H.mjs";
 import "./chunk-SGUTYISF.mjs";
-import "./chunk-7JZXMDDF.mjs";
+import "./chunk-KBXC5EHK.mjs";
+import "./chunk-7ADDKFT5.mjs";
+import "./chunk-NRTRTR7C.mjs";
 import "./chunk-6GJ4QHRI.mjs";
 import "./chunk-LKFHERRV.mjs";
 import "./chunk-VENQBMOA.mjs";

package/dist/chunks/{tui-RAUVFOYY.mjs → tui-NJKGFAKU.mjs}

@@ -6,20 +6,21 @@ const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
 import {
   DaemonClient
-} from "./chunk-IMVMSU3A.mjs";
+} from "./chunk-X6R32YVE.mjs";
+import {
+  cjs
+} from "./chunk-SGUTYISF.mjs";
 import {
   defaultPrefsPath,
   loadPrefs,
   savePrefs
 } from "./chunk-5QU5VY7N.mjs";
-import "./chunk-75DC5EWN.mjs";
-import {
-  cjs
-} from "./chunk-SGUTYISF.mjs";
+import "./chunk-JK6K2BMV.mjs";
+import "./chunk-KBXC5EHK.mjs";
 import {
   daemon_url_exports
-} from "./chunk-AEAJDCVK.mjs";
-import "./chunk-BS3USVEA.mjs";
+} from "./chunk-IM5JKLXO.mjs";
+import "./chunk-P4G5ZEBI.mjs";
 import "./chunk-WJGPNHGX.mjs";
 import "./chunk-PAK5JCO2.mjs";
 import "./chunk-ZPB3HYM7.mjs";
@@ -121,10 +122,10 @@ ${tuiUsage()}
     { LAYOUT_STATE_KEY }
   ] = await Promise.all([
     import("./react-IUIDQ5LX.mjs"),
-    import("./build-QF5W473T.mjs"),
-    import("./App-4AZZJNN2.mjs"),
+    import("./build-BFOCXM5S.mjs"),
+    import("./App-XOPHZTGN.mjs"),
     import("./themes-BQ72P446.mjs"),
-    import("./store-55CQSAOX.mjs"),
+    import("./store-37YHXFJ6.mjs"),
     import("./theme-HLBDTF6F.mjs"),
     import("./terminal-O5WO7C5U.mjs"),
     import("./layout-ECWGJF6M.mjs")
@@ -164,7 +165,7 @@ ${tuiUsage()}
   store.start().then(async () => {
     let { recordWelcomeLaunch } = await import("./welcome-J5JZZAM5.mjs");
     if (recordWelcomeLaunch()) {
-      let { openWelcome } = await import("./open-3OR6WT4T.mjs");
+      let { openWelcome } = await import("./open-T3VGLWGF.mjs");
       openWelcome(store);
     }
     if (!options.agent) return;

package/dist/chunks/web-F4XHDGUX.mjs

@@ -0,0 +1,149 @@
+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 {
+  browserLaunchCommand
+} from "./chunk-UBWWGUMU.mjs";
+import "./chunk-2NAP2ZF7.mjs";
+import {
+  DEFAULT_DAEMON_PORT,
+  isLocalDaemonUrl
+} from "./chunk-IM5JKLXO.mjs";
+import {
+  readLocalProof
+} from "./chunk-P4G5ZEBI.mjs";
+import {
+  daemonSettingsDir,
+  readDaemonToken
+} from "./chunk-WJGPNHGX.mjs";
+import "./chunk-PAK5JCO2.mjs";
+import "./chunk-ZPB3HYM7.mjs";
+import "./chunk-LTX74NU6.mjs";
+import "./chunk-M2RX3S2T.mjs";
+
+// src/main/cli/web.ts
+import { spawn } from "node:child_process";
+
+// src/main/services/studio-browser-launch.ts
+import { isIP } from "node:net";
+function localBrowserOrigin(value) {
+  let url = new URL(value), host = url.hostname.replace(/^\[|\]$/g, "");
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.pathname !== "/" || url.search || url.hash || !(host === "localhost" || host === "::1" || isIP(host) === 4 && host.startsWith("127.")))
+    throw new Error("Browser sign-in requires this computer\u2019s local daemon address.");
+  return url;
+}
+function validatedBrowserLaunch(baseUrl, value) {
+  let base = localBrowserOrigin(baseUrl);
+  if (typeof value != "string") throw new Error("Invalid browser launch address.");
+  let target = new URL(value), fragment = new URLSearchParams(target.hash.slice(1)), ticket = fragment.get("ticket");
+  if (target.origin !== base.origin || target.pathname !== "/studio/" || target.search || target.username || target.password || [...fragment.keys()].length !== 1 || !ticket || !/^[A-Za-z0-9_-]{43}$/.test(ticket))
+    throw new Error("Invalid browser launch address.");
+  return target.href;
+}
+
+// src/main/cli/web.ts
+var WEB_USAGE = `Usage: adf web [--port <n> | --url <local-daemon-url>] [--no-daemon]
+
+Open Browser Studio already signed in. Starts this computer's daemon if needed.
+No desktop Studio installation or token copying is required.
+--no-daemon (or ADF_NO_AUTOSTART=1) disables automatic daemon startup.
+
+On a headless host or for another device:
+  adf daemon remote on
+  adf daemon remote allow-network
+  adf daemon pair
+Open the displayed /studio/ address, enter the code, and approve in the terminal.
+Remote access uses only the networks you allow.
+`;
+function openWebBrowser(url, deps = {}) {
+  let { command, args } = browserLaunchCommand(url);
+  return new Promise((resolve, reject) => {
+    let child = (deps.spawn ?? spawn)(command, args, { detached: !0, stdio: "ignore", windowsHide: !0 }), timer = setTimeout(() => {
+      child.unref(), resolve();
+    }, 1e4);
+    child.once("error", () => {
+      clearTimeout(timer), reject(new Error("Browser launcher unavailable."));
+    }), child.once("exit", (code) => {
+      clearTimeout(timer), code === 0 ? resolve() : reject(new Error("Browser launch failed."));
+    });
+  });
+}
+async function runWebCommand(args, io) {
+  if (args.includes("--help") || args.includes("-h"))
+    return io.stdout(WEB_USAGE), 0;
+  let env = { ...io.env ?? process.env }, explicitUrl, port, noDaemon = env.ADF_NO_AUTOSTART === "1";
+  try {
+    for (let i = 0; i < args.length; i++) {
+      let [flag, inline] = args[i].split(/=(.*)/s);
+      if (flag === "--no-daemon" && inline === void 0) {
+        noDaemon = !0;
+        continue;
+      }
+      let value = inline ?? args[++i];
+      if (!value || value.startsWith("-")) throw new Error("Missing value.");
+      if (flag === "--port" || flag === "-p") port = value;
+      else if (flag === "--url" || flag === "-u") explicitUrl = value;
+      else throw new Error("Unknown option.");
+    }
+    if (explicitUrl && port) throw new Error("Choose --port or --url.");
+    if (port !== void 0 && (!/^\d+$/.test(port) || Number(port) < 1 || Number(port) > 65535)) throw new Error("Invalid port.");
+  } catch {
+    return io.stderr(WEB_USAGE), 2;
+  }
+  port && (env.ADF_DAEMON_PORT = port);
+  let configuredPort = port ?? env.ADF_DAEMON_PORT, address = explicitUrl ?? (configuredPort ? `http://127.0.0.1:${configuredPort}` : env.ADF_DAEMON_URL ?? `http://127.0.0.1:${DEFAULT_DAEMON_PORT}`), base;
+  try {
+    base = localBrowserOrigin(address);
+  } catch {
+    return io.stderr(`adf web signs in only to this computer\u2019s daemon. On another host, use adf daemon pair and open its /studio/ address.
+`), 2;
+  }
+  let origin = base.origin;
+  if (!isLocalDaemonUrl(origin, env))
+    return io.stderr(`That address is not a known local daemon port. For a local daemon, select it with --port; for a tunnel or another host, use browser pairing.
+`), 2;
+  try {
+    noDaemon || await io.ensureDaemon?.(origin, env);
+  } catch {
+    return io.stderr(`Could not start the local daemon. Run adf daemon start for details.
+`), 1;
+  }
+  let daemonPort = Number(base.port) || (base.protocol === "https:" ? 443 : 80), dataDir = daemonSettingsDir(env), token = env.ADF_DAEMON_TOKEN || readDaemonToken(dataDir), proof = readLocalProof(dataDir, daemonPort);
+  if (!token || !proof)
+    return io.stderr(`The local daemon is not ready for browser sign-in. Start it with adf daemon start, or update it if it is already running.
+`), 1;
+  let target;
+  try {
+    let response = await io.fetch(`${origin}/web/launch`, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(1e4),
+      headers: { Accept: "application/json", Authorization: `Bearer ${token}`, "X-ADF-Local-Proof": proof }
+    });
+    if (!response.ok)
+      return io.stderr(response.status === 404 ? `This daemon does not support Browser Studio yet. Update adf and restart the daemon when you are ready.
+` : `Browser sign-in was refused (${response.status}). Check that this is the local daemon and run adf daemon status.
+`), 1;
+    let body = await response.json();
+    target = validatedBrowserLaunch(origin, body?.url);
+  } catch {
+    return io.stderr(`Could not get a valid browser sign-in link from the local daemon. Check adf daemon status and update adf if needed.
+`), 1;
+  }
+  try {
+    await (io.openBrowser ?? openWebBrowser)(target);
+  } catch {
+    return io.stderr(`Could not open a browser on this computer. On a headless host, run adf daemon pair and open the displayed address on another device.
+`), 1;
+  }
+  return io.stdout(`Opened Browser Studio at ${origin}/studio/ and requested automatic sign-in.
+`), 0;
+}
+export {
+  WEB_USAGE,
+  openWebBrowser,
+  runWebCommand
+};

package/dist/chunks/{whatsapp-YJFFVN4Q.mjs → whatsapp-J7PX7TKT.mjs}

@@ -6,7 +6,7 @@ const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
 import {
   wrapper_default
-} from "./chunk-F5ELW46V.mjs";
+} from "./chunk-GJYMGPH4.mjs";
 import {
   require_dist,
   require_follow_redirects,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentdocumentformat/cli",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "ADF CLI: the ADF (Agent Document Format) daemon, command line and terminal app. Run your agents headless: `adf daemon`, then `adf`.",
   "type": "module",
   "bin": {
@@ -8,12 +8,13 @@
   },
   "files": [
     "dist/",
+    "web/",
     "resources/",
     "README.md",
     "LICENSE"
   ],
   "engines": {
-    "node": ">=22"
+    "node": "^22.23.4 || ^24.22.1 || ^26.12.1"
   },
   "keywords": [
     "adf",
@@ -41,7 +42,7 @@
     "url": "git+https://github.com/christianbalevski/adf.git"
   },
   "dependencies": {
-    "better-sqlite3": "^12.8.0",
+    "better-sqlite3": "^13.0.3",
     "@napi-rs/keyring": "^2.1.0",
     "sqlite-vec": "^0.1.9",
     "@modelcontextprotocol/sdk": "^1.27.1",