@yeaft/webchat-agent 0.1.856 → 0.1.859

package/conversation.js

@@ -6,6 +6,7 @@ import { query } from './sdk/index.js';
 import { loadSessionHistory } from './history.js';
 import { startClaudeQuery } from './claude.js';
 import { crewSessions, loadCrewIndex } from './crew.js';
+import { getProvider, DEFAULT_PROVIDER, isValidProvider } from './providers/index.js';
 
 // 不支持的斜杠命令（真正需要交互式 CLI 的命令）
 const UNSUPPORTED_SLASH_COMMANDS = ['/help', '/bug', '/login', '/logout', '/terminal-setup', '/vim', '/config'];
@@ -293,7 +294,8 @@ export async function sendConversationList() {
       createdAt: state.createdAt,
       processing: !!state.turnActive,
       userId: state.userId,
-      username: state.username
+      username: state.username,
+      provider: state.providerName || DEFAULT_PROVIDER
     };
     list.push(entry);
   }
@@ -356,33 +358,41 @@ export function sendError(conversationId, message) {
 export async function createConversation(msg) {
   const { conversationId, workDir, userId, username, disallowedTools } = msg;
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
+  const provider = isValidProvider(msg.provider) ? msg.provider : DEFAULT_PROVIDER;
 
-  console.log(`Creating conversation: ${conversationId} in ${effectiveWorkDir} (lazy start)`);
+  console.log(`Creating conversation: ${conversationId} in ${effectiveWorkDir} (lazy start, provider=${provider})`);
   if (username) console.log(`  User: ${username} (${userId})`);
 
-  // 只创建 conversation 状态，不启动 Claude 进程
-  // Claude 进程会在用户发送第一条消息时启动 (见 handleUserInput)
-  ctx.conversations.set(conversationId, {
-    query: null,
-    inputStream: null,
-    workDir: effectiveWorkDir,
-    claudeSessionId: null,
-    createdAt: Date.now(),
-    abortController: null,
-    tools: [],
-    slashCommands: [],
-    model: null,
-    userId,
-    username,
-    disallowedTools: disallowedTools || null,  // null = 使用全局默认
-    usage: {
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheRead: 0,
-      cacheCreation: 0,
-      totalCostUsd: 0
-    }
-  });
+  if (provider === 'claude-code') {
+    // Claude path: lazy-init state, real CLI boots on first message.
+    ctx.conversations.set(conversationId, {
+      query: null,
+      inputStream: null,
+      workDir: effectiveWorkDir,
+      claudeSessionId: null,
+      createdAt: Date.now(),
+      abortController: null,
+      tools: [],
+      slashCommands: [],
+      model: null,
+      userId,
+      username,
+      providerName: provider,
+      disallowedTools: disallowedTools || null,
+      usage: { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0, totalCostUsd: 0 }
+    });
+  } else {
+    // Non-Claude providers own their own state construction.
+    const driver = getProvider(provider);
+    const state = await driver.start({
+      conversationId,
+      workDir: effectiveWorkDir,
+      resumeSessionId: null,
+      userId,
+      username,
+    });
+    state.disallowedTools = disallowedTools || null;
+  }
 
   ctx.sendToServer({
     type: 'conversation_created',
@@ -390,6 +400,7 @@ export async function createConversation(msg) {
     workDir: effectiveWorkDir,
     userId,
     username,
+    provider,
     disallowedTools: disallowedTools || null
   });
 
@@ -414,13 +425,16 @@ export async function createConversation(msg) {
 
   // ★ Prestart Claude CLI in background to eagerly fetch skills/tools/model
   // Fire-and-forget: failure just degrades to lazy-start behavior
-  prestartClaude(conversationId, effectiveWorkDir, null);
+  if (provider === 'claude-code') {
+    prestartClaude(conversationId, effectiveWorkDir, null);
+  }
 }
 
 // Resume 历史 conversation (延迟启动 Claude，等待用户发送第一条消息)
 export async function resumeConversation(msg) {
   const { conversationId, claudeSessionId, workDir, userId, username, disallowedTools } = msg;
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
+  const provider = isValidProvider(msg.provider) ? msg.provider : DEFAULT_PROVIDER;
 
   console.log(`[Resume] conversationId: ${conversationId}`);
   console.log(`[Resume] claudeSessionId: ${claudeSessionId}`);
@@ -458,6 +472,7 @@ export async function resumeConversation(msg) {
     model: null,
     userId,
     username,
+    providerName: provider,
     disallowedTools: disallowedTools || null,  // null = 使用全局默认
     usage: {
       inputTokens: 0,
@@ -468,6 +483,19 @@ export async function resumeConversation(msg) {
     }
   });
 
+  // Non-Claude providers: re-init state via driver so sessionId/providerName are set correctly.
+  if (provider !== 'claude-code') {
+    const driver = getProvider(provider);
+    const state = await driver.start({
+      conversationId,
+      workDir: effectiveWorkDir,
+      resumeSessionId: claudeSessionId || null,
+      userId,
+      username,
+    });
+    state.disallowedTools = disallowedTools || null;
+  }
+
   ctx.sendToServer({
     type: 'conversation_resumed',
     conversationId,
@@ -475,7 +503,8 @@ export async function resumeConversation(msg) {
     workDir: effectiveWorkDir,
     historyMessages,
     userId,
-    username
+    username,
+    provider
   });
 
   // 立即发送 agent 级别的 MCP servers 列表
@@ -498,7 +527,7 @@ export async function resumeConversation(msg) {
   // ★ Prestart Claude CLI in background to eagerly fetch skills/tools/model
   // Skip if conversation already has an active query (shouldn't happen, but safety check)
   const resumeState = ctx.conversations.get(conversationId);
-  if (!resumeState?.query) {
+  if (provider === 'claude-code' && !resumeState?.query) {
     prestartClaude(conversationId, effectiveWorkDir, claudeSessionId);
   }
 }
@@ -704,6 +733,41 @@ export async function handleUserInput(msg) {
 
   let state = ctx.conversations.get(conversationId);
 
+  // ★ Non-Claude providers: dispatch to driver and return
+  const providerName = state?.providerName || DEFAULT_PROVIDER;
+  if (providerName !== 'claude-code') {
+    const driver = getProvider(providerName);
+    const effectiveWorkDir = workDir || state?.workDir || ctx.CONFIG.workDir;
+    if (!state) {
+      state = await driver.start({
+        conversationId,
+        workDir: effectiveWorkDir,
+        resumeSessionId: claudeSessionId || null,
+        userId: msg.userId,
+        username: msg.username,
+      });
+    }
+    if (workDir) state.workDir = workDir;
+    sendOutput(conversationId, { type: 'user', message: { role: 'user', content: prompt } });
+    state.turnActive = true;
+    sendConversationList();
+    try {
+      await driver.sendInput(state, prompt, { conversationId, raw: msg });
+    } catch (err) {
+      sendOutput(conversationId, {
+        type: 'result',
+        subtype: 'error',
+        session_id: state.sessionId || null,
+        is_error: true,
+        error: `${providerName} error: ${err?.message || err}`,
+      });
+    } finally {
+      state.turnActive = false;
+      sendConversationList();
+    }
+    return;
+  }
+
   // 如果没有活跃的查询，启动新的
   if (!state || !state.query || !state.inputStream) {
     const resumeSessionId = claudeSessionId || state?.claudeSessionId || null;

package/package.json

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

package/providers/base.js

@@ -0,0 +1,34 @@
+/**
+ * Chat provider abstraction.
+ *
+ * Wire-protocol note: `claude_output` is now a PROTOCOL name, not a
+ * vendor name. Every driver MUST emit events on
+ * `ctx.sendToServer({ type: 'claude_output', conversationId, data })`,
+ * where `data` follows the Claude stream-json envelope:
+ *   - { type: 'assistant', message: { role, content: [...] } }
+ *   - { type: 'user',      message: { role, content: [...] } }
+ *   - { type: 'result',    subtype, session_id, is_error, ... }
+ *   - { type: 'system',    subtype, ... }
+ *
+ * Non-Claude drivers (e.g. Copilot) MUST translate their native event
+ * streams into this envelope so the existing renderer needs no changes.
+ *
+ * @typedef {Object} ChatProvider
+ * @property {string} name
+ * @property {(opts: StartOpts) => Promise<Object>} start
+ * @property {(state: Object, prompt: string, opts?: Object) => Promise<void>} sendInput
+ * @property {(state: Object) => void} abort
+ *
+ * @typedef {Object} StartOpts
+ * @property {string} conversationId
+ * @property {string} workDir
+ * @property {string|null} [resumeSessionId]
+ * @property {string} [userId]
+ * @property {string} [username]
+ */
+
+export const PROVIDER_NAMES = Object.freeze(['claude-code', 'copilot']);
+export const DEFAULT_PROVIDER = 'claude-code';
+export function isValidProvider(name) {
+  return typeof name === 'string' && PROVIDER_NAMES.includes(name);
+}

package/providers/claude-code.js

@@ -0,0 +1,34 @@
+import { startClaudeQuery } from '../claude.js';
+
+export const name = 'claude-code';
+
+/**
+ * Start (or resume) a Claude Code CLI session.
+ * Returns the same state object that startClaudeQuery stores in ctx.conversations.
+ */
+export async function start(opts) {
+  const state = await startClaudeQuery(
+    opts.conversationId,
+    opts.workDir,
+    opts.resumeSessionId || null
+  );
+  state.providerName = name;
+  return state;
+}
+
+/**
+ * Claude CLI handles input via the persistent stdin Stream that
+ * conversation.js manages directly, so this driver's sendInput is a no-op.
+ * conversation.js's existing branch keeps owning the Claude path.
+ */
+export async function sendInput(_state, _prompt, _opts) {
+  /* handled inline by conversation.js for the Claude branch */
+}
+
+export function abort(state) {
+  if (state?.abortController) {
+    try { state.abortController.abort(); } catch { /* noop */ }
+  }
+}
+
+export default { name, start, sendInput, abort };

package/providers/copilot.js

@@ -0,0 +1,278 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import ctx from '../context.js';
+
+export const name = 'copilot';
+
+const COPILOT_BIN = process.env.COPILOT_BIN || 'copilot';
+// Opt-in only: --allow-all-tools is a destructive footgun by default in a
+// multi-tenant agent. Set COPILOT_YOLO=1 (and only if you know what you're
+// doing) to skip Copilot's tool prompts.
+const YOLO = process.env.COPILOT_YOLO === '1';
+
+/**
+ * Start (or resume) a Copilot session.
+ * Copilot's `-p` mode is one-shot per turn, so "start" just prepares state.
+ * Each sendInput() spawns one `copilot -p ...` child with the same
+ * --session-id for continuity.
+ */
+export async function start(opts) {
+  const conversationId = opts.conversationId;
+  // Tear down any prior entry so we don't leak children.
+  const prior = ctx.conversations.get(conversationId);
+  if (prior?.copilotChild) {
+    try { prior.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
+  }
+
+  const sessionId = opts.resumeSessionId || randomUUID();
+  const state = {
+    providerName: name,
+    conversationId: opts.conversationId,
+    query: null,
+    inputStream: null,
+    workDir: opts.workDir,
+    claudeSessionId: sessionId,
+    sessionId,
+    createdAt: prior?.createdAt || Date.now(),
+    abortController: null,
+    tools: [],
+    slashCommands: [],
+    model: 'copilot',
+    userId: opts.userId,
+    username: opts.username,
+    disallowedTools: prior?.disallowedTools || null,
+    copilotChild: null,
+    usage: { inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheCreation: 0, totalCostUsd: 0 },
+  };
+  ctx.conversations.set(conversationId, state);
+  return state;
+}
+
+export async function sendInput(state, prompt, opts = {}) {
+  const conversationId = opts.conversationId || state.conversationId;
+  if (!conversationId) throw new Error('copilot: conversationId required');
+  if (!state.sessionId) state.sessionId = randomUUID();
+
+  // Abort any in-flight turn.
+  if (state.copilotChild) {
+    try { state.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
+    state.copilotChild = null;
+  }
+  const abortController = new AbortController();
+  state.abortController = abortController;
+  state.turnActive = true;
+  state.turnResultReceived = false;
+
+  const args = ['-p', prompt, '--output-format', 'json', '-C', state.workDir, '--session-id', state.sessionId];
+  if (YOLO) args.push('--allow-all-tools');
+
+  let child;
+  try {
+    child = spawn(COPILOT_BIN, args, {
+      cwd: state.workDir,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (err) {
+    sendOutput(conversationId, {
+      type: 'result',
+      subtype: 'error',
+      session_id: state.sessionId,
+      is_error: true,
+      error: `copilot spawn failed: ${err?.message || err}`,
+    });
+    state.turnActive = false;
+    ctx.sendToServer({ type: 'turn_completed', conversationId, claudeSessionId: state.sessionId, workDir: state.workDir });
+    return;
+  }
+  state.copilotChild = child;
+
+  // Pre-register error handler so async ENOENT from spawn is never unhandled.
+  child.on('error', (err) => {
+    sendOutput(conversationId, {
+      type: 'result',
+      subtype: 'error',
+      session_id: state.sessionId,
+      is_error: true,
+      error: `copilot process error: ${err?.message || err}`,
+    });
+  });
+
+  let killTimer = null;
+  abortController.signal.addEventListener('abort', () => {
+    try { child.kill('SIGTERM'); } catch { /* noop */ }
+    // Escalate to SIGKILL if the child ignores SIGTERM, so the awaited
+    // close promise resolves and the next turn isn't blocked forever.
+    killTimer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch { /* noop */ }
+    }, 5000);
+  });
+
+  let stderrBuf = '';
+  const STDERR_CAP = 64 * 1024;
+  let sawResult = false;
+
+  const parser = createNdjsonParser((evt) => {
+    const envelopes = translateCopilotEvent(evt, state);
+    for (const e of envelopes) {
+      sendOutput(conversationId, e);
+      if (e?.type === 'result') sawResult = true;
+    }
+  });
+
+  child.stdout.on('data', (chunk) => parser.push(chunk));
+  child.stderr.on('data', (chunk) => {
+    if (stderrBuf.length < STDERR_CAP) {
+      stderrBuf += chunk.toString('utf8').slice(0, STDERR_CAP - stderrBuf.length);
+    }
+  });
+
+  await new Promise((resolve) => {
+    child.on('close', (code) => {
+      if (killTimer) clearTimeout(killTimer);
+      parser.flush();
+      if (!sawResult) {
+        const ok = code === 0;
+        sendOutput(conversationId, {
+          type: 'result',
+          subtype: ok ? 'success' : 'error',
+          session_id: state.sessionId,
+          is_error: !ok,
+          error: ok ? undefined : (stderrBuf.trim().slice(0, 2000) || `copilot exited with code ${code}`),
+        });
+      }
+      state.copilotChild = null;
+      state.turnActive = false;
+      ctx.sendToServer({
+        type: 'turn_completed',
+        conversationId,
+        claudeSessionId: state.sessionId,
+        workDir: state.workDir,
+      });
+      resolve();
+    });
+  });
+}
+
+export function abort(state) {
+  if (state?.abortController) {
+    try { state.abortController.abort(); } catch { /* noop */ }
+  }
+  if (state?.copilotChild) {
+    try { state.copilotChild.kill('SIGTERM'); } catch { /* noop */ }
+  }
+}
+
+// ---------- internals ----------
+
+function sendOutput(conversationId, data) {
+  ctx.sendToServer({ type: 'claude_output', conversationId, data });
+}
+
+export function createNdjsonParser(onEvent) {
+  let buf = '';
+  return {
+    push(chunk) {
+      buf += chunk.toString('utf8');
+      let idx;
+      while ((idx = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, idx).trim();
+        buf = buf.slice(idx + 1);
+        if (!line) continue;
+        let evt;
+        try { evt = JSON.parse(line); }
+        catch (err) {
+          if (ctx?.CONFIG?.debug) console.warn('[copilot] dropping unparsable line:', line.slice(0, 200));
+          continue;
+        }
+        try { onEvent(evt); }
+        catch (err) { console.warn('[copilot] event handler error:', err?.message || err); }
+      }
+    },
+    flush() {
+      const line = buf.trim();
+      buf = '';
+      if (!line) return;
+      try {
+        const evt = JSON.parse(line);
+        onEvent(evt);
+      } catch { /* discard trailing junk */ }
+    },
+  };
+}
+
+/**
+ * Map a Copilot NDJSON event to zero-or-more claude_output envelopes.
+ * Defensive: unknown shapes are logged and dropped.
+ *
+ * Recognized loose schemas (Copilot CLI JSON output is not yet stable, so
+ * we accept several aliases and forward only what we understand):
+ *  - text:        { type: 'text'|'text_delta'|'assistant_text', text|delta }
+ *  - message:     { type: 'message', role, content }
+ *  - tool_call:   { type: 'tool_call'|'tool_use', id, name|tool, input|arguments }
+ *  - tool_result: { type: 'tool_result', tool_use_id|id, content|output }
+ *  - done:        { type: 'result'|'done'|'complete', session_id?, error? }
+ *  - error:       { type: 'error', message|error }
+ */
+export function translateCopilotEvent(evt, state) {
+  if (!evt || typeof evt !== 'object') return [];
+  const t = evt.type;
+
+  if (t === 'text' || t === 'text_delta' || t === 'assistant_text') {
+    const text = typeof evt.text === 'string' ? evt.text : (typeof evt.delta === 'string' ? evt.delta : '');
+    if (!text) return [];
+    return [{ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text }] } }];
+  }
+
+  if (t === 'message' && evt.role === 'assistant') {
+    const content = normalizeContent(evt.content);
+    return [{ type: 'assistant', message: { role: 'assistant', content } }];
+  }
+
+  if (t === 'tool_call' || t === 'tool_use') {
+    const id = evt.id || evt.call_id || randomUUID();
+    const toolName = evt.name || evt.tool || 'unknown';
+    const input = evt.input ?? evt.arguments ?? {};
+    return [{ type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id, name: toolName, input }] } }];
+  }
+
+  if (t === 'tool_result') {
+    const tool_use_id = evt.tool_use_id || evt.id || 'unknown';
+    const content = typeof evt.content === 'string'
+      ? evt.content
+      : (typeof evt.output === 'string' ? evt.output : JSON.stringify(evt.content ?? evt.output ?? ''));
+    return [{ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id, content }] } }];
+  }
+
+  if (t === 'result' || t === 'done' || t === 'complete') {
+    const isErr = !!evt.error || evt.is_error === true;
+    return [{
+      type: 'result',
+      subtype: isErr ? 'error' : 'success',
+      session_id: evt.session_id || state?.sessionId || null,
+      is_error: isErr,
+      error: isErr ? (evt.error || evt.message || 'copilot error') : undefined,
+    }];
+  }
+
+  if (t === 'error') {
+    return [{
+      type: 'result',
+      subtype: 'error',
+      session_id: state?.sessionId || null,
+      is_error: true,
+      error: evt.message || evt.error || 'copilot error',
+    }];
+  }
+
+  if (ctx?.CONFIG?.debug) console.warn('[copilot] dropping unknown event type:', t);
+  return [];
+}
+
+function normalizeContent(content) {
+  if (typeof content === 'string') return [{ type: 'text', text: content }];
+  if (Array.isArray(content)) return content;
+  return [{ type: 'text', text: String(content ?? '') }];
+}
+
+export default { name, start, sendInput, abort };

package/providers/index.js

@@ -0,0 +1,19 @@
+import { PROVIDER_NAMES, DEFAULT_PROVIDER, isValidProvider } from './base.js';
+import * as claudeCode from './claude-code.js';
+import * as copilot from './copilot.js';
+
+const REGISTRY = Object.freeze({
+  'claude-code': claudeCode,
+  'copilot': copilot,
+});
+
+export function getProvider(nameOrUndef) {
+  const key = nameOrUndef || DEFAULT_PROVIDER;
+  const driver = REGISTRY[key];
+  if (!driver) {
+    throw new Error(`Unknown chat provider: ${nameOrUndef} (known: ${PROVIDER_NAMES.join(', ')})`);
+  }
+  return driver;
+}
+
+export { PROVIDER_NAMES, DEFAULT_PROVIDER, isValidProvider };

package/yeaft/compact/orchestrator.js

@@ -28,7 +28,6 @@
  */
 
 import { groupTurns, pickCoolingGroups, indicesFromGroups } from './turn-group.js';
-import { writeSummary } from '../memory/store-v2.js';
 
 /**
  * @typedef {{
@@ -57,7 +56,7 @@ import { writeSummary } from '../memory/store-v2.js';
  *   nextMessages: object[],
  * }>}
  */
-export async function runCompact({ messages, keepHot = 10, taskId = null, root, hooks }) {
+export async function runCompact({ messages, keepHot = 10, hooks }) {
   if (!Array.isArray(messages)) {
     throw new Error('runCompact: messages array required');
   }
@@ -104,17 +103,12 @@ export async function runCompact({ messages, keepHot = 10, taskId = null, root,
     archiveResults.push({ ...g, turnId: r?.turnId });
   }
 
-  // Track 2 — refresh task summary if applicable.
-  let taskSummaryRefreshed = false;
-  if (taskId && root && typeof hooks.refreshTaskSummary === 'function') {
-    const prior = typeof hooks.readPriorTaskSummary === 'function'
-      ? await hooks.readPriorTaskSummary() : '';
-    const next = await hooks.refreshTaskSummary(coolingMessages, prior);
-    if (typeof next === 'string' && next.trim()) {
-      await writeSummary({ kind: 'feature', id: taskId }, next, { root });
-      taskSummaryRefreshed = true;
-    }
-  }
+  // Track 2 — task summary refresh: removed. The legacy `feature/<id>` root
+  // scope was dropped along with the Feature system (2026-05-13); under the
+  // group-isolated layout feature summaries would live at
+  // `group/<g>/feature/<id>/` and are written by dream, not by post-turn
+  // compact. Engine no longer passes `taskId`/`root` to this orchestrator.
+  const taskSummaryRefreshed = false;
 
   // Track 3 — memory extraction.
   let extractedCount = 0;