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

package/dist/index.js

@@ -12768,6 +12768,7 @@ var simpleGit = gitInstanceFactory;
 //#endregion
 //#region src/workspace/workspace-manager.ts
 const PULL_TIMEOUT_MS = 4500;
+const cloneInFlight = /* @__PURE__ */ new Map();
 async function prepareWorkspace(agent) {
 	const cwd = agent.workspace.path;
 	mkdirSync(cwd, { recursive: true });
@@ -12776,11 +12777,52 @@ async function prepareWorkspace(agent) {
 		if (!existsSync(mem)) writeFileSync(mem, `# ${agent.name} memory\n`);
 		return cwd;
 	}
-	if (agent.workspace.pullOnNewSession && existsSync(join(cwd, ".git"))) try {
+	if (!existsSync(join(cwd, ".git"))) {
+		await cloneRepo(agent);
+		return cwd;
+	}
+	if (agent.workspace.pullOnNewSession) try {
 		await Promise.race([simpleGit(cwd).pull(["--ff-only"]), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("pull timeout")), PULL_TIMEOUT_MS))]);
 	} catch {}
 	return cwd;
 }
+/**
+* Eagerly clone a git-repo workspace that has no checkout yet — for reconcile-time
+* prefetch so the repo is warm before the first message arrives. No-op for
+* from-scratch or an already-cloned checkout (the session-time `prepareWorkspace`
+* stays authoritative and still owns pull + hard-fail). Reuses the single-flight
+* lock so a prefetch and a concurrent session-start clone never race into the same
+* dir. The caller invokes this fire-and-forget and logs any rejection — clone
+* failure here is non-fatal because `prepareWorkspace` re-clones (and hard-fails)
+* on the first session as the backstop.
+*/
+async function prefetchWorkspace(agent) {
+	if (agent.workspace.mode !== "git-repo") return;
+	const cwd = agent.workspace.path;
+	if (existsSync(join(cwd, ".git"))) return;
+	mkdirSync(cwd, { recursive: true });
+	await cloneRepo(agent);
+}
+/** Clone agent.workspace.gitRepo @ gitBranch into cwd, single-flight per cwd. */
+async function cloneRepo(agent) {
+	const cwd = agent.workspace.path;
+	const inflight = cloneInFlight.get(cwd);
+	if (inflight) return inflight;
+	const gitRepo = agent.workspace.gitRepo;
+	if (!gitRepo) throw new Error(`workspace clone: agent "${agent.id}" has git-repo mode but no gitRepo configured`);
+	const branch = agent.workspace.gitBranch;
+	const p = (async () => {
+		await simpleGit().clone(gitRepo, cwd, [
+			"--branch",
+			branch,
+			"--single-branch"
+		]);
+	})().finally(() => {
+		cloneInFlight.delete(cwd);
+	});
+	cloneInFlight.set(cwd, p);
+	return p;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/@agentclientprotocol+sdk@1.0.0_zod@4.4.3/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
 const AGENT_METHODS = {
@@ -23121,27 +23163,60 @@ function signature(a) {
 	const { dir, env, ...rest } = a;
 	return JSON.stringify(rest);
 }
+/** Sub-signature over the dimensions that determine the ACP host subprocess —
+*  the spawn binary (`runtime`) and the child env / system-prompt seed knobs that
+*  are baked into the host at spawn (agentChildEnv + cpRuntimeEnv). A change here
+*  means the cached host must be evicted so the next session respawns it fresh. */
+function hostSpawnSig(a) {
+	return JSON.stringify({
+		runtime: a.runtime,
+		model: a.runtimeOverrides?.model,
+		description: a.description,
+		reasoningEffort: a.reasoningEffort,
+		executionMode: a.executionMode,
+		env: a.runtimeOverrides?.env
+	});
+}
+/** Sub-signature over the workspace dimension — cwd is materialized per session by
+*  prepareWorkspace(agent), so a workspace change must also evict the host so the
+*  next session re-materializes the (possibly re-pointed/re-cloned) checkout. */
+function workspaceSig(a) {
+	return JSON.stringify(a.workspace);
+}
+/** Sub-signature over the integration dimension — Slack app/bot tokens + bindRules.
+*  A change here rebuilds routing (and, where safe, re-opens Slack connections) but
+*  does NOT by itself touch the host. */
+function integrationsSig(a) {
+	return JSON.stringify(a.integrations);
+}
 /**
 * 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.
+* - `toStart`  — desired ids not currently running.
+* - `toStop`   — running ids no longer desired.
+* - `toChange` — same id, changed effective config. Emitted whenever the overall
+*   signature differs; the three booleans classify which dimensions moved so the
+*   caller can react minimally (evict host vs rebuild routing vs nothing). All
+*   three false ⇒ a soft-only change. Without `toChange` an in-place agent.json
+*   edit would silently be a no-op.
 */
 function diffAgents(desired, actual) {
 	const desiredIds = new Set(desired.map((a) => a.id));
 	const toStart = [];
-	const toRestart = [];
+	const toChange = [];
 	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);
+		else if (signature(cur) !== signature(a)) toChange.push({
+			agent: a,
+			hostRespawn: hostSpawnSig(cur) !== hostSpawnSig(a),
+			workspace: workspaceSig(cur) !== workspaceSig(a),
+			integrations: integrationsSig(cur) !== integrationsSig(a)
+		});
 	}
 	return {
 		toStart,
 		toStop: [...actual.keys()].filter((id) => !desiredIds.has(id)),
-		toRestart
+		toChange
 	};
 }
 //#endregion
@@ -79663,6 +79738,10 @@ var SlackConnection = class {
 	deps;
 	app;
 	botUserId = "";
+	/** The appToken this socket is keyed by (one socket per unique appToken). */
+	appToken;
+	/** The botToken this socket authenticated with (used to detect a same-appToken swap). */
+	botToken;
 	constructor(deps, factory = (o) => new App({
 		token: o.token,
 		appToken: o.appToken,
@@ -79670,6 +79749,8 @@ var SlackConnection = class {
 		...deps.boltDebug ? { logLevel: LogLevel.DEBUG } : {}
 	})) {
 		this.deps = deps;
+		this.appToken = deps.group.appToken;
+		this.botToken = deps.group.botToken;
 		this.app = factory({
 			token: deps.group.botToken,
 			appToken: deps.group.appToken
@@ -81564,8 +81645,15 @@ var Daemon = class {
 		const files = this.loadAgentList();
 		this.fileAgents = new Map(files.map((a) => [a.id, a]));
 		const desired = this.effectiveAgents();
-		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(", ")}]`);
+		const { toStart, toStop, toChange } = diffAgents(desired, this.agents);
+		if (toStart.length || toStop.length || toChange.length) this.log.info(`reconcile: ${desired.length} desired agent(s) from ${this.agentsDir}; start=[${toStart.map((a) => a.id).join(", ")}] stop=[${toStop.join(", ")}] change=[${toChange.map((c) => {
+			const dims = [
+				c.hostRespawn && "host",
+				c.workspace && "workspace",
+				c.integrations && "integrations"
+			].filter(Boolean).join("+");
+			return `${c.agent.id}(${dims || "soft"})`;
+		}).join(", ")}]`);
 		else this.log.debug(`reconcile: no changes (${desired.length} desired agent(s))`);
 		for (const id of toStop) {
 			const host = this.hosts.get(id);
@@ -81576,16 +81664,88 @@ 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);
+		for (const change of toChange) {
+			const a = change.agent;
+			this.agents.set(a.id, a);
+			if (change.hostRespawn || change.workspace) {
+				const host = this.hosts.get(a.id);
+				if (host) {
+					await host.stop();
+					this.hosts.delete(a.id);
+				}
+				this.hostStarts.delete(a.id);
 			}
-			this.hostStarts.delete(a.id);
+			if (change.workspace) this.prefetchClone(a);
+			if (change.integrations) await this.reconcileSlackConnections();
+		}
+		for (const a of toStart) {
 			this.agents.set(a.id, a);
+			this.prefetchClone(a);
+		}
+		if (toStart.some((a) => a.integrations.some((i) => i.platform === "slack")) || toStop.length) await this.reconcileSlackConnections();
+	}
+	/**
+	* Fire-and-forget eager clone of a git-repo workspace so the checkout is warm
+	* before the first message. Deliberately NOT awaited: reconcile must not block on
+	* the network (design §4.3), and `prepareWorkspace` is the authoritative clone
+	* (awaited + hard-fail) at session start — so a prefetch failure here is only
+	* logged and harmlessly retried then. No-op for from-scratch / already-cloned.
+	*/
+	prefetchClone(agent) {
+		prefetchWorkspace(agent).catch((err) => this.log.warn(`workspace: prefetch clone for "${agent.id}" failed (will retry at first session): ${formatErr(err)}`));
+	}
+	/**
+	* Reconcile the connection-derived Slack state (`botUserIds`, `connByIntegration`,
+	* open sockets) against the live `this.agents` set. Routing itself is rebuilt
+	* implicitly each message (mergedRules reads this.agents) — this only maintains the
+	* socket layer that is otherwise written only at startup.
+	*
+	* Safe-by-construction (per the recon report):
+	*  - NEW appToken  → construct + start an isolated socket, then fan botUserId/conn
+	*    out to every integrationId on that appToken. A failed start() is logged and
+	*    leaves all existing sockets untouched (never throws out of reconcile).
+	*  - NEW integration reusing an ALREADY-OPEN appToken → no socket churn; just
+	*    backfill botUserIds/connByIntegration from the existing conn (mention routing
+	*    for the new bot would otherwise silently never match).
+	*  - REMOVED appToken / close-or-replace of a still-shared socket → NOT performed
+	*    here. Tearing down a socket that other agents or in-flight turns depend on is
+	*    the one genuinely dangerous op; it is left as a logged deferred-close TODO so
+	*    a stale socket simply lingers (harmless) rather than risking the daemon.
+	*/
+	async reconcileSlackConnections() {
+		const groups = consolidate([...this.agents.values()]);
+		new Set([...this.connByIntegration.values()].map((c) => c.appToken));
+		for (const group of groups.values()) {
+			const existing = [...this.connByIntegration.values()].find((c) => c.appToken === group.appToken);
+			if (existing) {
+				if (existing.botToken !== group.botToken) this.log.warn(`slack: botToken changed for appToken (socket bot user ${existing.botUserId}) — deferred: the live socket keeps the old botToken until it is closed+reopened`);
+				for (const { integrationId } of group.integrations) if (this.connByIntegration.get(integrationId) !== existing) {
+					this.botUserIds[integrationId] = existing.botUserId;
+					this.connByIntegration.set(integrationId, existing);
+					this.log.info(`slack: bound integration ${integrationId} onto existing socket (appToken reuse)`);
+				}
+				continue;
+			}
+			try {
+				const conn = new SlackConnection({
+					group,
+					newTraceId: () => randomUUID(),
+					onMessage: (msg) => this.onInbound(msg),
+					log: this.log,
+					boltDebug: this.cfg.logging.level === "debug" || this.cfg.logging.level === "trace"
+				});
+				this.log.info(`slack: opening new socket at runtime (${group.integrations.length} integration(s): ${group.integrations.map((i) => i.agentId).join(", ")})…`);
+				await conn.start();
+				this.log.info(`slack: runtime socket connected as bot user ${conn.botUserId}`);
+				for (const { integrationId } of group.integrations) {
+					this.botUserIds[integrationId] = conn.botUserId;
+					this.connByIntegration.set(integrationId, conn);
+				}
+				this.connections.push(conn);
+			} catch (err) {
+				this.log.error(`slack: failed to open runtime socket for appToken — leaving existing sockets intact: ${formatErr(err)}`);
+			}
 		}
-		for (const a of toStart) this.agents.set(a.id, a);
 	}
 	ensureHost(agentId, cfg) {
 		let host = this.hosts.get(agentId);