@agentconnect.md/daemon 1.0.0-rc.10 → 1.0.0-rc.12

package/dist/index.js

@@ -3,8 +3,8 @@ import { createRequire } from "node:module";
 import { EventEmitter } from "node:events";
 import childProcess, { execFile, spawn } from "node:child_process";
 import * as sp from "node:path";
-import path, { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
-import fs, { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
+import path, { delimiter, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import fs, { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, stat, unwatchFile, watch, watchFile, writeFileSync } from "node:fs";
 import process$1 from "node:process";
 import { stripVTControlCharacters } from "node:util";
 import { fileURLToPath } from "node:url";
@@ -7483,6 +7483,19 @@ async function fetchRegistry(root, opts = {}) {
 		clearTimeout(timer);
 	}
 }
+/**
+* Display names (registry id -> human-facing `name`) read from the local cache.
+* Used for capability reporting — the daemon advertises the tool name to the CP
+* rather than the registry id. Entries with no `name` are omitted (callers fall
+* back to the id). Returns `{}` when no cached registry doc exists.
+*/
+function cachedRuntimeNames(root) {
+	const doc = readCachedDoc(root);
+	if (!doc) return {};
+	const out = {};
+	for (const [id, entry] of Object.entries(doc.agents)) if (entry.name) out[id] = entry.name;
+	return out;
+}
 async function defaultRuntimes(root, opts = {}) {
 	const cached = (opts.mode ?? "blocking") === "cache-first" ? readCachedDoc(root) : null;
 	let doc;
@@ -79998,6 +80011,104 @@ var Scheduler = class {
 	}
 };
 //#endregion
+//#region src/runtimes/probe.ts
+/**
+* Host-availability probing for runtimes.
+*
+* `resolveRuntimes()` produces a runtime for every ACP-registry entry that has a
+* distribution for this platform — but that says nothing about whether the tool
+* is actually runnable *here*. This module answers that question so the daemon
+* 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.
+*
+* 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
+* file instead (e.g. `~/.codex/auth.json`), but that yields false negatives for
+* users who authenticate via an API-key env var, so directory presence is the
+* pragmatic signal. Paths verified against each tool's docs (June 2026).
+*/
+const isWin = process.platform === "win32";
+function isExecutableFile(p) {
+	try {
+		accessSync(p, isWin ? constants.F_OK : constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve a launcher command the way a shell would. A command containing a path
+* separator is treated as a literal path; a bare name is searched across `$PATH`
+* (trying `$PATHEXT` extensions on Windows).
+*/
+function isCommandAvailable(command, env = process.env) {
+	const exts = isWin ? ["", ...(env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")] : [""];
+	if (command.includes("/") || isWin && command.includes("\\")) return exts.some((ext) => isExecutableFile(command + ext));
+	return (env.PATH ?? "").split(delimiter).filter(Boolean).some((dir) => exts.some((ext) => isExecutableFile(join(dir, command) + ext)));
+}
+function home(env) {
+	return (isWin ? env.USERPROFILE : env.HOME) || homedir();
+}
+function xdgConfigHome(env) {
+	return env.XDG_CONFIG_HOME || join(home(env), ".config");
+}
+function xdgDataHome(env) {
+	return env.XDG_DATA_HOME || join(home(env), ".local", "share");
+}
+function pathExists(p) {
+	return !!p && existsSync(p);
+}
+/** True if any candidate path exists (undefined candidates are skipped). */
+function anyExists(...candidates) {
+	return candidates.some(pathExists);
+}
+/**
+* Custom probes keyed by ACP-registry runtime id. Add an entry here whenever the
+* launcher-on-PATH check is too weak to mean "actually installed & set up".
+* Each tests for the tool's home/XDG config dir (or, where the dir is ambiguous,
+* a tool-specific file), honoring the documented env overrides.
+*/
+const CUSTOM_PROBES = {
+	"claude-acp": (env) => anyExists(join(home(env), ".claude"), join(home(env), ".claude.json")),
+	"codex-acp": (env) => anyExists(env.CODEX_HOME, join(home(env), ".codex")),
+	gemini: (env) => pathExists(join(home(env), ".gemini")),
+	"qwen-code": (env) => pathExists(join(home(env), ".qwen")),
+	"github-copilot-cli": (env) => anyExists(env.COPILOT_HOME, join(home(env), ".copilot")),
+	cursor: (env) => anyExists(env.CURSOR_CONFIG_DIR ? join(env.CURSOR_CONFIG_DIR, "cli-config.json") : void 0, join(home(env), ".cursor", "cli-config.json")),
+	opencode: (env) => anyExists(join(xdgConfigHome(env), "opencode"), join(xdgDataHome(env), "opencode", "auth.json")),
+	goose: (env) => pathExists(join(xdgConfigHome(env), "goose")),
+	"amp-acp": (env) => anyExists(env.AMP_SETTINGS_FILE, join(xdgConfigHome(env), "amp")),
+	auggie: (env) => pathExists(join(home(env), ".augment")),
+	cline: (env) => anyExists(env.CLINE_DATA_DIR, join(home(env), ".cline")),
+	"grok-build": (env) => pathExists(join(home(env), ".grok")),
+	kimi: (env) => anyExists(env.KIMI_CODE_HOME, join(home(env), ".kimi"), join(home(env), ".kimi-code")),
+	"factory-droid": (env) => pathExists(join(home(env), ".factory")),
+	devin: (env) => anyExists(join(xdgConfigHome(env), "devin"), join(xdgDataHome(env), "devin"))
+};
+/** 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;
+}
+/**
+* Filter a runtime map down to those installed on this host — what the daemon
+* should report to the Control Plane and is able to launch.
+*/
+function installedRuntimes(runtimes, env = process.env) {
+	const out = {};
+	for (const [id, rt] of Object.entries(runtimes)) if (isRuntimeAvailable(id, rt, env)) out[id] = rt;
+	return out;
+}
+//#endregion
 //#region src/log.ts
 const ORDER = {
 	trace: 10,
@@ -80442,6 +80553,7 @@ var Daemon = class {
 	log = makeLogger("info");
 	root = "";
 	runtimes = {};
+	runtimeNames = {};
 	cpClient;
 	cpCrons;
 	botUserIds = {};
@@ -80471,11 +80583,15 @@ var Daemon = class {
 		for (const a of agents) this.agents.set(a.id, a);
 		this.log.info(`loaded ${agents.length} agent(s) from ${this.agentsDir}${agents.length ? `: ${agents.map((a) => a.id).join(", ")}` : ""}`);
 		this.root = root;
-		this.runtimes = await resolveRuntimes(cfg, root, {
+		const resolvedRuntimes = await resolveRuntimes(cfg, root, {
 			neededRuntimes: agents.map((a) => a.runtime),
 			mode: "cache-first"
 		});
+		this.runtimes = installedRuntimes(resolvedRuntimes);
+		this.runtimeNames = cachedRuntimeNames(root);
 		this.log.info(`runtimes ready: ${Object.keys(this.runtimes).join(", ") || "(none)"}`);
+		const skipped = Object.keys(resolvedRuntimes).filter((id) => !this.runtimes[id]);
+		if (skipped.length) this.log.info(`runtimes not installed (skipped): ${skipped.join(", ")}`);
 		this.store = new LocalStore(statePath(root));
 		this.cpRouting = new CpRoutingLayer({
 			load: () => {
@@ -80564,7 +80680,7 @@ var Daemon = class {
 		if (this.opts.hostFactory) host = this.opts.hostFactory(agent, onUpdate);
 		else {
 			const runtime = this.runtimes[agent.runtime];
-			if (!runtime) throw new Error(`runtime "${agent.runtime}" not in config.runtimes or ACP registry`);
+			if (!runtime) throw new Error(`runtime "${agent.runtime}" not available: not installed on this host, or absent from config.runtimes / the ACP registry`);
 			host = new AcpHost(runtime, {
 				onUpdate,
 				env: agentChildEnv(agent)
@@ -80729,7 +80845,7 @@ var Daemon = class {
 			maxAgents: this.cfg.limits.maxAgents,
 			capabilities: () => ({
 				platforms: ["slack"],
-				runtimes: Object.keys(this.runtimes),
+				runtimes: Object.keys(this.runtimes).map((id) => this.runtimeNames[id] ?? id),
 				acp: true,
 				features: []
 			}),