@agentconnect.md/daemon 1.0.0-rc.59 → 1.0.0-rc.60

package/dist/index.js

@@ -13132,6 +13132,22 @@ const IntegrationSpec = object({
 const IntegrationUpsert = IntegrationSpec;
 /** C→D EVT — remove an integration from the daemon. */
 const IntegrationRemove = object({ integrationId: string().uuid() });
+/** One channel the bot is currently a member of (metadata only — no messages). */
+const IntegrationChannel = object({
+	id: string(),
+	name: string().optional(),
+	isPrivate: boolean().optional()
+});
+/**
+* D→C EVT — the FULL set of channels the integration's bot is a member of
+* (fire-and-forget, latest-wins). Emitted on socket start and whenever the bot
+* is invited to / removed from a channel, so the console can offer per-channel
+* trigger config. Channel names are control metadata, never message content.
+*/
+const IntegrationChannels = object({
+	integrationId: string().uuid(),
+	channels: array(IntegrationChannel)
+});
 //#endregion
 //#region ../protocol/dist/frames/register.js
 /**
@@ -13284,6 +13300,7 @@ const FRAME_SCHEMAS = {
 	"cron/remove": CronRemove,
 	"integration/upsert": IntegrationUpsert,
 	"integration/remove": IntegrationRemove,
+	"integration/channels": IntegrationChannels,
 	"secrets/request": SecretsRequest,
 	"secrets/grant": SecretsGrant,
 	"secrets/renew": SecretsRenew,
@@ -13408,6 +13425,7 @@ discriminatedUnion("type", [
 	frame("cron/remove", FRAME_SCHEMAS["cron/remove"]),
 	frame("integration/upsert", FRAME_SCHEMAS["integration/upsert"]),
 	frame("integration/remove", FRAME_SCHEMAS["integration/remove"]),
+	frame("integration/channels", FRAME_SCHEMAS["integration/channels"]),
 	frame("secrets/request", FRAME_SCHEMAS["secrets/request"]),
 	frame("secrets/grant", FRAME_SCHEMAS["secrets/grant"]),
 	frame("secrets/renew", FRAME_SCHEMAS["secrets/renew"]),
@@ -80633,6 +80651,16 @@ var SlackConnection = class {
 			if (!ev.channel) return;
 			deliver(ev, "app_mention");
 		});
+		this.app.event("member_joined_channel", async ({ event }) => {
+			const ev = event;
+			if (ev.user !== this.botUserId) return;
+			log?.debug(`slack: bot joined channel ${ev.channel ?? "?"}`);
+			this.deps.onChannelsChanged?.();
+		});
+		for (const type of ["channel_left", "group_left"]) this.app.event(type, async ({ event }) => {
+			log?.debug(`slack: bot left channel ${event.channel ?? "?"} (${type})`);
+			this.deps.onChannelsChanged?.();
+		});
 		log?.debug("slack: app.start → opening Socket Mode WebSocket (wss://…slack.com)…");
 		await this.app.start();
 		log?.debug("slack: app.start resolved → socket established");
@@ -80750,6 +80778,39 @@ var SlackConnection = class {
 			isBot: p.isBot
 		})).catch(() => ({ id }))));
 	}
+	/**
+	* The channels this bot is a MEMBER of (users.conversations, cursor-paginated) —
+	* the membership snapshot behind the console's per-channel trigger config. DMs /
+	* group DMs are excluded (they are not configurable channels). Returns null on
+	* any API failure so the caller never mistakes an error for "left all channels".
+	*/
+	async listBotChannels() {
+		const out = [];
+		let cursor;
+		try {
+			do {
+				const res = await this.app.client.users.conversations({
+					types: "public_channel,private_channel",
+					exclude_archived: true,
+					limit: 200,
+					...cursor ? { cursor } : {}
+				});
+				for (const c of res.channels ?? []) {
+					if (!c.id || c.is_im || c.is_mpim) continue;
+					out.push({
+						id: c.id,
+						...c.name ? { name: c.name } : {},
+						...c.is_private ? { isPrivate: true } : {}
+					});
+				}
+				cursor = res.response_metadata?.next_cursor || void 0;
+			} while (cursor);
+		} catch (err) {
+			this.deps.log?.debug(`slack: users.conversations failed: ${err.message}`);
+			return null;
+		}
+		return out;
+	}
 	async listChannels() {
 		return ((await this.app.client.conversations.list({
 			types: "public_channel,private_channel",
@@ -82098,6 +82159,16 @@ var CpClient = class {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
 		this.transport?.send(encode(buildEnvelope("usage/report", report)));
 	}
+	/**
+	* Report an integration's channel-membership snapshot (D→C `integration/channels`
+	* EVT, fire-and-forget, latest-wins). No-op unless READY/DRAINING — the daemon
+	* re-emits its cached snapshots on each (re)connect (see onReady in daemon.ts),
+	* so a dropped report only delays the console's channel list, never loses it.
+	*/
+	emitIntegrationChannels(snapshot) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("integration/channels", snapshot)));
+	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
 		return this.correlator.request(frame, (e) => this.transport.send(e));
@@ -82770,6 +82841,7 @@ var Daemon = class Daemon {
 	lastProbeAtMs = 0;
 	cpClient;
 	cpCrons;
+	channelSnapshots = /* @__PURE__ */ new Map();
 	cpAgents;
 	cpIntegrations;
 	botUserIds = {};
@@ -82894,6 +82966,7 @@ var Daemon = class Daemon {
 				group,
 				newTraceId: () => randomUUID(),
 				onMessage: (msg) => this.onInbound(msg),
+				onChannelsChanged: () => void this.refreshChannels(conn),
 				log: this.log,
 				boltDebug: cfg.logging.level === "debug" || cfg.logging.level === "trace"
 			});
@@ -82905,6 +82978,7 @@ var Daemon = class Daemon {
 				this.connByIntegration.set(integrationId, conn);
 			}
 			this.connections.push(conn);
+			this.refreshChannels(conn);
 		}
 		let cronCount = 0;
 		for (const a of agents) for (const c of a.crons) {
@@ -83051,11 +83125,14 @@ var Daemon = class Daemon {
 			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`);
+				let bound = false;
 				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)`);
+					bound = true;
 				}
+				if (bound) this.refreshChannels(existing);
 				continue;
 			}
 			try {
@@ -83063,6 +83140,7 @@ var Daemon = class Daemon {
 					group,
 					newTraceId: () => randomUUID(),
 					onMessage: (msg) => this.onInbound(msg),
+					onChannelsChanged: () => void this.refreshChannels(conn),
 					log: this.log,
 					boltDebug: this.cfg.logging.level === "debug" || this.cfg.logging.level === "trace"
 				});
@@ -83074,11 +83152,37 @@ var Daemon = class Daemon {
 					this.connByIntegration.set(integrationId, conn);
 				}
 				this.connections.push(conn);
+				this.refreshChannels(conn);
 			} catch (err) {
 				this.log.error(`slack: failed to open runtime socket for appToken — leaving existing sockets intact: ${formatErr(err)}`);
 			}
 		}
 	}
+	/**
+	* Re-list the channels this connection's bot is a member of and report the
+	* snapshot to the CP for every integration bound to the connection (one bot ⇒
+	* one membership set, fanned out per integrationId). Best-effort + never throws:
+	* a Slack API failure keeps the previous snapshot (listBotChannels returns null),
+	* and the emit is a no-op while the CP is down — the cached snapshot is re-emitted
+	* on the next CP (re)connect (see startCpClient's onReady).
+	*/
+	async refreshChannels(conn) {
+		try {
+			const channels = await conn.listBotChannels();
+			if (!channels) return;
+			for (const [integrationId, c] of this.connByIntegration) {
+				if (c !== conn) continue;
+				this.channelSnapshots.set(integrationId, channels);
+				this.cpClient?.emitIntegrationChannels({
+					integrationId,
+					channels
+				});
+			}
+			this.log.debug(`slack: channel snapshot for bot ${conn.botUserId}: ${channels.length} channel(s)`);
+		} catch (err) {
+			this.log.debug(`slack: channel snapshot refresh failed: ${formatErr(err)}`);
+		}
+	}
 	ensureHost(agentId, cfg) {
 		let host = this.hosts.get(agentId);
 		if (host) return host;
@@ -83768,7 +83872,13 @@ var Daemon = class Daemon {
 				features: []
 			}),
 			runtimeProfiles: () => Object.keys(this.runtimes).map((id) => this.runtimeProfileFor(id)),
-			onReady: () => void this.probeRuntimesAndEmit(),
+			onReady: () => {
+				this.probeRuntimesAndEmit();
+				for (const [integrationId, channels] of this.channelSnapshots) this.cpClient?.emitIntegrationChannels({
+					integrationId,
+					channels
+				});
+			},
 			localState: () => ({
 				assignments: [],
 				crons: this.cpCrons?.ids() ?? [],