@agentdocumentformat/cli 0.7.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Balevski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @agentdocumentformat/cli
+
+The ADF CLI: the ADF (Agent Document Format) daemon, command line and terminal app. An ADF agent is a single `.adf` file: config, memory, files and history in one document. This package runs your agents headless from a terminal, with no desktop app. For the desktop app (ADF Studio), see the [releases](https://github.com/christianbalevski/adf/releases).
+
+## Install
+
+Requires Node.js 22 or newer.
+
+```bash
+npm i -g @agentdocumentformat/cli
+adf
+```
+
+Native modules (SQLite, OS keychain) install from prebuilt binaries; no compiler is needed on Windows, macOS (arm64/x64) or Linux (x64/arm64, glibc).
+
+## Use
+
+```bash
+adf                   # the terminal app; starts the daemon in the background if needed
+adf agents            # one-shot CLI commands; `adf help` lists them
+adf daemon status     # the background daemon: status | stop | restart | logs -f
+adf daemon            # or run the daemon in the foreground (http://127.0.0.1:7385)
+adf --version
+```
+
+The daemon keeps running after you quit the terminal app (`adf daemon stop` stops it gracefully). It is only started automatically for a daemon URL on this machine, never next to a running ADF Studio, and not with `--no-daemon` / `ADF_NO_AUTOSTART=1`. `adf --url http://127.0.0.1:7400` (or `ADF_DAEMON_URL`) targets, and if needed starts, a daemon on another port. Other daemon settings: `ADF_DAEMON_HOST`, `ADF_DAEMON_SETTINGS` (settings JSON path), `ADF_USER_DATA_DIR`, `ADF_DAEMON_TOKEN` (required off loopback).
+
+The daemon shares its settings file with ADF Studio on the same machine by default, so providers and tracked directories you set up in Studio carry over.
+
+## Identity and sign-in
+
+- `adf identity` shows the owner identity status; `adf identity create` / `adf identity restore` sets it up (the seed phrase is typed at a hidden prompt; the same phrase as Studio means the same owner). The phrase is kept in the OS keychain, or a passphrase-protected file where no keychain exists (`adf identity unlock`).
+- `adf providers` lists model providers; `adf auth <provider>` signs in to subscription providers (ChatGPT, Grok) from the terminal.
+- `adf new` creates an agent from a template, sealed with the owner identity.
+
+## Docs
+
+- [Daemon getting started](https://github.com/christianbalevski/adf/blob/main/docs/daemon/getting-started.md)
+- [CLI reference](https://github.com/christianbalevski/adf/blob/main/docs/daemon/cli.md)
+- [Terminal app](https://github.com/christianbalevski/adf/blob/main/docs/daemon/tui.md)
+- [HTTP API](https://github.com/christianbalevski/adf/blob/main/docs/daemon/http-api.md)
+
+## License
+
+MIT

package/dist/adf.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+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 "./chunks/chunk-M2RX3S2T.mjs";
+
+// src/main/cli/bin.ts
+function version() {
+  return "0.7.2";
+}
+var DAEMON_HELP = `Usage: adf daemon [--port <n>] [--host <h>] [--settings <file>]
+       adf daemon start [--port <n>] [--force]
+       adf daemon status | stop | restart [--port <n>]
+       adf daemon logs [-f] [-n <lines>] [--port <n>]
+       adf daemon token
+
+Without a subcommand the daemon runs in the foreground (Ctrl+C stops it).
+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).
+ADF_DAEMON_TOKEN overrides the file, and is required with a non-loopback
+--host (plus ADF_DAEMON_ALLOWED_HOSTS for host names clients use).
+
+Environment: ADF_DAEMON_PORT, ADF_DAEMON_HOST, ADF_DAEMON_SETTINGS,
+ADF_USER_DATA_DIR, ADF_DAEMON_PIDFILE, ADF_DAEMON_TOKEN,
+ADF_DAEMON_ALLOWED_HOSTS`;
+function applyDaemonArgs(args, env = process.env) {
+  for (let i = 0; i < args.length; i++) {
+    let arg = args[i], [flag, inline] = arg.startsWith("--") && arg.includes("=") ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, void 0], value = () => {
+      let v = inline ?? args[++i];
+      if (v === void 0) throw new Error(`${flag} requires a value`);
+      return v;
+    };
+    if (flag === "--port" || flag === "-p") env.ADF_DAEMON_PORT = value();
+    else if (flag === "--host") env.ADF_DAEMON_HOST = value();
+    else if (flag === "--settings") env.ADF_DAEMON_SETTINGS = value();
+    else throw new Error(`Unknown daemon option: ${arg}
+
+${DAEMON_HELP}`);
+  }
+}
+var DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "status", "stop", "restart", "logs", "token"]);
+async function daemonSubcommand(sub, args) {
+  let control = await import("./chunks/daemon-control-WDX7PMTC.mjs"), out = (text) => {
+    process.stdout.write(text);
+  }, { url, rest } = control.daemonUrlFrom(args), target = control.daemonTarget(url), force = rest.includes("--force"), start = async () => {
+    if (await control.isHealthy(target.url))
+      return out(`The ADF daemon is already running at ${target.url}.
+`), 0;
+    try {
+      return await control.startDaemon(target, { force }), 0;
+    } catch (err) {
+      let advice = err.advice;
+      return process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+${advice ? `${advice}
+` : ""}`), 1;
+    }
+  };
+  switch (sub) {
+    case "start":
+      return await start();
+    case "status": {
+      let { running, lines } = await control.daemonStatus(target);
+      return out(`${lines.join(`
+`)}
+`), running ? 0 : 3;
+    }
+    case "stop": {
+      out(`Stopping the ADF daemon at ${target.url}\u2026
+`);
+      let result = await control.stopDaemon(target);
+      return out(`${result.message}
+`), result.stopped ? 0 : 1;
+    }
+    case "restart": {
+      if (await control.isHealthy(target.url)) {
+        out(`Stopping the ADF daemon at ${target.url}\u2026
+`);
+        let result = await control.stopDaemon(target);
+        if (out(`${result.message}
+`), !result.stopped) return 1;
+      }
+      return await start();
+    }
+    case "token": {
+      if (process.env.ADF_DAEMON_TOKEN)
+        return process.stderr.write(`(from ADF_DAEMON_TOKEN)
+`), out(`${process.env.ADF_DAEMON_TOKEN}
+`), 0;
+      let { ensureDaemonToken } = await import("./chunks/daemon-token-WRSULP7G.mjs"), { token, path } = ensureDaemonToken(control.daemonPaths(target.port).dataDir);
+      return process.stderr.write(`(${path})
+`), out(`${token}
+`), 0;
+    }
+    case "logs": {
+      let follow = rest.includes("-f") || rest.includes("--follow"), at = rest.findIndex((a) => a === "-n" || a === "--lines"), lines = at >= 0 && Number(rest[at + 1]) || 50, file = control.daemonPaths(target.port).logFile;
+      if (!follow) {
+        let tail = control.tailLines(file, lines);
+        return out(tail ? `${tail}
+` : `No log yet at ${file} (it is written by a daemon adf started in the background).
+`), 0;
+      }
+      return out(`${file} (Ctrl+C stops following)
+`), await control.followLog(file, { lines, follow: !0, write: out }), 0;
+    }
+  }
+  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"));
+  let [command, ...rest] = argv;
+  if (command === "--version" || command === "-v" || command === "version")
+    return process.stdout.write(`${version()}
+`), 0;
+  if (command === "daemon") {
+    if (rest.includes("--help") || rest.includes("-h"))
+      return process.stdout.write(`${DAEMON_HELP}
+`), 0;
+    if (rest[0] && DAEMON_SUBCOMMANDS.has(rest[0])) return await daemonSubcommand(rest[0], rest.slice(1));
+    try {
+      applyDaemonArgs(rest);
+    } catch (err) {
+      return process.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`), 2;
+    }
+    if (!process.env.ADF_DAEMON_PIDFILE) {
+      let { daemonPaths } = await import("./chunks/daemon-control-WDX7PMTC.mjs");
+      process.env.ADF_DAEMON_PIDFILE = daemonPaths(Number(process.env.ADF_DAEMON_PORT ?? 7385)).pidFile;
+    }
+    return await import("./chunks/daemon-ZC3FZ2P4.mjs"), -1;
+  }
+  let [{ runCli, tuiInvocation }, control] = await Promise.all([import("./chunks/cli-TCMBNZF6.mjs"), import("./chunks/daemon-control-WDX7PMTC.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 })
+  });
+}
+main(process.argv.slice(2)).then(
+  (code) => {
+    code >= 0 && (process.exitCode = code);
+  },
+  (err) => {
+    process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}
+`), process.exitCode = 1;
+  }
+);
+export {
+  applyDaemonArgs
+};

package/dist/chunks/APEv2Parser-2CNNHMXV.mjs

@@ -0,0 +1,22 @@
+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 {
+  APEv2Parser,
+  ApeContentError,
+  tryParseApeHeader
+} from "./chunk-NBTUWMGP.mjs";
+import "./chunk-XX7OSWTO.mjs";
+import "./chunk-HBUENVQL.mjs";
+import "./chunk-I2HJYHFT.mjs";
+import "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import "./chunk-M2RX3S2T.mjs";
+export {
+  APEv2Parser,
+  ApeContentError,
+  tryParseApeHeader
+};

package/dist/chunks/AiffParser-7BR4RL6G.mjs

@@ -0,0 +1,162 @@
+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 {
+  ID3v2Parser
+} from "./chunk-XYTWGHFS.mjs";
+import "./chunk-VAUOM3IN.mjs";
+import "./chunk-DXWDD5XJ.mjs";
+import {
+  FourCcToken
+} from "./chunk-NBTUWMGP.mjs";
+import "./chunk-XX7OSWTO.mjs";
+import {
+  EndOfStreamError,
+  fromBuffer
+} from "./chunk-HBUENVQL.mjs";
+import {
+  BasicParser,
+  StringType,
+  UINT16_BE,
+  UINT32_BE,
+  UINT8,
+  Uint8ArrayType,
+  makeUnexpectedFileContentError
+} from "./chunk-I2HJYHFT.mjs";
+import {
+  require_src
+} from "./chunk-AUYKRQPJ.mjs";
+import "./chunk-NZ7JTHEO.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/music-metadata/lib/aiff/AiffParser.js
+var import_debug = __toESM(require_src(), 1);
+
+// node_modules/music-metadata/lib/aiff/AiffToken.js
+var compressionTypes = {
+  NONE: "not compressed	PCM	Apple Computer",
+  sowt: "PCM (byte swapped)",
+  fl32: "32-bit floating point IEEE 32-bit float",
+  fl64: "64-bit floating point IEEE 64-bit float	Apple Computer",
+  alaw: "ALaw 2:1	8-bit ITU-T G.711 A-law",
+  ulaw: "\xB5Law 2:1	8-bit ITU-T G.711 \xB5-law	Apple Computer",
+  ULAW: "CCITT G.711 u-law 8-bit ITU-T G.711 \xB5-law",
+  ALAW: "CCITT G.711 A-law 8-bit ITU-T G.711 A-law",
+  FL32: "Float 32	IEEE 32-bit float "
+}, AiffContentError = class extends makeUnexpectedFileContentError("AIFF") {
+}, Common = class {
+  constructor(header, isAifc) {
+    this.isAifc = isAifc;
+    let minimumChunkSize = isAifc ? 22 : 18;
+    if (header.chunkSize < minimumChunkSize)
+      throw new AiffContentError(`COMMON CHUNK size should always be at least ${minimumChunkSize}`);
+    this.len = header.chunkSize;
+  }
+  get(buf, off) {
+    let shift = UINT16_BE.get(buf, off + 8) - 16398, baseSampleRate = UINT16_BE.get(buf, off + 8 + 2), res = {
+      numChannels: UINT16_BE.get(buf, off),
+      numSampleFrames: UINT32_BE.get(buf, off + 2),
+      sampleSize: UINT16_BE.get(buf, off + 6),
+      sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
+    };
+    if (this.isAifc) {
+      if (res.compressionType = FourCcToken.get(buf, off + 18), this.len > 22) {
+        let strLen = UINT8.get(buf, off + 22);
+        if (strLen > 0) {
+          let padding = (strLen + 1) % 2;
+          if (23 + strLen + padding === this.len)
+            res.compressionName = new StringType(strLen, "latin1").get(buf, off + 23);
+          else
+            throw new AiffContentError("Illegal pstring length");
+        } else
+          res.compressionName = void 0;
+      }
+    } else
+      res.compressionName = "PCM";
+    return res;
+  }
+};
+
+// node_modules/music-metadata/lib/iff/index.js
+var Header = {
+  len: 8,
+  get: (buf, off) => ({
+    // Chunk type ID
+    chunkID: FourCcToken.get(buf, off),
+    // Chunk size
+    chunkSize: Number(BigInt(UINT32_BE.get(buf, off + 4)))
+  })
+};
+
+// node_modules/music-metadata/lib/aiff/AiffParser.js
+var debug = (0, import_debug.default)("music-metadata:parser:aiff"), AIFFParser = class extends BasicParser {
+  constructor() {
+    super(...arguments), this.isCompressed = null;
+  }
+  async parse() {
+    if ((await this.tokenizer.readToken(Header)).chunkID !== "FORM")
+      throw new AiffContentError("Invalid Chunk-ID, expected 'FORM'");
+    let type = await this.tokenizer.readToken(FourCcToken);
+    switch (type) {
+      case "AIFF":
+        this.metadata.setFormat("container", type), this.isCompressed = !1;
+        break;
+      case "AIFC":
+        this.metadata.setFormat("container", "AIFF-C"), this.isCompressed = !0;
+        break;
+      default:
+        throw new AiffContentError(`Unsupported AIFF type: ${type}`);
+    }
+    this.metadata.setFormat("lossless", !this.isCompressed), this.metadata.setAudioOnly();
+    try {
+      for (; !this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= Header.len; ) {
+        debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
+        let chunkHeader = await this.tokenizer.readToken(Header), nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2), bytesRead = await this.readData(chunkHeader);
+        await this.tokenizer.ignore(nextChunk - bytesRead);
+      }
+    } catch (err) {
+      if (err instanceof EndOfStreamError)
+        debug("End-of-stream");
+      else
+        throw err;
+    }
+  }
+  async readData(header) {
+    switch (header.chunkID) {
+      case "COMM": {
+        if (this.isCompressed === null)
+          throw new AiffContentError("Failed to parse AIFF.COMM chunk when compression type is unknown");
+        let common = await this.tokenizer.readToken(new Common(header, this.isCompressed));
+        return this.metadata.setFormat("bitsPerSample", common.sampleSize), this.metadata.setFormat("sampleRate", common.sampleRate), this.metadata.setFormat("numberOfChannels", common.numChannels), this.metadata.setFormat("numberOfSamples", common.numSampleFrames), this.metadata.setFormat("duration", common.numSampleFrames / common.sampleRate), (common.compressionName || common.compressionType) && this.metadata.setFormat("codec", common.compressionName ?? compressionTypes[common.compressionType]), header.chunkSize;
+      }
+      case "ID3 ": {
+        let id3_data = await this.tokenizer.readToken(new Uint8ArrayType(header.chunkSize)), rst = fromBuffer(id3_data);
+        return await new ID3v2Parser().parse(this.metadata, rst, this.options), header.chunkSize;
+      }
+      case "SSND":
+        return this.metadata.format.duration && this.metadata.setFormat("bitrate", 8 * header.chunkSize / this.metadata.format.duration), 0;
+      case "NAME":
+      // Sample name chunk
+      case "AUTH":
+      // Author chunk
+      case "(c) ":
+      // Copyright chunk
+      case "ANNO":
+        return this.readTextChunk(header);
+      default:
+        return debug(`Ignore chunk id=${header.chunkID}, size=${header.chunkSize}`), 0;
+    }
+  }
+  async readTextChunk(header) {
+    let values = (await this.tokenizer.readToken(new StringType(header.chunkSize, "ascii"))).split("\0").map((v) => v.trim()).filter((v) => v?.length);
+    return await Promise.all(values.map((v) => this.metadata.addTag("AIFF", header.chunkID, v))), header.chunkSize;
+  }
+};
+export {
+  AIFFParser
+};