@abraca/mcp 1.0.15 → 1.0.18

package/dist/index.d.ts

@@ -8783,8 +8783,10 @@ declare class AbracadabraMCPServer {
   private _handleStatelessChat;
   /**
    * Set the agent's status in root awareness with auto-clear after idle.
+   * @param statusContext — scopes the status to a specific channel/context so the
+   *   dashboard only shows it in the relevant chat. Defaults to `_lastChatChannel`.
    */
-  setAutoStatus(status: string | null, docId?: string): void;
+  setAutoStatus(status: string | null, docId?: string, statusContext?: string | null): void;
   /** Re-send typing indicator every 2s so dashboard keeps showing it (expires at 3s). */
   private _startTypingInterval;
   private _stopTypingInterval;

package/package.json

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

package/src/converters/markdownToYjs.ts

@@ -113,6 +113,10 @@ export function parseFrontmatter(markdown: string): FrontmatterResult {
   if (subtitle) meta.subtitle = subtitle
   const url = getStr(['url'])
   if (url) meta.url = url
+  const email = getStr(['email'])
+  if (email) meta.email = email
+  const phone = getStr(['phone'])
+  if (phone) meta.phone = phone
 
   const ratingRaw = getStr(['rating'])
   if (ratingRaw !== undefined) {
@@ -120,6 +124,36 @@ export function parseFrontmatter(markdown: string): FrontmatterResult {
     if (!Number.isNaN(n)) meta.rating = Math.min(5, Math.max(0, n))
   }
 
+  // Datetime fields
+  const datetimeStart = getStr(['datetimeStart'])
+  if (datetimeStart) meta.datetimeStart = datetimeStart
+  const datetimeEnd = getStr(['datetimeEnd'])
+  if (datetimeEnd) meta.datetimeEnd = datetimeEnd
+  const allDayRaw = raw['allDay']
+  if (allDayRaw !== undefined) meta.allDay = allDayRaw === 'true' || allDayRaw === true
+
+  // Geo fields
+  const geoLatRaw = getStr(['geoLat'])
+  if (geoLatRaw !== undefined) { const n = Number(geoLatRaw); if (!Number.isNaN(n)) meta.geoLat = n }
+  const geoLngRaw = getStr(['geoLng'])
+  if (geoLngRaw !== undefined) { const n = Number(geoLngRaw); if (!Number.isNaN(n)) meta.geoLng = n }
+  const geoType = getStr(['geoType'])
+  if (geoType && (geoType === 'marker' || geoType === 'line' || geoType === 'measure')) {
+    meta.geoType = geoType
+  }
+  const geoDescription = getStr(['geoDescription'])
+  if (geoDescription) meta.geoDescription = geoDescription
+
+  // Numeric fields
+  const numberRaw = getStr(['number'])
+  if (numberRaw !== undefined) { const n = Number(numberRaw); if (!Number.isNaN(n)) meta.number = n }
+  const unit = getStr(['unit'])
+  if (unit) meta.unit = unit
+
+  // Note
+  const note = getStr(['note'])
+  if (note) meta.note = note
+
   const title = typeof raw['title'] === 'string' ? raw['title'] : undefined
 
   return { title, meta, body }
@@ -156,8 +190,10 @@ function parseInline(text: string): InlineToken[] {
       const kbdProps = parseMdcProps(`{${match[4]}}`)
       tokens.push({ text: kbdProps['value'] || '', attrs: { kbd: { value: kbdProps['value'] || '' } } })
     } else if (match[5] !== undefined) {
-      const displayText = match[6] ?? match[5]
-      tokens.push({ text: displayText! })
+      // Inline wikilink [[docId]] or [[docId|label]] → link to /doc/docId
+      const docId = match[5]
+      const displayText = match[6] ?? docId
+      tokens.push({ text: displayText!, attrs: { link: { href: `/doc/${docId}` } } })
     } else if (match[7] !== undefined) {
       tokens.push({ text: match[7], attrs: { strike: true } })
     } else if (match[8] !== undefined) {
@@ -211,6 +247,7 @@ type Block =
   | { type: 'field'; name: string; fieldType: string; required: boolean; innerBlocks: Block[] }
   | { type: 'fieldGroup'; fields: Block[] }
   | { type: 'image'; src: string; alt: string; width?: string; height?: string }
+  | { type: 'docEmbed'; docId: string }
 
 function parseTableRow(line: string): string[] {
   const parts = line.split('|')
@@ -339,6 +376,13 @@ function parseBlocks(markdown: string): Block[] {
       continue
     }
 
+    const docEmbedMatch = line.match(/^!\[\[([^\]|]+?)(?:\|[^\]]*?)?\]\]\s*$/)
+    if (docEmbedMatch) {
+      blocks.push({ type: 'docEmbed', docId: docEmbedMatch[1]! })
+      i++
+      continue
+    }
+
     const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)(\{[^}]*\})?\s*$/)
     if (imgMatch) {
       const alt = imgMatch[1] ?? ''
@@ -590,6 +634,7 @@ function blockElName(b: Block): string {
     case 'field': return 'field'
     case 'fieldGroup': return 'fieldGroup'
     case 'image': return 'image'
+    case 'docEmbed': return 'docEmbed'
   }
 }
 
@@ -783,6 +828,10 @@ function fillBlock(el: Y.XmlElement, block: Block): void {
       if (block.height) el.setAttribute('height', block.height)
       break
     }
+    case 'docEmbed': {
+      el.setAttribute('docId', block.docId)
+      break
+    }
   }
 }
 
@@ -838,6 +887,7 @@ export function populateYDocFromMarkdown(
         case 'field': return new Y.XmlElement('field')
         case 'fieldGroup': return new Y.XmlElement('fieldGroup')
         case 'image': return new Y.XmlElement('image')
+        case 'docEmbed': return new Y.XmlElement('docEmbed')
       }
     })
 

package/src/converters/types.ts

@@ -17,8 +17,13 @@ export interface UserMetaField {
 }
 
 export interface PageMeta extends Record<string, unknown> {
+  // Universal display
   color?: string
   icon?: string
+  subtitle?: string
+  note?: string
+
+  // Datetime
   datetimeStart?: string
   datetimeEnd?: string
   allDay?: boolean
@@ -26,39 +31,84 @@ export interface PageMeta extends Record<string, unknown> {
   dateEnd?: string
   timeStart?: string
   timeEnd?: string
-  taskProgress?: number
-  tags?: string[]
+
+  // Task/status
   checked?: boolean
   priority?: number
   status?: string
+  taskProgress?: number
   rating?: number
+  tags?: string[]
+  members?: { id: string; label: string }[]
+
+  // Contact/value
   url?: string
   email?: string
   phone?: string
   number?: number
   unit?: string
-  subtitle?: string
-  note?: string
+
+  // Cover image
   coverUploadId?: string
   coverDocId?: string
   coverMimeType?: string
+
+  // Geo/Map
   geoType?: 'marker' | 'line' | 'measure'
   geoLat?: number
   geoLng?: number
   geoDescription?: string
+
+  // Whiteboard
   wbX?: number
   wbY?: number
   wbW?: number
   wbH?: number
   wbBg?: string
+
+  // Dashboard
   deskX?: number
   deskY?: number
+  deskZ?: number
   deskMode?: string
+
+  // Mindmap
   mmX?: number
   mmY?: number
+
+  // Graph
   graphX?: number
   graphY?: number
   graphPinned?: boolean
+  showRefEdges?: boolean
+
+  // Spatial (3D)
+  spShape?: string
+  spColor?: string
+  spOpacity?: number
+  spX?: number
+  spY?: number
+  spZ?: number
+  spRX?: number
+  spRY?: number
+  spRZ?: number
+  spSX?: number
+  spSY?: number
+  spSZ?: number
+  spModelUploadId?: string
+  spModelDocId?: string
+
+  // Renderer config (set on the page doc itself, not children)
+  kanbanColumnWidth?: string
+  galleryColumns?: number
+  galleryAspect?: string
+  calendarView?: string
+  calendarWeekStart?: string
+  calendarShowWeekNumbers?: boolean
+  tableMode?: string
+  timelineZoom?: string
+
+  // Internal
   _metaFields?: UserMetaField[]
   _metaInitialized?: boolean
 }

package/src/converters/yjsToMarkdown.ts

@@ -95,6 +95,11 @@ function serializeElement(el: Y.XmlElement, indent = ''): string {
     case 'table':
       return serializeTable(el)
 
+    case 'docEmbed': {
+      const docId = el.getAttribute('docId')
+      return docId ? `![[${docId}]]` : ''
+    }
+
     case 'image': {
       const src = el.getAttribute('src') || ''
       const alt = el.getAttribute('alt') || ''

package/src/hook-bridge.ts

@@ -0,0 +1,204 @@
+/**
+ * HookBridge — lightweight HTTP server that receives Claude Code hook events
+ * and translates them into Yjs awareness updates via AbracadabraMCPServer.
+ *
+ * Claude Code hooks (PreToolUse, PostToolUse, SubagentStart, SubagentStop, Stop)
+ * POST JSON to http://127.0.0.1:{port}/hook. The bridge maps these to awareness
+ * fields (status, activeToolCall) so the cou-sh dashboard shows real-time activity.
+ */
+import * as http from 'node:http'
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import type { AbracadabraMCPServer } from './server.ts'
+
+/** Map Claude Code tool names to awareness-friendly names + extract a target string. */
+function mapToolCall(toolName: string, toolInput: Record<string, any>): { name: string; target?: string } | null {
+  switch (toolName) {
+    case 'Bash':
+      return { name: 'bash', target: truncate(toolInput.command ?? toolInput.description, 60) }
+    case 'Read':
+      return { name: 'read_file', target: basename(toolInput.file_path) }
+    case 'Edit':
+      return { name: 'edit_file', target: basename(toolInput.file_path) }
+    case 'Write':
+      return { name: 'write_file', target: basename(toolInput.file_path) }
+    case 'Grep':
+      return { name: 'grep', target: truncate(toolInput.pattern, 40) }
+    case 'Glob':
+      return { name: 'glob', target: truncate(toolInput.pattern, 40) }
+    case 'Agent':
+      return { name: 'subagent', target: toolInput.description || toolInput.subagent_type || 'agent' }
+    case 'WebFetch':
+      return { name: 'web_fetch', target: hostname(toolInput.url) }
+    case 'WebSearch':
+      return { name: 'web_search', target: truncate(toolInput.query, 40) }
+    default:
+      // Unknown tool — use the name as-is, lowercased with underscores
+      return { name: toolName.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase() }
+  }
+}
+
+function truncate(str: string | undefined, max: number): string | undefined {
+  if (!str) return undefined
+  return str.length > max ? str.slice(0, max) + '...' : str
+}
+
+function basename(filePath: string | undefined): string | undefined {
+  if (!filePath) return undefined
+  return path.basename(filePath)
+}
+
+function hostname(url: string | undefined): string | undefined {
+  if (!url) return undefined
+  try {
+    return new URL(url).hostname
+  } catch {
+    return url.slice(0, 30)
+  }
+}
+
+export class HookBridge {
+  private httpServer: http.Server | null = null
+  private _port: number | null = null
+  private portFilePath: string
+
+  constructor(private server: AbracadabraMCPServer) {
+    this.portFilePath = process.env.ABRA_HOOK_PORT_FILE
+      || path.join(os.tmpdir(), 'abracadabra-mcp-hook.port')
+  }
+
+  get port(): number | null {
+    return this._port
+  }
+
+  /** Start the HTTP server on a random port and write the port file. */
+  async start(): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const srv = http.createServer((req, res) => this.handleRequest(req, res))
+
+      srv.on('error', reject)
+
+      srv.listen(0, '127.0.0.1', () => {
+        const addr = srv.address()
+        if (!addr || typeof addr === 'string') {
+          reject(new Error('Failed to get server address'))
+          return
+        }
+
+        this._port = addr.port
+        this.httpServer = srv
+
+        // Write port file for hook discovery
+        try {
+          fs.writeFileSync(this.portFilePath, String(this._port), 'utf-8')
+        } catch (err: any) {
+          console.error(`[hook-bridge] Warning: could not write port file: ${err.message}`)
+        }
+
+        console.error(`[hook-bridge] Listening on 127.0.0.1:${this._port}`)
+        console.error(`[hook-bridge] Port file: ${this.portFilePath}`)
+        resolve(this._port)
+      })
+    })
+  }
+
+  /** Shut down the HTTP server and remove the port file. */
+  async destroy(): Promise<void> {
+    if (this.httpServer) {
+      await new Promise<void>((resolve) => {
+        this.httpServer!.close(() => resolve())
+      })
+      this.httpServer = null
+    }
+
+    // Remove port file
+    try {
+      fs.unlinkSync(this.portFilePath)
+    } catch {
+      // Already gone or never written
+    }
+
+    this._port = null
+    console.error('[hook-bridge] Shut down')
+  }
+
+  private handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
+    // Only accept POST /hook
+    if (req.method !== 'POST' || req.url !== '/hook') {
+      res.writeHead(404)
+      res.end()
+      return
+    }
+
+    let body = ''
+    req.on('data', (chunk: Buffer) => { body += chunk.toString() })
+    req.on('end', () => {
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end('{}')
+
+      try {
+        const payload = JSON.parse(body)
+        this.routeEvent(payload)
+      } catch {
+        // Invalid JSON — ignore silently (fire-and-forget)
+      }
+    })
+  }
+
+  private routeEvent(payload: Record<string, any>): void {
+    const event = payload.hook_event_name
+    switch (event) {
+      case 'PreToolUse':
+        this.onPreToolUse(payload)
+        break
+      case 'PostToolUse':
+        this.onPostToolUse(payload)
+        break
+      case 'SubagentStart':
+        this.onSubagentStart(payload)
+        break
+      case 'SubagentStop':
+        this.onSubagentStop(payload)
+        break
+      case 'Stop':
+        this.onStop()
+        break
+    }
+  }
+
+  private onPreToolUse(payload: Record<string, any>): void {
+    const toolName: string = payload.tool_name ?? ''
+    // Skip Abracadabra MCP tools — they set awareness themselves
+    if (toolName.startsWith('mcp__abracadabra__')) return
+
+    const toolInput = payload.tool_input ?? {}
+    const mapped = mapToolCall(toolName, toolInput)
+    if (mapped) {
+      this.server.setActiveToolCall(mapped)
+      this.server.setAutoStatus('working')
+    }
+  }
+
+  private onPostToolUse(payload: Record<string, any>): void {
+    const toolName: string = payload.tool_name ?? ''
+    if (toolName.startsWith('mcp__abracadabra__')) return
+
+    this.server.setActiveToolCall(null)
+  }
+
+  private onSubagentStart(payload: Record<string, any>): void {
+    const agentType: string = payload.agent_type ?? 'agent'
+    this.server.setActiveToolCall({ name: 'subagent', target: agentType })
+    this.server.setAutoStatus('thinking')
+  }
+
+  private onSubagentStop(_payload: Record<string, any>): void {
+    this.server.setActiveToolCall(null)
+  }
+
+  private onStop(): void {
+    this.server.setAutoStatus(null)
+    this.server.setActiveToolCall(null)
+  }
+}

package/src/index.ts

@@ -21,6 +21,8 @@ import { registerChannelTools } from './tools/channel.ts'
 import { registerAgentGuide } from './resources/agent-guide.ts'
 import { registerTreeResource } from './resources/tree-resource.ts'
 import { registerServerInfoResource } from './resources/server-info.ts'
+import { registerHookTools } from './tools/hooks.ts'
+import { HookBridge } from './hook-bridge.ts'
 
 async function main() {
   const url = process.env.ABRA_URL
@@ -55,8 +57,9 @@ async function main() {
 ## Key Concepts
 - Documents form a tree. A kanban board's columns are child documents; cards are grandchildren.
 - A document's label IS its display name everywhere. Children ARE the content (not just the body text).
-- Page types (doc, kanban, table, calendar, timeline, outline, etc.) are views over the SAME tree — switching types preserves data.
+- Page types (doc, kanban, table, calendar, timeline, checklist, outline, gallery, map, graph, dashboard, spatial, media, mindmap, etc.) are views over the SAME tree — switching types preserves data.
 - An empty markdown body does NOT mean empty content — always check the children array.
+- Use ![[docId]] in content to embed another document, or [[docId|label]] for inline links.
 
 ## Finding Documents
 - list_documents only shows ONE level of children. If you don't find what you need, use find_document to search the entire tree by name, or get_document_tree to see the full hierarchy.
@@ -101,6 +104,18 @@ Read the resource at abracadabra://agent-guide for the complete guide covering p
     process.exit(1)
   }
 
+  // Start Claude Code hook bridge (HTTP server for activity events)
+  const hookBridge = new HookBridge(server)
+  try {
+    const hookPort = await hookBridge.start()
+    console.error(`[abracadabra-mcp] Hook bridge listening on port ${hookPort}`)
+  } catch (error: any) {
+    console.error(`[abracadabra-mcp] Hook bridge failed to start: ${error.message}`)
+  }
+
+  // Register hook config tool (must be after bridge starts so port is available)
+  registerHookTools(mcp, hookBridge)
+
   // Start MCP stdio transport
   const transport = new StdioServerTransport()
   await mcp.connect(transport)
@@ -112,6 +127,7 @@ Read the resource at abracadabra://agent-guide for the complete guide covering p
   // Graceful shutdown
   const shutdown = async () => {
     console.error('[abracadabra-mcp] Shutting down...')
+    await hookBridge.destroy()
     await server.destroy()
     process.exit(0)
   }