@abraca/mcp 1.0.12 → 1.0.15

package/dist/index.d.ts

@@ -8728,6 +8728,9 @@ declare class AbracadabraMCPServer {
   private _serverRef;
   private _handledTaskIds;
   private _userId;
+  private _statusClearTimer;
+  private _typingInterval;
+  private _lastChatChannel;
   constructor(config: MCPServerConfig);
   get agentName(): string;
   get agentColor(): string;
@@ -8778,6 +8781,25 @@ declare class AbracadabraMCPServer {
   clearAiTask(taskId: string): void;
   /** Handle incoming stateless chat messages and dispatch as channel notifications. */
   private _handleStatelessChat;
+  /**
+   * Set the agent's status in root awareness with auto-clear after idle.
+   */
+  setAutoStatus(status: string | null, docId?: string): void;
+  /** Re-send typing indicator every 2s so dashboard keeps showing it (expires at 3s). */
+  private _startTypingInterval;
+  private _stopTypingInterval;
+  /**
+   * Broadcast which tool the agent is currently executing.
+   * Dashboard renders this as a ChatTool indicator.
+   */
+  setActiveToolCall(toolCall: {
+    name: string;
+    target?: string;
+  } | null): void;
+  /**
+   * Send a typing indicator to a chat channel.
+   */
+  sendTypingIndicator(channel: string): void;
   /** Graceful shutdown. */
   destroy(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/mcp",
-  "version": "1.0.12",
+  "version": "1.0.15",
   "description": "MCP server for Abracadabra — AI agent collaboration on CRDT documents",
   "license": "MIT",
   "type": "module",

package/src/server.ts

@@ -48,6 +48,9 @@ export class AbracadabraMCPServer {
   private _serverRef: Server | null = null
   private _handledTaskIds = new Set<string>()
   private _userId: string | null = null
+  private _statusClearTimer: ReturnType<typeof setTimeout> | null = null
+  private _typingInterval: ReturnType<typeof setInterval> | null = null
+  private _lastChatChannel: string | null = null
 
   constructor(config: MCPServerConfig) {
     this.config = config
@@ -176,6 +179,7 @@ export class AbracadabraMCPServer {
       name: this.agentName,
       color: this.agentColor,
       publicKey: this._userId,
+      isAgent: true,
     })
 
     const conn: SpaceConnection = { doc, provider, docId }
@@ -240,6 +244,7 @@ export class AbracadabraMCPServer {
       name: this.agentName,
       color: this.agentColor,
       publicKey: this._userId,
+      isAgent: true,
     })
 
     this.childCache.set(docId, {
@@ -323,6 +328,7 @@ export class AbracadabraMCPServer {
           : 'Unknown'
 
         console.error(`[abracadabra-mcp] Handling ai:task id=${id} from ${senderName}: ${text.slice(0, 80)}`)
+        this.setAutoStatus('thinking')
         this._dispatchAiTask({
           id,
           text,
@@ -400,6 +406,25 @@ export class AbracadabraMCPServer {
         }
       }
 
+      // Auto-mark channel as read so sender sees a read receipt
+      if (channel) {
+        const rootProvider = this._activeConnection?.provider
+        if (rootProvider) {
+          rootProvider.sendStateless(JSON.stringify({
+            type: 'chat:mark_read',
+            channel,
+            timestamp: Math.floor(Date.now() / 1000),
+          }))
+        }
+        // Send immediate typing indicator and start periodic re-sends
+        this._lastChatChannel = channel
+        this.sendTypingIndicator(channel)
+        this._startTypingInterval(channel)
+      }
+
+      // Set status to "thinking" so dashboard shows AI is processing
+      this.setAutoStatus('thinking')
+
       await this._serverRef.notification({
         method: 'notifications/claude/channel',
         params: {
@@ -420,8 +445,82 @@ export class AbracadabraMCPServer {
     }
   }
 
+  /**
+   * Set the agent's status in root awareness with auto-clear after idle.
+   */
+  setAutoStatus(status: string | null, docId?: string): void {
+    const provider = this._activeConnection?.provider
+    if (!provider) return
+
+    if (this._statusClearTimer) {
+      clearTimeout(this._statusClearTimer)
+      this._statusClearTimer = null
+    }
+
+    provider.awareness.setLocalStateField('status', status)
+    if (docId !== undefined) {
+      provider.awareness.setLocalStateField('docId', docId)
+    }
+
+    // When clearing status, also stop typing interval
+    if (!status) {
+      this._stopTypingInterval()
+    }
+
+    // Auto-clear status after 30s of no updates
+    if (status) {
+      this._statusClearTimer = setTimeout(() => {
+        provider.awareness.setLocalStateField('status', null)
+        provider.awareness.setLocalStateField('activeToolCall', null)
+        this._stopTypingInterval()
+      }, 30_000)
+    }
+  }
+
+  /** Re-send typing indicator every 2s so dashboard keeps showing it (expires at 3s). */
+  private _startTypingInterval(channel: string): void {
+    this._stopTypingInterval()
+    this._typingInterval = setInterval(() => {
+      this.sendTypingIndicator(channel)
+    }, 2000)
+  }
+
+  private _stopTypingInterval(): void {
+    if (this._typingInterval) {
+      clearInterval(this._typingInterval)
+      this._typingInterval = null
+    }
+    this._lastChatChannel = null
+  }
+
+  /**
+   * Broadcast which tool the agent is currently executing.
+   * Dashboard renders this as a ChatTool indicator.
+   */
+  setActiveToolCall(toolCall: { name: string; target?: string } | null): void {
+    this._activeConnection?.provider?.awareness.setLocalStateField('activeToolCall', toolCall)
+  }
+
+  /**
+   * Send a typing indicator to a chat channel.
+   */
+  sendTypingIndicator(channel: string): void {
+    const rootProvider = this._activeConnection?.provider
+    if (!rootProvider) return
+    rootProvider.sendStateless(JSON.stringify({
+      type: 'chat:typing',
+      channel,
+      sender_name: this.agentName,
+    }))
+  }
+
   /** Graceful shutdown. */
   async destroy(): Promise<void> {
+    this._stopTypingInterval()
+    if (this._statusClearTimer) {
+      clearTimeout(this._statusClearTimer)
+      this._statusClearTimer = null
+    }
     if (this.evictionTimer) {
       clearInterval(this.evictionTimer)
       this.evictionTimer = null

package/src/tools/channel.ts

@@ -17,9 +17,13 @@ export function registerChannelTools(mcp: McpServer, server: AbracadabraMCPServe
     },
     async ({ doc_id, text, task_id }) => {
       try {
+        server.setAutoStatus('writing', doc_id)
+        server.setActiveToolCall({ name: 'reply', target: doc_id })
+
         const treeMap = server.getTreeMap()
         const rootDoc = server.rootDocument
         if (!treeMap || !rootDoc) {
+          server.setActiveToolCall(null)
           return { content: [{ type: 'text' as const, text: 'Not connected' }], isError: true }
         }
 
@@ -47,10 +51,13 @@ export function registerChannelTools(mcp: McpServer, server: AbracadabraMCPServe
           server.clearAiTask(task_id)
         }
 
+        server.setActiveToolCall(null)
+
         return {
           content: [{ type: 'text' as const, text: JSON.stringify({ replyDocId: replyId, parentId: doc_id }) }],
         }
       } catch (error: any) {
+        server.setActiveToolCall(null)
         return {
           content: [{ type: 'text' as const, text: `Error: ${error.message}` }],
           isError: true,
@@ -80,6 +87,10 @@ export function registerChannelTools(mcp: McpServer, server: AbracadabraMCPServe
           sender_name: server.agentName,
         }))
 
+        // Clear thinking/typing status after sending the reply
+        server.setAutoStatus(null)
+        server.setActiveToolCall(null)
+
         return { content: [{ type: 'text' as const, text: `Sent to ${channel}` }] }
       } catch (error: any) {
         return {

package/src/tools/content.ts

@@ -17,6 +17,9 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
     },
     async ({ docId }) => {
       try {
+        server.setAutoStatus('reading', docId)
+        server.setActiveToolCall({ name: 'read_document', target: docId })
+
         const provider = await server.getChildProvider(docId)
         const fragment = provider.document.getXmlFragment('default')
 
@@ -48,6 +51,8 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
           children.sort((a: any, b: any) => ((treeMap.get(a.id)?.order ?? 0) - (treeMap.get(b.id)?.order ?? 0)))
         }
 
+        server.setActiveToolCall(null)
+
         const result: Record<string, unknown> = { label, type, meta, markdown, children }
         return {
           content: [{
@@ -56,6 +61,7 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
           }],
         }
       } catch (error: any) {
+        server.setActiveToolCall(null)
         return {
           content: [{ type: 'text', text: `Error reading document: ${error.message}` }],
           isError: true,
@@ -74,6 +80,9 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
     },
     async ({ docId, markdown, mode }) => {
       try {
+        server.setAutoStatus('writing', docId)
+        server.setActiveToolCall({ name: 'write_document', target: docId })
+
         const writeMode = mode ?? 'replace'
         const provider = await server.getChildProvider(docId)
         const doc = provider.document
@@ -119,10 +128,13 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
         server.setFocusedDoc(docId)
         server.setDocCursor(docId, fragment.length)
 
+        server.setActiveToolCall(null)
+
         return {
           content: [{ type: 'text', text: `Document ${docId} updated (${writeMode} mode)` }],
         }
       } catch (error: any) {
+        server.setActiveToolCall(null)
         return {
           content: [{ type: 'text', text: `Error writing document: ${error.message}` }],
           isError: true,

package/src/tools/tree.ts

@@ -186,9 +186,15 @@ export function registerTreeTools(mcp: McpServer, server: AbracadabraMCPServer)
       meta: z.record(z.unknown()).optional().describe('Initial metadata (PageMeta fields: color as hex string, icon as Lucide kebab-case name like "star"/"code-2"/"users" — never emoji, dateStart, dateEnd, priority 0-4, tags array, etc). Omit icon entirely to use page type default.'),
     },
     async ({ parentId, label, type, meta }) => {
+      server.setAutoStatus('creating')
+      server.setActiveToolCall({ name: 'create_document', target: label })
+
       const treeMap = server.getTreeMap()
       const rootDoc = server.rootDocument
-      if (!treeMap || !rootDoc) return { content: [{ type: 'text', text: 'Not connected' }] }
+      if (!treeMap || !rootDoc) {
+        server.setActiveToolCall(null)
+        return { content: [{ type: 'text', text: 'Not connected' }] }
+      }
 
       const id = crypto.randomUUID()
       const normalizedParent = normalizeRootId(parentId, server)
@@ -205,6 +211,8 @@ export function registerTreeTools(mcp: McpServer, server: AbracadabraMCPServer)
         })
       })
 
+      server.setActiveToolCall(null)
+
       return {
         content: [{
           type: 'text',