cc-viewer 1.6.93 → 1.6.95

package/lib/sdk-manager.js

@@ -0,0 +1,464 @@
+/**
+ * sdk-manager.js — Agent SDK session lifecycle manager.
+ *
+ * Wraps @anthropic-ai/claude-agent-sdk query() to provide:
+ * - Structured message processing → JSONL entries for the frontend
+ * - canUseTool callback for AskUserQuestion + permission approval
+ * - Streaming status tracking
+ * - Multi-turn conversation via session resume
+ */
+
+import { sdkToJSONLEntry, buildStreamingStatus } from './sdk-adapter.js';
+
+let _query;
+try {
+  const sdk = await import('@anthropic-ai/claude-agent-sdk');
+  _query = sdk.query;
+} catch (err) {
+  console.warn('[SDK] Agent SDK not available:', err.message);
+}
+
+// Interactive tool names — filtered from entries, handled via canUseTool → WS
+const INTERACTIVE_TOOLS = new Set(['AskUserQuestion', 'ExitPlanMode']);
+
+// Session state
+let _sessionId = null;
+let _model = null;
+let _cwd = null;
+let _projectName = null;
+let _permissionMode = 'default';
+let _accumulatedMessages = [];
+let _activeQuery = null;
+let _queryBusy = false; // concurrency guard
+let _sdkTools = null;    // real tools list from SDKSystemMessage
+
+// Stable timestamp per conversation turn — used as dedup key by frontend
+let _turnTimestamp = null;
+
+// Streaming accumulation state
+let _streamingContent = [];
+let _currentBlockData = null;
+let _streamingRequestId = null;
+let _streamThrottleTimer = null;
+
+// Callbacks registered by server.js
+let _onEntry = null;
+let _onStreamingStatus = null;
+let _broadcastWs = null;
+
+// Pending canUseTool promises: id → { resolve }
+const _pendingApprovals = new Map();
+
+// Message queue for messages sent while a query is running
+let _messageQueue = [];
+
+export function isSdkAvailable() {
+  return typeof _query === 'function';
+}
+
+/**
+ * Initialize SDK session.
+ * Does NOT start a query — waits for the first user message via sendUserMessage().
+ */
+export function initSdkSession(cwd, projectName, { onEntry, onStreamingStatus, broadcastWs, permissionMode }) {
+  _cwd = cwd;
+  _projectName = projectName;
+  _onEntry = onEntry;
+  _onStreamingStatus = onStreamingStatus;
+  _broadcastWs = broadcastWs;
+  _permissionMode = permissionMode || 'default';
+  _resetFullState();
+}
+
+/**
+ * Send a user message. Starts a new query (or resumes existing session).
+ * Queues the message if a query is already running.
+ */
+export async function sendUserMessage(text) {
+  if (!_query) throw new Error('Agent SDK not available');
+
+  // If a query is already running, queue this message and return
+  if (_queryBusy) {
+    _messageQueue.push(text);
+    return;
+  }
+
+  _queryBusy = true;
+
+  try {
+    await _executeQuery(text);
+
+    // Process any queued messages
+    while (_messageQueue.length > 0) {
+      const next = _messageQueue.shift();
+      await _executeQuery(next);
+    }
+  } finally {
+    _queryBusy = false;
+  }
+}
+
+/**
+ * Execute a single query for one user message.
+ */
+async function _executeQuery(text) {
+  // Generate stable timestamp for this turn — all entries share it for dedup
+  _turnTimestamp = new Date().toISOString();
+  _streamingRequestId = `sdk_${Date.now()}`;
+
+  // Accumulate user message BEFORE creating entries (this is the request)
+  _accumulatedMessages.push({ role: 'user', content: text });
+
+  const options = {
+    cwd: _cwd,
+    includePartialMessages: true,
+    permissionMode: _permissionMode,
+    canUseTool: _permissionMode === 'bypassPermissions' ? undefined : _handleCanUseTool,
+    ..._permissionMode === 'bypassPermissions' && { allowDangerouslySkipPermissions: true },
+  };
+
+  if (_sessionId) {
+    options.resume = _sessionId;
+  }
+
+  if (_onStreamingStatus) _onStreamingStatus(buildStreamingStatus(true, { model: _model }));
+
+  try {
+    _activeQuery = _query({ prompt: text, options });
+
+    for await (const msg of _activeQuery) {
+      _processMessage(msg);
+    }
+  } catch (err) {
+    if (err.name !== 'AbortError') {
+      console.error('[SDK] Query error:', err.message);
+    }
+  } finally {
+    _resetStreamingState();
+    _activeQuery = null;
+    if (_onStreamingStatus) _onStreamingStatus(buildStreamingStatus(false));
+  }
+}
+
+/**
+ * Process a single SDK message.
+ */
+function _processMessage(msg) {
+  switch (msg.type) {
+    case 'system':
+      if (msg.session_id) _sessionId = msg.session_id;
+      if (msg.model) _model = msg.model;
+      // Capture real tools from init message (tools is string[], convert to {name} format)
+      if (msg.subtype === 'init') {
+        if (Array.isArray(msg.tools)) _sdkTools = msg.tools.map(name => ({ name }));
+      }
+      // Handle compact boundary: reset accumulated messages since SDK compacted internally
+      if (msg.subtype === 'compact_boundary') {
+        _accumulatedMessages = [];
+      }
+      break;
+
+    case 'assistant':
+      // Main agent message (not sub-agent)
+      if (!msg.parent_tool_use_id && msg.message) {
+        _resetStreamingState();
+
+        // Snapshot messages BEFORE adding assistant (body.messages = request history, unfiltered)
+        const requestMessages = [..._accumulatedMessages];
+
+        // Accumulate the assistant response for future turns
+        // Merge with previous if both are assistant (same API turn, multiple content blocks)
+        const lastMsg = _accumulatedMessages[_accumulatedMessages.length - 1];
+        if (lastMsg && lastMsg.role === 'assistant' && Array.isArray(lastMsg.content) && Array.isArray(msg.message.content)) {
+          lastMsg.content = [...lastMsg.content, ...msg.message.content];
+        } else {
+          _accumulatedMessages.push({ role: 'assistant', content: msg.message.content });
+        }
+
+        // Only filter interactive tools from the RESPONSE content (Last Response rendering),
+        // NOT from body.messages (history) — filtering history creates orphaned tool_results
+        const filteredContent = _filterInteractiveContent(msg.message.content);
+        const displayMsg = { ...msg, message: { ...msg.message, content: filteredContent } };
+
+        // Convert to JSONL entry with stable turn timestamp and real SDK metadata
+        const entry = sdkToJSONLEntry(displayMsg, requestMessages, _model, _projectName, {
+          timestamp: _turnTimestamp,
+          tools: _sdkTools,
+        });
+        if (_onEntry) _onEntry(entry);
+      }
+      if (msg.session_id) _sessionId = msg.session_id;
+      break;
+
+    case 'user':
+      // Tool results from tool execution — accumulate (skip replays)
+      if (msg.message && !msg.isReplay) {
+        // Merge with previous if both are user (consecutive tool_results for same turn)
+        const lastUserMsg = _accumulatedMessages[_accumulatedMessages.length - 1];
+        if (lastUserMsg && lastUserMsg.role === 'user' && Array.isArray(lastUserMsg.content) && Array.isArray(msg.message.content)) {
+          lastUserMsg.content = [...lastUserMsg.content, ...msg.message.content];
+        } else {
+          _accumulatedMessages.push({ role: 'user', content: msg.message.content });
+        }
+      }
+      break;
+
+    case 'stream_event':
+      if (_onStreamingStatus) {
+        _onStreamingStatus(buildStreamingStatus(true, { model: _model }));
+      }
+      if (!msg.parent_tool_use_id) {
+        _processStreamEvent(msg.event);
+      }
+      break;
+
+    case 'result':
+      if (msg.session_id) _sessionId = msg.session_id;
+      if (_onStreamingStatus) _onStreamingStatus(buildStreamingStatus(false));
+      break;
+
+    default:
+      break;
+  }
+}
+
+/**
+ * Filter interactive tool_use blocks from an array of content blocks.
+ */
+function _filterInteractiveContent(content) {
+  return Array.isArray(content)
+    ? content.filter(b => b.type !== 'tool_use' || !INTERACTIVE_TOOLS.has(b.name))
+    : content;
+}
+
+/**
+ * Process a single streaming event.
+ * Accumulates content blocks and pushes throttled in-progress entries.
+ */
+function _processStreamEvent(event) {
+  if (!event) return;
+  const type = event.type;
+
+  if (type === 'message_start') {
+    _streamingContent = [];
+    _currentBlockData = null;
+  } else if (type === 'content_block_start') {
+    const block = event.content_block;
+    if (!block) return;
+    if (block.type === 'text') {
+      _currentBlockData = { type: 'text', text: block.text || '' };
+    } else if (block.type === 'thinking') {
+      _currentBlockData = { type: 'thinking', thinking: block.thinking || '' };
+    } else if (block.type === 'tool_use') {
+      if (INTERACTIVE_TOOLS.has(block.name)) {
+        _currentBlockData = null;
+      } else {
+        _currentBlockData = { type: 'tool_use', id: block.id, name: block.name, input: {} };
+      }
+    } else {
+      _currentBlockData = null;
+    }
+  } else if (type === 'content_block_delta') {
+    const delta = event.delta;
+    if (!delta || !_currentBlockData) return;
+    if (delta.type === 'text_delta' && _currentBlockData.type === 'text') {
+      _currentBlockData.text += delta.text || '';
+      _pushStreamingEntry();
+    } else if (delta.type === 'thinking_delta' && _currentBlockData.type === 'thinking') {
+      _currentBlockData.thinking += delta.thinking || '';
+    } else if (delta.type === 'input_json_delta' && _currentBlockData.type === 'tool_use') {
+      if (!_currentBlockData._rawInput) _currentBlockData._rawInput = '';
+      _currentBlockData._rawInput += delta.partial_json || '';
+    }
+  } else if (type === 'content_block_stop') {
+    if (_currentBlockData) {
+      if (_currentBlockData.type === 'tool_use' && _currentBlockData._rawInput) {
+        try { _currentBlockData.input = JSON.parse(_currentBlockData._rawInput); } catch {}
+        delete _currentBlockData._rawInput;
+      }
+      _streamingContent.push(_currentBlockData);
+      _currentBlockData = null;
+      _pushStreamingEntry();
+    }
+  } else if (type === 'message_stop') {
+    _resetStreamingState();
+  }
+}
+
+/**
+ * Push a throttled in-progress entry with accumulated streaming content.
+ */
+function _pushStreamingEntry() {
+  if (_streamThrottleTimer) return;
+  _streamThrottleTimer = setTimeout(() => {
+    _streamThrottleTimer = null;
+    _flushStreamingEntry();
+  }, 100);
+}
+
+function _flushStreamingEntry() {
+  if (!_onEntry) return;
+  const content = [..._streamingContent];
+  if (_currentBlockData) {
+    const clone = { ..._currentBlockData };
+    if (clone._rawInput) delete clone._rawInput;
+    content.push(clone);
+  }
+  if (content.length === 0) return;
+
+  const syntheticMsg = {
+    message: {
+      id: _streamingRequestId,
+      type: 'message',
+      role: 'assistant',
+      model: _model,
+      content,
+      stop_reason: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    },
+  };
+  // Use the SAME stable turn timestamp so in-progress entries dedup with the final entry
+  const entry = sdkToJSONLEntry(syntheticMsg, [..._accumulatedMessages], _model, _projectName, {
+    inProgress: true,
+    tools: _sdkTools,
+    requestId: _streamingRequestId,
+    timestamp: _turnTimestamp,
+  });
+  _onEntry(entry);
+}
+
+function _resetStreamingState() {
+  _streamingContent = [];
+  _currentBlockData = null;
+  if (_streamThrottleTimer) {
+    clearTimeout(_streamThrottleTimer);
+    _streamThrottleTimer = null;
+  }
+}
+
+/**
+ * canUseTool callback — handles AskUserQuestion + permission approval.
+ */
+async function _handleCanUseTool(toolName, input, options) {
+  const id = options?.toolUseID || `sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+  if (toolName === 'ExitPlanMode') {
+    if (_broadcastWs) {
+      _broadcastWs({ type: 'sdk-plan-pending', id, input });
+    }
+    const result = await _waitForApproval(id, 5 * 60 * 1000);
+    if (result === null) {
+      return { behavior: 'deny', message: 'Timeout waiting for plan approval' };
+    }
+    if (typeof result === 'object' && result.approve === false) {
+      return { behavior: 'deny', message: result.feedback || 'User rejected the plan' };
+    }
+    return { behavior: 'allow', updatedInput: input };
+  }
+
+  if (toolName === 'AskUserQuestion') {
+    if (_broadcastWs) {
+      _broadcastWs({ type: 'sdk-ask-pending', id, questions: input.questions });
+    }
+    const answers = await _waitForApproval(id, 5 * 60 * 1000);
+    if (answers === null) {
+      return { behavior: 'deny', message: 'Timeout waiting for user answer' };
+    }
+    return { behavior: 'allow', updatedInput: { questions: input.questions, answers } };
+  }
+
+  // Only mutating tools need explicit approval; read-only tools auto-allow
+  const APPROVAL_TOOLS = new Set(['Bash', 'Edit', 'Write', 'NotebookEdit']);
+  if (!APPROVAL_TOOLS.has(toolName)) {
+    return { behavior: 'allow', updatedInput: input };
+  }
+
+  // Permission approval for mutating tools
+  const suggestions = options?.suggestions;
+  if (_broadcastWs) {
+    _broadcastWs({ type: 'perm-hook-pending', id, toolName, input });
+  }
+
+  const result = await _waitForApproval(id, 5 * 60 * 1000);
+  if (result === null) {
+    return { behavior: 'deny', message: 'Timeout waiting for user approval' };
+  }
+  const decision = typeof result === 'object' ? result.decision : result;
+  const allowSession = typeof result === 'object' && result.allowSession;
+  if (decision === 'deny') {
+    return { behavior: 'deny', message: 'User denied via cc-viewer' };
+  }
+  const response = { behavior: 'allow', updatedInput: input };
+  if (allowSession && Array.isArray(suggestions) && suggestions.length > 0) {
+    response.updatedPermissions = suggestions;
+  }
+  return response;
+}
+
+function _waitForApproval(id, timeoutMs) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      _pendingApprovals.delete(id);
+      resolve(null);
+    }, timeoutMs);
+    _pendingApprovals.set(id, {
+      resolve: (value) => {
+        clearTimeout(timer);
+        _pendingApprovals.delete(id);
+        resolve(value);
+      },
+    });
+  });
+}
+
+/**
+ * Resolve a pending canUseTool approval.
+ * Called by server.js when a WS message arrives.
+ */
+export function resolveApproval(id, value) {
+  const pending = _pendingApprovals.get(id);
+  if (pending) {
+    pending.resolve(value);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Stop the active SDK session.
+ */
+export function stopSession() {
+  // Use close() instead of interrupt() — works in all modes
+  if (_activeQuery && typeof _activeQuery.close === 'function') {
+    _activeQuery.close();
+  }
+  _resetFullState();
+}
+
+/**
+ * Reset all session state.
+ */
+function _resetFullState() {
+  _activeQuery = null;
+  _sessionId = null;
+  _model = null;
+  _sdkTools = null;
+  _queryBusy = false;
+  _accumulatedMessages = [];
+  _turnTimestamp = null;
+  _messageQueue = [];
+  _resetStreamingState();
+  _streamingRequestId = null;
+  // Reject all pending approvals
+  for (const [, pending] of _pendingApprovals) {
+    pending.resolve(null);
+  }
+  _pendingApprovals.clear();
+}
+
+/**
+ * Get current session ID (for resume).
+ */
+export function getSessionId() {
+  return _sessionId;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.93",
+  "version": "1.6.95",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",
@@ -80,9 +80,9 @@
     "antd": "^5.29.2",
     "diff": "^8.0.3",
     "highlight.js": "^11.11.1",
-    "mermaid": "^11.13.0",
     "html2canvas": "^1.4.1",
     "marked": "^17.0.2",
+    "mermaid": "^11.13.0",
     "qrcode.react": "^4.2.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -95,5 +95,8 @@
     "node-pty": "^1.1.0",
     "undici": "^7.22.0",
     "ws": "^8.19.0"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.91"
   }
 }

package/server.js

@@ -43,7 +43,7 @@ import { uploadPlugins, installPluginFromUrl } from './lib/plugin-manager.js';
 import { getUserProfile } from './lib/user-profile.js';
 import { getGitDiffs } from './lib/git-diff.js';
 import { CONTEXT_WINDOW_FILE, readModelContextSize, buildContextWindowEvent, getContextSizeForModel } from './lib/context-watcher.js';
-import { watchLogFile, startWatching, getWatchedFiles, sendEventToClients } from './lib/log-watcher.js';
+import { watchLogFile, startWatching, getWatchedFiles, sendEventToClients, sendToClients } from './lib/log-watcher.js';
 import { isMainAgentEntry, extractCachedContent } from './lib/kv-cache-analyzer.js';
 import { listLocalLogs, deleteLogFiles, mergeLogFiles } from './lib/log-management.js';
 import { countLogEntries, streamRawEntriesAsync, readPagedEntries } from './lib/log-stream.js';
@@ -60,6 +60,7 @@ try {
   }
 } catch { }
 const isCliMode = process.env.CCV_CLI_MODE === '1';
+const isSdkMode = process.env.CCV_SDK_MODE === '1';
 const isWorkspaceMode = process.env.CCV_WORKSPACE_MODE === '1';
 const _defaultProxyProfiles = { active: 'max', profiles: [{ id: 'max', name: 'Default' }] };
 const _maskApiKey = (k) => k && typeof k === 'string' && k.length > 4 ? '****' + k.slice(-4) : k ? '****' : '';
@@ -1874,7 +1875,7 @@ async function handleRequest(req, res) {
   // CLI 模式检测
   if (url === '/api/cli-mode' && method === 'GET') {
     res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ cliMode: isCliMode, workspaceMode: isWorkspaceMode && !_workspaceLaunched }));
+    res.end(JSON.stringify({ cliMode: isCliMode, sdkMode: isSdkMode, workspaceMode: isWorkspaceMode && !_workspaceLaunched }));
     return;
   }
 
@@ -2641,8 +2642,10 @@ async function setupTerminalWebSocket(httpServer) {
               } catch {}
             }
           } else if (msg.type === 'perm-hook-answer') {
-            // Client answered permission approval via hook bridge
-            if (pendingPermHook && msg.id && msg.id === pendingPermHook.id) {
+            // Permission approval — SDK mode (canUseTool) or PTY mode (hook bridge)
+            if (isSdkMode && _sdkResolveApproval) {
+              _sdkResolveApproval(msg.id, msg.allowSession ? { decision: msg.decision || 'allow', allowSession: true } : (msg.decision || 'deny'));
+            } else if (pendingPermHook && msg.id && msg.id === pendingPermHook.id) {
               const { res: hookRes, timer } = pendingPermHook;
               clearTimeout(timer);
               pendingPermHook = null;
@@ -2653,6 +2656,23 @@ async function setupTerminalWebSocket(httpServer) {
                 }
               } catch {}
             }
+          } else if (msg.type === 'sdk-ask-answer') {
+            // AskUserQuestion answer in SDK mode — resolve canUseTool Promise
+            if (_sdkResolveApproval) {
+              _sdkResolveApproval(msg.id, msg.answers);
+            }
+          } else if (msg.type === 'sdk-plan-answer') {
+            // Plan approval in SDK mode
+            if (_sdkResolveApproval) {
+              _sdkResolveApproval(msg.id, { approve: msg.approve !== false, feedback: msg.feedback || '' });
+            }
+          } else if (msg.type === 'sdk-user-message') {
+            // User message in SDK mode — relay to sdk-manager
+            if (_sdkSendUserMessage && msg.text) {
+              _sdkSendUserMessage(msg.text).catch(err => {
+                console.error('[SDK] sendUserMessage error:', err.message);
+              });
+            }
           } else if (msg.type === 'resize') {
             // 存储该客户端的尺寸
             clientSizes.set(ws, { cols: msg.cols, rows: msg.rows });
@@ -2717,6 +2737,8 @@ let _lastStreamingActive = false;
 function startStreamingStatusTimer() {
   if (_streamingStatusTimer) return;
   _streamingStatusTimer = setInterval(() => {
+    // SDK mode uses its own streaming state (pushed directly via setSdkStreamingState)
+    if (isSdkMode) return;
     const changed = streamingState.active !== _lastStreamingActive;
     if (changed || streamingState.active) {
       const data = streamingState.active
@@ -2777,6 +2799,38 @@ async function _doStop() {
   try { unwatchFile(PROFILE_PATH); } catch {} // 清理 interceptor 的 StatWatcher
 }
 
+// ─── SDK Mode Exports ──────────────────────────────────────────
+
+/** Push a JSONL entry to all SSE clients (for SDK mode). */
+export function pushSdkEntry(entry) {
+  if (sendToClients) sendToClients(clients, entry);
+}
+
+/** Update streaming status (for SDK mode). */
+export function setSdkStreamingState(data) {
+  if (clients.length > 0 && sendEventToClients) {
+    sendEventToClients(clients, 'streaming_status', data);
+  }
+}
+
+/** Broadcast a message to all terminal WS clients (for SDK canUseTool). */
+export function broadcastWsMessage(msg) {
+  if (terminalWss) {
+    const str = typeof msg === 'string' ? msg : JSON.stringify(msg);
+    terminalWss.clients.forEach((c) => {
+      if (c.readyState === 1) try { c.send(str); } catch {}
+    });
+  }
+}
+
+/** Reference to sdk-manager's resolveApproval (set by cli.js after import). */
+let _sdkResolveApproval = null;
+export function setSdkResolveApproval(fn) { _sdkResolveApproval = fn; }
+
+/** Reference to sdk-manager's sendUserMessage (set by cli.js after import). */
+let _sdkSendUserMessage = null;
+export function setSdkSendUserMessage(fn) { _sdkSendUserMessage = fn; }
+
 // Auto-start the viewer after log file init completes
 // 工作区模式下由 cli.js 直接 import server.js 触发启动，跳过 _initPromise 自动启动
 if (!isWorkspaceMode) {