@agentconnect.md/daemon 1.0.0-rc.45 → 1.0.0-rc.47

package/dist/index.js

@@ -4,12 +4,12 @@ import { EventEmitter } from "node:events";
 import childProcess, { execFile, spawn } from "node:child_process";
 import * as sp from "node:path";
 import path, { delimiter, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import fs, { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, stat, unlinkSync, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
+import fs, { accessSync, chmodSync, constants, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, stat, unlinkSync, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import process$1 from "node:process";
 import { stripVTControlCharacters } from "node:util";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
-import { cpus, freemem, homedir, hostname, totalmem, type } from "node:os";
+import { cpus, freemem, homedir, hostname, tmpdir, totalmem, type } from "node:os";
 import { spawn as spawn$1 } from "child_process";
 import { Readable, Writable } from "node:stream";
 import { randomBytes, randomUUID } from "node:crypto";
@@ -7529,7 +7529,7 @@ function toRuntimeDef(entry) {
 	return null;
 }
 const REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
-const DEFAULT_TIMEOUT_MS = 4500;
+const DEFAULT_TIMEOUT_MS$1 = 4500;
 function readCachedDoc(root) {
 	const file = registryPath(root);
 	if (!existsSync(file)) return null;
@@ -7555,7 +7555,7 @@ async function fetchRegistry(root, opts = {}) {
 	if (meta.etag) headers["If-None-Match"] = meta.etag;
 	if (meta.lastModified) headers["If-Modified-Since"] = meta.lastModified;
 	const ac = new AbortController();
-	const timer = setTimeout(() => ac.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+	const timer = setTimeout(() => ac.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1);
 	try {
 		const res = await doFetch(REGISTRY_URL, {
 			headers,
@@ -16891,6 +16891,21 @@ CLIENT_METHODS.session_update, CLIENT_METHODS.elicitation_complete;
 //#endregion
 //#region src/acp/acp-host.ts
 const PROTOCOL_VERSION = 1;
+/**
+* Extract the model selector from a session's `configOptions`. ACP models are an
+* (experimental) session config option tagged `category: "model"`, `type:
+* "select"`; the selectable values (optionally grouped) are the model list.
+* Returns null when the agent advertises no model selector.
+*/
+function modelOptionsFrom(configOptions) {
+	const model = configOptions?.find((o) => o.category === "model" && o.type === "select");
+	if (!model || model.type !== "select") return null;
+	const models = model.options.flatMap((o) => "group" in o ? o.options : [o]).map((o) => o.value);
+	return {
+		current: model.currentValue,
+		models
+	};
+}
 var AcpHost = class {
 	runtime;
 	opts;
@@ -16900,6 +16915,7 @@ var AcpHost = class {
 	loadingSessions = /* @__PURE__ */ new Set();
 	canLoad = false;
 	promptCaps = {};
+	lastModelOptions = null;
 	constructor(runtime, opts) {
 		this.runtime = runtime;
 		this.opts = opts;
@@ -16953,9 +16969,15 @@ var AcpHost = class {
 			cwd,
 			mcpServers
 		});
+		this.lastModelOptions = modelOptionsFrom(res.configOptions);
 		this.live.add(res.sessionId);
 		return res.sessionId;
 	}
+	/** The model selector advertised by the most recent session/new, or null if the
+	*  agent exposed none. Used by the runtime probe to report available models. */
+	modelOptions() {
+		return this.lastModelOptions;
+	}
 	/** True iff THIS agent process created or loaded `sessionId` in its current lifetime. */
 	hasSession(sessionId) {
 		return this.live.has(sessionId);
@@ -81439,13 +81461,18 @@ var Scheduler = class {
 * only advertises genuinely-installed runtimes in `RegisterReq.capabilities`.
 *
 * Two layers:
-*  1. A generic launcher check — is the runtime's `command` resolvable? Most
-*     agents ship as `npx`/`uvx` packages, which fetch on demand, so the launcher
-*     being present is enough for them.
-*  2. Per-runtime custom probes (`CUSTOM_PROBES`) for the cases where (1) is too
-*     weak — almost every agent runs via `npx`, so "npx exists" is meaningless.
-*     For those we additionally look for the wrapped CLI's own config/state dir,
-*     which appears once the user has installed and run/initialized it.
+*  1. A generic launcher check — is the runtime's `command` resolvable? For a
+*     runtime distributed as a real binary (`command` is the tool's own
+*     executable) this is a meaningful signal: the binary on `$PATH` means it's
+*     installed.
+*  2. For runtimes distributed via a package launcher (`npx`/`uvx`), (1) is
+*     meaningless — the launcher fetches on demand, so "npx exists" is true on
+*     virtually every dev host and tells us nothing about the wrapped agent. For
+*     those we REQUIRE a per-runtime custom probe (`CUSTOM_PROBES`) that looks for
+*     the wrapped CLI's own config/state dir, which appears once the user has
+*     installed and run/initialized it. A launcher-distributed runtime with no
+*     probe is treated as NOT installed — otherwise every npx/uvx agent in the
+*     ACP registry would be falsely advertised just because `npx` is on `$PATH`.
 *
 * The custom probes test for the config *directory* (the "installed & initialized
 * on this host" signal). A stricter "is logged in" check would look for the auth
@@ -81511,11 +81538,18 @@ const CUSTOM_PROBES = {
 	"factory-droid": (env) => pathExists(join(home(env), ".factory")),
 	devin: (env) => anyExists(join(xdgConfigHome(env), "devin"), join(xdgDataHome(env), "devin"))
 };
+/**
+* Package launchers that fetch-and-run on demand. When a runtime is launched via
+* one of these, the launcher being on `$PATH` says nothing about whether the
+* wrapped agent is installed, so such runtimes require a custom probe to count.
+*/
+const PACKAGE_LAUNCHERS = /* @__PURE__ */ new Set(["npx", "uvx"]);
 /** Is this runtime actually usable on this host? */
 function isRuntimeAvailable(id, rt, env = process.env) {
 	if (!isCommandAvailable(rt.command, env)) return false;
 	const custom = CUSTOM_PROBES[id];
-	return custom ? custom(env) : true;
+	if (custom) return custom(env);
+	return !PACKAGE_LAUNCHERS.has(rt.command);
 }
 /**
 * Filter a runtime map down to those installed on this host — what the daemon
@@ -81527,6 +81561,89 @@ function installedRuntimes(runtimes, env = process.env) {
 	return out;
 }
 //#endregion
+//#region src/runtimes/runtime-prober.ts
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_CONCURRENCY = 3;
+function makeHost(rt, log) {
+	return new AcpHost(rt, {
+		onUpdate: () => {},
+		log
+	});
+}
+/**
+* Probe one runtime. Never throws: any failure (spawn error, handshake failure,
+* timeout) is captured in `{ ok: false, error }`. On success, `models` reflects
+* whatever the agent advertised — an empty list is normal for agents that expose
+* no model selector, and is not a failure.
+*/
+async function probeRuntime(id, rt, cwd, opts = {}) {
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const host = (opts.hostFactory ?? ((r) => makeHost(r, opts.log)))(rt);
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`probe timed out after ${timeoutMs}ms`)), timeoutMs);
+	});
+	const run = async () => {
+		await host.start();
+		await host.newSession(cwd);
+		return host.modelOptions();
+	};
+	try {
+		const models = await Promise.race([run(), timeout]);
+		opts.log?.info(`probe: ${id} ok (models: ${models?.models.length ? models.models.join(", ") : "none advertised"})`);
+		return {
+			runtime: id,
+			ok: true,
+			models: models?.models ?? [],
+			currentModel: models?.current
+		};
+	} catch (err) {
+		const error = err.message;
+		opts.log?.warn(`probe: ${id} failed — ${error}`);
+		return {
+			runtime: id,
+			ok: false,
+			models: [],
+			error
+		};
+	} finally {
+		if (timer) clearTimeout(timer);
+		await host.stop().catch(() => {});
+	}
+}
+/**
+* Probe every runtime with bounded concurrency. All probes share one temp cwd
+* (removed afterward). Result order is not meaningful — callers key by
+* `result.runtime`.
+*/
+async function probeAllRuntimes(runtimes, opts = {}) {
+	const ids = Object.keys(runtimes);
+	if (ids.length === 0) return [];
+	const cwd = mkdtempSync(join(tmpdir(), "ac-probe-"));
+	const limit = Math.max(1, opts.concurrency ?? DEFAULT_CONCURRENCY);
+	const results = [];
+	let next = 0;
+	const worker = async () => {
+		for (let i = next++; i < ids.length; i = next++) {
+			const id = ids[i];
+			results.push(await probeRuntime(id, runtimes[id], cwd, opts));
+		}
+	};
+	try {
+		await Promise.all(Array.from({ length: Math.min(limit, ids.length) }, () => worker()));
+	} finally {
+		try {
+			rmSync(cwd, {
+				recursive: true,
+				force: true
+			});
+		} catch (err) {
+			opts.log?.debug(`probe: temp cwd cleanup failed for ${cwd}: ${err.message}`);
+		}
+	}
+	return results;
+}
+//#endregion
 //#region src/log.ts
 const ORDER = {
 	trace: 10,
@@ -81728,7 +81845,17 @@ var CpClient = class {
 		this.heartbeatMs = ok.heartbeatSec > 0 ? ok.heartbeatSec * 1e3 : this.deps.heartbeatDefaultMs;
 		this.armHeartbeat();
 		this.deps.log.info(`cp: READY (epoch=${this.sessionEpoch}, routingEpoch=${this.routingEpoch})`);
-		for (const profile of this.deps.runtimeProfiles()) this.transport?.send(encode(buildEnvelope("facts/runtime-profile", profile)));
+		for (const profile of this.deps.runtimeProfiles()) this.emitRuntimeProfile(profile);
+		this.deps.onReady?.();
+	}
+	/**
+	* Push a single runtime profile mid-session (D→C EVT, fire-and-forget). No-op
+	* unless connected and READY/DRAINING — the CP only accepts control frames
+	* there, and a reconnect's handshake re-emits the latest profiles anyway.
+	*/
+	emitRuntimeProfile(profile) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("facts/runtime-profile", profile)));
 	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
@@ -82244,7 +82371,7 @@ function cpuTotals() {
 		busy
 	};
 }
-var Daemon = class {
+var Daemon = class Daemon {
 	opts;
 	store;
 	mcp;
@@ -82266,6 +82393,9 @@ var Daemon = class {
 	runtimes = {};
 	runtimeNames = {};
 	runtimeVersions = {};
+	runtimeModels = /* @__PURE__ */ new Map();
+	probing = false;
+	lastProbeAtMs = 0;
 	cpClient;
 	cpCrons;
 	cpAgents;
@@ -83216,13 +83346,8 @@ var Daemon = class {
 				acp: true,
 				features: []
 			}),
-			runtimeProfiles: () => Object.keys(this.runtimes).map((id) => ({
-				runtime: id,
-				version: this.runtimeVersions[id] ?? "",
-				models: [],
-				acpSupport: "full",
-				toolCalling: true
-			})),
+			runtimeProfiles: () => Object.keys(this.runtimes).map((id) => this.runtimeProfileFor(id)),
+			onReady: () => void this.probeRuntimesAndEmit(),
 			localState: () => ({
 				assignments: [],
 				crons: this.cpCrons?.ids() ?? [],
@@ -83244,6 +83369,54 @@ var Daemon = class {
 		this.cpClient.start();
 		this.log.info(`cp: connecting to ${url}…`);
 	}
+	/** Build the current `facts/runtime-profile` for a runtime, folding in any
+	*  models learned by the probe sweep. */
+	runtimeProfileFor(id) {
+		return {
+			runtime: id,
+			version: this.runtimeVersions[id] ?? "",
+			models: this.runtimeModels.get(id) ?? [],
+			acpSupport: "full",
+			toolCalling: true
+		};
+	}
+	/** How long a completed probe sweep stays fresh — reconnects within this window
+	*  re-emit the cached profiles instead of re-spawning every agent. */
+	static PROBE_TTL_MS = 5 * 6e4;
+	/**
+	* Probe every installed runtime in the background (launch → initialize →
+	* session/new → read models → tear down), then emit a refreshed
+	* `facts/runtime-profile` per runtime once the whole sweep completes.
+	*
+	* Triggered on each CP (re)connect. Deduped while in flight; skipped (with a
+	* cached re-emit) when the last sweep is still fresh, so a reconnect storm can't
+	* spawn a fleet of agent subprocesses. Never throws — probing is best-effort and
+	* must not affect the CP connection.
+	*/
+	async probeRuntimesAndEmit() {
+		if (this.opts.hostFactory && !this.opts.probeRuntimes) return;
+		const ids = Object.keys(this.runtimes);
+		if (ids.length === 0) return;
+		if (this.probing) return;
+		if (this.lastProbeAtMs > 0 && Date.now() - this.lastProbeAtMs < Daemon.PROBE_TTL_MS) {
+			for (const id of ids) this.cpClient?.emitRuntimeProfile(this.runtimeProfileFor(id));
+			return;
+		}
+		this.probing = true;
+		this.log.info(`probe: sweeping ${ids.length} runtime(s): ${ids.join(", ")}`);
+		try {
+			const results = await (this.opts.probeRuntimes ?? probeAllRuntimes)(this.runtimes, { log: this.log });
+			for (const r of results) this.runtimeModels.set(r.runtime, r.ok ? r.models : []);
+			this.lastProbeAtMs = Date.now();
+			const okCount = results.filter((r) => r.ok).length;
+			this.log.info(`probe: sweep complete — ${okCount}/${results.length} runtime(s) reachable`);
+			for (const id of ids) this.cpClient?.emitRuntimeProfile(this.runtimeProfileFor(id));
+		} catch (err) {
+			this.log.warn(`probe: sweep failed: ${formatErr(err)}`);
+		} finally {
+			this.probing = false;
+		}
+	}
 	async stop() {
 		this.draining = true;
 		clearTimeout(this.debounceTimer);