@office-xyz/claude-code 0.1.8 → 0.1.9

package/index.js

@@ -37,6 +37,13 @@ const TOOL_NAME_MAP = {
   execute_command: 'Bash', read_file: 'Read', write_file: 'Write', edit_file: 'Edit',
   search: 'Grep', run_command: 'Bash', code_edit: 'FileEdit', code_search: 'Grep',
   terminal: 'Bash', file_operation: 'FileEdit',
+  // Claude server-side tools (content_block type → display name)
+  server_tool_use: 'ServerTool', web_search_tool_result: 'WebSearch',
+  web_fetch_tool_result: 'WebFetch', code_execution_tool_result: 'CodeExecution',
+  mcp_tool_use: 'Mcp', mcp_tool_result: 'Mcp',
+  bash_code_execution_tool_result: 'Bash',
+  text_editor_code_execution_tool_result: 'Edit',
+  tool_search_tool_result: 'ToolSearch', container_upload: 'Upload',
   // General aliases
   bash: 'Bash', grep: 'Grep', glob: 'Glob', ls: 'LS',
 }
@@ -257,16 +264,28 @@ const model = argv.model || providerConfig.defaultModel
 
 // ── Session tracking ───────────────────────────────────────────────────────
 // Map VO sessionId → Claude session_id for conversation continuity.
-// Cleared on clock-in to avoid stale sessions that ignore --append-system-prompt.
+// Persisted to disk so sessions survive clock-out / clock-in cycles.
+// --resume and --append-system-prompt coexist fine, so resumed sessions
+// still pick up fresh system prompts and MCP tools (registered globally).
 const SESSION_MAP_FILE = path.join(os.tmpdir(), `vo-sessions-${(argv.agent || 'pending').replace(/\./g, '-')}.json`)
 const sessionMap = new Map()
 
-// Clear stale sessions on startup — stale sessions from previous clock-ins
-// ignore new --append-system-prompt and MCP tools.
+// Load persisted sessions from previous clock-in (if any)
 try {
-  require('fs').unlinkSync(SESSION_MAP_FILE)
-  // Will be re-created when first session is mapped
-} catch { /* no file to delete */ }
+  const raw = require('fs').readFileSync(SESSION_MAP_FILE, 'utf-8')
+  const parsed = JSON.parse(raw)
+  // Support both formats: Array of entries [[k,v], ...] and Object {k: v}
+  const entries = Array.isArray(parsed) ? parsed : Object.entries(parsed)
+  for (const [k, v] of entries) sessionMap.set(k, v)
+  log(chalk.dim(`Restored ${sessionMap.size} session mapping(s) from previous clock-in`))
+} catch { /* no file or invalid — start fresh */ }
+
+/** Persist session map to disk (fire-and-forget) */
+function persistSessionMap() {
+  try {
+    require('fs').writeFileSync(SESSION_MAP_FILE, JSON.stringify([...sessionMap]), 'utf-8')
+  } catch { /* best-effort */ }
+}
 
 // Track active command processes PER SESSION for concurrent conversation support.
 // Key: sessionId, Value: { child, commandId }. Different clients (web, Telegram)
@@ -516,7 +535,7 @@ async function handleMessage(message) {
     // Kill previous command for THIS SESSION only. Other sessions continue in parallel.
     const prev = sessionId ? activeChildren.get(sessionId) : null
     if (prev?.child) {
-      log(chalk.dim(`[${sessionLabel}] Killing previous command for same session`))
+      log(chalk.dim(`[${sessionId}] Killing previous command for same session`))
       sendJSON({
         type: 'streaming.aborted',
         sessionId,
@@ -538,6 +557,9 @@ async function handleMessage(message) {
     const claudeSessionId = sessionId ? sessionMap.get(sessionId) : null
     if (claudeSessionId && providerConfig.resumeFlag) {
       args.push(providerConfig.resumeFlag, claudeSessionId)
+      log(chalk.green(`[session] Resuming: ${sessionId} → ${claudeSessionId}`))
+    } else if (sessionId) {
+      log(chalk.yellow(`[session] No resume binding for ${sessionId} (map size: ${sessionMap.size})`))
     }
     // System prompt + platform context injection.
     // shell: false — no escaping needed, args passed directly.
@@ -734,6 +756,11 @@ async function handleMessage(message) {
           return
         }
 
+        // Citations delta — ignore silently (citations are embedded in final text)
+        if (streamEvent?.type === 'content_block_delta' && streamEvent?.delta?.type === 'citations_delta') {
+          return
+        }
+
         // Thinking deltas
         if (streamEvent?.type === 'content_block_delta' && streamEvent?.delta?.type === 'thinking_delta') {
           const deltaText = streamEvent.delta.thinking || streamEvent.delta.text || ''
@@ -788,19 +815,42 @@ async function handleMessage(message) {
             return
           }
 
-          if (block?.type === 'tool_use') {
-            const toolUseId = block.id || `tool-${now}-${Math.random().toString(36).slice(2, 8)}`
+          // All tool-like block types: tool_use (client), server_tool_use (Anthropic server),
+          // mcp_tool_use, and result blocks that appear as content_block_start in stream-json.
+          // The original Claude CLI sets "tool-input" spinner state for all of these.
+          const TOOL_BLOCK_TYPES = new Set([
+            'tool_use', 'server_tool_use', 'mcp_tool_use',
+            'web_search_tool_result', 'web_fetch_tool_result',
+            'code_execution_tool_result', 'bash_code_execution_tool_result',
+            'text_editor_code_execution_tool_result', 'tool_search_tool_result',
+            'mcp_tool_result', 'container_upload',
+          ])
+          if (TOOL_BLOCK_TYPES.has(block?.type)) {
+            // For server_tool_use, the tool name is in block.name (e.g. "web_search")
+            // For result blocks, derive name from block type itself
+            const rawName = block.name || block.type
+            const toolUseId = block.id || block.tool_use_id || `tool-${now}-${Math.random().toString(36).slice(2, 8)}`
             if (blockIndex !== null) {
               activeToolsByIndex.set(blockIndex, {
                 toolUseId,
-                toolName: block.name || 'tool',
-                input: block.input,
+                toolName: rawName,
+                input: block.input || {},
               })
             }
             emitToolStart({
               toolUseId,
-              toolName: block.name || 'tool',
-              input: block.input,
+              toolName: rawName,
+              input: block.input || {},
+              timestamp: now,
+            })
+          }
+
+          // Compaction events — notify frontend that context is being compressed
+          if (block?.type === 'compaction') {
+            emitToolStart({
+              toolUseId: block.id || `compaction-${now}`,
+              toolName: 'Compaction',
+              input: {},
               timestamp: now,
             })
           }
@@ -865,10 +915,11 @@ async function handleMessage(message) {
             if (block.type === 'text' && block.text) {
               if (!fullText) fullText = block.text
             }
-            // Extract complete tool_use input — the assistant message contains the
+            // Extract complete tool input — the assistant message contains the
             // fully accumulated input (unlike content_block_start which has {}).
-            // This allows us to retroactively update tool events with real input data.
-            if (block.type === 'tool_use' && block.id && block.input) {
+            // This applies to tool_use, server_tool_use, and mcp_tool_use blocks.
+            const isToolBlock = block.type === 'tool_use' || block.type === 'server_tool_use' || block.type === 'mcp_tool_use'
+            if (isToolBlock && block.id && block.input) {
               const existing = activeToolsById.get(block.id)
               if (existing && (!existing.input || Object.keys(existing.input).length === 0)) {
                 existing.input = block.input
@@ -921,6 +972,39 @@ async function handleMessage(message) {
           }
           return
         }
+
+        // System events — forward plan mode, hooks, and other system subtypes
+        // These are top-level events (not wrapped in stream_event) that the CLI
+        // emits in --verbose stream-json mode for UI state changes.
+        if (event.type === 'system') {
+          const subtype = event.subtype
+          // Plan mode transitions — let frontend know agent entered/exited planning
+          if (subtype === 'plan_mode' || subtype === 'plan_mode_exit' || subtype === 'plan_mode_reentry') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, timestamp: now } })
+            return
+          }
+          // Hook lifecycle — show user that hooks are running
+          if (subtype === 'hook_started' || subtype === 'hook_progress' || subtype === 'hook_response') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, hookName: event.hook_name, timestamp: now } })
+            return
+          }
+          // Task/agent notifications (subagent spawned, progress, etc.)
+          if (subtype === 'task_notification' || subtype === 'task_progress') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, message: event.message, timestamp: now } })
+            return
+          }
+          // MCP progress
+          if (subtype === 'mcp_message' || subtype === 'mcp_progress') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, message: event.message, timestamp: now } })
+            return
+          }
+          // Context compaction boundaries
+          if (subtype === 'compact_boundary' || subtype === 'microcompact_boundary') {
+            sendJSON({ type: 'system_event', sessionId, commandId, event: { subtype, timestamp: now } })
+            return
+          }
+          return
+        }
       } catch {
         // Not JSON or unrecognized format — ignore
       }
@@ -947,6 +1031,7 @@ async function handleMessage(message) {
       // Store Claude session_id for conversation continuity
       if (resultSessionId && sessionId) {
         sessionMap.set(sessionId, resultSessionId)
+        persistSessionMap()
         log(chalk.dim(`Session mapped: ${sessionId} → ${resultSessionId}`))
       }
 
@@ -1132,18 +1217,14 @@ function connect() {
       if (mcpRegistered) mcpConfigPath = 'registered'  // flag to skip re-registration
     }
 
-    // Banner
-    console.log('')
-    console.log(chalk.bold.cyan('  ╔══════════════════════════════════════╗'))
-    console.log(chalk.bold.cyan('  ║  Clocked in to Virtual Office       ║'))
-    console.log(chalk.bold.cyan('  ╚══════════════════════════════════════╝'))
-    console.log(chalk.dim(`  Agent:    ${argv.agent}`))
-    console.log(chalk.dim(`  Provider: ${argv.provider}`))
-    console.log(chalk.dim(`  Workspace: ${workspace}`))
-    console.log(chalk.dim(`  Identity: ${cachedSystemPrompt ? 'loaded' : 'default'}`))
-    console.log(chalk.dim(`  Tools:    ${mcpRegistered ? 'VO MCP registered ✓' : 'basic only'}`))
-    console.log(chalk.dim(`  Press Ctrl+C to clock out`))
-    console.log('')
+    // Banner — use the printClockInBanner from onboarding for consistent look
+    const { printClockInBanner: printBanner } = await import('./onboarding.js')
+    printBanner({
+      agentHandle: argv.agent,
+      model: argv.provider,
+      seat: null,
+      workspace,
+    })
   })
 
   ws.on('message', (data) => {

package/onboarding.js

@@ -125,38 +125,67 @@ export async function checkForUpdate() {
   }
 }
 
+// ── Adam Sprite Art (auto-generated from pixel art sprite sheet) ──────────
+// Half-block rendering: 2x2 pixels → 1 char, truecolor ANSI
+import { ADAM_IDLE_FRAMES, ADAM_SIT_FRAME, ADAM_FRAMES } from './adam-frames.js'
+
 // ── Banner ────────────────────────────────────────────────────────────────
 
 export function printBanner(subtitle = 'Manage Your AI Agents') {
+  const frame = ADAM_IDLE_FRAMES[0]
+
+  // Text lines aligned to Adam sprite rows (~23 rows)
+  // Adam is ~32 chars wide; text appears to the right with padding
+  const textLines = [
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    '',
+    chalk.bold.white('  Virtual Office'),
+    chalk.dim(`  ${subtitle}`),
+    '',
+    chalk.dim('  office.xyz'),
+  ]
+
   console.log('')
-  console.log(chalk.cyan('  ┌─────────────────────────────────────────┐'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('   ▓▓▓') + '                                   ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('  ▓░░▓') + chalk.bold.white('   Virtual Office') + '                  ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('  ▓▓▓▓') + chalk.dim(`   ${subtitle}`) + '           ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.bold.white('   ██') + '                                    ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.dim('  ▓▓▓▓   office.xyz') + '                      ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  └─────────────────────────────────────────┘'))
+  for (let i = 0; i < frame.length; i++) {
+    console.log('  ' + frame[i] + (textLines[i] || ''))
+  }
   console.log('')
 }
 
 export function printClockInBanner({ agentHandle, model, seat, workspace }) {
+  const frame = ADAM_SIT_FRAME
+
+  // Right-side info lines aligned to Adam's sitting sprite (~23 rows)
+  const infoLines = [
+    '',
+    '',
+    '',
+    '',
+    '',
+    chalk.green.bold('  ✓ Clocked in to Virtual Office'),
+    '',
+    chalk.dim('  Agent:  ') + chalk.bold.white(agentHandle),
+    chalk.dim('  Model:  ') + chalk.white(model || 'Claude Opus 4.6'),
+    seat ? (chalk.dim('  Seat:   ') + chalk.white(seat)) : '',
+    chalk.dim('  Dir:    ') + chalk.white(workspace || process.cwd()),
+    '',
+    chalk.dim('  Web:    ') + chalk.underline.cyan('https://beta.office.xyz'),
+    '',
+    chalk.dim('  Press ') + chalk.yellow('Ctrl+C') + chalk.dim(' to clock out'),
+  ]
+
   console.log('')
-  console.log(chalk.cyan('  ┌─────────────────────────────────────────┐'))
-  console.log(chalk.cyan('  │') + chalk.green.bold('  ✓ Clocked in to Virtual Office') + '         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.dim('  Agent:     ') + chalk.bold.white(agentHandle))
-  console.log(chalk.cyan('  │') + chalk.dim('  Model:     ') + chalk.white(model || 'Claude Opus 4.6'))
-  if (seat) {
-    console.log(chalk.cyan('  │') + chalk.dim('  Seat:      ') + chalk.white(seat))
+  for (let i = 0; i < Math.max(frame.length, infoLines.length); i++) {
+    const sprite = (i < frame.length) ? frame[i] : ''
+    const info = (i < infoLines.length) ? infoLines[i] : ''
+    console.log('  ' + sprite + info)
   }
-  console.log(chalk.cyan('  │') + chalk.dim('  Workspace: ') + chalk.white(workspace || process.cwd()))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.dim('  Web UI:    ') + chalk.underline.cyan('https://beta.office.xyz'))
-  console.log(chalk.cyan('  │') + '                                         ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  │') + chalk.yellow('  Press Ctrl+C to clock out') + '              ' + chalk.cyan('│'))
-  console.log(chalk.cyan('  └─────────────────────────────────────────┘'))
   console.log('')
 }
 
@@ -510,19 +539,54 @@ export async function runOnboarding() {
   // 1. Check cached session
   const cached = loadSession()
 
-  if (cached?.sessionToken && cached?.lastAgent?.handle && cached?.lastAgent?.connectionToken) {
-    // Quick reconnect path
+  if (cached?.sessionToken && cached?.lastAgent?.handle) {
+    // Quick reconnect path — always refresh token to avoid stale token rejection
     const spinner = ora('Validating session...').start()
     try {
       const validation = await api('GET', '/api/cli/auth/session', null, cached.sessionToken)
       if (validation.success) {
+        spinner.text = 'Refreshing connection...'
+
+        // Re-hire with same agent name to get a fresh connectionToken.
+        // This is idempotent — if agent exists, it just refreshes the token.
+        const agentName = cached.lastAgent.handle.split('.')[0]
+        const officeId = cached.lastOfficeId || null
+
+        let freshToken = cached.lastAgent.connectionToken
+        let seat = cached.lastAgent.seat
+
+        if (agentName && officeId) {
+          try {
+            const result = await api('POST', '/api/cli/office/hire', {
+              officeId,
+              agentName,
+              provider: 'claude-code',
+            }, cached.sessionToken)
+            freshToken = result.connectionToken || freshToken
+            seat = result.seat || seat
+
+            // Update cached session with fresh token
+            saveSession({
+              ...cached,
+              lastAgent: {
+                ...cached.lastAgent,
+                connectionToken: freshToken,
+                seat,
+              },
+            })
+          } catch (err) {
+            // If refresh fails, try with cached token anyway
+            console.log(chalk.dim(`  Token refresh failed (${err.message}), using cached token`))
+          }
+        }
+
         spinner.succeed(`Welcome back, ${chalk.bold(cached.email || cached.displayName || 'user')}!`)
         console.log(chalk.dim(`  Reconnecting as ${cached.lastAgent.handle}...`))
         console.log(chalk.dim(`  Web interface: ${chalk.underline.cyan('https://beta.office.xyz')}`))
         return {
           agent: cached.lastAgent.handle,
-          token: cached.lastAgent.connectionToken,
-          seat: cached.lastAgent.seat,
+          token: freshToken,
+          seat,
         }
       }
     } catch {
@@ -548,6 +612,7 @@ export async function runOnboarding() {
     sessionToken: session.sessionToken,
     expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
     lastOffice: domain,
+    lastOfficeId: officeId,
     lastAgent: {
       handle: hired.agentHandle,
       connectionToken: hired.connectionToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@office-xyz/claude-code",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Connect Claude Code to Office.xyz — a shared working environment for all your AI agents, cloud and local",
   "type": "module",
   "bin": {