@agentdocumentformat/cli 0.7.8 → 0.8.0

package/dist/chunks/{daemon-control-HKFVSQTQ.mjs → chunk-PRPTKMQW.mjs}

@@ -4,22 +4,25 @@ import { dirname as __adfDirname } from 'node:path';
 const require = __adfCreateRequire(import.meta.url);
 const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
+import {
+  leaseDir,
+  listRuntimeHosts,
+  listStudioClients
+} from "./chunk-JVPZIMXW.mjs";
 import {
   DEFAULT_DAEMON_PORT,
   DEFAULT_DAEMON_URL,
   isLocalDaemonUrl,
-  localProofHeaders,
-  resolveDaemonToken
-} from "./chunk-GKKCMXIZ.mjs";
-import "./chunk-UEZR2CNS.mjs";
+  localDaemonToken,
+  localProofHeaders
+} from "./chunk-V2T6NZX2.mjs";
 import {
   defaultUserDataPath
-} from "./chunk-IHDDCZBS.mjs";
-import "./chunk-M2RX3S2T.mjs";
+} from "./chunk-PAK5JCO2.mjs";
 
 // src/main/cli/daemon-control.ts
 import { spawn, execFileSync } from "node:child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, readSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync, readSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -87,8 +90,21 @@ function readJson(file) {
     return null;
   }
 }
+function sameFile(a, b) {
+  let norm = (p) => {
+    let out = resolve(p);
+    try {
+      out = realpathSync.native(out);
+    } catch {
+    }
+    return process.platform === "linux" ? out : out.toLowerCase();
+  };
+  return norm(a) === norm(b);
+}
 async function studioConflict(paths, env = process.env, fetchImpl = fetch) {
-  let settings = readJson(paths.settingsFile) ?? {}, meshPort = Number(env.MESH_PORT) || (typeof settings.meshPort == "number" ? settings.meshPort : DEFAULT_MESH_PORT), runtimeId = typeof settings.runtimeId == "string" ? settings.runtimeId : null;
+  let registry = leaseDir({ ...process.env, ...env }), embedded = (await listRuntimeHosts(registry)).filter((h) => h.alive && h.kind === "studio-embedded"), same = embedded.find((h) => sameFile(h.settingsPath, paths.settingsFile));
+  if (same) return `ADF Studio (pid ${same.pid}) is running agents from the same settings file (${paths.settingsFile}).`;
+  let studioRegistered = embedded.length > 0 || (await listStudioClients(registry)).some((c) => c.alive), settings = readJson(paths.settingsFile) ?? {}, meshPort = Number(env.MESH_PORT) || (typeof settings.meshPort == "number" ? settings.meshPort : DEFAULT_MESH_PORT), runtimeId = typeof settings.runtimeId == "string" ? settings.runtimeId : null;
   if (runtimeId)
     try {
       let res = await fetchImpl(`http://127.0.0.1:${meshPort}/ping`, { signal: AbortSignal.timeout(800) });
@@ -96,7 +112,7 @@ async function studioConflict(paths, env = process.env, fetchImpl = fetch) {
         return `Another ADF runtime on the same settings is already running (its mesh answers on 127.0.0.1:${meshPort}), most likely ADF Studio.`;
     } catch {
     }
-  return !paths.custom && studioProcessRunning() ? "ADF Studio is running." : null;
+  return !paths.custom && !studioRegistered && studioProcessRunning() ? "ADF Studio is running." : null;
 }
 function studioProcessRunning() {
   try {
@@ -216,8 +232,15 @@ async function ensureDaemon(url, options = {}) {
   let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, target = daemonTarget(url);
   return await isHealthy(target.url, fetchImpl) || !target.loopback || !isLocalDaemonUrl(target.url, env) || options.disabled || env.ADF_NO_AUTOSTART === "1" ? null : await startDaemon(target, options);
 }
+function hostControlToken(url, env = process.env) {
+  if (daemonTarget(url).loopback)
+    return env.ADF_DAEMON_TOKEN || localDaemonToken(url, env);
+}
+function hostOnlyRefusal(sub, target) {
+  return target.loopback ? null : `adf daemon ${sub} manages this computer's ADF daemon only; run it on ${target.host}.`;
+}
 async function stopDaemon(target, options = {}) {
-  let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, paths = daemonPaths(target.port, env), record = readPidFile(paths.pidFile), token = resolveDaemonToken(void 0, env, target.url);
+  let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, paths = daemonPaths(target.port, env), record = readPidFile(paths.pidFile), token = hostControlToken(target.url, env);
   if (!await isHealthy(target.url, fetchImpl))
     return record && processAlive(record.pid) ? { stopped: !1, message: `No daemon answers ${target.url}, but pid ${record.pid} from ${paths.pidFile} is alive. It may be starting or stuck; see adf daemon logs.` } : { stopped: !0, message: `No daemon running at ${target.url}.` };
   let accepted = !1;
@@ -246,13 +269,29 @@ async function stopDaemon(target, options = {}) {
 }
 async function daemonStatus(target, options = {}) {
   let env = options.env ?? process.env, fetchImpl = options.fetch ?? fetch, paths = daemonPaths(target.port, env), running = await isHealthy(target.url, fetchImpl), record = readPidFile(paths.pidFile), lines = [`url       ${target.url}`, `status    ${running ? "running" : "not running"}`];
-  if (running)
+  if (running) {
     try {
-      let token = resolveDaemonToken(void 0, env, target.url), body = await (await fetchImpl(`${target.url}/runtime`, { headers: token ? { Authorization: `Bearer ${token}` } : {}, signal: AbortSignal.timeout(3e3) })).json();
+      let token = hostControlToken(target.url, env), body = await (await fetchImpl(`${target.url}/runtime`, { headers: token ? { Authorization: `Bearer ${token}` } : {}, signal: AbortSignal.timeout(3e3) })).json();
       body.daemon?.pid && lines.push(`pid       ${body.daemon.pid}`), typeof body.daemon?.uptime == "number" && lines.push(`uptime    ${formatUptime(body.daemon.uptime)}`), body.daemon?.version && lines.push(`version   ${body.daemon.version}`), Array.isArray(body.agents) && lines.push(`agents    ${body.agents.length} loaded`);
     } catch {
     }
-  else record && processAlive(record.pid) && lines.push(`pid       ${record.pid} (alive, not answering: starting or stuck)`);
+    try {
+      let token = hostControlToken(target.url, env), res = await fetchImpl(`${target.url}/version`, { headers: token ? { Authorization: `Bearer ${token}` } : {}, signal: AbortSignal.timeout(3e3) });
+      if (res.ok) {
+        let info = await res.json();
+        info.startedBy && lines.push(`started   by ${info.startedBy}`), info.trust?.state && info.trust.state !== "not-applicable" && lines.push(`trust     ${info.trust.state === "trusted" ? `key ${info.trust.label ?? ""} trusted by the owner` : "key not trusted"}: ${info.trust.message ?? ""}`), info.localProof && !info.localProof.available && lines.push(`proof     unavailable: ${info.localProof.problem ?? "unknown reason"} (owner import and stored-value reveal refuse until the daemon restarts with a protected proof file)`), info.keychainProblem && lines.push(`keychain  unavailable: ${info.keychainProblem}`);
+      }
+    } catch {
+    }
+    try {
+      let token = hostControlToken(target.url, env), res = await fetchImpl(`${target.url}/network/server`, { headers: token ? { Authorization: `Bearer ${token}` } : {}, signal: AbortSignal.timeout(3e3) });
+      if (res.ok) {
+        let server = await res.json();
+        typeof server.warning == "string" && server.warning && lines.push(`mesh      ${server.warning}`);
+      }
+    } catch {
+    }
+  } else record && processAlive(record.pid) && lines.push(`pid       ${record.pid} (alive, not answering: starting or stuck)`);
   return target.loopback && (lines.push(`data      ${paths.dataDir}`), lines.push(`log       ${paths.logFile}${existsSync(paths.logFile) ? "" : " (none yet)"}`)), { running, lines };
 }
 function formatUptime(seconds) {
@@ -296,23 +335,25 @@ function daemonUrlFrom(args, env = process.env) {
   let p = port ?? env.ADF_DAEMON_PORT;
   return p ? { url: `http://127.0.0.1:${p}`, rest } : { url: (env.ADF_DAEMON_URL ?? DEFAULT_DAEMON_URL).replace(/\/+$/, ""), rest };
 }
+
 export {
-  DEFAULT_DAEMON_PORT,
-  DaemonStartError,
-  STUDIO_ADVICE,
-  daemonLaunch,
-  daemonPaths,
-  daemonStatus,
   daemonTarget,
-  daemonUrlFrom,
-  ensureDaemon,
-  followLog,
-  isHealthy,
   isLoopbackHost,
-  processAlive,
+  daemonPaths,
+  isHealthy,
   readPidFile,
+  processAlive,
+  studioConflict,
+  STUDIO_ADVICE,
+  daemonLaunch,
+  DaemonStartError,
   startDaemon,
+  ensureDaemon,
+  hostControlToken,
+  hostOnlyRefusal,
   stopDaemon,
-  studioConflict,
-  tailLines
+  daemonStatus,
+  tailLines,
+  followLog,
+  daemonUrlFrom
 };