@agentdocumentformat/cli 0.8.2 → 0.8.4

package/README.md

@@ -8,13 +8,19 @@ the [releases](https://github.com/christianbalevski/adf/releases).
 - `adf`: the **terminal app**. Your fleet of agents in one screen: chat with
   any agent or any of its loops, approve tool calls, edit files, schedule
   inner loops (side loops), watch live events.
+- `adf web`: **Browser Studio**, using the shared desktop renderer. Available
+  in builds that include browser support; published npm v0.8.3 does not include it.
 - `adf <command>`: one-shot commands for scripts (`adf help`).
 - `adf daemon`: the background daemon that runs the agents. `adf` starts it
   for you; it keeps running after you quit.
 
 ## Install
 
-Requires Node.js 22 or newer. Native modules (SQLite, OS keychain) come
+Current `main` requires Node.js `^22.23.4 || ^24.22.1 || ^26.12.1`; `adf`
+refuses earlier releases and 23.x/25.x because of CVE-2026-111497, and 27+
+until tested. Published npm v0.8.3 declares `>=22` and predates this check.
+See [Node.js versions](https://github.com/christianbalevski/adf/blob/main/docs/cli/index.md#nodejs-versions).
+Native modules (SQLite, OS keychain) come
 prebuilt for Windows, macOS (arm64, x64) and Linux (x64, arm64, glibc).
 
 ```bash
@@ -28,6 +34,48 @@ adf
 Upgrade: `npm i -g @agentdocumentformat/cli@latest`, then
 `adf daemon restart`.
 
+## Browser Studio
+
+With a browser-enabled CLI and daemon build:
+
+```bash
+adf web                   # start the local daemon if needed and open the browser
+adf web --port 7485        # choose another local daemon port
+adf web --no-daemon        # use an already-running daemon
+```
+
+The browser signs in through a short-lived, one-use link. No desktop app or
+manual token copying is needed. `adf web` is local-only; for another device,
+run these commands on the daemon host:
+
+```bash
+adf daemon remote on
+adf daemon remote status
+adf daemon remote allow-network <network-id-or-name>   # if not already allowed
+adf daemon pair
+```
+
+Open the printed `/studio/` address on the other device, enter the six-digit
+code and a browser name, then approve that request in the host terminal.
+Paired browsers are remembered for up to 30 days; browser sessions last eight
+hours. Signing out clears the remembered credential. Revoke access with
+`adf daemon devices revoke <id-or-label>`.
+
+These instructions describe the browser-enabled build, not published npm
+v0.8.3. From its source checkout, use `npm run build:web` followed by
+`npm run adf -- web`; `npm run build:npm` packages the browser assets with the
+CLI. See the [Browser Studio guide](https://github.com/christianbalevski/adf/blob/main/docs/guides/studio-web.md)
+for source setup, network access and browser limitations.
+
+## Local models
+
+Use Ollama, LM Studio, or any server that implements the OpenAI-compatible
+chat API. Both the server and selected model need tool calling for agent
+tools. Vision is needed only when the model must understand images or screenshots. Add the server with
+`/provider add`, using its API base URL and model ID; supply a key only if
+the server requires one. See
+[local model requirements](https://github.com/christianbalevski/adf/blob/main/docs/cli/models-and-providers.md#local-model-requirements).
+
 ## Quickstart
 
 In the terminal app (a welcome checklist opens on first run):
@@ -49,14 +97,17 @@ adf chat agent-1 "hello"
 adf events agent-1
 ```
 
-Daemon: `adf daemon status | stop | restart | logs -f | token`. Studio and
-the CLI share settings and the owner identity on one machine; `adf` does not
-start a daemon while Studio is running.
+Daemon: `adf daemon status | stop | restart | logs -f | token`. On current
+`main`, Studio in Local mode and the CLI share one daemon, settings and owner
+identity, and can run side by side. With Inside Studio (legacy), `adf`
+refuses to start a daemon on the same settings while Studio runs; switch
+Studio to Local mode or quit it first.
 
 ## Docs
 
 - [ADF CLI](https://github.com/christianbalevski/adf/blob/main/docs/cli/index.md)
 - [Getting started](https://github.com/christianbalevski/adf/blob/main/docs/cli/getting-started.md)
+- [Browser Studio](https://github.com/christianbalevski/adf/blob/main/docs/guides/studio-web.md) (browser-enabled build)
 - [Terminal app](https://github.com/christianbalevski/adf/blob/main/docs/cli/terminal-app.md)
 - [Reference](https://github.com/christianbalevski/adf/blob/main/docs/cli/reference.md): every command, flag, slash command and key
 - [Remote daemon](https://github.com/christianbalevski/adf/blob/main/docs/cli/remote-daemon.md)

package/dist/adf.mjs

@@ -5,11 +5,14 @@ import { dirname as __adfDirname } from 'node:path';
 const require = __adfCreateRequire(import.meta.url);
 const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
+import "./chunks/chunk-J2N63ZUD.mjs";
+import "./chunks/chunk-ZECGH3LT.mjs";
+import "./chunks/chunk-26RK7T5L.mjs";
 import "./chunks/chunk-M2RX3S2T.mjs";
 
 // src/main/cli/bin.ts
 function version() {
-  return "0.8.2";
+  return "0.8.4";
 }
 var DAEMON_HELP = `Usage: adf daemon [--port <n>] [--host <h>] [--settings <file>]
        adf daemon start [--port <n>] [--force]
@@ -25,9 +28,12 @@ start runs it in the background, like adf does on its own when it needs one;
 the log goes to <data dir>/logs/adf-daemon.log. stop is graceful: agents are
 unloaded and compute containers stopped.
 
-Every request but GET /health needs the daemon's access token. adf reads it
-on this machine by itself (<data dir>/daemon-token, created on first start);
-token prints it for a client elsewhere (--token or ADF_DAEMON_TOKEN there).
+CLI and REST operations use bearer authentication. adf reads this machine's
+token itself (<data dir>/daemon-token, created on first start). token prints
+it for advanced clients (--token or ADF_DAEMON_TOKEN); remote-access listeners
+require a device token instead. Browser Studio uses cookie sessions: adf web
+opens a local one-use sign-in link; adf daemon pair prints browser addresses
+and a six-digit code, then asks for approval in this terminal.
 ADF_DAEMON_TOKEN overrides the file, and is required with a non-loopback
 --host (plus ADF_DAEMON_ALLOWED_HOSTS for host names clients use).
 Behind a reverse proxy on this host set ADF_DAEMON_BEHIND_PROXY=1: identity
@@ -59,7 +65,7 @@ ${DAEMON_HELP}`);
 }
 var DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "status", "stop", "restart", "logs", "token", "remote", "devices", "pair"]);
 async function daemonSubcommand(sub, args) {
-  let control = await import("./chunks/daemon-control-MKN7G5M3.mjs"), out = (text) => {
+  let control = await import("./chunks/daemon-control-U4OGCAAJ.mjs"), out = (text) => {
     process.stdout.write(text);
   }, { url, rest } = control.daemonUrlFrom(args), target = control.daemonTarget(url), force = rest.includes("--force"), refusal = sub === "logs" || sub === "token" ? null : control.hostOnlyRefusal(sub, target);
   if (refusal)
@@ -124,7 +130,7 @@ ${advice ? `${advice}
 `), 3;
         if (await start() !== 0) return 1;
       }
-      let [{ runHostRemoteCommand }, { stdinPrompt }] = await Promise.all([import("./chunks/remote-access-cli-GLEEP7DI.mjs"), import("./chunks/prompt-RRHZX4YT.mjs")]), prompt = stdinPrompt();
+      let [{ runHostRemoteCommand }, { stdinPrompt }] = await Promise.all([import("./chunks/remote-access-cli-EFVCXFOY.mjs"), import("./chunks/prompt-RRHZX4YT.mjs")]), prompt = stdinPrompt();
       try {
         return await runHostRemoteCommand(sub, rest, {
           fetch: globalThis.fetch.bind(globalThis),
@@ -156,9 +162,6 @@ ${advice ? `${advice}
   return 2;
 }
 async function main(argv) {
-  if (Number(process.versions.node.split(".")[0]) < 22)
-    return process.stderr.write(`adf needs Node.js 22 or newer (this is ${process.version}).
-`), 1;
   let noDaemon = argv.includes("--no-daemon");
   noDaemon && (argv = argv.filter((a) => a !== "--no-daemon"));
   for (let i = 0; i < argv.length; i++) {
@@ -188,17 +191,17 @@ async function main(argv) {
 `), 2;
     }
     if (!process.env.ADF_DAEMON_PIDFILE) {
-      let { daemonPaths } = await import("./chunks/daemon-control-MKN7G5M3.mjs");
+      let { daemonPaths } = await import("./chunks/daemon-control-U4OGCAAJ.mjs");
       process.env.ADF_DAEMON_PIDFILE = daemonPaths(Number(process.env.ADF_DAEMON_PORT ?? 7385)).pidFile;
     }
-    return await import("./chunks/daemon-HEQ3FUYH.mjs"), -1;
+    return await import("./chunks/daemon-DK3KUDZJ.mjs"), -1;
   }
-  let [{ runCli, tuiInvocation }, control] = await Promise.all([import("./chunks/cli-PCVFB6B4.mjs"), import("./chunks/daemon-control-MKN7G5M3.mjs")]);
+  let [{ runCli, tuiInvocation }, control] = await Promise.all([import("./chunks/cli-JPRYEY4J.mjs"), import("./chunks/daemon-control-U4OGCAAJ.mjs")]);
   return tuiInvocation(argv) && process.env.NODE_ENV === void 0 && (process.env.NODE_ENV = "production", process.env.ADF_NODE_ENV_DEFAULTED = "1"), await runCli(argv, {
     fetch: globalThis.fetch.bind(globalThis),
     stdout: (text) => process.stdout.write(text),
     stderr: (text) => process.stderr.write(text),
-    ensureDaemon: (url) => control.ensureDaemon(url, { disabled: noDaemon })
+    ensureDaemon: (url, env) => control.ensureDaemon(url, { disabled: noDaemon, env })
   });
 }
 main(process.argv.slice(2)).then(