@agentconnect.md/daemon 1.0.0-rc.64 → 1.0.0-rc.66

package/dist/index.js

@@ -13227,7 +13227,9 @@ const SessionListItem = object({
 	status: string().optional(),
 	lastActivityAt: string().optional(),
 	usage: SessionUsage.optional(),
-	triggeredBy: string().optional()
+	triggeredBy: string().optional(),
+	channelName: string().optional(),
+	triggeredByName: string().optional()
 });
 /** C→D REQ: list the daemon's sessions (optionally just one agent's). */
 const SessionListReq = object({ agentId: string().uuid().optional() });
@@ -13237,6 +13239,7 @@ const SessionListPage = object({ sessions: array(SessionListItem) });
 const SessionMessage = object({
 	seq: number().int(),
 	sender: string(),
+	senderName: string().optional(),
 	ts: string(),
 	kind: string(),
 	text: string()
@@ -23761,7 +23764,12 @@ var LocalStore = class {
       CREATE TABLE IF NOT EXISTS sessions (
         key TEXT PRIMARY KEY, agentId TEXT, platform TEXT, channel TEXT, thread TEXT,
         acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER,
-        usage TEXT, muted INTEGER
+        usage TEXT, muted INTEGER, triggeredBy TEXT
+      );
+      -- Platform id → human display name (Slack channel/user names, daemon-resolved
+      -- and cached here so session read-back can label ids without a Slack call).
+      CREATE TABLE IF NOT EXISTS display_names (
+        id TEXT PRIMARY KEY, name TEXT NOT NULL, updatedAt INTEGER
       );
       CREATE TABLE IF NOT EXISTS transcript (
         seq INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -23780,14 +23788,15 @@ var LocalStore = class {
     `);
 		this.migrateSessionUsage();
 	}
-	/** Add the `sessions.usage` (JSON token accounting) and `sessions.muted` (`!stop`
-	*  thread mute) columns to a pre-existing DB. CREATE TABLE IF NOT EXISTS above adds
-	*  them for fresh DBs but never alters an existing table, so upgrade in place.
-	*  No-op once the columns are present. */
+	/** Add the `sessions.usage` (JSON token accounting), `sessions.muted` (`!stop`
+	*  thread mute) and `sessions.triggeredBy` columns to a pre-existing DB. CREATE
+	*  TABLE IF NOT EXISTS above adds them for fresh DBs but never alters an existing
+	*  table, so upgrade in place. No-op once the columns are present. */
 	migrateSessionUsage() {
 		const cols = this.db.prepare("PRAGMA table_info(sessions)").all();
 		if (!cols.some((c) => c.name === "usage")) this.db.exec("ALTER TABLE sessions ADD COLUMN usage TEXT");
 		if (!cols.some((c) => c.name === "muted")) this.db.exec("ALTER TABLE sessions ADD COLUMN muted INTEGER");
+		if (!cols.some((c) => c.name === "triggeredBy")) this.db.exec("ALTER TABLE sessions ADD COLUMN triggeredBy TEXT");
 	}
 	/**
 	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
@@ -23837,11 +23846,12 @@ var LocalStore = class {
 		};
 	}
 	upsertSession(rec) {
-		this.db.prepare(`INSERT INTO sessions (key, agentId, platform, channel, thread, acpSessionId, state, lastDeliveredTs, updatedAt)
-         VALUES (@key, @agentId, @platform, @channel, @thread, @acpSessionId, @state, @lastDeliveredTs, @updatedAt)
+		this.db.prepare(`INSERT INTO sessions (key, agentId, platform, channel, thread, acpSessionId, state, lastDeliveredTs, updatedAt, triggeredBy)
+         VALUES (@key, @agentId, @platform, @channel, @thread, @acpSessionId, @state, @lastDeliveredTs, @updatedAt, @triggeredBy)
          ON CONFLICT(key) DO UPDATE SET
            acpSessionId=excluded.acpSessionId, state=excluded.state,
-           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt`).run({
+           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt,
+           triggeredBy=COALESCE(sessions.triggeredBy, excluded.triggeredBy)`).run({
 			key: rec.key,
 			agentId: rec.agentId,
 			platform: rec.platform,
@@ -23850,7 +23860,8 @@ var LocalStore = class {
 			acpSessionId: rec.acpSessionId,
 			state: rec.state,
 			lastDeliveredTs: rec.lastDeliveredTs,
-			updatedAt: rec.updatedAt
+			updatedAt: rec.updatedAt,
+			triggeredBy: rec.triggeredBy ?? null
 		});
 	}
 	/** Targeted state transition for an existing session (§7.3), stamping `updatedAt`
@@ -23947,6 +23958,22 @@ var LocalStore = class {
 	activeSessionCountSince(channel, thread, sinceTs) {
 		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed' AND updatedAt >= ?").get(channel, thread, sinceTs)?.n ?? 0;
 	}
+	/** Cache a platform id's human display name (channel or user; Slack ids don't
+	*  collide across the two). Latest-wins — renames overwrite. */
+	setDisplayName(id, name, updatedAt) {
+		this.db.prepare(`INSERT INTO display_names (id, name, updatedAt) VALUES (?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET name=excluded.name, updatedAt=excluded.updatedAt`).run(id, name, updatedAt);
+	}
+	/** Display names for a set of platform ids — only the ids that have one.
+	*  One batched `IN (…)` query, not a round-trip per id. */
+	getDisplayNames(ids) {
+		const out = /* @__PURE__ */ new Map();
+		const unique = [...new Set(ids)];
+		if (unique.length === 0) return out;
+		const rows = this.db.prepare(`SELECT id, name FROM display_names WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+		for (const r of rows) if (r.name) out.set(r.id, r.name);
+		return out;
+	}
 	getCpRouting() {
 		return this.db.prepare("SELECT routingEpoch, assignments, globalRules FROM cp_routing WHERE id = 1").get();
 	}
@@ -24067,7 +24094,8 @@ var SessionManager = class {
 				acpSessionId,
 				state: "idle",
 				lastDeliveredTs: null,
-				updatedAt: Date.now()
+				updatedAt: Date.now(),
+				triggeredBy: msg.sender.id
 			};
 			this.deps.store.upsertSession(rec);
 		} else if (host.hasSession?.(rec.acpSessionId) === false) {
@@ -80959,6 +80987,74 @@ var SlackConnection = class {
 	}
 };
 //#endregion
+//#region src/slack/name-resolver.ts
+/**
+* Resolves Slack ids (channel "C…", user "U…/W…") to human display names off the
+* inbound-message path and caches the results into the LocalStore `display_names`
+* table, so session read-back (`session/list` / `session/history`) can label ids
+* without ever calling Slack at read time.
+*
+* Design constraints:
+*  - Fire-and-forget: never on the dispatch hot path, never throws into it.
+*  - Rate-friendly: an in-memory attempt cache means each id hits the Web API at
+*    most once per TTL (short TTL after a failure, long after success/no-name),
+*    regardless of message volume.
+*  - Names persist in SQLite, so a daemon restart keeps stale-but-useful names
+*    while the cache warms back up (rename lag is bounded by OK_TTL_MS).
+*/
+const OK_TTL_MS = 360 * 60 * 1e3;
+const FAIL_TTL_MS = 600 * 1e3;
+const MAX_TRACKED_IDS = 5e3;
+var SlackNameResolver = class {
+	save;
+	log;
+	now;
+	/** id → epoch ms until which we won't re-attempt a lookup. */
+	nextAttemptAt = /* @__PURE__ */ new Map();
+	constructor(save, log, now = Date.now) {
+		this.save = save;
+		this.log = log;
+		this.now = now;
+	}
+	/** Kick off (cached) resolution for a message's channel + human sender. */
+	noteMessage(conn, msg) {
+		this.resolveChannel(conn, msg.channel);
+		if (!msg.sender.isBot && /^[UW]/.test(msg.sender.id)) this.resolveUser(conn, msg.sender.id);
+	}
+	claim(id) {
+		const at = this.nextAttemptAt.get(id);
+		if (at !== void 0 && this.now() < at) return false;
+		this.nextAttemptAt.delete(id);
+		this.nextAttemptAt.set(id, this.now() + OK_TTL_MS);
+		for (const key of this.nextAttemptAt.keys()) {
+			if (this.nextAttemptAt.size <= MAX_TRACKED_IDS) break;
+			this.nextAttemptAt.delete(key);
+		}
+		return true;
+	}
+	async resolveChannel(conn, channel) {
+		if (!this.claim(channel)) return;
+		try {
+			const info = await conn.getChannelInfo(channel);
+			if (info.name) this.save(channel, info.name);
+		} catch (err) {
+			this.nextAttemptAt.set(channel, this.now() + FAIL_TTL_MS);
+			this.log?.debug(`slack: name lookup failed for channel ${channel}: ${err.message}`);
+		}
+	}
+	async resolveUser(conn, user) {
+		if (!this.claim(user)) return;
+		try {
+			const p = await conn.getUserProfile(user);
+			const name = p.realName || p.name;
+			if (name) this.save(user, name);
+		} catch (err) {
+			this.nextAttemptAt.set(user, this.now() + FAIL_TTL_MS);
+			this.log?.debug(`slack: name lookup failed for user ${user}: ${err.message}`);
+		}
+	}
+};
+//#endregion
 //#region src/slack/formatter.ts
 /**
 * Last-mile Slack formatting (§9.1 / §9.3). Two pure helpers:
@@ -82711,8 +82807,12 @@ function parseUsage(raw) {
 function createSessionReader(store) {
 	return {
 		list(req) {
-			return { sessions: store.listSessions(req.agentId).map((r) => {
+			const rows = store.listSessions(req.agentId);
+			const names = store.getDisplayNames(rows.flatMap((r) => [r.channel, ...r.triggeredBy ? [r.triggeredBy] : []]));
+			return { sessions: rows.map((r) => {
 				const usage = parseUsage(r.usage);
+				const channelName = names.get(r.channel);
+				const triggeredByName = r.triggeredBy ? names.get(r.triggeredBy) : void 0;
 				return {
 					sessionId: r.acpSessionId,
 					sessionKey: {
@@ -82723,7 +82823,10 @@ function createSessionReader(store) {
 					agentId: r.agentId,
 					status: r.state,
 					lastActivityAt: new Date(r.updatedAt).toISOString(),
-					...usage ? { usage } : {}
+					...usage ? { usage } : {},
+					...r.triggeredBy ? { triggeredBy: r.triggeredBy } : {},
+					...channelName ? { channelName } : {},
+					...triggeredByName ? { triggeredByName } : {}
 				};
 			}) };
 		},
@@ -82735,13 +82838,19 @@ function createSessionReader(store) {
 			};
 			const before = req.cursor != null && Number.isFinite(Number(req.cursor)) ? Number(req.cursor) : null;
 			const { rows, hasMore } = store.transcriptPage(rec.channel, rec.thread, before, req.limit);
-			const messages = rows.slice().reverse().map((r) => ({
-				seq: r.seq,
-				sender: r.sender,
-				ts: r.ts,
-				kind: r.kind,
-				text: r.text
-			}));
+			const ordered = rows.slice().reverse();
+			const names = store.getDisplayNames(ordered.map((r) => r.sender));
+			const messages = ordered.map((r) => {
+				const senderName = names.get(r.sender);
+				return {
+					seq: r.seq,
+					sender: r.sender,
+					...senderName ? { senderName } : {},
+					ts: r.ts,
+					kind: r.kind,
+					text: r.text
+				};
+			});
 			return {
 				sessionId: req.sessionId,
 				messages,
@@ -83178,6 +83287,7 @@ var Daemon = class Daemon {
 	fileAgents = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
 	connections = [];
+	nameResolver;
 	scheduler;
 	sessions;
 	connByIntegration = /* @__PURE__ */ new Map();
@@ -83247,6 +83357,7 @@ var Daemon = class Daemon {
 		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.nameResolver = new SlackNameResolver((id, name) => this.store.setDisplayName(id, name, Date.now()), this.log);
 		this.cpRouting = new CpRoutingLayer({
 			load: () => {
 				const row = this.store.getCpRouting();
@@ -83321,7 +83432,10 @@ var Daemon = class Daemon {
 			const conn = new SlackConnection({
 				group,
 				newTraceId: () => randomUUID(),
-				onMessage: (msg) => this.onInbound(msg),
+				onMessage: (msg) => {
+					this.nameResolver?.noteMessage(conn, msg);
+					this.onInbound(msg);
+				},
 				onChannelsChanged: () => void this.refreshChannels(conn),
 				log: this.log,
 				boltDebug: cfg.logging.level === "debug" || cfg.logging.level === "trace"
@@ -83495,7 +83609,10 @@ var Daemon = class Daemon {
 				const conn = new SlackConnection({
 					group,
 					newTraceId: () => randomUUID(),
-					onMessage: (msg) => this.onInbound(msg),
+					onMessage: (msg) => {
+						this.nameResolver?.noteMessage(conn, msg);
+						this.onInbound(msg);
+					},
 					onChannelsChanged: () => void this.refreshChannels(conn),
 					log: this.log,
 					boltDebug: this.cfg.logging.level === "debug" || this.cfg.logging.level === "trace"
@@ -83526,6 +83643,7 @@ var Daemon = class Daemon {
 		try {
 			const channels = await conn.listBotChannels();
 			if (!channels) return;
+			for (const c of channels) if (c.name) this.store.setDisplayName(c.id, c.name, Date.now());
 			for (const [integrationId, c] of this.connByIntegration) {
 				if (c !== conn) continue;
 				this.channelSnapshots.set(integrationId, channels);