@office-xyz/claude-code 0.1.7 → 0.1.8

package/index.js

@@ -98,6 +98,10 @@ const argv = yargs(hideBin(process.argv))
     type: 'string',
     describe: 'Override the CLI binary (e.g. /usr/local/bin/claude)',
   })
+  .option('channel', {
+    type: 'string',
+    describe: 'Only show messages from this channel (web, telegram, slack, discord, office, feishu, wechat)',
+  })
   .example('$0', 'Interactive setup (login, create office, name agent)')
   .example('$0 --agent claude.my.office.xyz --token xxx', 'Direct connect (skip login)')
   .help()
@@ -346,7 +350,10 @@ async function registerMcpServer() {
   try {
     const agentHandle = argv.agent
     const officeId = agentHandle.split('.').slice(1).join('.')
-    const mcpServerPath = path.resolve(__dirname, '../mcp-server/skyoffice-mcp-server.js')
+    // Use the lightweight MCP server bundled with the npm package.
+    // It fetches tool schemas from Chat Bridge and proxies all calls via HTTP,
+    // so it doesn't need the 150+ monorepo files that the full MCP server requires.
+    const mcpServerPath = path.resolve(__dirname, 'mcp-server-lite.cjs')
 
     const chatBridgeUrl = process.env.CHAT_BRIDGE_URL ||
       process.env.CHAT_BRIDGE_BASE_URL ||
@@ -397,6 +404,47 @@ function unregisterMcpServer() {
   } catch { /* ignore */ }
 }
 
+// ── Channel resolution ─────────────────────────────────────────────────────
+
+/**
+ * Resolve message channel from platformInfo / metadata / sessionId.
+ * Returns { type, color, sender, chatId } for display formatting.
+ */
+function resolveChannel(message) {
+  const platformInfo = message.platformInfo || {}
+  const meta = message.metadata || {}
+  const source = meta.source || platformInfo.clientType || ''
+  const sessionId = message.sessionId || ''
+
+  if (source.includes('telegram')) {
+    const from = meta.telegram?.from
+    const name = from?.username ? `@${from.username}` : from?.firstName || 'user'
+    return { type: 'Telegram', color: 'blue', sender: name, chatId: platformInfo.chatId }
+  }
+  if (source.includes('slack')) {
+    const channel = meta.slack?.channelId || platformInfo.channelId || ''
+    const user = meta.slack?.username || 'user'
+    return { type: 'Slack', color: 'magenta', sender: channel ? `#${channel} — ${user}` : user, chatId: null }
+  }
+  if (source.includes('discord')) {
+    return { type: 'Discord', color: 'blueBright', sender: meta.discord?.username || 'user', chatId: null }
+  }
+  if (source.includes('feishu') || source.includes('lark')) {
+    return { type: 'Feishu', color: 'cyan', sender: meta.feishu?.username || 'user', chatId: null }
+  }
+  if (source.includes('wecom') || source.includes('wechat') || source.includes('whatsapp')) {
+    const label = source.includes('whatsapp') ? 'WhatsApp' : 'WeChat'
+    return { type: label, color: 'green', sender: 'user', chatId: null }
+  }
+  if (sessionId.includes('office-wide')) {
+    const senderParts = sessionId.split('--')
+    return { type: 'Office Chat', color: 'greenBright', sender: senderParts[0] || 'colleague', chatId: null }
+  }
+  // Default: Web dialog
+  const userId = sessionId.split('--')[1] || 'user'
+  return { type: 'Web', color: 'cyanBright', sender: userId.slice(0, 20), chatId: null }
+}
+
 // ── Message handling ───────────────────────────────────────────────────────
 
 function sendJSON(payload) {
@@ -454,8 +502,16 @@ async function handleMessage(message) {
     const sessionId = message.sessionId || null
     const commandId = message.commandId || message.messageId || `cmd-${Date.now()}`
 
-    const sessionLabel = sessionId ? sessionId.split('--')[1]?.slice(0, 15) || sessionId.slice(0, 20) : 'default'
-    log(chalk.cyan(`→ [${sessionLabel}] ${text.slice(0, 80)}${text.length > 80 ? '...' : ''}`))
+    const channel = resolveChannel(message)
+
+    // --channel filter: skip messages not matching the requested channel
+    if (argv.channel && !channel.type.toLowerCase().includes(argv.channel.toLowerCase())) return
+
+    const badge = chalk[channel.color](`[${channel.type}]`)
+    const time = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })
+    const sender = chalk.dim(channel.sender)
+    log(`${badge} ${chalk.dim(time)}  ${sender}`)
+    log(`  ${text.slice(0, 200)}${text.length > 200 ? '...' : ''}`)
 
     // Kill previous command for THIS SESSION only. Other sessions continue in parallel.
     const prev = sessionId ? activeChildren.get(sessionId) : null
@@ -523,6 +579,19 @@ async function handleMessage(message) {
       startedAt: new Date().toISOString(),
     })
 
+    // Heartbeat: Send periodic streaming.heartbeat during long-running claude -p execution.
+    // This prevents WS proxies (Cloudflare 100s, ALB 60s) from killing idle connections
+    // when Claude Code is thinking but not emitting any streaming tokens.
+    const HEARTBEAT_INTERVAL_MS = 25_000 // 25s — below Cloudflare/ALB idle timeouts
+    const heartbeatTimer = setInterval(() => {
+      sendJSON({
+        type: 'streaming.heartbeat',
+        sessionId,
+        commandId,
+        timestamp: Date.now(),
+      })
+    }, HEARTBEAT_INTERVAL_MS)
+
     // 2. Spawn the CLI process
     // shell: false — args are passed directly to the process as an array,
     // avoiding ALL shell interpretation issues. The command is resolved via
@@ -867,6 +936,7 @@ async function handleMessage(message) {
 
     // 4. On process exit, send completion events
     child.on('close', (code) => {
+      clearInterval(heartbeatTimer) // Stop heartbeat — task is done
       if (sessionId && activeChildren.get(sessionId)?.child === child) activeChildren.delete(sessionId)
 
       // Clean up system prompt temp file
@@ -882,7 +952,7 @@ async function handleMessage(message) {
 
       if (fullText) {
         process.stdout.write('\n')
-        log(chalk.green(`← ${fullText.slice(0, 80)}${fullText.length > 80 ? '...' : ''}`))
+        log(chalk[channel.color](`[${channel.type}] ←`) + chalk.dim(` ${fullText.slice(0, 120)}${fullText.length > 120 ? '...' : ''}`))
       }
 
       // Send streaming.completed
@@ -964,6 +1034,7 @@ async function handleMessage(message) {
     })
 
     child.on('error', (err) => {
+      clearInterval(heartbeatTimer) // Stop heartbeat on error
       log(chalk.red(`CLI process error: ${err.message}`))
       if (err.code === 'ENOENT') {
         log(chalk.yellow(`"${cmd}" not found. Install it with: ${providerConfig.installHint}`))

package/mcp-server-lite.cjs

@@ -0,0 +1,492 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════════════════════════════════════
+// MCP Server Lite — Lightweight MCP server for the @office-xyz/claude-code npm package
+//
+// This is a self-contained MCP server that:
+//   1. Fetches tool schemas from Chat Bridge at startup
+//   2. Proxies all tool calls to Chat Bridge / Registry via HTTP
+//   3. Requires zero monorepo dependencies — works with Node.js 18+ built-in fetch
+//
+// Used by the npm package instead of the full skyoffice-mcp-server.js which
+// requires 150+ files from the monorepo.
+// ═══════════════════════════════════════════════════════════════════════════════
+
+const readline = require('readline')
+
+// ── Config from environment ──────────────────────────────────────────────────
+
+const CHAT_BRIDGE_URL = process.env.CHAT_BRIDGE_URL || process.env.CHAT_BRIDGE_BASE_URL || 'https://chatbridge.aladdinagi.xyz'
+const CANONICAL_AGENT_HANDLE = process.env.CANONICAL_AGENT_HANDLE || null
+const REGISTRY_OFFICE_ID = process.env.REGISTRY_OFFICE_ID || null
+const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || process.cwd()
+
+function log(...args) {
+  console.error(`[mcp-lite] ${new Date().toISOString()}`, ...args)
+}
+
+// ── HTTP helpers ─────────────────────────────────────────────────────────────
+
+const HTTP_TIMEOUT_MS = 30_000
+
+async function fetchJSON(url, options = {}) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS)
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        ...(options.headers || {}),
+      },
+    })
+    if (!response.ok) {
+      const text = await response.text().catch(() => '')
+      throw new Error(`HTTP ${response.status}: ${text.slice(0, 200)}`)
+    }
+    return response.json()
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      throw new Error(`Request timed out after ${HTTP_TIMEOUT_MS / 1000}s: ${url}`)
+    }
+    throw err
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+// ── Tool schema loading ──────────────────────────────────────────────────────
+
+let cachedTools = null
+
+async function loadToolSchemas() {
+  if (cachedTools) return cachedTools
+
+  if (!CANONICAL_AGENT_HANDLE) {
+    log('WARNING: No agent handle — returning empty tool list')
+    cachedTools = []
+    return cachedTools
+  }
+
+  try {
+    const url = `${CHAT_BRIDGE_URL}/api/cli/mcp-tools/${encodeURIComponent(CANONICAL_AGENT_HANDLE)}`
+    log(`Fetching tool schemas from ${url}`)
+    const data = await fetchJSON(url)
+
+    if (data?.success && Array.isArray(data.tools)) {
+      cachedTools = data.tools
+      log(`Loaded ${cachedTools.length} tool schemas from Chat Bridge`)
+      return cachedTools
+    }
+  } catch (err) {
+    log(`Failed to fetch tool schemas: ${err.message}`)
+  }
+
+  // Fallback: return empty (tools will fail gracefully)
+  log('WARNING: Using empty tool list — tool calls will be proxied but may fail')
+  cachedTools = []
+  return cachedTools
+}
+
+// ── Tool call routing ────────────────────────────────────────────────────────
+//
+// Most tools follow: POST /api/{handle}/tools/{kebab-name}
+// Special tools have custom URL patterns mapped below.
+
+function toKebab(snakeName) {
+  return snakeName.replace(/_/g, '-')
+}
+
+// Tools with non-standard URL patterns
+const SPECIAL_ROUTES = {
+  // SkyOffice endpoints (no /tools/ prefix)
+  get_skyoffice_location: { method: 'GET', path: (h) => `/api/${h}/skyoffice/location` },
+  list_skyoffice_seats:   { method: 'GET', path: (h) => `/api/${h}/skyoffice/seats` },
+  list_skyoffice_rooms:   { method: 'GET', path: (h) => `/api/${h}/skyoffice/rooms` },
+
+  // Office auth (different path)
+  office_auth_status: { method: 'GET', path: (h) => `/api/${h}/services/available` },
+
+  // SkyOffice chat (no agent handle, uses args for IDs)
+  react_to_message:     { method: 'POST', path: (h, a) => `/api/skyoffice/messages/${enc(a.messageId)}/reactions` },
+  reply_in_thread:      { method: 'POST', path: (h, a) => `/api/skyoffice/messages/${enc(a.parentMessageId)}/thread` },
+  get_thread_messages:  { method: 'GET',  path: (h, a) => `/api/skyoffice/messages/${enc(a.parentMessageId)}/thread` },
+  send_channel_message: { method: 'POST', path: (h, a) => `/api/skyoffice/channels/${enc(a.channelId)}/messages` },
+  get_channel_messages: { method: 'GET',  path: (h, a) => `/api/skyoffice/channels/${enc(a.channelId)}/messages?limit=${Math.min(a.limit || 50, 200)}` },
+  create_channel:       { method: 'POST', path: () => `/api/skyoffice/channels` },
+  pin_message:          { method: 'POST', path: (h, a) => `/api/skyoffice/messages/${enc(a.messageId)}/pin` },
+  search_chat_messages: { method: 'GET',  path: (h, a) => `/api/skyoffice/messages/search?officeId=${enc(REGISTRY_OFFICE_ID)}&q=${enc(a.query || '')}&limit=${Math.min(a.limit || 20, 100)}${a.channelId ? `&channelId=${enc(a.channelId)}` : ''}` },
+
+  // Meetings (no agent handle in URL)
+  join_meeting:              { method: 'POST', path: () => `/api/meetings/join` },
+  leave_meeting:             { method: 'POST', path: () => `/api/meetings/leave` },
+  get_meeting_transcript:    { method: 'GET',  path: (h, a) => `/api/meetings/${enc(a.meetingId)}/transcript` },
+  generate_meeting_notes:    { method: 'POST', path: (h, a) => `/api/meetings/${enc(a.meetingId)}/notes/generate` },
+  list_meetings:             { method: 'GET',  path: () => `/api/meetings` },
+  get_meeting_notes:         { method: 'GET',  path: (h, a) => `/api/meetings/${enc(a.meetingId)}/notes` },
+  distribute_meeting_notes:  { method: 'POST', path: (h, a) => `/api/meetings/${enc(a.meetingId)}/notes/distribute` },
+  speak_in_meeting:          { method: 'POST', path: (h, a) => `/api/meetings/${enc(a.meetingId)}/speak` },
+
+  // Google auth (GET instead of POST)
+  list_connected_google_accounts:    { method: 'GET', path: (h) => `/api/${h}/tools/list-connected-google-accounts` },
+  list_connected_microsoft_accounts: { method: 'GET', path: (h) => `/api/${h}/tools/list-connected-microsoft-accounts` },
+}
+
+function enc(v) { return encodeURIComponent(v || '') }
+
+// ── Custom tool handlers ─────────────────────────────────────────────────────
+// Tools that need officeId or have multi-step logic can't use simple routing.
+
+const CUSTOM_HANDLERS = {
+  // File management → /api/offices/{officeId}/files
+  list_files: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams()
+    if (args.prefix) params.append('prefix', args.prefix)
+    if (args.maxKeys) params.append('maxKeys', String(args.maxKeys))
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files?${params}`)
+  },
+  get_file: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const qs = args.metadataOnly ? '?metadataOnly=true' : ''
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files/${args.filePath}${qs}`)
+  },
+  read_document: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const fp = args.path || args.filePath
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files/${fp}?parseContent=true`)
+  },
+  delete_file: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files/${args.filePath}`, { method: 'DELETE' })
+  },
+  upload_file: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/files`, {
+      method: 'POST',
+      body: JSON.stringify(args),
+    })
+  },
+
+  // Draft management → /api/offices/{officeId}/drafts
+  create_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts`, {
+      method: 'POST',
+      body: JSON.stringify({ agentHandle: CANONICAL_AGENT_HANDLE, ...args }),
+    })
+  },
+  save_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ content: args.content, agentHandle: CANONICAL_AGENT_HANDLE }),
+    })
+  },
+  submit_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}/submit`, { method: 'POST' })
+  },
+  get_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}`)
+  },
+  list_drafts: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams()
+    if (CANONICAL_AGENT_HANDLE) params.set('agentHandle', CANONICAL_AGENT_HANDLE)
+    if (args.status) params.set('status', args.status)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts?${params}`)
+  },
+  discard_draft: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/drafts/${enc(args.draftId)}/discard`, { method: 'POST' })
+  },
+
+  // Task management → /api/offices/{officeId}/tasks
+  create_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks`, {
+      method: 'POST',
+      body: JSON.stringify({
+        title: args.title,
+        description: args.description || '',
+        priority: args.priority || 'medium',
+        executionMode: args.executionMode || 'agent',
+        createdBy: CANONICAL_AGENT_HANDLE || 'agent',
+        assigneeIds: args.assigneeIds || [],
+        contextFiles: args.contextFiles || [],
+      }),
+    })
+  },
+  batch_create_tasks: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const results = { created: [], failed: [] }
+    for (const t of (args.tasks || [])) {
+      try {
+        const r = await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks`, {
+          method: 'POST',
+          body: JSON.stringify({
+            title: t.title, description: t.description || '',
+            priority: t.priority || args.defaultPriority || 'medium',
+            executionMode: t.executionMode || args.defaultExecutionMode || 'agent',
+            createdBy: CANONICAL_AGENT_HANDLE || 'agent',
+            assigneeIds: t.assigneeIds || [],
+          }),
+        })
+        if (r.success && r.data) results.created.push({ id: r.data.id, title: t.title })
+        else results.failed.push({ title: t.title, error: r.error || 'Unknown' })
+      } catch (e) { results.failed.push({ title: t.title, error: e.message }) }
+    }
+    return { success: results.created.length > 0, ...results, summary: `Created ${results.created.length}/${args.tasks?.length || 0} tasks` }
+  },
+  assign_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ assigneeIds: args.agentHandles }),
+    })
+  },
+  list_available_tasks: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams({ unassigned: 'true', limit: String(args.limit || 10) })
+    if (args.status) params.append('status', args.status)
+    if (args.priority) params.append('priority', args.priority)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks?${params}`)
+  },
+  list_my_tasks: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const params = new URLSearchParams({ assigneeId: CANONICAL_AGENT_HANDLE, limit: '20' })
+    if (args.status) params.append('status', args.status)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks?${params}`)
+  },
+  get_task_details: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`)
+  },
+  claim_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/claim`, {
+      method: 'POST',
+      body: JSON.stringify({ agentHandle: CANONICAL_AGENT_HANDLE, agentLabel: CANONICAL_AGENT_HANDLE?.split('.')[0] }),
+    })
+  },
+  unclaim_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/unclaim`, {
+      method: 'POST',
+      body: JSON.stringify({ agentHandle: CANONICAL_AGENT_HANDLE }),
+    })
+  },
+  update_task_progress: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    const r = await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/outputs`, {
+      method: 'POST',
+      body: JSON.stringify({ type: 'result', content: args.notes, agentId: CANONICAL_AGENT_HANDLE, agentName: CANONICAL_AGENT_HANDLE?.split('.')[0] || 'Agent' }),
+    })
+    if (args.status) {
+      await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`, {
+        method: 'PATCH', body: JSON.stringify({ status: args.status }),
+      }).catch(() => {})
+    }
+    return r
+  },
+  complete_task: async (args) => {
+    const o = enc(REGISTRY_OFFICE_ID)
+    if (args.notes) {
+      const note = `✅ COMPLETED by ${CANONICAL_AGENT_HANDLE || 'Agent'}\n\n${args.notes}${args.artifacts?.length ? `\n\nArtifacts:\n${args.artifacts.map(a => `• ${a}`).join('\n')}` : ''}`
+      await fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}/outputs`, {
+        method: 'POST',
+        body: JSON.stringify({ type: 'result', content: note, agentId: CANONICAL_AGENT_HANDLE }),
+      }).catch(() => {})
+    }
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/offices/${o}/tasks/${enc(args.taskId)}`, {
+      method: 'PATCH', body: JSON.stringify({ status: 'done' }),
+    })
+  },
+
+  // Spawn task session → /api/{agentId}/conversations
+  spawn_task_session: async (args) => {
+    const h = enc(args.agentId || CANONICAL_AGENT_HANDLE)
+    return fetchJSON(`${CHAT_BRIDGE_URL}/api/${h}/conversations`, {
+      method: 'POST',
+      body: JSON.stringify({
+        taskId: args.taskId, projectPath: args.projectPath,
+        branchName: args.branchName, provider: args.provider,
+        modelId: args.modelId, systemPromptAddition: args.systemPromptAddition,
+      }),
+    })
+  },
+  batch_spawn_task_sessions: async (args) => {
+    const results = { spawned: [], failed: [] }
+    for (const s of (args.sessions || [])) {
+      try {
+        const h = enc(s.agentId || CANONICAL_AGENT_HANDLE)
+        const r = await fetchJSON(`${CHAT_BRIDGE_URL}/api/${h}/conversations`, {
+          method: 'POST',
+          body: JSON.stringify({ taskId: s.taskId, provider: s.provider || args.defaultProvider, modelId: s.modelId, systemPromptAddition: s.systemPromptAddition }),
+        })
+        results.spawned.push({ taskId: s.taskId, agentId: s.agentId, ...r })
+      } catch (e) { results.failed.push({ taskId: s.taskId, error: e.message }) }
+    }
+    return { success: results.spawned.length > 0, ...results }
+  },
+}
+
+async function callTool(name, args) {
+  const handle = CANONICAL_AGENT_HANDLE
+  if (!handle) return { success: false, error: 'Agent handle not configured' }
+  const h = encodeURIComponent(handle)
+
+  try {
+    // 1. Check custom handlers (file/task/draft tools with complex logic)
+    const custom = CUSTOM_HANDLERS[name]
+    if (custom) {
+      if (!REGISTRY_OFFICE_ID && name !== 'spawn_task_session' && name !== 'batch_spawn_task_sessions') {
+        return { success: false, error: 'Office ID not configured' }
+      }
+      log(`[call] ${name} → custom handler`)
+      return await custom(args || {})
+    }
+
+    // 2. Check special routes (non-standard URL patterns)
+    const special = SPECIAL_ROUTES[name]
+    let method, urlPath
+    if (special) {
+      method = special.method
+      urlPath = special.path(h, args)
+    } else {
+      // 3. Default pattern: POST /api/{handle}/tools/{kebab-name}
+      method = 'POST'
+      urlPath = `/api/${h}/tools/${toKebab(name)}`
+    }
+
+    const url = `${CHAT_BRIDGE_URL}${urlPath}`
+    log(`[call] ${name} → ${method} ${urlPath}`)
+
+    const options = method === 'GET'
+      ? { method: 'GET' }
+      : { method, body: JSON.stringify(args || {}) }
+
+    return await fetchJSON(url, options)
+  } catch (err) {
+    log(`[call] ${name} failed:`, err.message)
+    return { success: false, error: err.message }
+  }
+}
+
+// ── MCP JSON-RPC protocol ────────────────────────────────────────────────────
+
+class McpServer {
+  constructor() {
+    this.toolsLoaded = false
+    this.tools = []
+  }
+
+  async ensureToolsLoaded() {
+    if (!this.toolsLoaded) {
+      this.tools = await loadToolSchemas()
+      this.toolsLoaded = true
+    }
+  }
+
+  async handleRequest(request) {
+    const { method, params, id } = request
+
+    switch (method) {
+      case 'initialize':
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            serverInfo: { name: 'vo-mcp-lite', version: '1.0.0' },
+          },
+        }
+
+      case 'tools/list':
+        await this.ensureToolsLoaded()
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            tools: this.tools.map(t => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema,
+            })),
+          },
+        }
+
+      case 'tools/call': {
+        const { name, arguments: toolArgs } = params || {}
+        if (!name) return this.error(id, -32602, 'Tool name is required')
+
+        log(`Tool call: ${name}`)
+        const result = await callTool(name, toolArgs || {})
+        return {
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+          },
+        }
+      }
+
+      case 'notifications/initialized':
+        return null
+
+      default:
+        return this.error(id, -32601, `Method not found: ${method}`)
+    }
+  }
+
+  error(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } }
+  }
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  log('Starting VO MCP Lite v1.0.0')
+  log('Chat Bridge:', CHAT_BRIDGE_URL)
+  log('Agent:', CANONICAL_AGENT_HANDLE || '(not set)')
+  log('Office:', REGISTRY_OFFICE_ID || '(not set)')
+
+  const server = new McpServer()
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  })
+
+  rl.on('line', async (line) => {
+    if (!line.trim()) return
+    try {
+      const request = JSON.parse(line)
+      const response = await server.handleRequest(request)
+      if (response) console.log(JSON.stringify(response))
+    } catch (error) {
+      log('Parse error:', error.message)
+      console.log(JSON.stringify({
+        jsonrpc: '2.0',
+        id: null,
+        error: { code: -32700, message: 'Parse error' },
+      }))
+    }
+  })
+
+  rl.on('close', () => {
+    log('Connection closed')
+    process.exit(0)
+  })
+}
+
+main().catch(error => {
+  log('Fatal error:', error)
+  process.exit(1)
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@office-xyz/claude-code",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Connect Claude Code to Office.xyz — a shared working environment for all your AI agents, cloud and local",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
   "files": [
     "index.js",
     "onboarding.js",
+    "mcp-server-lite.cjs",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"