@agentconnect.md/daemon 1.0.0-rc.28 → 1.0.0-rc.29

package/dist/index.js

@@ -23095,27 +23095,6 @@ function watch$1(paths, options = {}) {
 }
 //#endregion
 //#region src/agents/cp-overlay.ts
-/** Apply a CP `AgentSpec` onto a local agent, returning a new overlaid agent. */
-function overlayCpSpec(base, spec) {
-	const envMap = new Map((base.runtimeOverrides?.env ?? []).map((e) => [e.name, e.value]));
-	for (const [name, value] of Object.entries(spec.env ?? {})) envMap.set(name, value);
-	const env = [...envMap].map(([name, value]) => ({
-		name,
-		value
-	}));
-	return {
-		...base,
-		name: spec.name,
-		...spec.description !== void 0 ? { description: spec.description } : {},
-		...spec.reasoningEffort !== void 0 ? { reasoningEffort: spec.reasoningEffort } : {},
-		...spec.executionMode !== void 0 ? { executionMode: spec.executionMode } : {},
-		runtimeOverrides: {
-			...base.runtimeOverrides,
-			...spec.model !== void 0 ? { model: spec.model } : {},
-			env
-		}
-	};
-}
 /**
 * Runtime config the daemon can only surface to an ACP child as environment
 * variables: ACP `session/new`/`initialize` carry no model or system-prompt
@@ -23189,10 +23168,6 @@ var LocalStore = class {
         id INTEGER PRIMARY KEY CHECK (id = 1),
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
       );
-      CREATE TABLE IF NOT EXISTS cp_agents (
-        id INTEGER PRIMARY KEY CHECK (id = 1),
-        specs TEXT
-      );
     `);
 	}
 	getSession(key) {
@@ -23226,13 +23201,6 @@ var LocalStore = class {
 			globalRules
 		});
 	}
-	getCpAgents() {
-		return this.db.prepare("SELECT specs FROM cp_agents WHERE id = 1").get();
-	}
-	setCpAgents(specs) {
-		this.db.prepare(`INSERT INTO cp_agents (id, specs) VALUES (1, @specs)
-         ON CONFLICT(id) DO UPDATE SET specs=excluded.specs`).run({ specs });
-	}
 	close() {
 		this.db.close();
 	}
@@ -81149,42 +81117,164 @@ var CpCronRegistry = class {
 	}
 };
 //#endregion
+//#region src/agents/write-agent.ts
+/**
+* Persist CP-owned agent spec onto the daemon's on-disk `agent.json`, which is
+* the SINGLE SOURCE OF TRUTH for agent config. The CP pushes an `AgentSpec`
+* (agent/upsert + the register/ok roster); we map its CP-owned fields onto the
+* matching `<agentsDir>/<id>/agent.json`:
+*
+*  - if one with that id exists  → field-level MERGE the CP-owned keys into it;
+*  - if none exists             → CREATE a new `<agentsDir>/<id>/agent.json`.
+*
+* CRITICAL: we operate on the RAW JSON TEXT (readFileSync → JSON.parse → set
+* only CP-owned keys → writeFileSync). We never serialize the parsed/interpolated
+* `LoadedAgent` — that has `${VAR}` already substituted (secrets baked in) and
+* `workspace.path` rewritten to an absolute path. Editing the raw file preserves
+* `${VAR}` templates and the original relative `workspace.path`.
+*
+* Locally-owned keys (id, status, runtime, integrations, output, permissions,
+* crons, workspace.path / pullOnNewSession / skills) are preserved untouched.
+*/
+/** Map a CP workspace mode onto the daemon's AgentSchema workspace mode. */
+function mapWorkspaceMode(mode) {
+	return mode === "scratch" ? "from-scratch" : "git-repo";
+}
+/**
+* Locate the on-disk `agent.json` whose INTERNAL `id` equals `agentId`.
+* Agents live under arbitrary directory layouts (discoverAgents walks recursively
+* and the dir name need NOT equal the id), so we must match by parsed id — never
+* assume the file sits at `<agentsDir>/<id>/agent.json`. Returns the file path, or
+* undefined if no agent with that id exists. Unparseable files are skipped.
+*/
+function findAgentFileById(agentsDir, agentId) {
+	for (const file of findAgentFiles(agentsDir)) try {
+		if (JSON.parse(readFileSync(file, "utf8")).id === agentId) return file;
+	} catch {}
+}
+/**
+* Apply the CP-owned spec fields onto a parsed raw agent.json object IN PLACE.
+* `creating` controls whether workspace.path may be set (only on create — an
+* update never overwrites a path).
+*/
+function applySpecFields(raw, spec, opts) {
+	raw.name = spec.name;
+	if (spec.description !== void 0) raw.description = spec.description;
+	if (spec.reasoningEffort !== void 0) raw.reasoningEffort = spec.reasoningEffort;
+	if (spec.executionMode !== void 0) raw.executionMode = spec.executionMode;
+	if (spec.model !== void 0 || spec.env !== void 0) {
+		const ro = typeof raw.runtimeOverrides === "object" && raw.runtimeOverrides !== null ? raw.runtimeOverrides : {};
+		if (spec.model !== void 0) ro.model = spec.model;
+		if (spec.env !== void 0) ro.env = Object.entries(spec.env).map(([name, value]) => ({
+			name,
+			value
+		}));
+		raw.runtimeOverrides = ro;
+	}
+	if (spec.workspace !== void 0) {
+		const ws = spec.workspace;
+		const existing = typeof raw.workspace === "object" && raw.workspace !== null ? raw.workspace : {};
+		existing.mode = mapWorkspaceMode(ws.mode);
+		if (ws.mode === "github") {
+			existing.gitRepo = ws.gitRepo;
+			existing.gitBranch = ws.branch;
+		}
+		if (opts.creating && existing.path === void 0) existing.path = join(opts.agentDir, "workspace");
+		raw.workspace = existing;
+	}
+}
+/**
+* Create-or-merge the CP spec onto `<agentsDir>/<agentId>/agent.json`.
+*
+* MERGE (file exists): re-read the raw JSON text, set only CP-owned keys,
+* write it back pretty-printed. Preserves ${VAR} templates, the relative
+* workspace.path, and all locally-owned keys.
+*
+* CREATE (no file): synthesize a minimal valid agent.json under a fresh
+* `<agentsDir>/<agentId>/` dir — runtime from `spec.runtime` (falling back to
+* the first known runtime + a warn), workspace translated or defaulted to
+* from-scratch, path daemon-generated.
+*/
+function writeAgentSpec(agentsDir, agentId, spec, deps) {
+	const existingFile = findAgentFileById(agentsDir, agentId);
+	if (existingFile) {
+		const raw = JSON.parse(readFileSync(existingFile, "utf8"));
+		applySpecFields(raw, spec, {
+			agentId,
+			agentDir: dirname(existingFile),
+			creating: false
+		});
+		writeFileSync(existingFile, JSON.stringify(raw, null, 2) + "\n");
+		return;
+	}
+	const agentDir = join(agentsDir, agentId);
+	const file = join(agentDir, "agent.json");
+	let runtime = spec.runtime;
+	if (!runtime) {
+		runtime = deps.knownRuntimes[0];
+		if (!runtime) throw new Error(`cannot create agent "${agentId}": spec has no runtime and no runtimes are known`);
+		deps.warn?.(`cp: agent "${agentId}" spec has no runtime; defaulting to "${runtime}"`);
+	}
+	const raw = {
+		id: agentId,
+		name: spec.name,
+		status: "active",
+		runtime,
+		workspace: {
+			mode: "from-scratch",
+			path: join(agentDir, "workspace")
+		}
+	};
+	applySpecFields(raw, spec, {
+		agentId,
+		agentDir,
+		creating: true
+	});
+	mkdirSync(agentDir, { recursive: true });
+	writeFileSync(file, JSON.stringify(raw, null, 2) + "\n");
+}
+/**
+* Delete the agent whose internal `id` is `agentId`. Called ONLY from the
+* `agent/remove` handler — unconditional. Locates the file by id (any directory
+* layout) and removes its containing dir; falls back to `<agentsDir>/<id>` when
+* no such agent exists (no-op). `discoverAgents` treats an agent.json dir as a
+* leaf, so the containing dir is the agent's own dir.
+*/
+function removeAgent(agentsDir, agentId) {
+	const existingFile = findAgentFileById(agentsDir, agentId);
+	rmSync(existingFile ? dirname(existingFile) : join(agentsDir, agentId), {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
 //#region src/cp/cp-agent-registry.ts
 var CpAgentRegistry = class {
-	io;
+	agentsDir;
+	deps;
 	onChange;
-	specs = /* @__PURE__ */ new Map();
-	constructor(io, onChange) {
-		this.io = io;
+	constructor(agentsDir, deps, onChange) {
+		this.agentsDir = agentsDir;
+		this.deps = deps;
 		this.onChange = onChange;
-		const s = io.load();
-		if (s) this.specs = new Map(Object.entries(s));
 	}
-	/** Add or replace one agent's spec (agent/upsert EVT). */
+	/** Add or merge one agent's spec onto disk (agent/upsert EVT). */
 	upsert(agentId, spec) {
-		this.specs.set(agentId, spec);
-		this.changed();
+		writeAgentSpec(this.agentsDir, agentId, spec, this.deps);
+		this.onChange();
 	}
-	/** Drop one agent's spec (agent/remove EVT). No-op if absent. */
+	/** Delete one agent's on-disk dir (agent/remove EVT). Unconditional. */
 	remove(agentId) {
-		if (this.specs.delete(agentId)) this.changed();
+		removeAgent(this.agentsDir, agentId);
+		this.onChange();
 	}
-	/** Make the live set exactly `roster` (register/ok reconcile snapshot). */
+	/**
+	* Apply the register/ok reconcile roster: create-or-merge EACH entry and
+	* NOTHING else. Never prunes agents absent from the roster (deletion is only
+	* via agent/remove).
+	*/
 	converge(roster) {
-		const next = /* @__PURE__ */ new Map();
-		for (const { agentId, ...spec } of roster) next.set(agentId, spec);
-		this.specs = next;
-		this.changed();
-	}
-	get(agentId) {
-		return this.specs.get(agentId);
-	}
-	/** agentIds the CP currently wants present. */
-	ids() {
-		return [...this.specs.keys()];
-	}
-	changed() {
-		this.io.save(Object.fromEntries(this.specs));
+		for (const { agentId, ...spec } of roster) writeAgentSpec(this.agentsDir, agentId, spec, this.deps);
 		this.onChange();
 	}
 };
@@ -81340,12 +81430,9 @@ var Daemon = class {
 			},
 			save: (s) => this.store.setCpRouting(s.routingEpoch, JSON.stringify(s.assignments), JSON.stringify(s.globalRules))
 		});
-		this.cpAgents = new CpAgentRegistry({
-			load: () => {
-				const row = this.store.getCpAgents();
-				return row ? JSON.parse(row.specs) : void 0;
-			},
-			save: (s) => this.store.setCpAgents(JSON.stringify(s))
+		this.cpAgents = new CpAgentRegistry(this.agentsDir, {
+			knownRuntimes: Object.keys(this.runtimes),
+			warn: (m) => this.log.warn(m)
 		}, () => void this.reconcile().catch((err) => this.log.error(`cp: agent reconcile failed: ${err.stack ?? err}`)));
 		for (const a of this.effectiveAgents()) this.agents.set(a.id, a);
 		this.mcp = new McpControlServer({
@@ -81436,16 +81523,13 @@ var Daemon = class {
 		return this.opts.agentName ? [selectAgent(this.agentsDir, this.opts.agentName)] : loadAgents(this.agentsDir);
 	}
 	/**
-	* Effective agent set = on-disk `agent.json` base with the CP spec overlaid
-	* (joined by id; CP owns name/description/model/reasoning/execution/env, the
-	* file owns runtime/workspace). CP-only ids with no local base are skipped —
-	* not runnable — and surfaced via cpDegradedScopes().
+	* Effective agent set = the on-disk `agent.json` files verbatim. The CP spec is
+	* no longer overlaid in memory — `agent/upsert` writes it straight to disk (see
+	* cp/cp-agent-registry.ts → agents/write-agent.ts), so the loaded file already
+	* carries the CP-owned fields.
 	*/
 	effectiveAgents() {
-		return [...this.fileAgents.values()].map((base) => {
-			const spec = this.cpAgents?.get(base.id);
-			return spec ? overlayCpSpec(base, spec) : base;
-		});
+		return [...this.fileAgents.values()];
 	}
 	/**
 	* Converge the running set to the desired effective agents. Driven by both the
@@ -81623,13 +81707,12 @@ var Daemon = class {
 	}
 	/**
 	* agentIds the daemon can't fully serve: CP routing rules with no servable
-	* Slack integration, plus CP agent specs with no on-disk base (no runtime /
-	* workspace to materialize — the spec alone can't be run).
+	* Slack integration. (CP agent specs are now written to disk and create a
+	* runnable agent.json, so they no longer contribute a "no base" degraded scope.)
 	*/
 	cpDegradedScopes() {
 		const out = /* @__PURE__ */ new Set();
 		for (const cpRule of this.cpRouting?.effectiveRules() ?? []) if (!this.resolveCpAgent(cpRule.agentId)) out.add(cpRule.agentId);
-		for (const id of this.cpAgents?.ids() ?? []) if (!this.fileAgents.has(id)) out.add(id);
 		return [...out];
 	}
 	async dispatch(agentId, msg, integrationId) {