@yeaft/webchat-agent 0.0.2

package/claude.js

@@ -0,0 +1,405 @@
+import { query, Stream } from './sdk/index.js';
+import ctx from './context.js';
+import { sendConversationList, sendOutput, sendError, handleAskUserQuestion } from './conversation.js';
+
+/**
+ * Start a Claude SDK query for a conversation
+ * Uses the SDK with AsyncIterable input stream for bidirectional communication
+ */
+export async function startClaudeQuery(conversationId, workDir, resumeSessionId) {
+  // 如果已存在，先保存 per-session 设置，再关闭
+  let savedDisallowedTools = null;
+  let savedUserId = undefined;
+  let savedUsername = undefined;
+  if (ctx.conversations.has(conversationId)) {
+    const existing = ctx.conversations.get(conversationId);
+    savedDisallowedTools = existing.disallowedTools ?? null;
+    savedUserId = existing.userId;
+    savedUsername = existing.username;
+    if (existing.abortController) {
+      existing.abortController.abort();
+    }
+    ctx.conversations.delete(conversationId);
+  }
+
+  // 创建输入流和 abort controller
+  const inputStream = new Stream();
+  const abortController = new AbortController();
+
+  const state = {
+    query: null,
+    inputStream,
+    workDir,
+    claudeSessionId: resumeSessionId || null,
+    createdAt: Date.now(),
+    abortController,
+    turnActive: false, // 是否有 turn 正在处理中
+    // Metadata from system init message
+    tools: [],
+    slashCommands: [],
+    model: null,
+    // Usage tracking
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheCreation: 0,
+      totalCostUsd: 0
+    },
+    // 后台任务追踪: taskId -> { command, status, output, startTime, endTime }
+    backgroundTasks: new Map(),
+    // Per-session 工具禁用设置
+    disallowedTools: savedDisallowedTools,
+    // 保留用户信息（从旧 state 恢复）
+    userId: savedUserId,
+    username: savedUsername,
+  };
+
+  // 配置 SDK query 选项
+  const options = {
+    cwd: workDir,
+    permissionMode: 'bypassPermissions', // Auto-approve all tool uses
+    abort: abortController.signal,
+    // 拦截 AskUserQuestion 工具调用，转发到 Web UI
+    canCallTool: async (toolName, input, toolCtx) => {
+      if (toolName === 'AskUserQuestion') {
+        return await handleAskUserQuestion(conversationId, input, toolCtx);
+      }
+      // 其他工具自动批准
+      return input;
+    }
+  };
+
+  // 禁用的工具：per-session 优先，否则使用全局默认
+  const effectiveDisallowedTools = savedDisallowedTools != null
+    ? savedDisallowedTools
+    : (ctx.CONFIG.disallowedTools || []);
+  if (effectiveDisallowedTools.length > 0) {
+    options.disallowedTools = effectiveDisallowedTools;
+    console.log(`[SDK] Disallowed tools: ${effectiveDisallowedTools.join(', ')}`);
+  }
+
+  // Validate session ID is a valid UUID before using it
+  const isValidUUID = (id) => {
+    if (!id) return false;
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(id);
+  };
+
+  const validResumeId = isValidUUID(resumeSessionId) ? resumeSessionId : null;
+  console.log(`[SDK] resumeSessionId: "${resumeSessionId}" (length: ${resumeSessionId?.length})`);
+  console.log(`[SDK] isValidUUID: ${isValidUUID(resumeSessionId)}`);
+  console.log(`[SDK] validResumeId: "${validResumeId}"`);
+  if (resumeSessionId && !validResumeId) {
+    console.warn(`[SDK] Invalid session ID (not UUID): ${resumeSessionId}, starting fresh`);
+    state.claudeSessionId = null; // Clear invalid ID
+  }
+
+  if (validResumeId) {
+    options.resume = validResumeId;
+  }
+
+  console.log(`[SDK] Starting Claude query for ${conversationId}, resume: ${validResumeId || 'none'}`);
+
+  // 使用 SDK 的 query 函数
+  const claudeQuery = query({
+    prompt: inputStream,
+    options
+  });
+
+  state.query = claudeQuery;
+  ctx.conversations.set(conversationId, state);
+
+  // 异步处理 Claude 输出
+  processClaudeOutput(conversationId, claudeQuery, state);
+
+  // 注意：不在这里调用 sendConversationList()
+  // 因为此时 turnActive 还是 false，会发送 processing: false 给 server
+  // 由调用方（handleUserInput）在设置 turnActive = true 后再调用
+  return state;
+}
+
+/**
+ * 检测并追踪后台任务（仅 Bash 和 Agent 任务）
+ * 普通工具调用（Read、Edit、Grep、Glob 等）不跟踪
+ */
+function detectAndTrackBackgroundTask(conversationId, state, message) {
+  // 检测 assistant 消息中的 tool_use
+  if (message.type === 'assistant' && message.message?.content) {
+    const content = message.message.content;
+    if (!Array.isArray(content)) return;
+
+    for (const block of content) {
+      if (block.type === 'tool_use') {
+        const toolName = block.name;
+        const toolInput = block.input || {};
+        const toolUseId = block.id;
+
+        // 跟踪 Bash 工具调用
+        if (toolName === 'Bash') {
+          const taskInfo = {
+            id: toolUseId,
+            type: 'bash',
+            command: toolInput.command || '',
+            description: toolInput.description || '',
+            background: !!toolInput.run_in_background,
+            status: 'running',
+            output: '',
+            startTime: Date.now(),
+            endTime: null
+          };
+          state.backgroundTasks.set(toolUseId, taskInfo);
+          console.log(`[Tasks] Bash: ${toolUseId}, command: ${taskInfo.command.substring(0, 50)}...`);
+
+          ctx.sendToServer({
+            type: 'background_task_started',
+            conversationId,
+            task: taskInfo
+          });
+        }
+
+        // 跟踪 Task 工具（Agent 任务）
+        else if (toolName === 'Task') {
+          const taskInfo = {
+            id: toolUseId,
+            type: 'agent',
+            description: toolInput.description || toolInput.prompt?.substring(0, 100) || 'Agent Task',
+            prompt: toolInput.prompt || '',
+            background: !!toolInput.run_in_background,
+            status: 'running',
+            output: '',
+            startTime: Date.now(),
+            endTime: null
+          };
+          state.backgroundTasks.set(toolUseId, taskInfo);
+          console.log(`[Tasks] Agent: ${toolUseId}, desc: ${taskInfo.description}`);
+
+          ctx.sendToServer({
+            type: 'background_task_started',
+            conversationId,
+            task: taskInfo
+          });
+        }
+      }
+    }
+  }
+
+  // 检测 tool_result 消息（任务完成或输出更新）
+  if (message.type === 'user' && message.tool_use_result) {
+    const result = message.tool_use_result;
+    // tool_use_result 格式可能是数组或单个对象
+    const results = Array.isArray(result) ? result : [result];
+
+    for (const r of results) {
+      const toolUseId = r.tool_use_id;
+      if (toolUseId && state.backgroundTasks.has(toolUseId)) {
+        const taskInfo = state.backgroundTasks.get(toolUseId);
+        const content = r.content || '';
+
+        // 更新任务输出
+        taskInfo.output += (typeof content === 'string' ? content : JSON.stringify(content)) + '\n';
+        taskInfo.status = 'completed';
+        taskInfo.endTime = Date.now();
+
+        console.log(`[Tasks] Completed: ${toolUseId}`);
+
+        ctx.sendToServer({
+          type: 'background_task_output',
+          conversationId,
+          taskId: toolUseId,
+          task: taskInfo
+        });
+      }
+    }
+  }
+
+  // 检测 system 消息中的任务输出（实时输出）
+  if (message.type === 'system' && message.subtype === 'task_output') {
+    const taskId = message.task_id;
+    if (taskId && state.backgroundTasks.has(taskId)) {
+      const taskInfo = state.backgroundTasks.get(taskId);
+      const output = message.output || message.content || '';
+
+      taskInfo.output += output;
+
+      ctx.sendToServer({
+        type: 'background_task_output',
+        conversationId,
+        taskId,
+        task: taskInfo,
+        newOutput: output
+      });
+    }
+  }
+}
+
+/**
+ * Process Claude output messages asynchronously
+ */
+async function processClaudeOutput(conversationId, claudeQuery, state) {
+  // 标记是否已在 result 消息中发送了 turn_completed
+  let resultHandled = false;
+
+  try {
+    for await (const message of claudeQuery) {
+      console.log('Output:', message.type, message.subtype || '');
+
+      // 捕获 system init 消息中的 metadata
+      if (message.type === 'system' && message.subtype === 'init') {
+        state.claudeSessionId = message.session_id;
+        state.tools = message.tools || [];
+        state.slashCommands = message.slash_commands || [];
+        state.model = message.model || null;
+        console.log(`Claude session ID: ${state.claudeSessionId}`);
+        console.log(`Model: ${state.model}`);
+        console.log(`Available tools: ${state.tools.length}`);
+        console.log(`Available slash commands: ${state.slashCommands.join(', ')}`);
+
+        // 通知服务器更新 claudeSessionId（用于历史会话恢复）
+        ctx.sendToServer({
+          type: 'session_id_update',
+          conversationId,
+          claudeSessionId: state.claudeSessionId,
+          workDir: state.workDir
+        });
+
+        // 通知 web 端可用的 slash commands 列表（用于自动补全）
+        // 缓存到 agent 级别，只在列表变化时才发送
+        if (state.slashCommands.length > 0) {
+          const changed = JSON.stringify(state.slashCommands) !== JSON.stringify(ctx.slashCommands);
+          if (changed) {
+            ctx.slashCommands = [...state.slashCommands];
+            ctx.sendToServer({
+              type: 'slash_commands_update',
+              conversationId,
+              slashCommands: state.slashCommands
+            });
+          }
+        }
+      }
+
+      // 捕获 compact 相关的 system 消息
+      // Claude Code 在 context 不足时会自动 compact
+      if (message.type === 'system') {
+        // 新格式: subtype: 'status', status: 'compacting'
+        if (message.subtype === 'status' && message.status === 'compacting') {
+          console.log(`[${conversationId}] Compact started (status)`);
+          ctx.sendToServer({
+            type: 'compact_status',
+            conversationId,
+            status: 'compacting',
+            message: 'Context compacting in progress...'
+          });
+        }
+        // compact 边界标记 — 表示 compact 完成
+        if (message.subtype === 'compact_boundary') {
+          console.log(`[${conversationId}] Compact completed (boundary)`);
+          ctx.sendToServer({
+            type: 'compact_status',
+            conversationId,
+            status: 'completed',
+            message: 'Context compacted successfully'
+          });
+        }
+        // 旧格式兼容
+        if (message.subtype === 'compact_start' || message.message?.includes?.('Compacting')) {
+          console.log(`[${conversationId}] Compact started`);
+          ctx.sendToServer({
+            type: 'compact_status',
+            conversationId,
+            status: 'compacting',
+            message: message.message || 'Context compacting in progress...'
+          });
+        }
+        if (message.subtype === 'compact_complete' || message.subtype === 'compact_end') {
+          console.log(`[${conversationId}] Compact completed`);
+          ctx.sendToServer({
+            type: 'compact_status',
+            conversationId,
+            status: 'completed',
+            message: message.message || 'Context compacted successfully'
+          });
+        }
+      }
+
+      // 捕获 result 消息中的 usage 信息
+      if (message.type === 'result') {
+        if (message.usage) {
+          state.usage.inputTokens += message.usage.input_tokens || 0;
+          state.usage.outputTokens += message.usage.output_tokens || 0;
+          state.usage.cacheRead += message.usage.cache_read_input_tokens || 0;
+          state.usage.cacheCreation += message.usage.cache_creation_input_tokens || 0;
+        }
+        state.usage.totalCostUsd += message.total_cost_usd || 0;
+        console.log(`[SDK] Query completed for ${conversationId}, cost: $${state.usage.totalCostUsd.toFixed(4)}`);
+
+        // ★ Turn 完成：发送 turn_completed，进程继续运行等待下一条消息
+        // stream-json 模式下 Claude 进程是持久运行的，for-await 在 result 后继续等待
+        // 不清空 state.query 和 state.inputStream，下次用户消息直接通过同一个 inputStream 发送
+        sendOutput(conversationId, message);
+
+        resultHandled = true;
+        state.turnActive = false;
+
+        ctx.sendToServer({
+          type: 'turn_completed',
+          conversationId,
+          claudeSessionId: state.claudeSessionId,
+          workDir: state.workDir
+        });
+        sendConversationList();
+        continue;
+      }
+
+      // 检测后台任务
+      detectAndTrackBackgroundTask(conversationId, state, message);
+
+      sendOutput(conversationId, message);
+    }
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      console.log(`[SDK] Query aborted for ${conversationId}`);
+    } else {
+      console.error(`[SDK] Error for ${conversationId}:`, error.message);
+      sendError(conversationId, error.message);
+    }
+  } finally {
+    // 查询完成后清理
+    // 注意：必须用传入的 state 参数，不能用 conversations.get(conversationId)
+    // 因为在取消+重发的竞态场景下，conversations 中可能已经是新 state 了
+    const conv = state;
+    const currentConv = ctx.conversations.get(conversationId);
+    const isStale = currentConv !== conv; // 已被新 startClaudeQuery 替换
+
+    const claudeSessionId = conv?.claudeSessionId;
+    const wasCancelled = conv?.cancelled;
+    const wasTurnActive = conv?.turnActive; // 保存清理前的 turnActive 状态
+
+    // 只有当前 state 未被替换时才清理
+    if (!isStale && conv) {
+      conv.query = null;
+      conv.inputStream = null;
+      conv.turnActive = false;
+      conv.cancelled = false; // 重置取消标志
+    }
+
+    if (isStale) {
+      // state 已被新查询替换，不做任何清理操作
+      console.log(`[SDK] Stale processClaudeOutput for ${conversationId}, skipping cleanup`);
+    } else if (!wasCancelled && (wasTurnActive || !resultHandled)) {
+      // 进程异常退出：要么 turn 正在进行中，要么从未成功完成过任何 turn
+      ctx.sendToServer({
+        type: 'conversation_closed',
+        conversationId,
+        claudeSessionId,
+        workDir: conv?.workDir,
+        exitCode: 0,
+        processExited: true
+      });
+    }
+    // wasCancelled 时由 handleCancelExecution 已发送 execution_cancelled
+
+    sendConversationList();
+  }
+}
+

package/cli.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for @yeaft/webchat-agent
+ * Parses command-line arguments and starts the agent or runs subcommands
+ */
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subArgs = args.slice(1);
+
+// Service management subcommands
+const SERVICE_COMMANDS = ['install', 'uninstall', 'start', 'stop', 'restart', 'status', 'logs'];
+
+if (command === 'upgrade') {
+  upgrade();
+} else if (command === '--version' || command === '-v') {
+  console.log(pkg.version);
+} else if (command === '--help' || command === '-h') {
+  printHelp();
+} else if (SERVICE_COMMANDS.includes(command)) {
+  handleServiceCommand(command, subArgs);
+} else {
+  // Normal agent startup — parse flags and set env vars
+  parseAndStart(args);
+}
+
+function printHelp() {
+  console.log(`
+  ${pkg.name} v${pkg.version}
+
+  Usage:
+    yeaft-agent [options]              Run agent in foreground
+    yeaft-agent install [options]      Install as system service
+    yeaft-agent uninstall              Remove system service
+    yeaft-agent start                  Start installed service
+    yeaft-agent stop                   Stop installed service
+    yeaft-agent restart                Restart installed service
+    yeaft-agent status                 Show service status
+    yeaft-agent logs                   View service logs (follow mode)
+    yeaft-agent upgrade                Upgrade to latest version
+    yeaft-agent --version              Show version
+
+  Options:
+    --server <url>      WebSocket server URL (default: ws://localhost:3456)
+    --name <name>       Agent display name (default: Worker-{platform}-{pid})
+    --secret <secret>   Agent secret for authentication
+    --work-dir <dir>    Default working directory (default: cwd)
+    --auto-upgrade      Check for updates on startup
+
+  Environment variables (alternative to flags):
+    SERVER_URL          WebSocket server URL
+    AGENT_NAME          Agent display name
+    AGENT_SECRET        Agent secret
+    WORK_DIR            Working directory
+
+  Examples:
+    yeaft-agent --server wss://your-server.com --name my-worker --secret xxx
+    yeaft-agent install --server wss://your-server.com --name my-worker --secret xxx
+    yeaft-agent status
+    yeaft-agent logs
+`);
+}
+
+async function handleServiceCommand(command, args) {
+  const service = await import('./service.js');
+  switch (command) {
+    case 'install':   service.install(args); break;
+    case 'uninstall': service.uninstall(); break;
+    case 'start':     service.start(); break;
+    case 'stop':      service.stop(); break;
+    case 'restart':   service.restart(); break;
+    case 'status':    service.status(); break;
+    case 'logs':      service.logs(); break;
+  }
+}
+
+function parseAndStart(args) {
+  // Parse CLI flags → set environment variables (env vars take precedence over flags)
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+
+    switch (arg) {
+      case '--server':
+        if (next) { process.env.SERVER_URL = process.env.SERVER_URL || next; i++; }
+        break;
+      case '--name':
+        if (next) { process.env.AGENT_NAME = process.env.AGENT_NAME || next; i++; }
+        break;
+      case '--secret':
+        if (next) { process.env.AGENT_SECRET = process.env.AGENT_SECRET || next; i++; }
+        break;
+      case '--work-dir':
+        if (next) { process.env.WORK_DIR = process.env.WORK_DIR || next; i++; }
+        break;
+      case '--auto-upgrade':
+        checkForUpdates();
+        break;
+      default:
+        if (arg.startsWith('-')) {
+          console.warn(`Unknown option: ${arg}`);
+          printHelp();
+          process.exit(1);
+        }
+    }
+  }
+
+  // Import and start the agent
+  import('./index.js');
+}
+
+async function checkForUpdates() {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`);
+    if (!res.ok) return;
+    const data = await res.json();
+    const latest = data.version;
+    if (latest && latest !== pkg.version) {
+      console.log(`\n  Update available: ${pkg.version} → ${latest}`);
+      console.log(`  Run "yeaft-agent upgrade" to update\n`);
+    }
+  } catch {
+    // Silently ignore — network may be unavailable
+  }
+}
+
+function upgrade() {
+  console.log(`Current version: ${pkg.version}`);
+  console.log('Checking for updates...');
+
+  try {
+    const res = execSync(`npm view ${pkg.name} version`, { encoding: 'utf-8' }).trim();
+    if (res === pkg.version) {
+      console.log('Already up to date.');
+      return;
+    }
+    console.log(`Upgrading to ${res}...`);
+    execSync(`npm install -g ${pkg.name}@latest`, { stdio: 'inherit' });
+    console.log(`Successfully upgraded to ${res}`);
+  } catch (e) {
+    console.error('Upgrade failed:', e.message);
+    process.exit(1);
+  }
+}