@yeaft/webchat-agent 0.1.859 → 0.1.860

package/conversation.js

@@ -390,6 +390,7 @@ export async function createConversation(msg) {
       resumeSessionId: null,
       userId,
       username,
+      providerOptions: msg.providerOptions || {},
     });
     state.disallowedTools = disallowedTools || null;
   }
@@ -441,9 +442,11 @@ export async function resumeConversation(msg) {
   console.log(`[Resume] workDir: ${effectiveWorkDir} (lazy start)`);
 
   // 清理旧条目：同 conversationId 或同 claudeSessionId 的条目（避免重复恢复同一个 session 累积）
+  let priorProviderOptions = null;
   for (const [id, conv] of ctx.conversations) {
     if (id === conversationId || (claudeSessionId && conv.claudeSessionId === claudeSessionId)) {
       console.log(`[Resume] Cleaning up old conversation: ${id} (claudeSessionId: ${conv.claudeSessionId})`);
+      if (conv.providerOptions && !priorProviderOptions) priorProviderOptions = conv.providerOptions;
       if (conv.abortController) {
         conv.abortController.abort();
       }
@@ -454,7 +457,15 @@ export async function resumeConversation(msg) {
     }
   }
 
-  const historyMessages = loadSessionHistory(effectiveWorkDir, claudeSessionId);
+  let driverForHistory;
+  try { driverForHistory = getProvider(provider); }
+  catch (err) {
+    console.warn(`[Resume] unknown provider "${provider}", falling back to claude-code history loader:`, err?.message || err);
+    driverForHistory = {};
+  }
+  const historyMessages = typeof driverForHistory.loadHistory === 'function'
+    ? await driverForHistory.loadHistory(effectiveWorkDir, claudeSessionId)
+    : loadSessionHistory(effectiveWorkDir, claudeSessionId);
   if (username) console.log(`[Resume] User: ${username} (${userId})`);
   console.log(`Loaded ${historyMessages.length} history messages`);
 
@@ -492,6 +503,7 @@ export async function resumeConversation(msg) {
       resumeSessionId: claudeSessionId || null,
       userId,
       username,
+      providerOptions: msg.providerOptions || priorProviderOptions || {},
     });
     state.disallowedTools = disallowedTools || null;
   }
@@ -656,9 +668,15 @@ export async function handleCancelExecution(msg) {
   // 标记为取消状态，防止 processClaudeOutput 的 finally 发送 conversation_closed
   state.cancelled = true;
 
-  // 中止当前查询
-  if (state.abortController) {
-    state.abortController.abort();
+  // 通过 driver 中止当前查询（Claude 走 abortController；Copilot 走 SIGTERM）
+  try {
+    const driver = getProvider(state.providerName || DEFAULT_PROVIDER);
+    if (typeof driver.abort === 'function') driver.abort(state);
+  } catch (err) {
+    console.warn(`[${conversationId}] driver.abort failed:`, err?.message || err);
+    if (state.abortController) {
+      try { state.abortController.abort(); } catch { /* noop */ }
+    }
   }
 
   // 关闭输入流

package/history.js

@@ -2,6 +2,7 @@ import { homedir } from 'os';
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import ctx from './context.js';
+import { getProvider, DEFAULT_PROVIDER } from './providers/index.js';
 
 // Claude 项目目录
 export function getClaudeProjectsDir() {
@@ -184,18 +185,23 @@ export function loadSessionHistory(workDir, claudeSessionId, limit = 500) {
 }
 
 export async function handleListHistorySessions(msg) {
-  const { workDir, requestId, _requestClientId } = msg;
+  const { workDir, requestId, _requestClientId, provider } = msg;
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
+  const providerName = provider || DEFAULT_PROVIDER;
 
-  console.log(`Listing history sessions for: ${effectiveWorkDir}`);
+  console.log(`Listing history sessions for: ${effectiveWorkDir} (provider=${providerName})`);
 
   try {
-    const sessions = await getHistorySessions(effectiveWorkDir);
+    const driver = getProvider(providerName);
+    const sessions = typeof driver.listSessions === 'function'
+      ? await driver.listSessions(effectiveWorkDir)
+      : await getHistorySessions(effectiveWorkDir);
     ctx.sendToServer({
       type: 'history_sessions_list',
       requestId,
       _requestClientId,
       workDir: effectiveWorkDir,
+      provider: providerName,
       sessions
     });
   } catch (e) {
@@ -205,85 +211,42 @@ export async function handleListHistorySessions(msg) {
       requestId,
       _requestClientId,
       workDir: effectiveWorkDir,
+      provider: providerName,
       sessions: [],
       error: e.message
     });
   }
 }
 
-// 列出 Claude projects 目录下的所有 folder (工作目录)
+// 列出指定 provider 下所有 folder (工作目录)
 export async function handleListFolders(msg) {
-  const { requestId, _requestClientId } = msg;
-  const projectsDir = getClaudeProjectsDir();
+  const { requestId, _requestClientId, provider } = msg;
+  const providerName = provider || DEFAULT_PROVIDER;
 
-  console.log(`Listing folders from: ${projectsDir}`);
+  console.log(`Listing folders for provider=${providerName}`);
 
   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()) {
-          // 过滤掉 crew 角色的 session 文件夹
-          // crew 角色的 cwd 在 .crew/roles/{roleName} 下，对应的文件夹名包含 --crew-roles-
-          if (entry.includes('--crew-roles-')) {
-            continue;
-          }
-
-          // 从 session 文件读取真实的工作目录路径
-          const originalPath = getWorkDirFromProjectFolder(entryPath, entry);
-
-          // 快速计数：只数 .jsonl 文件数量，不读取文件内容
-          let sessionCount = 0;
-          let lastModified = stats.mtime.getTime();
-
-          try {
-            const files = readdirSync(entryPath);
-
-            for (const file of files) {
-              if (file.endsWith('.jsonl')) {
-                sessionCount++;
-                try {
-                  const fileStats = statSync(join(entryPath, file));
-                  if (fileStats.mtime.getTime() > lastModified) {
-                    lastModified = fileStats.mtime.getTime();
-                  }
-                } catch {}
-              }
-            }
-          } catch {}
-
-          folders.push({
-            name: entry,
-            path: originalPath,
-            sessionCount,
-            lastModified
-          });
-        }
-      }
+    const driver = getProvider(providerName);
+    let folders = [];
+    if (typeof driver.listFolders === 'function') {
+      folders = await driver.listFolders();
     }
-
-    folders.sort((a, b) => b.lastModified - a.lastModified);
-
-    console.log(`Found ${folders.length} folders, sending response...`);
+    folders.sort((a, b) => (b.lastModified || 0) - (a.lastModified || 0));
+    console.log(`Found ${folders.length} folders (provider=${providerName}), sending response...`);
     ctx.sendToServer({
       type: 'folders_list',
       requestId,
       _requestClientId,
+      provider: providerName,
       folders
     });
-    console.log(`folders_list sent with ${folders.length} folders`);
   } catch (e) {
     console.error('Error listing folders:', e);
     ctx.sendToServer({
       type: 'folders_list',
       requestId,
       _requestClientId,
+      provider: providerName,
       folders: [],
       error: e.message
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.859",
+  "version": "0.1.860",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/providers/base.js

@@ -18,6 +18,13 @@
  * @property {(opts: StartOpts) => Promise<Object>} start
  * @property {(state: Object, prompt: string, opts?: Object) => Promise<void>} sendInput
  * @property {(state: Object) => void} abort
+ * @property {() => Promise<FolderInfo[]>} listFolders
+ *   Return the list of work-directories that this provider has sessions for.
+ * @property {(workDir: string) => Promise<SessionInfo[]>} listSessions
+ *   Return resumable sessions for a given work-directory.
+ * @property {(workDir: string, sessionId: string, limit?: number) => Promise<HistoryMessage[]>} loadHistory
+ *   Return the resumable transcript as an array of `claude_output`-compatible
+ *   envelopes (the same shape the live stream would have produced).
  *
  * @typedef {Object} StartOpts
  * @property {string} conversationId
@@ -25,6 +32,23 @@
  * @property {string|null} [resumeSessionId]
  * @property {string} [userId]
  * @property {string} [username]
+ * @property {Object} [providerOptions]   per-provider knobs (model, allowAllTools, ...)
+ *
+ * @typedef {Object} FolderInfo
+ * @property {string} name           opaque folder identifier (provider-specific)
+ * @property {string} path           original cwd path
+ * @property {number} sessionCount
+ * @property {number} lastModified   epoch ms
+ *
+ * @typedef {Object} SessionInfo
+ * @property {string} sessionId
+ * @property {string} workDir
+ * @property {string} title
+ * @property {string} [preview]
+ * @property {number} lastModified
+ * @property {number} [size]
+ *
+ * @typedef {Object} HistoryMessage   a single claude_output `data` envelope
  */
 
 export const PROVIDER_NAMES = Object.freeze(['claude-code', 'copilot']);

package/providers/claude-code.js

@@ -1,4 +1,12 @@
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
 import { startClaudeQuery } from '../claude.js';
+import {
+  getClaudeProjectsDir,
+  getHistorySessions,
+  loadSessionHistory,
+  getWorkDirFromProjectFolder,
+} from '../history.js';
 
 export const name = 'claude-code';
 
@@ -31,4 +39,46 @@ export function abort(state) {
   }
 }
 
-export default { name, start, sendInput, abort };
+// ---------- history surface ----------
+
+export async function listFolders() {
+  const projectsDir = getClaudeProjectsDir();
+  const folders = [];
+  if (!existsSync(projectsDir)) return folders;
+
+  for (const entry of readdirSync(projectsDir)) {
+    const entryPath = join(projectsDir, entry);
+    let stats;
+    try { stats = statSync(entryPath); } catch { continue; }
+    if (!stats.isDirectory()) continue;
+    if (entry.includes('--crew-roles-')) continue;
+
+    const originalPath = getWorkDirFromProjectFolder(entryPath, entry);
+    let sessionCount = 0;
+    let lastModified = stats.mtime.getTime();
+    try {
+      for (const file of readdirSync(entryPath)) {
+        if (!file.endsWith('.jsonl')) continue;
+        sessionCount++;
+        try {
+          const fs = statSync(join(entryPath, file));
+          if (fs.mtime.getTime() > lastModified) lastModified = fs.mtime.getTime();
+        } catch { /* noop */ }
+      }
+    } catch { /* noop */ }
+
+    folders.push({ name: entry, path: originalPath, sessionCount, lastModified });
+  }
+  folders.sort((a, b) => b.lastModified - a.lastModified);
+  return folders;
+}
+
+export async function listSessions(workDir) {
+  return await getHistorySessions(workDir);
+}
+
+export async function loadHistory(workDir, sessionId, limit = 500) {
+  return loadSessionHistory(workDir, sessionId, limit);
+}
+
+export default { name, start, sendInput, abort, listFolders, listSessions, loadHistory };

package/providers/copilot.js

@@ -1,5 +1,9 @@
 import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { DatabaseSync } from 'node:sqlite';
 import ctx from '../context.js';
 
 export const name = 'copilot';
@@ -25,6 +29,7 @@ export async function start(opts) {
   }
 
   const sessionId = opts.resumeSessionId || randomUUID();
+  const providerOptions = opts.providerOptions || prior?.providerOptions || {};
   const state = {
     providerName: name,
     conversationId: opts.conversationId,
@@ -37,11 +42,12 @@ export async function start(opts) {
     abortController: null,
     tools: [],
     slashCommands: [],
-    model: 'copilot',
+    model: providerOptions.model || 'copilot',
     userId: opts.userId,
     username: opts.username,
     disallowedTools: prior?.disallowedTools || null,
     copilotChild: null,
+    providerOptions,
     usage: { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0, totalCostUsd: 0 },
   };
   ctx.conversations.set(conversationId, state);
@@ -64,7 +70,15 @@ export async function sendInput(state, prompt, opts = {}) {
   state.turnResultReceived = false;
 
   const args = ['-p', prompt, '--output-format', 'json', '-C', state.workDir, '--session-id', state.sessionId];
-  if (YOLO) args.push('--allow-all-tools');
+  const po = { ...(state.providerOptions || {}), ...(opts.providerOptions || {}) };
+  if (po.model) args.push('--model', String(po.model));
+  if (po.effort) args.push('--effort', String(po.effort));
+  if (Array.isArray(po.addDirs)) {
+    for (const d of po.addDirs) args.push('--add-dir', String(d));
+  }
+  // YOLO env var still wins as a global override; per-conv allowAllTools
+  // lets the user opt in from the UI without setting an env var.
+  if (YOLO || po.allowAllTools) args.push('--allow-all-tools');
 
   let child;
   try {
@@ -275,4 +289,196 @@ function normalizeContent(content) {
   return [{ type: 'text', text: String(content ?? '') }];
 }
 
-export default { name, start, sendInput, abort };
+export default { name, start, sendInput, abort, listFolders, listSessions, loadHistory };
+
+// ---------- history surface (reads ~/.copilot/session-store.db) ----------
+
+export function getCopilotDbPath() {
+  return process.env.COPILOT_DB_PATH || join(homedir(), '.copilot', 'session-store.db');
+}
+
+let _dbHandle = null;
+let _dbHandlePath = null;
+function openDb() {
+  const path = getCopilotDbPath();
+  if (!existsSync(path)) return null;
+  if (_dbHandle && _dbHandlePath === path) return _dbHandle;
+  if (_dbHandle) {
+    try { _dbHandle.close(); } catch { /* noop */ }
+    _dbHandle = null;
+  }
+  try {
+    _dbHandle = new DatabaseSync(path, { readOnly: true });
+    _dbHandlePath = path;
+    return _dbHandle;
+  } catch (err) {
+    if (ctx?.CONFIG?.debug) console.warn('[copilot] cannot open session DB:', err?.message || err);
+    return null;
+  }
+}
+
+// Exposed for tests so they can drop the cached handle when swapping
+// COPILOT_DB_PATH between cases.
+export function _resetCopilotDbHandle() {
+  if (_dbHandle) {
+    try { _dbHandle.close(); } catch { /* noop */ }
+  }
+  _dbHandle = null;
+  _dbHandlePath = null;
+}
+
+function toEpochMs(iso) {
+  if (!iso) return 0;
+  const t = Date.parse(iso);
+  return Number.isFinite(t) ? t : 0;
+}
+
+export async function listFolders() {
+  const db = openDb();
+  if (!db) return [];
+  try {
+    const rows = db.prepare(`
+      SELECT cwd, COUNT(*) AS sessionCount, MAX(updated_at) AS lastUpdated
+      FROM sessions
+      WHERE cwd IS NOT NULL AND cwd <> ''
+      GROUP BY cwd
+      ORDER BY lastUpdated DESC
+    `).all();
+    return rows.map(r => ({
+      name: r.cwd,
+      path: r.cwd,
+      sessionCount: Number(r.sessionCount) || 0,
+      lastModified: toEpochMs(r.lastUpdated),
+    }));
+  } catch (err) {
+    if (ctx?.CONFIG?.debug) console.warn('[copilot] listFolders failed:', err?.message || err);
+    return [];
+  }
+}
+
+export async function listSessions(workDir) {
+  if (!workDir) return [];
+  const db = openDb();
+  if (!db) return [];
+  try {
+    const rows = db.prepare(`
+      SELECT s.id, s.summary, s.created_at, s.updated_at,
+             (SELECT user_message FROM turns WHERE session_id = s.id ORDER BY turn_index ASC LIMIT 1) AS first_user
+      FROM sessions s
+      WHERE s.cwd = ?
+      ORDER BY s.updated_at DESC
+    `).all(workDir);
+    return rows.map(r => {
+      const preview = (r.first_user || '').toString().slice(0, 100);
+      const title = (r.summary && r.summary.trim()) || preview || r.id.slice(0, 8);
+      return {
+        sessionId: r.id,
+        workDir,
+        title,
+        preview,
+        lastModified: toEpochMs(r.updated_at) || toEpochMs(r.created_at),
+      };
+    }).filter(s => s.title);
+  } catch (err) {
+    if (ctx?.CONFIG?.debug) console.warn('[copilot] listSessions failed:', err?.message || err);
+    return [];
+  }
+}
+
+export async function loadHistory(workDir, sessionId, limit = 500) {
+  if (!sessionId) return [];
+  const db = openDb();
+  if (!db) return [];
+  try {
+    const allTurns = db.prepare(`
+      SELECT turn_index, user_message, assistant_response, timestamp
+      FROM turns WHERE session_id = ? ORDER BY turn_index ASC
+    `).all(sessionId);
+    // Apply limit at the turn level so we never split a tool_use / tool_result
+    // pair when truncating. Each turn typically expands to <=4 messages, so
+    // ceil(limit/4) turns is a safe upper bound that preserves recency.
+    const turns = limit && allTurns.length > Math.ceil(limit / 4)
+      ? allTurns.slice(-Math.ceil(limit / 4))
+      : allTurns;
+
+    // Tool-call events per turn, in order. Copilot's schema is not fully
+    // documented; in some versions a single tool call writes multiple rows
+    // (e.g. a "started" row with the command and a "completed" row with
+    // output/exit_code). Dedupe by tool_call_id, preferring rows that
+    // carry output so we render one tool_use + one tool_result per call.
+    const events = db.prepare(`
+      SELECT id, turn_index, tool_call_id, event_type, command, output, exit_code,
+             event_key, event_value, created_at
+      FROM forge_trajectory_events
+      WHERE session_id = ?
+      ORDER BY turn_index ASC, id ASC
+    `).all(sessionId);
+
+    const mergedByCallId = new Map();
+    const orderedKeys = [];
+    for (const e of events) {
+      const key = e.tool_call_id || `__row:${e.id}`;
+      const prev = mergedByCallId.get(key);
+      if (!prev) {
+        orderedKeys.push(key);
+        mergedByCallId.set(key, { ...e });
+      } else {
+        // Merge later rows in; non-null values win so the "completed" row
+        // adds output/exit_code without erasing the "started" row's command.
+        for (const [k, v] of Object.entries(e)) {
+          if (v != null && v !== '') prev[k] = v;
+        }
+      }
+    }
+    const eventsByTurn = new Map();
+    for (const key of orderedKeys) {
+      const e = mergedByCallId.get(key);
+      const arr = eventsByTurn.get(e.turn_index) || [];
+      arr.push(e);
+      eventsByTurn.set(e.turn_index, arr);
+    }
+
+    const messages = [];
+    for (const t of turns) {
+      if (t.user_message) {
+        messages.push({
+          type: 'user',
+          message: { role: 'user', content: [{ type: 'text', text: String(t.user_message) }] },
+        });
+      }
+      // Render any tool calls captured for this turn as assistant tool_use +
+      // user tool_result pairs, then the final assistant text.
+      const turnEvents = eventsByTurn.get(t.turn_index) || [];
+      for (const e of turnEvents) {
+        if (!e.event_type) continue;
+        const toolId = e.tool_call_id || `copilot-${t.turn_index}-${messages.length}`;
+        const toolName = e.event_type;
+        const input = e.command
+          ? { command: e.command }
+          : (e.event_key ? { [e.event_key]: e.event_value } : {});
+        messages.push({
+          type: 'assistant',
+          message: { role: 'assistant', content: [{ type: 'tool_use', id: toolId, name: toolName, input }] },
+        });
+        const outText = e.output != null
+          ? String(e.output)
+          : (e.exit_code != null ? `exit ${e.exit_code}` : '');
+        messages.push({
+          type: 'user',
+          message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: toolId, content: outText }] },
+        });
+      }
+      if (t.assistant_response) {
+        messages.push({
+          type: 'assistant',
+          message: { role: 'assistant', content: [{ type: 'text', text: String(t.assistant_response) }] },
+        });
+      }
+    }
+    return messages;
+  } catch (err) {
+    if (ctx?.CONFIG?.debug) console.warn('[copilot] loadHistory failed:', err?.message || err);
+    return [];
+  }
+}
+