@agentconnect.md/daemon 1.0.0-rc.23 → 1.0.0-rc.24

package/dist/index.js

@@ -16741,6 +16741,9 @@ var AcpHost = class {
 	opts;
 	child;
 	conn;
+	live = /* @__PURE__ */ new Set();
+	loadingSessions = /* @__PURE__ */ new Set();
+	canLoad = false;
 	constructor(runtime, opts) {
 		this.runtime = runtime;
 		this.opts = opts;
@@ -16764,6 +16767,7 @@ var AcpHost = class {
 		const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
 		const self = this;
 		this.conn = client({ name: "agentconnect" }).onNotification(methods.client.session.update, (ctx) => {
+			if (self.loadingSessions.has(ctx.params.sessionId)) return;
 			self.opts.onUpdate(ctx.params.sessionId, ctx.params.update);
 		}).onRequest(methods.client.session.requestPermission, (ctx) => {
 			const optionId = (ctx.params.options.find((o) => o.kind === "allow_once" || o.kind === "allow_always") ?? ctx.params.options[0])?.optionId;
@@ -16772,19 +16776,52 @@ var AcpHost = class {
 				optionId
 			} : { outcome: "cancelled" } };
 		}).connect(stream);
-		await this.conn.agent.request(methods.agent.initialize, {
+		const init = await this.conn.agent.request(methods.agent.initialize, {
 			protocolVersion: PROTOCOL_VERSION,
 			clientCapabilities: { fs: {
 				readTextFile: false,
 				writeTextFile: false
 			} }
 		});
+		this.canLoad = init.agentCapabilities?.loadSession ?? false;
+		this.opts.log?.debug(`acp: agent initialized (loadSession capability=${this.canLoad})`);
 	}
 	async newSession(cwd) {
-		return (await this.conn.agent.request(methods.agent.session.new, {
+		const res = await this.conn.agent.request(methods.agent.session.new, {
 			cwd,
 			mcpServers: []
-		})).sessionId;
+		});
+		this.live.add(res.sessionId);
+		return res.sessionId;
+	}
+	/** True iff THIS agent process created or loaded `sessionId` in its current lifetime. */
+	hasSession(sessionId) {
+		return this.live.has(sessionId);
+	}
+	/** Whether the agent advertised the `loadSession` capability (session/load is usable). */
+	loadSupported() {
+		return this.canLoad;
+	}
+	/** Resume a previously-created session by id (ACP `session/load`). The agent
+	*  restores its own history server-side; its replayed session/update stream is
+	*  suppressed so it isn't re-posted. Throws if the agent can't load the id
+	*  (caller falls back to newSession). */
+	async loadSession(sessionId, cwd) {
+		this.loadingSessions.add(sessionId);
+		try {
+			await this.conn.agent.request(methods.agent.session.load, {
+				sessionId,
+				cwd,
+				mcpServers: []
+			});
+			this.live.add(sessionId);
+			this.opts.log?.info(`acp: resumed session ${sessionId} via session/load`);
+		} catch (err) {
+			this.opts.log?.debug(`acp: session/load failed for ${sessionId} (${err.message}) — will recreate`);
+			throw err;
+		} finally {
+			this.loadingSessions.delete(sessionId);
+		}
 	}
 	async prompt(sessionId, blocks) {
 		return (await this.conn.agent.request(methods.agent.session.prompt, {
@@ -21140,7 +21177,7 @@ const defaultExec = (cmd, args) => new Promise((resolve) => {
 /** macOS launchd controller. Writes a LaunchAgent plist that runs
 *  `<node> <cli-entry> run`, and drives it with `launchctl bootstrap/bootout`
 *  (falling back to legacy `load/unload` on older macOS). */
-const LABEL = "co.sentio.agentconnect";
+const LABEL = "md.agentconnect.daemon";
 function buildPlist(a) {
 	const env = a.includeRootEnv ? `  <key>EnvironmentVariables</key>\n  <dict>\n    <key>AGENTCONNECT_ROOT</key>\n    <string>${a.root}</string>\n  </dict>\n` : "";
 	return `<?xml version="1.0" encoding="UTF-8"?>
@@ -22949,11 +22986,36 @@ function watch$1(paths, options = {}) {
 }
 //#endregion
 //#region src/reconciler/reconciler.ts
-function diffAgents(desired, actualIds) {
+/** Stable identity-free signature of an agent's effective config. Excludes the
+*  loader-only `dir`/`env` fields (present on `LoadedAgent`) so the comparison is
+*  over the agent's behaviour, not where it was found. Both sides are the LOADED
+*  form (interpolated, path-absolutized), so this is apples-to-apples and stable
+*  across re-serialization (zod key order is fixed by the schema). */
+function signature(a) {
+	const { dir, env, ...rest } = a;
+	return JSON.stringify(rest);
+}
+/**
+* Diff desired (freshly loaded active agents) against the running set.
+* - `toStart`   — desired ids not currently running.
+* - `toStop`    — running ids no longer desired.
+* - `toRestart` — same id, changed config (runtime/workspace/integrations/…): the
+*   host must be evicted so the next session picks up fresh config (design §5.2).
+*   Without this, an in-place edit to an existing agent.json is silently a no-op.
+*/
+function diffAgents(desired, actual) {
 	const desiredIds = new Set(desired.map((a) => a.id));
+	const toStart = [];
+	const toRestart = [];
+	for (const a of desired) {
+		const cur = actual.get(a.id);
+		if (!cur) toStart.push(a);
+		else if (signature(cur) !== signature(a)) toRestart.push(a);
+	}
 	return {
-		toStart: desired.filter((a) => !actualIds.includes(a.id)),
-		toStop: actualIds.filter((id) => !desiredIds.has(id))
+		toStart,
+		toStop: [...actual.keys()].filter((id) => !desiredIds.has(id)),
+		toRestart
 	};
 }
 //#endregion
@@ -23057,6 +23119,24 @@ var SessionManager = class {
 				updatedAt: Date.now()
 			};
 			this.deps.store.upsertSession(rec);
+		} else if (host.hasSession?.(rec.acpSessionId) === false) {
+			const cwd = await prepareWorkspace(agent);
+			let resumed = false;
+			if (host.loadSupported?.()) try {
+				await host.loadSession(rec.acpSessionId, cwd);
+				resumed = true;
+			} catch {}
+			if (!resumed) {
+				const acpSessionId = await host.newSession(cwd);
+				rec = {
+					...rec,
+					acpSessionId,
+					state: "idle",
+					lastDeliveredTs: null,
+					updatedAt: Date.now()
+				};
+				this.deps.store.upsertSession(rec);
+			}
 		}
 		const gap = this.deps.store.transcriptSince(msg.channel, thread, rec.lastDeliveredTs);
 		const blocks = [];
@@ -23128,11 +23208,8 @@ function routeRules(msg, rules, threadOwner) {
 	if (msg.thread) {
 		const owner = threadOwner(msg.channel, msg.thread);
 		if (owner) {
-			const reachable = new Set(scopeCandidates.map((r) => r.agentId));
-			if (reachable.has(owner)) {
-				if (reachable.size === 1) return pickRule(scopeCandidates.find((x) => x.agentId === owner));
-				return null;
-			}
+			const ownerRule = scopeCandidates.find((x) => x.agentId === owner);
+			if (ownerRule) return pickRule(ownerRule);
 		}
 	}
 	const layer = kindCandidates.some((r) => r.source === "cp" && r.scope.channel === msg.channel && (r.scope.thread === void 0 || r.scope.thread === msg.thread)) ? kindCandidates.filter((r) => r.source === "cp") : kindCandidates;
@@ -80577,11 +80654,17 @@ var SystemClock = class {
 const systemClock = new SystemClock();
 //#endregion
 //#region src/daemon.ts
-const LOADING_MSGS = [
-	"Working on it…",
-	"Crunching through it…",
-	"Hang tight…"
-];
+/** Format an error for logs, surfacing a JSON-RPC/ACP RequestError's `code` and
+*  `data` — for an agent-side `Internal error` the actionable detail (the adapter's
+*  underlying exception) lives in `data`, which a bare `.stack` discards. */
+function formatErr(err) {
+	const e = err;
+	if (e && typeof e.code === "number") {
+		const data = e.data === void 0 ? "" : ` data=${typeof e.data === "string" ? e.data : JSON.stringify(e.data)}`;
+		return `${e.name ?? "Error"}: ${e.message ?? ""} (code=${e.code})${data}`;
+	}
+	return e?.stack ?? String(err);
+}
 const MAX_QUEUED_PER_SESSION = 10;
 var Daemon = class {
 	opts;
@@ -80657,7 +80740,7 @@ var Daemon = class {
 			agentById: (id) => this.agents.get(id)
 		});
 		this.scheduler = new Scheduler({
-			onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${err.stack ?? err}`)),
+			onFire: (agentId, msg) => void this.dispatch(agentId, msg).catch((err) => this.log.error(`cron dispatch failed for agent "${agentId}": ${formatErr(err)}`)),
 			newTraceId: () => randomUUID()
 		});
 		const groups = consolidate(agents);
@@ -80707,7 +80790,10 @@ var Daemon = class {
 		return this.opts.agentName ? [selectAgent(this.agentsDir, this.opts.agentName)] : loadAgents(this.agentsDir);
 	}
 	async reconcile() {
-		const { toStart, toStop } = diffAgents(this.loadAgentList(), [...this.agents.keys()]);
+		const desired = this.loadAgentList();
+		const { toStart, toStop, toRestart } = diffAgents(desired, this.agents);
+		if (toStart.length || toStop.length || toRestart.length) this.log.info(`reconcile: ${desired.length} desired agent(s) from ${this.agentsDir}; start=[${toStart.map((a) => a.id).join(", ")}] stop=[${toStop.join(", ")}] restart=[${toRestart.map((a) => a.id).join(", ")}]`);
+		else this.log.debug(`reconcile: no changes (${desired.length} desired agent(s))`);
 		for (const id of toStop) {
 			const host = this.hosts.get(id);
 			if (host) {
@@ -80717,6 +80803,15 @@ var Daemon = class {
 			this.hostStarts.delete(id);
 			this.agents.delete(id);
 		}
+		for (const a of toRestart) {
+			const host = this.hosts.get(a.id);
+			if (host) {
+				await host.stop();
+				this.hosts.delete(a.id);
+			}
+			this.hostStarts.delete(a.id);
+			this.agents.set(a.id, a);
+		}
 		for (const a of toStart) this.agents.set(a.id, a);
 	}
 	ensureHost(agentId, cfg) {
@@ -80730,7 +80825,8 @@ var Daemon = class {
 			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)
+				env: agentChildEnv(agent),
+				log: this.log
 			});
 		}
 		this.hosts.set(agentId, host);
@@ -80755,7 +80851,7 @@ var Daemon = class {
 			return;
 		}
 		this.log.info(`routing: ch=${msg.channel} → agent "${result.agentId}" (integration ${result.integrationId})`);
-		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${err.stack ?? err}`));
+		this.dispatch(result.agentId, msg, result.integrationId).catch((err) => this.log.error(`dispatch failed for agent "${result.agentId}": ${formatErr(err)}`));
 	}
 	queued = /* @__PURE__ */ new Map();
 	/**
@@ -80844,7 +80940,7 @@ var Daemon = class {
 		const replyConn = this.replyConnFor(agentId, integrationId);
 		const wasRunning = this.hostStarts.has(agentId);
 		const statusThread = msg.thread ?? msg.msgId;
-		replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…", LOADING_MSGS);
+		replyConn?.setStatus(msg.channel, statusThread, wasRunning ? "is thinking…" : "is starting up…");
 		const { sessionId, blocks } = await this.sessions.handle(agentId, msg);
 		this.pending.set(sessionId, {
 			conv,
@@ -80854,7 +80950,7 @@ var Daemon = class {
 		});
 		try {
 			const host = await this.ensureHostAsync(agentId);
-			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…", LOADING_MSGS);
+			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
 			await host.prompt(sessionId, blocks);
 			for (const action of conv.onFinal(`local://session/${sessionId}`)) await this.applyAction(action, replyConn, msg.channel, statusThread);
 		} finally {
@@ -80862,10 +80958,10 @@ var Daemon = class {
 		}
 		this.flushQueued(agentId, sessionId, integrationId);
 	}
-	/** Route a converger action: set-status → setStatus (loading_messages only when not clearing); else postMessage. */
+	/** Route a converger action: set-status → setStatus (status text only; '' clears); else postMessage. */
 	async applyAction(action, conn, channel, thread) {
 		if (action.kind === "set-status") {
-			if (conn && thread) await conn.setStatus(channel, thread, action.text, action.text ? LOADING_MSGS : void 0);
+			if (conn && thread) await conn.setStatus(channel, thread, action.text);
 			return;
 		}
 		await conn?.postMessage(channel, action.text, thread);