@abraca/mcp 2.4.0 → 2.5.0

package/dist/abracadabra-mcp.esm.js

@@ -4,7 +4,7 @@ import addFormats from "ajv-formats";
 import { ZodOptional, z } from "zod";
 import process$1 from "node:process";
 import * as Y from "yjs";
-import { AbracadabraClient, AbracadabraProvider, Kind, SERVER_ROOT_ID, awarenessStatesToArray } from "@abraca/dabra";
+import { AbracadabraClient, AbracadabraProvider, Kind, SERVER_ROOT_ID, awarenessStatesToArray, foldRecords, isEncryptedContent, makeEntryMap, patchEntry, recordFromYAny, toPlain } from "@abraca/dabra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import * as fs from "node:fs";
 import { existsSync, readFileSync } from "node:fs";
@@ -14086,6 +14086,9 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 	static {
 		this.TOOL_HISTORY_MAX = 20;
 	}
+	static {
+		this.DEDUPE_MAX = 1e3;
+	}
 	constructor(config) {
 		this._serverInfo = null;
 		this._rootDocId = null;
@@ -14103,6 +14106,14 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 		this._lastChatChannel = null;
 		this._signFn = null;
 		this._toolHistory = [];
+		this._inboxStarted = false;
+		this._inboxDocId = null;
+		this._inboxDoc = null;
+		this._inboxProvider = null;
+		this._inboxDisposers = [];
+		this._inboxInitialized = false;
+		this._seenInboxIds = /* @__PURE__ */ new Set();
+		this._dispatchedMessageIds = /* @__PURE__ */ new Set();
 		this.config = config;
 		this.client = new AbracadabraClient({
 			url: config.url,
@@ -14332,6 +14343,182 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 				this._handleStatelessChat(payload);
 			});
 			console.error("[abracadabra-mcp] Stateless chat listener attached");
+			this._startInboxNotifications();
+		}
+	}
+	/**
+	* Bootstrap inbox observation. Sends `messages:inbox_fetch` over the active
+	* provider; the server's `messages:inbox_history` reply carries the
+	* `inbox_doc_id`. We then open a dedicated provider on that doc and observe
+	* its `entries` Y.Array for live DM/mention dispatch. Mirrors the
+	* dashboard's `useNotifications` pattern.
+	*/
+	async _startInboxNotifications() {
+		if (this._inboxStarted) return;
+		const provider = this._activeConnection?.provider;
+		if (!provider) return;
+		this._inboxStarted = true;
+		provider.on("stateless", ({ payload }) => {
+			if (!payload.includes("\"messages:inbox_history\"")) return;
+			try {
+				const data = JSON.parse(payload);
+				if (data?.type !== "messages:inbox_history") return;
+				const inboxDocId = typeof data.inbox_doc_id === "string" ? data.inbox_doc_id : null;
+				if (inboxDocId) this._ensureInboxObserver(inboxDocId);
+			} catch {}
+		});
+		provider.sendStateless(JSON.stringify({
+			type: "messages:inbox_fetch",
+			limit: 50,
+			unread_only: false
+		}));
+		console.error("[abracadabra-mcp] Inbox bootstrap sent (messages:inbox_fetch)");
+	}
+	/**
+	* Open a dedicated provider on the agent's inbox doc and observe its
+	* `entries` Y.Array. The server is the only writer; we only read.
+	*/
+	async _ensureInboxObserver(inboxDocId) {
+		if (this._inboxDocId) return;
+		this._inboxDocId = inboxDocId;
+		if (!this.client.isTokenValid() && this._signFn && this._userId) await this.client.loginWithKey(this._userId, this._signFn);
+		const doc = new Y.Doc({ guid: inboxDocId });
+		const provider = new AbracadabraProvider({
+			name: inboxDocId,
+			document: doc,
+			client: this.client,
+			disableOfflineStore: true,
+			subdocLoading: "lazy"
+		});
+		this._inboxDoc = doc;
+		this._inboxProvider = provider;
+		try {
+			await waitForSync(provider);
+		} catch (err) {
+			console.error(`[abracadabra-mcp] Inbox sync failed: ${err?.message ?? err}`);
+			return;
+		}
+		const entriesArr = doc.getArray("entries");
+		const readMap = doc.getMap("read");
+		const onChange = () => {
+			this._pumpInbox(entriesArr, readMap);
+		};
+		entriesArr.observe(onChange);
+		readMap.observe(onChange);
+		this._inboxDisposers.push(() => entriesArr.unobserve(onChange));
+		this._inboxDisposers.push(() => readMap.unobserve(onChange));
+		await this._pumpInbox(entriesArr, readMap);
+		console.error(`[abracadabra-mcp] Inbox observer attached (${inboxDocId})`);
+	}
+	/**
+	* Diff the inbox `entries` array against what we've already seen. On the
+	* first pump we only record a baseline (don't replay history). New entries
+	* are classified by their authoritative `kind` and dispatched.
+	*/
+	async _pumpInbox(entriesArr, readMap) {
+		const entries = entriesArr.toArray().map((e) => typeof e?.toJSON === "function" ? e.toJSON() : e);
+		if (!this._inboxInitialized) {
+			for (const e of entries) if (e?.id) this._seenInboxIds.add(e.id);
+			this._inboxInitialized = true;
+			console.error(`[abracadabra-mcp] Inbox baseline: ${this._seenInboxIds.size} existing entries (not replayed)`);
+			return;
+		}
+		for (const e of entries) {
+			const id = e?.id;
+			if (!id || this._seenInboxIds.has(id)) continue;
+			this._seenInboxIds.add(id);
+			if (readMap.get(id)) continue;
+			try {
+				await this._dispatchInboxEntry(e);
+			} catch (err) {
+				console.error(`[abracadabra-mcp] Inbox dispatch failed for ${id}: ${err?.message ?? err}`);
+			}
+		}
+		this._trimSet(this._seenInboxIds);
+	}
+	/** Classify + dispatch one inbox entry as a channel notification. */
+	async _dispatchInboxEntry(entry) {
+		if (!this._serverRef) return;
+		const kind = typeof entry?.kind === "string" ? entry.kind : "";
+		const channelDocId = typeof entry?.channel_doc_id === "string" ? entry.channel_doc_id : "";
+		const messageId = typeof entry?.message_id === "string" ? entry.message_id : null;
+		const senderId = typeof entry?.sender_id === "string" ? entry.sender_id : "";
+		if (!channelDocId) return;
+		if (senderId && senderId === this._userId) return;
+		const mode = this.triggerMode;
+		if (kind === "mention" || kind === "reply") {
+			if (mode === "task") return;
+		} else if (kind !== "dm") return;
+		if (messageId && this._rememberDispatched(messageId)) return;
+		const content = await this._resolveInboxContent(channelDocId, messageId, entry?.preview);
+		this._lastChatChannel = channelDocId;
+		this._beginTurn();
+		this.setAutoStatus("thinking");
+		await this._serverRef.notification({
+			method: "notifications/claude/channel",
+			params: {
+				content,
+				instructions: `You MUST use send_chat_message with channel_doc_id="${channelDocId}" for ALL responses — both progress updates and final answers. The user CANNOT see plain text output; they only see messages sent via send_chat_message. When doing multi-step work, send brief status updates via send_chat_message (e.g. "Looking into that..." or "Found it, writing up results...") so the user knows you're working. Never output plain text as a substitute for send_chat_message.`,
+				meta: {
+					source: "abracadabra",
+					type: kind === "dm" ? "dm_message" : "chat_message",
+					channel_doc_id: channelDocId,
+					sender: entry?.sender_name ?? "Unknown",
+					sender_id: senderId,
+					doc_id: channelDocId
+				}
+			}
+		});
+		console.error(`[abracadabra-mcp] Dispatched ${kind} on ${channelDocId} from ${entry?.sender_name ?? (senderId || "unknown")}`);
+		this._activeConnection?.provider?.sendStateless(JSON.stringify({
+			type: "messages:inbox_mark_read",
+			id: entry.id
+		}));
+	}
+	/**
+	* Resolve full message content. The inbox `preview` is truncated to ≤200
+	* bytes (and null for E2E), so for fidelity we read the actual record from
+	* the channel/DM doc's active period — same shape the dashboard reads.
+	* Falls back to the preview, then a short notice.
+	*/
+	async _resolveInboxContent(channelDocId, messageId, preview) {
+		const previewStr = typeof preview === "string" && preview.length > 0 ? preview : null;
+		const root = this._activeConnection?.provider;
+		if (root && messageId) try {
+			const wrapper = await root.loadChild(channelDocId);
+			if (!wrapper.synced) await waitForSync(wrapper);
+			const periods = wrapper.document.getArray("periods");
+			const len = periods.length;
+			for (let i = len - 1; i >= 0 && i >= len - 2; i--) {
+				const p = periods.get(i);
+				const periodId = p?.id ?? p?.get?.("id");
+				if (!periodId) continue;
+				const period = await root.loadChild(periodId);
+				if (!period.synced) await waitForSync(period);
+				const hit = foldRecords(period.document.getArray("messages").toArray().map((v) => recordFromYAny(v)).filter((r) => r !== null)).find((f) => f.id === messageId);
+				if (hit) {
+					if (isEncryptedContent(hit.content)) return previewStr ?? "[encrypted message — this agent is not provisioned to read this channel]";
+					return hit.content;
+				}
+			}
+		} catch (err) {
+			console.error(`[abracadabra-mcp] content read failed for ${channelDocId}/${messageId}: ${err?.message ?? err}`);
+		}
+		return previewStr ?? "[message content unavailable]";
+	}
+	_rememberDispatched(messageId) {
+		if (this._dispatchedMessageIds.has(messageId)) return true;
+		this._dispatchedMessageIds.add(messageId);
+		this._trimSet(this._dispatchedMessageIds);
+		return false;
+	}
+	_trimSet(s) {
+		if (s.size <= AbracadabraMCPServer.DEDUPE_MAX) return;
+		const excess = s.size - AbracadabraMCPServer.DEDUPE_MAX;
+		let i = 0;
+		for (const v of s) {
+			if (i++ >= excess) break;
+			s.delete(v);
 		}
 	}
 	/** Attach awareness observer to detect `ai:task` fields from human users. */
@@ -14417,6 +14604,7 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 			if (data.sender_id && data.sender_id === this._userId) return;
 			const channelDocId = data.channel_doc_id;
 			if (!channelDocId) return;
+			if (data.id && this._rememberDispatched(data.id)) return;
 			const mode = this.triggerMode;
 			const content = typeof data.content === "string" ? data.content : "";
 			let dispatchContent = content;
@@ -14567,6 +14755,13 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 			clearInterval(this.evictionTimer);
 			this.evictionTimer = null;
 		}
+		for (const dispose of this._inboxDisposers) try {
+			dispose();
+		} catch {}
+		this._inboxDisposers = [];
+		this._inboxProvider?.destroy();
+		this._inboxProvider = null;
+		this._inboxDoc = null;
 		for (const [, cached] of this.childCache) cached.provider.destroy();
 		this.childCache.clear();
 		for (const [, conn] of this._spaceConnections) {
@@ -15327,13 +15522,13 @@ function normalizeRootId(id, server) {
 	return id === server.rootDocId ? null : id;
 }
 /** Safely read a tree map value, converting Y.Map to plain object if needed. */
-function toPlain(val) {
+function toPlain$1(val) {
 	return val instanceof Y.Map ? val.toJSON() : val;
 }
 function readEntries$1(treeMap) {
 	const entries = [];
 	treeMap.forEach((raw, id) => {
-		const value = toPlain(raw);
+		const value = toPlain$1(raw);
 		if (typeof value !== "object" || value === null) return;
 		entries.push({
 			id,
@@ -15530,7 +15725,7 @@ function registerTreeTools(mcp, server, validator = null) {
 		const normalizedParent = normalizeRootId(parentId, server);
 		const now = Date.now();
 		rootDoc.transact(() => {
-			treeMap.set(id, {
+			treeMap.set(id, makeEntryMap({
 				label,
 				parentId: normalizedParent,
 				order: now,
@@ -15538,7 +15733,7 @@ function registerTreeTools(mcp, server, validator = null) {
 				meta,
 				createdAt: now,
 				updatedAt: now
-			});
+			}));
 		});
 		server.setFocusedDoc(id);
 		return { content: [{
@@ -15565,14 +15760,11 @@ function registerTreeTools(mcp, server, validator = null) {
 			type: "text",
 			text: "Not connected"
 		}] };
-		const raw = treeMap.get(id);
-		if (!raw) return { content: [{
+		if (!treeMap.get(id)) return { content: [{
 			type: "text",
 			text: `Document ${id} not found`
 		}] };
-		const entry = toPlain(raw);
-		treeMap.set(id, {
-			...entry,
+		patchEntry(treeMap, id, {
 			label,
 			updatedAt: Date.now()
 		});
@@ -15596,14 +15788,11 @@ function registerTreeTools(mcp, server, validator = null) {
 			type: "text",
 			text: "Not connected"
 		}] };
-		const raw = treeMap.get(id);
-		if (!raw) return { content: [{
+		if (!treeMap.get(id)) return { content: [{
 			type: "text",
 			text: `Document ${id} not found`
 		}] };
-		const entry = toPlain(raw);
-		treeMap.set(id, {
-			...entry,
+		patchEntry(treeMap, id, {
 			parentId: normalizeRootId(newParentId, server),
 			order: order ?? Date.now(),
 			updatedAt: Date.now()
@@ -15632,7 +15821,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			for (const nid of toDelete) {
 				const raw = treeMap.get(nid);
 				if (!raw) continue;
-				const entry = toPlain(raw);
+				const entry = toPlain$1(raw);
 				trashMap.set(nid, {
 					label: entry.label || "Untitled",
 					parentId: entry.parentId ?? null,
@@ -15663,14 +15852,11 @@ function registerTreeTools(mcp, server, validator = null) {
 			type: "text",
 			text: "Not connected"
 		}] };
-		const raw = treeMap.get(id);
-		if (!raw) return { content: [{
+		if (!treeMap.get(id)) return { content: [{
 			type: "text",
 			text: `Document ${id} not found`
 		}] };
-		const entry = toPlain(raw);
-		treeMap.set(id, {
-			...entry,
+		patchEntry(treeMap, id, {
 			type,
 			updatedAt: Date.now()
 		});
@@ -15713,13 +15899,13 @@ function registerTreeTools(mcp, server, validator = null) {
 			type: "text",
 			text: `Document ${id} not found`
 		}] };
-		const entry = toPlain(raw);
+		const entry = toPlain$1(raw);
 		const newId = crypto.randomUUID();
-		treeMap.set(newId, {
+		treeMap.set(newId, makeEntryMap({
 			...entry,
 			label: (entry.label || "Untitled") + " (copy)",
 			order: Date.now()
-		});
+		}));
 		server.setFocusedDoc(newId);
 		return { content: [{
 			type: "text",
@@ -15762,31 +15948,37 @@ function registerContentTools(mcp, server) {
 				name: "read_document",
 				target: docId
 			});
-			const { title, markdown } = yjsToMarkdown((await server.getChildProvider(docId)).document.getXmlFragment("default"));
+			const fragment = (await server.getChildProvider(docId)).document.getXmlFragment("default");
 			server.setFocusedDoc(docId);
 			server.setDocCursor(docId, 0);
 			const treeMap = server.getTreeMap();
-			let label = title;
+			let label = "Untitled";
 			let type;
 			let meta;
 			let children = [];
 			if (treeMap) {
-				const entry = treeMap.get(docId);
-				if (entry) {
-					label = entry.label || title;
+				const entry = toPlain(treeMap.get(docId));
+				if (entry && typeof entry === "object") {
+					label = entry.label || label;
 					type = entry.type;
 					meta = entry.meta;
 				}
-				treeMap.forEach((value, id) => {
-					if (value.parentId === docId) children.push({
+				const collected = [];
+				treeMap.forEach((raw, id) => {
+					const value = toPlain(raw);
+					if (typeof value !== "object" || value === null) return;
+					if (value.parentId === docId) collected.push({
 						id,
 						label: value.label || "Untitled",
 						type: value.type,
-						meta: value.meta
+						meta: value.meta,
+						order: value.order ?? 0
 					});
 				});
-				children.sort((a, b) => (treeMap.get(a.id)?.order ?? 0) - (treeMap.get(b.id)?.order ?? 0));
+				collected.sort((a, b) => a.order - b.order);
+				children = collected.map(({ order, ...rest }) => rest);
 			}
+			const markdown = yjsToMarkdown(fragment, label, meta, type);
 			const result = {
 				label,
 				type,
@@ -15827,19 +16019,19 @@ function registerContentTools(mcp, server) {
 				const treeMap = server.getTreeMap();
 				const rootDoc = server.rootDocument;
 				if (treeMap && rootDoc) {
-					const entry = treeMap.get(docId);
-					if (entry) rootDoc.transact(() => {
-						const updates = {
-							...entry,
-							updatedAt: Date.now()
-						};
-						if (title) updates.label = title;
-						if (Object.keys(meta).length > 0) updates.meta = {
-							...entry.meta ?? {},
-							...meta
-						};
-						treeMap.set(docId, updates);
-					});
+					const rawEntry = treeMap.get(docId);
+					if (rawEntry) {
+						const cur = toPlain(rawEntry);
+						rootDoc.transact(() => {
+							const patch = { updatedAt: Date.now() };
+							if (title) patch.label = title;
+							if (Object.keys(meta).length > 0) patch.meta = {
+								...cur.meta ?? {},
+								...meta
+							};
+							patchEntry(treeMap, docId, patch);
+						});
+					}
 				}
 			}
 			if (writeMode === "replace") doc.transact(() => {
@@ -15907,11 +16099,12 @@ function registerMetaTools(mcp, server, validator = null) {
 			type: "text",
 			text: "Not connected"
 		}] };
-		const entry = treeMap.get(docId);
-		if (!entry) return { content: [{
+		const rawEntry = treeMap.get(docId);
+		if (!rawEntry) return { content: [{
 			type: "text",
 			text: `Document ${docId} not found`
 		}] };
+		const entry = toPlain(rawEntry);
 		const mergedMeta = {
 			...entry.meta ?? {},
 			...meta
@@ -15929,8 +16122,7 @@ function registerMetaTools(mcp, server, validator = null) {
 				};
 			}
 		}
-		treeMap.set(docId, {
-			...entry,
+		patchEntry(treeMap, docId, {
 			meta: mergedMeta,
 			updatedAt: Date.now()
 		});
@@ -16120,7 +16312,7 @@ function registerAwarenessTools(mcp, server) {
 				})
 			}] };
 			const resolvedInboxId = inboxId;
-			const { markdown } = yjsToMarkdown((await server.getChildProvider(resolvedInboxId)).document.getXmlFragment("default"));
+			const markdown = yjsToMarkdown((await server.getChildProvider(resolvedInboxId)).document.getXmlFragment("default"), "AI Inbox");
 			const pendingTasks = [];
 			treeMap.forEach((value, id) => {
 				if (value.parentId === resolvedInboxId) pendingTasks.push({
@@ -16206,16 +16398,16 @@ function registerChannelTools(mcp, server) {
 			const replyId = crypto.randomUUID();
 			const now = Date.now();
 			rootDoc.transact(() => {
-				treeMap.set(replyId, {
+				treeMap.set(replyId, makeEntryMap({
 					label,
 					parentId: doc_id,
 					order: now,
 					type: "doc",
 					createdAt: now,
 					updatedAt: now
-				});
+				}));
 			});
-			populateYDocFromMarkdown((await server.getChildProvider(replyId)).document, text);
+			populateYDocFromMarkdown((await server.getChildProvider(replyId)).document.getXmlFragment("default"), text);
 			if (task_id) server.clearAiTask(task_id);
 			return { content: [{
 				type: "text",
@@ -16989,9 +17181,14 @@ function registerAgentGuide(mcp) {
 
 //#endregion
 //#region packages/mcp/src/resources/tree-resource.ts
+/**
+* Dynamic resource: document tree as navigable JSON.
+*/
 function readEntries(treeMap) {
 	const entries = [];
-	treeMap.forEach((value, id) => {
+	treeMap.forEach((raw, id) => {
+		const value = toPlain(raw);
+		if (typeof value !== "object" || value === null) return;
 		entries.push({
 			id,
 			label: value.label || "Untitled",