@yeaft/webchat-agent 0.0.2

package/history.js

@@ -0,0 +1,283 @@
+import { homedir } from 'os';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import ctx from './context.js';
+
+// Claude 项目目录
+export function getClaudeProjectsDir() {
+  return join(homedir(), '.claude', 'projects');
+}
+
+// 将路径转换为 Claude 项目文件夹名
+export function pathToProjectFolder(workDir) {
+  return workDir
+    .replace(/:/g, '-')
+    .replace(/[\\\/]/g, '-');
+}
+
+// 从 session 文件中提取原始工作目录路径
+// Claude session jsonl 文件的每条消息都包含 cwd 字段
+export function extractWorkDirFromSessionFile(sessionFilePath) {
+  try {
+    const content = readFileSync(sessionFilePath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    for (const line of lines.slice(0, 5)) { // 只检查前几行
+      try {
+        const data = JSON.parse(line);
+        // 每条消息都有 cwd 字段
+        if (data.cwd) {
+          return data.cwd.replace(/\\/g, '/');
+        }
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+
+// 从项目文件夹中获取原始工作目录路径
+// 优先从 session 文件读取，失败则用简单转换
+export function getWorkDirFromProjectFolder(projectFolderPath, folderName) {
+  // 尝试从第一个 session 文件读取真实路径
+  try {
+    const files = readdirSync(projectFolderPath);
+    for (const file of files) {
+      if (file.endsWith('.jsonl')) {
+        const workDir = extractWorkDirFromSessionFile(join(projectFolderPath, file));
+        if (workDir) {
+          return workDir;
+        }
+      }
+    }
+  } catch {}
+
+  // 回退：简单转换（可能不准确，但总比没有好）
+  if (/^[A-Za-z]--/.test(folderName)) {
+    return folderName.replace(/^([A-Za-z])--/, '$1:/').replace(/-/g, '/');
+  }
+  if (folderName.startsWith('-')) {
+    return '/' + folderName.substring(1).replace(/-/g, '/');
+  }
+  return folderName.replace(/-/g, '/');
+}
+
+// 获取指定目录的历史会话列表
+export async function getHistorySessions(workDir) {
+  const projectsDir = getClaudeProjectsDir();
+  const projectFolder = pathToProjectFolder(workDir);
+  const projectPath = join(projectsDir, projectFolder);
+
+  console.log(`Looking for sessions in: ${projectPath}`);
+
+  if (!existsSync(projectPath)) {
+    console.log(`Project folder not found: ${projectPath}`);
+    return [];
+  }
+
+  const sessions = [];
+  const files = readdirSync(projectPath);
+
+  for (const file of files) {
+    if (file.endsWith('.jsonl') && file !== 'sessions-index.json') {
+      const sessionId = file.replace('.jsonl', '');
+      const filePath = join(projectPath, file);
+      const stats = statSync(filePath);
+
+      let title = '';
+      let firstMessage = '';
+      let hasUserMessage = false;
+
+      try {
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+
+        for (const line of lines.slice(0, 30)) {
+          try {
+            const data = JSON.parse(line);
+            if (data.type === 'user' && data.message?.content) {
+              const text = typeof data.message.content === 'string'
+                ? data.message.content
+                : data.message.content[0]?.text || '';
+              if (text.trim()) {
+                firstMessage = text.substring(0, 100);
+                title = text.substring(0, 100);
+                hasUserMessage = true;
+                break;
+              }
+            }
+          } catch {}
+        }
+      } catch (e) {
+        console.error(`Error reading session file: ${e.message}`);
+      }
+
+      // 只添加有实际用户消息的会话，过滤掉空会话
+      if (hasUserMessage) {
+        sessions.push({
+          sessionId,
+          workDir,
+          title: title || sessionId.slice(0, 8),
+          preview: firstMessage,
+          lastModified: stats.mtime.getTime(),
+          size: stats.size
+        });
+      }
+    }
+  }
+
+  sessions.sort((a, b) => b.lastModified - a.lastModified);
+  return sessions;
+}
+
+// 读取 session 文件中的历史消息
+export function loadSessionHistory(workDir, claudeSessionId, limit = 500) {
+  const projectsDir = getClaudeProjectsDir();
+  const projectFolder = pathToProjectFolder(workDir);
+  const sessionFile = join(projectsDir, projectFolder, `${claudeSessionId}.jsonl`);
+
+  console.log(`Loading session history from: ${sessionFile}`);
+
+  if (!existsSync(sessionFile)) {
+    console.log(`Session file not found: ${sessionFile}`);
+    return [];
+  }
+
+  const messages = [];
+  try {
+    const content = readFileSync(sessionFile, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.type === 'user' || data.type === 'assistant') {
+          messages.push(data);
+        }
+      } catch {}
+    }
+  } catch (e) {
+    console.error(`Error reading session file: ${e.message}`);
+  }
+
+  // ★ Phase 6: 限制返回数量（取最后 N 条）
+  if (limit && messages.length > limit) {
+    return messages.slice(-limit);
+  }
+
+  return messages;
+}
+
+export async function handleListHistorySessions(msg) {
+  const { workDir, requestId } = msg;
+  const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
+
+  console.log(`Listing history sessions for: ${effectiveWorkDir}`);
+
+  try {
+    const sessions = await getHistorySessions(effectiveWorkDir);
+    ctx.sendToServer({
+      type: 'history_sessions_list',
+      requestId,
+      workDir: effectiveWorkDir,
+      sessions
+    });
+  } catch (e) {
+    console.error('Error listing history sessions:', e);
+    ctx.sendToServer({
+      type: 'history_sessions_list',
+      requestId,
+      workDir: effectiveWorkDir,
+      sessions: [],
+      error: e.message
+    });
+  }
+}
+
+// 列出 Claude projects 目录下的所有 folder (工作目录)
+export async function handleListFolders(msg) {
+  const { requestId } = msg;
+  const projectsDir = getClaudeProjectsDir();
+
+  console.log(`Listing folders from: ${projectsDir}`);
+
+  try {
+    const folders = [];
+
+    if (existsSync(projectsDir)) {
+      const entries = readdirSync(projectsDir);
+
+      for (const entry of entries) {
+        const entryPath = join(projectsDir, entry);
+        const stats = statSync(entryPath);
+
+        if (stats.isDirectory()) {
+          // 从 session 文件读取真实的工作目录路径
+          const originalPath = getWorkDirFromProjectFolder(entryPath, entry);
+
+          // 获取该目录下的会话数量（只计算有实际用户消息的会话）
+          let sessionCount = 0;
+          let lastModified = stats.mtime.getTime();
+
+          try {
+            const files = readdirSync(entryPath);
+
+            for (const file of files) {
+              if (file.endsWith('.jsonl')) {
+                const filePath = join(entryPath, file);
+                const fileStats = statSync(filePath);
+                if (fileStats.mtime.getTime() > lastModified) {
+                  lastModified = fileStats.mtime.getTime();
+                }
+
+                // 检查文件是否包含用户消息（与 getHistorySessions 保持一致）
+                try {
+                  const content = readFileSync(filePath, 'utf-8');
+                  const lines = content.split('\n').filter(l => l.trim()).slice(0, 30);
+                  for (const line of lines) {
+                    try {
+                      const data = JSON.parse(line);
+                      if (data.type === 'user' && data.message?.content) {
+                        const text = typeof data.message.content === 'string'
+                          ? data.message.content
+                          : data.message.content[0]?.text || '';
+                        if (text.trim()) {
+                          sessionCount++;
+                          break;
+                        }
+                      }
+                    } catch {}
+                  }
+                } catch {}
+              }
+            }
+          } catch {}
+
+          folders.push({
+            name: entry,
+            path: originalPath,
+            sessionCount,
+            lastModified
+          });
+        }
+      }
+    }
+
+    folders.sort((a, b) => b.lastModified - a.lastModified);
+
+    console.log(`Found ${folders.length} folders, sending response...`);
+    ctx.sendToServer({
+      type: 'folders_list',
+      requestId,
+      folders
+    });
+    console.log(`folders_list sent with ${folders.length} folders`);
+  } catch (e) {
+    console.error('Error listing folders:', e);
+    ctx.sendToServer({
+      type: 'folders_list',
+      requestId,
+      folders: [],
+      error: e.message
+    });
+  }
+}

package/index.js

@@ -0,0 +1,159 @@
+import 'dotenv/config';
+import { platform } from 'os';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import ctx from './context.js';
+import { getConfigPath, loadServiceConfig } from './service.js';
+import { loadNodePty } from './terminal.js';
+import { connect } from './connection.js';
+
+const execAsync = promisify(exec);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load package version
+const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
+ctx.agentVersion = pkg.version;
+
+// 配置文件路径（向后兼容：先查当前目录 .claude-agent.json）
+const LOCAL_CONFIG_FILE = join(process.cwd(), '.claude-agent.json');
+
+// 加载或创建配置
+function loadConfig() {
+  const defaults = {
+    serverUrl: 'ws://localhost:3456',
+    agentName: `Worker-${platform()}-${process.pid}`,
+    workDir: process.cwd(),
+    reconnectInterval: 5000,
+    agentSecret: 'agent-shared-secret'
+  };
+
+  // Priority 1: Local .claude-agent.json (backward compat)
+  if (existsSync(LOCAL_CONFIG_FILE)) {
+    try {
+      const saved = JSON.parse(readFileSync(LOCAL_CONFIG_FILE, 'utf-8'));
+      const { agentId, ...rest } = saved;
+      return { ...defaults, ...rest };
+    } catch {
+      // fall through
+    }
+  }
+
+  // Priority 2: Standard config location (~/.config/yeaft-agent/config.json)
+  const serviceConfig = loadServiceConfig();
+  if (serviceConfig) {
+    return { ...defaults, ...serviceConfig };
+  }
+
+  return defaults;
+}
+
+function saveConfig(config) {
+  writeFileSync(LOCAL_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+const fileConfig = loadConfig();
+const CONFIG = {
+  serverUrl: process.env.SERVER_URL || fileConfig.serverUrl,
+  agentName: process.env.AGENT_NAME || fileConfig.agentName,
+  workDir: process.env.WORK_DIR || fileConfig.workDir,
+  reconnectInterval: fileConfig.reconnectInterval,
+  agentSecret: process.env.AGENT_SECRET || fileConfig.agentSecret,
+  // 禁用的工具列表（逗号分隔），如 "mcp__github,mcp__sentry"
+  // 默认禁用所有 MCP 工具（避免超过 Claude API 128 工具限制）
+  // 设置 DISALLOWED_TOOLS=none 可取消默认禁用
+  disallowedTools: (() => {
+    const raw = process.env.DISALLOWED_TOOLS || fileConfig.disallowedTools || '';
+    if (raw === 'none') return [];
+    const list = raw.split(',').map(s => s.trim()).filter(Boolean);
+    return list.length > 0 ? list : ['mcp__*'];
+  })()
+};
+
+// 初始化共享上下文
+ctx.CONFIG = CONFIG;
+ctx.saveConfig = saveConfig;
+
+// Agent capabilities（启动时自动检测）
+async function detectCapabilities() {
+  const capabilities = ['background_tasks', 'file_editor'];
+  const pty = await loadNodePty();
+  if (pty) capabilities.push('terminal');
+  console.log(`[Capabilities] Detected: ${capabilities.join(', ')}`);
+  return capabilities;
+}
+
+// 确保依赖已安装（特别是 optionalDependencies 如 node-pty）
+async function ensureDependencies() {
+  const agentDir = new URL('.', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1');
+  const nodeModulesPath = join(agentDir, 'node_modules');
+
+  // 检查 node_modules 是否存在
+  if (!existsSync(nodeModulesPath)) {
+    console.log('[Startup] node_modules not found, running npm install...');
+    try {
+      await execAsync('npm install', { cwd: agentDir, timeout: 120000 });
+      console.log('[Startup] npm install completed');
+    } catch (e) {
+      console.warn('[Startup] npm install failed:', e.message);
+    }
+    return;
+  }
+
+  // 检查 node-pty 是否可用（optionalDependency，可能需要编译）
+  try {
+    await import('node-pty');
+  } catch (e) {
+    console.log('[Startup] node-pty not available, attempting install...');
+    try {
+      await execAsync('npm install node-pty', { cwd: agentDir, timeout: 120000 });
+      console.log('[Startup] node-pty installed successfully');
+    } catch (installErr) {
+      console.warn('[Startup] node-pty install failed (terminal will be unavailable):', installErr.message);
+    }
+  }
+}
+
+// 优雅退出
+function cleanup() {
+  // 清理所有终端
+  for (const [, term] of ctx.terminals) {
+    if (term.pty) {
+      try { term.pty.kill(); } catch {}
+    }
+    if (term.timer) clearTimeout(term.timer);
+  }
+  ctx.terminals.clear();
+
+  for (const [, state] of ctx.conversations) {
+    if (state.abortController) {
+      state.abortController.abort();
+    }
+    if (state.inputStream) {
+      state.inputStream.done();
+    }
+  }
+  ctx.conversations.clear();
+  if (ctx.ws) ctx.ws.close();
+}
+
+process.on('SIGINT', () => {
+  console.log('Shutting down...');
+  cleanup();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  console.log('Shutting down...');
+  cleanup();
+  process.exit(0);
+});
+
+// 启动 - 先确保依赖，再检测能力，再连接
+(async () => {
+  await ensureDependencies();
+  ctx.agentCapabilities = await detectCapabilities();
+  connect();
+})();

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@yeaft/webchat-agent",
+  "version": "0.0.2",
+  "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "yeaft-agent": "./cli.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude",
+    "agent",
+    "remote",
+    "websocket",
+    "cli",
+    "yeaft"
+  ],
+  "homepage": "https://github.com/yeaft/claude-web-chat",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yeaft/claude-web-chat.git",
+    "directory": "agent"
+  },
+  "bugs": {
+    "url": "https://github.com/yeaft/claude-web-chat/issues"
+  },
+  "files": [
+    "cli.js",
+    "service.js",
+    "index.js",
+    "context.js",
+    "connection.js",
+    "conversation.js",
+    "claude.js",
+    "terminal.js",
+    "proxy.js",
+    "workbench.js",
+    "history.js",
+    "encryption.js",
+    "sdk/"
+  ],
+  "license": "MIT",
+  "author": "Yeaft",
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  },
+  "nodemonConfig": {
+    "watch": [
+      "*.js",
+      "sdk/*.js"
+    ],
+    "ignore": [
+      "node_modules",
+      "package-lock.json",
+      ".claude-agent.json"
+    ],
+    "ext": "js"
+  },
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "tweetnacl": "^1.0.3",
+    "tweetnacl-util": "^0.15.1",
+    "ws": "^8.16.0"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.0.0"
+  }
+}

package/proxy.js

@@ -0,0 +1,169 @@
+import WebSocket from 'ws';
+import http from 'http';
+import https from 'https';
+import ctx from './context.js';
+
+export function handleProxyHttpRequest(msg) {
+  const { requestId, port, method, path, headers, body, scheme, host } = msg;
+  const effectiveHost = host || 'localhost';
+  const effectiveScheme = scheme || 'http';
+  const httpModule = effectiveScheme === 'https' ? https : http;
+
+  const options = {
+    hostname: effectiveHost,
+    port,
+    path,
+    method,
+    headers: { ...headers },
+    timeout: 60000
+  };
+
+  // For HTTPS: skip certificate verification for local services
+  if (effectiveScheme === 'https') {
+    options.rejectUnauthorized = false;
+  }
+
+  // Clean hop-by-hop headers
+  delete options.headers['host'];
+  options.headers['host'] = `${effectiveHost}:${port}`;
+  delete options.headers['connection'];
+  delete options.headers['upgrade'];
+  delete options.headers['accept-encoding']; // Let agent handle raw data
+
+  const req = httpModule.request(options, (res) => {
+    const contentType = res.headers['content-type'] || '';
+    const isStreaming = (
+      contentType.includes('text/event-stream') ||
+      (contentType.includes('text/plain') && res.headers['transfer-encoding'] === 'chunked')
+    );
+
+    if (isStreaming) {
+      ctx.sendToServer({
+        type: 'proxy_response_chunk',
+        requestId,
+        statusCode: res.statusCode,
+        headers: res.headers
+      });
+
+      res.on('data', (chunk) => {
+        ctx.sendToServer({
+          type: 'proxy_response_chunk',
+          requestId,
+          chunk: chunk.toString('base64')
+        });
+      });
+
+      res.on('end', () => {
+        ctx.sendToServer({ type: 'proxy_response_end', requestId });
+      });
+    } else {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        const responseBody = Buffer.concat(chunks);
+        ctx.sendToServer({
+          type: 'proxy_response',
+          requestId,
+          statusCode: res.statusCode,
+          headers: res.headers,
+          body: responseBody.toString('base64')
+        });
+      });
+    }
+
+    res.on('error', (err) => {
+      ctx.sendToServer({
+        type: 'proxy_response',
+        requestId,
+        statusCode: 502,
+        headers: { 'content-type': 'text/plain' },
+        body: Buffer.from(`Proxy stream error: ${err.message}`).toString('base64')
+      });
+    });
+  });
+
+  req.on('error', (err) => {
+    ctx.sendToServer({
+      type: 'proxy_response',
+      requestId,
+      statusCode: 502,
+      headers: { 'content-type': 'text/plain' },
+      body: Buffer.from(`Proxy error: ${err.message}`).toString('base64')
+    });
+  });
+
+  req.on('timeout', () => {
+    req.destroy();
+    ctx.sendToServer({
+      type: 'proxy_response',
+      requestId,
+      statusCode: 504,
+      headers: { 'content-type': 'text/plain' },
+      body: Buffer.from('Proxy request timeout').toString('base64')
+    });
+  });
+
+  if (body) req.write(Buffer.from(body, 'base64'));
+  req.end();
+}
+
+export function handleProxyWsOpen(msg) {
+  const { proxyWsId, port, path, headers, scheme, host } = msg;
+  const effectiveHost = host || 'localhost';
+  const wsScheme = (scheme === 'https') ? 'wss' : 'ws';
+  const url = `${wsScheme}://${effectiveHost}:${port}${path || '/'}`;
+
+  const wsHeaders = { ...headers };
+  wsHeaders['host'] = `${effectiveHost}:${port}`;
+
+  const wsOptions = { headers: wsHeaders };
+  if (wsScheme === 'wss') {
+    wsOptions.rejectUnauthorized = false;
+  }
+
+  const localWs = new WebSocket(url, wsOptions);
+
+  localWs.on('open', () => {
+    ctx.sendToServer({ type: 'proxy_ws_opened', proxyWsId });
+  });
+
+  localWs.on('message', (data, isBinary) => {
+    ctx.sendToServer({
+      type: 'proxy_ws_message',
+      proxyWsId,
+      data: isBinary ? Buffer.from(data).toString('base64') : data.toString(),
+      isBinary
+    });
+  });
+
+  localWs.on('close', (code) => {
+    ctx.proxyWsSockets.delete(proxyWsId);
+    ctx.sendToServer({ type: 'proxy_ws_closed', proxyWsId, code });
+  });
+
+  localWs.on('error', (err) => {
+    ctx.proxyWsSockets.delete(proxyWsId);
+    ctx.sendToServer({ type: 'proxy_ws_error', proxyWsId, error: err.message });
+  });
+
+  ctx.proxyWsSockets.set(proxyWsId, localWs);
+}
+
+export function handleProxyWsMessage(msg) {
+  const localWs = ctx.proxyWsSockets.get(msg.proxyWsId);
+  if (localWs && localWs.readyState === WebSocket.OPEN) {
+    if (msg.isBinary) {
+      localWs.send(Buffer.from(msg.data, 'base64'));
+    } else {
+      localWs.send(msg.data);
+    }
+  }
+}
+
+export function handleProxyWsClose(msg) {
+  const localWs = ctx.proxyWsSockets.get(msg.proxyWsId);
+  if (localWs) {
+    localWs.close(msg.code || 1000);
+    ctx.proxyWsSockets.delete(msg.proxyWsId);
+  }
+}

package/sdk/index.js

@@ -0,0 +1,9 @@
+/**
+ * Claude Code SDK integration for WebChat Agent
+ * Spawns Claude CLI as a subprocess with stream-json I/O
+ */
+
+export { query, Query } from './query.js';
+export { Stream } from './stream.js';
+export { AbortError } from './types.js';
+export { logDebug, getDefaultClaudeCodePath, isWindows } from './utils.js';