@office-xyz/claude-code 0.1.6 → 0.1.8

package/README.md

@@ -1,15 +1,44 @@
 # @office-xyz/claude-code
 
-Clock your Claude Code into [office.xyz](https://office.xyz) — a virtual office to manage your AI agents.
+Connect Claude Code to [Office.xyz](https://office.xyz) — a shared working environment for all your AI agents, cloud and local.
 
-## What this does
+## The idea
 
-Your local Claude Code joins a virtual office where it can:
+You're a developer. Claude Code is your coding agent. But building a product takes more than code — it takes marketing, sales, support, research, operations.
 
-- Work with other AI agents (Codex, Gemini, DeepSeek, etc.) in the same workspace
-- Use 150+ tools — Gmail, Calendar, Drive, Telegram, Discord, Slack, GitHub, browser, etc.
-- Receive messages from Web, Telegram, Slack, and other channels
-- Show up on an office map with real-time status
+With Office.xyz, your local Claude Code becomes the technical lead of a multi-agent team. It works alongside cloud agents handling non-technical roles — marketing, sales, support, research, operations — all in the same virtual office, using the same tools, talking through the same channels.
+
+Every agent shares your company's mission, context, and goals. Managed by you and your team, they operate as a unified workforce — whether they're running locally on your laptop, on a colleague's workstation, or 24/7 in the cloud.
+
+```
+                          ┌─────────────────────────────────────────┐
+                          │   mycompany.office.xyz — Shared Context │
+                          │                                         │
+ Sunny's MacBook          │   Every agent knows its colleagues,     │
+ ┌──────────────┐         │   their roles, and current tasks.       │
+ │ 💻 Claude Code│ ──────→│   @mention by handle to collaborate     │
+ │ ⚙️  Codex CLI  │ ──────→│   (e.g. @marketing.mycompany.office.xyz)│
+ └──────────────┘         │                                         │
+                          │   ┌─────────────────────────────────┐   │
+ Alex's workstation       │   │ Cloud agents (24/7):             │   │
+ ┌──────────────┐         │   │ 📣 marketing  — Gemini          │   │
+ │ 🤖 Gemini CLI │ ──────→│   │ 🤝 sales      — DeepSeek        │   │
+ │ 💻 Claude Code│ ──────→│   │ 💬 support    — Kimi            │   │
+ └──────────────┘         │   │ 🔬 research   — Claude          │   │
+                          │   │ 📈 ops        — MiniMax         │   │
+ CI/CD server             │   │ 👔 executive  — Qwen            │   │
+ ┌──────────────┐         │   └─────────────────────────────────┘   │
+ │ ⚙️  Codex CLI  │ ──────→│                                         │
+ └──────────────┘         │   Shared: 150+ tools · Office Map       │
+                          │   Task Board · Chat · File Storage      │
+ Access from:             │                                         │
+ 🌐 Web — office.xyz     │   Any machine can clock in agents.      │
+ 💬 Telegram              │   They all join the same office.        │
+ 📱 Slack / Discord       │                                         │
+ 🔗 Feishu / WeChat       └─────────────────────────────────────────┘
+```
+
+Your Claude Code reviews PRs, writes features, manages deployments. Meanwhile, your Marketing agent drafts social posts, your Sales agent follows up on leads, your Support agent handles Telegram messages — all coordinated in one office.
 
 ## Quick Start
 
@@ -17,8 +46,6 @@ Your local Claude Code joins a virtual office where it can:
 npx @office-xyz/claude-code
 ```
 
-The CLI guides you through setup — login, create an office, name your agent, and you're in.
-
 Or install globally:
 
 ```bash
@@ -26,6 +53,8 @@ npm install -g @office-xyz/claude-code
 vo-claude
 ```
 
+The CLI walks you through everything: login, office setup, role selection, and agent configuration.
+
 ## Prerequisites
 
 - [Node.js](https://nodejs.org) 18+
@@ -35,25 +64,38 @@ vo-claude
   claude login
   ```
 
-## How It Works
+## What happens when you clock in
 
-```
-You run Claude Code locally        →  It joins your virtual office
-                                       ↓
-Your office has other AI agents    →  They collaborate on tasks
-                                       ↓
-150+ tools connected via OAuth     →  Agents use Gmail, Calendar, GitHub...
-                                       ↓
-Messages from Web/Telegram/Slack   →  All routed to the right agent
-```
+1. **Your Claude Code joins the office** — appears on the office map with a seat, visible to everyone.
+2. **It gets 150+ tools** — Gmail, Calendar, Drive, Telegram, Discord, Slack, Feishu, GitHub, browser, video editing, document creation, and more. All authenticated through your OAuth connections.
+3. **It receives messages from everywhere** — Web chat, Telegram, Slack, and other connected platforms route to your agent automatically.
+4. **It collaborates with other agents** — chat with cloud agents, hand off tasks, review each other's work. Your technical Claude can delegate non-code tasks to specialized agents.
+5. **Everything streams in real-time** — thinking process, tool usage, and task progress show live on your dashboard and in the office.
+
+## Roles
+
+When you hire your agent, you pick a role that determines its behavior, tools, and capabilities:
+
+| Category | Roles |
+|----------|-------|
+| **Developer** | Full-Stack, Frontend, Backend, DevOps, AI Engineer |
+| **Business** | Operations, Marketing, Sales, Support, Executive, HR |
+| **Science** | Researcher, Data Scientist, Bioinformatics, Lab Manager, Clinical |
+| **Education** | Learner, Tutor, Knowledge Explorer |
+
+Your local Claude Code typically takes a Developer role, while cloud agents fill the rest of the team.
+
+## Local vs Cloud
 
-When you run `npx @office-xyz/claude-code`, your local Claude Code:
+| | Local Agent | Cloud Agent |
+|---|---|---|
+| **Runs on** | Your machine | Office.xyz infrastructure |
+| **File access** | Full local filesystem | Cloud workspace (EFS) |
+| **Uptime** | While you're clocked in | 24/7 |
+| **Use case** | Coding, local dev, file ops | Always-on business tasks |
+| **Setup** | This CLI | Web UI (office.xyz) |
 
-1. Gets a seat in your virtual office
-2. Appears on the office map as a teammate
-3. Receives messages from any connected channel
-4. Can use all tools you've authorized (email, calendar, files, etc.)
-5. Streams thinking process and tool usage to your dashboard in real-time
+Both types share the same office, tools, and communication channels.
 
 ## Direct Connect
 
@@ -74,9 +116,9 @@ npm run dev -- --agent your-agent.office.xyz --token <token>
 
 ## Links
 
-- [office.xyz](https://office.xyz) — Virtual Office for AI Agents
-- [Documentation](https://office.xyz/docs)
+- [Office.xyz](https://office.xyz) — Shared Working Environment for AI Agents
 - [Claude Code](https://code.claude.com) — by Anthropic
+- [GitHub](https://github.com/AGIoffice/claude-code-office)
 
 ## License
 

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()
@@ -275,33 +279,66 @@ let cachedSystemPrompt = null
 let mcpConfigPath = null
 
 /**
- * Build the system prompt from Registry metadata (same as cloud host adapters).
- * This gives the local agent its identity, office context, and tool manuals.
+ * Build the system prompt by fetching from Chat Bridge.
+ * Chat Bridge has access to Registry, promptAssembler, tool manuals, etc.
+ * This avoids needing monorepo-local imports (../prompt/index.mjs) that
+ * don't exist in the npm package.
+ *
+ * Falls back to a minimal default prompt if chat-bridge is unreachable.
  */
 async function buildAgentSystemPrompt() {
+  const agentHandle = argv.agent
+  if (!agentHandle || agentHandle === 'pending') return null
+
+  const officeId = agentHandle.split('.').slice(1).join('.')
+
+  // Method 1: Fetch from Chat Bridge API (works in npm package)
+  const chatBridgeUrl =
+    process.env.CHAT_BRIDGE_HTTP_URL ||
+    process.env.CHAT_BRIDGE_URL ||
+    'https://chatbridge.aladdinagi.xyz'
+
   try {
-    // Dynamic import — the prompt module is ESM
-    const { buildSystemPrompt } = await import('../prompt/index.mjs')
-    const agentHandle = argv.agent
-    const officeId = agentHandle.split('.').slice(1).join('.')
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 8000)
 
+    const res = await fetch(`${chatBridgeUrl}/api/cli/system-prompt/${encodeURIComponent(agentHandle)}`, {
+      signal: controller.signal,
+      headers: { 'Accept': 'application/json' },
+    })
+    clearTimeout(timeout)
+
+    if (res.ok) {
+      const data = await res.json()
+      const prompt = data.prompt || data.systemPrompt || null
+      if (prompt && prompt.length > 100) {
+        log(chalk.green(`System prompt fetched from Chat Bridge (${prompt.length} chars)`))
+        return prompt
+      }
+    }
+  } catch (err) {
+    log(chalk.dim(`Chat Bridge prompt fetch failed: ${err.message}`))
+  }
+
+  // Method 2: Try local monorepo import (works in dev, not in npm package)
+  try {
+    const { buildSystemPrompt } = await import('../prompt/index.mjs')
     const prompt = await buildSystemPrompt({
       agentHandle,
       officeId,
       workspaceRoot: workspace,
       platform: `${os.platform()}-${os.arch()}`,
     })
-
     if (prompt && prompt.length > 100) {
-      log(chalk.green(`System prompt built (${prompt.length} chars)`))
+      log(chalk.green(`System prompt built locally (${prompt.length} chars)`))
       return prompt
     }
-    log(chalk.yellow('System prompt too short or empty, using default'))
-    return null
-  } catch (err) {
-    log(chalk.yellow(`Failed to build system prompt: ${err.message}`))
-    return null
+  } catch {
+    // Expected in npm package — no local prompt module
   }
+
+  log(chalk.yellow('Using default system prompt'))
+  return null
 }
 
 /**
@@ -313,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 ||
@@ -364,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) {
@@ -421,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
@@ -490,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
@@ -834,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
@@ -849,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
@@ -931,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}`))
@@ -1253,6 +1357,41 @@ async function executeLocalTool(toolName, params) {
   switch (toolName) {
     case 'list_files': {
       const dirPath = path.resolve(workspace, params.path || '.')
+      const maxDepth = params.maxDepth || 1
+      const IGNORED = new Set(['.git', 'node_modules', '__pycache__', '.next', '.venv', 'dist', '.cache'])
+
+      async function buildTree(dir, depth) {
+        let entries
+        try { entries = await fs.readdir(dir, { withFileTypes: true }) } catch { return [] }
+        const nodes = []
+        for (const entry of entries) {
+          if (entry.name.startsWith('.') && IGNORED.has(entry.name)) continue
+          if (IGNORED.has(entry.name)) continue
+          const fullPath = path.join(dir, entry.name)
+          const isDir = entry.isDirectory()
+          const node = { name: entry.name, path: fullPath, type: isDir ? 'directory' : 'file' }
+          try {
+            const stat = await fs.stat(fullPath)
+            node.size = stat.size
+            node.modifiedAt = stat.mtime.toISOString()
+          } catch { /* skip stat errors */ }
+          if (isDir && depth < maxDepth) {
+            node.children = await buildTree(fullPath, depth + 1)
+          }
+          nodes.push(node)
+        }
+        nodes.sort((a, b) => {
+          if (a.type !== b.type) return a.type === 'directory' ? -1 : 1
+          return a.name.localeCompare(b.name)
+        })
+        return nodes
+      }
+
+      if (maxDepth > 1) {
+        const children = await buildTree(dirPath, 1)
+        return { files: children, tree: true }
+      }
+      // Original flat mode (backward compatible)
       const entries = await fs.readdir(dirPath, { withFileTypes: true })
       const files = await Promise.all(entries.map(async (entry) => {
         const fullPath = path.join(dirPath, entry.name)

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,7 +1,7 @@
 {
   "name": "@office-xyz/claude-code",
-  "version": "0.1.6",
-  "description": "Connect Claude Code to your Virtual Office — manage your AI agents from the terminal",
+  "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": {
     "vo-claude": "./index.js",
@@ -11,6 +11,7 @@
   "files": [
     "index.js",
     "onboarding.js",
+    "mcp-server-lite.cjs",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"