@winmatrix/supervisor 1.0.5

package/src/run-engine.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * Engine executor — supervise-run worker 的统一子进程入口。
+ *
+ * 用法: node /opt/winmatrix/run-engine.mjs \
+ *        --engine <claude-code|codex|hermes|openclaw> \
+ *        [--model <model>] [--permission-mode <mode>] \
+ *        [--allowed-tools <tool1,tool2>] [--resume <sessionId>|--fork <sessionId>] \
+ *        [--timeout <seconds>] [--work-dir <dir>] \
+ *        <prompt>
+ *
+ * 通过 @winmatrix/agent-sdk 的对应 Adapter 执行，将 AdapterEvent 序列化为 JSONL
+ * 输出到 stdout，供 run-agent-engine.mjs 解析并写入 events.jsonl。
+ */
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+const SDK_PATH = process.env.WINMATRIX_AGENT_SDK_PATH
+  || '/home/node/.local/lib/node_modules/@winmatrix/agent-sdk';
+
+function parseArgs(argv) {
+  const options = {
+    engineId: undefined,
+    model: undefined,
+    permissionMode: undefined,
+    allowedTools: undefined,
+    resume: undefined,
+    fork: undefined,
+    timeoutSec: undefined,
+    workDir: undefined,
+  };
+  const positionals = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--engine') {
+      options.engineId = argv[++i];
+    } else if (arg === '--model') {
+      options.model = argv[++i];
+    } else if (arg === '--permission-mode') {
+      options.permissionMode = argv[++i];
+    } else if (arg === '--allowed-tools') {
+      options.allowedTools = argv[++i];
+    } else if (arg === '--resume') {
+      options.resume = argv[++i];
+    } else if (arg === '--fork') {
+      options.fork = argv[++i];
+    } else if (arg === '--timeout') {
+      options.timeoutSec = argv[++i];
+    } else if (arg === '--work-dir') {
+      options.workDir = argv[++i];
+    } else if (arg.startsWith('--')) {
+      // 忽略未来可能透传的 engine-specific 选项；后续可按 engineId 路由
+      console.error(`[run-engine] 忽略未知选项: ${arg}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  return { options, positionals };
+}
+
+function writeEvent(event) {
+  process.stdout.write(`${JSON.stringify(event)}\n`);
+}
+
+async function main() {
+  const { options, positionals } = parseArgs(process.argv.slice(2));
+  const prompt = positionals[0];
+
+  if (!options.engineId) {
+    console.error('[run-engine] 缺少 --engine');
+    process.exit(1);
+  }
+  if (!prompt) {
+    console.error('[run-engine] 缺少任务描述（第一个位置参数）');
+    process.exit(1);
+  }
+
+  let sdk;
+  try {
+    sdk = require(SDK_PATH);
+  } catch (e) {
+    console.error(`[run-engine] 无法加载 @winmatrix/agent-sdk: ${e.message}`);
+    process.exit(1);
+  }
+
+  const {
+    AdapterRegistry,
+    ClaudeAdapter,
+    CodexAdapter,
+    HermesAdapter,
+    OpenClawAdapter,
+  } = sdk;
+
+  const registry = new AdapterRegistry();
+  registry.register('claude-code', ClaudeAdapter);
+  registry.register('codex', CodexAdapter);
+  registry.register('hermes', HermesAdapter);
+  registry.register('openclaw', OpenClawAdapter);
+
+  if (!registry.has(options.engineId)) {
+    console.error(`[run-engine] 不支持的 engineId: ${options.engineId}`);
+    process.exit(1);
+  }
+
+  const adapterConfig = {};
+  const adapter = registry.create(options.engineId, adapterConfig);
+
+  /** @type {import('@winmatrix/agent-sdk').AgentTaskContext} */
+  const task = {
+    taskId: `run-engine-${process.pid}`,
+    input: prompt,
+    prompt,
+    engineId: options.engineId,
+    workDir: options.workDir,
+  };
+
+  if (options.engineId === 'claude-code') {
+    task.claude = {};
+    if (options.permissionMode) task.claude.permissionMode = options.permissionMode;
+    if (options.allowedTools) task.claude.tools = options.allowedTools.split(',').map((s) => s.trim());
+  } else if (options.engineId === 'hermes') {
+    task.hermes = {};
+    if (options.model) task.hermes.model = options.model;
+  } else if (options.engineId === 'codex') {
+    task.codex = {};
+    if (options.model) task.codex.model = options.model;
+  } else if (options.engineId === 'openclaw') {
+    task.openclaw = {};
+  }
+
+  if (options.resume) {
+    task.sessionId = options.resume;
+    task.resumeSession = true;
+  } else if (options.fork) {
+    task.sessionId = options.fork;
+    task.forkSession = true;
+  }
+
+  let abortController;
+  let timeoutHandle;
+  if (options.timeoutSec) {
+    const timeoutMs = Number(options.timeoutSec) * 1000;
+    if (!Number.isNaN(timeoutMs) && timeoutMs > 0) {
+      abortController = new AbortController();
+      timeoutHandle = setTimeout(() => abortController.abort(), timeoutMs);
+    }
+  }
+
+  try {
+    for await (const event of adapter.execute(task, abortController?.signal)) {
+      switch (event.type) {
+        case 'delta':
+          writeEvent({ type: 'content_delta', text: event.content });
+          break;
+        case 'thinking':
+          writeEvent({ type: 'thinking_delta', text: event.content });
+          break;
+        case 'tool_call':
+          writeEvent({ type: 'tool_call', name: event.name, input: event.args });
+          break;
+        case 'result':
+          writeEvent({
+            type: 'result',
+            result: {
+              success: true,
+              text: event.content,
+              ...(event.sessionId ? { sessionId: event.sessionId } : {}),
+              ...(event.usage ? { usage: event.usage } : {}),
+            },
+          });
+          break;
+        case 'error':
+          writeEvent({ type: 'error', error: event.message, code: event.code });
+          break;
+        default:
+          // 其他事件忽略，不破坏 JSONL 解析
+          break;
+      }
+    }
+    process.exit(0);
+  } catch (e) {
+    writeEvent({ type: 'error', error: e instanceof Error ? e.message : String(e) });
+    process.exit(1);
+  } finally {
+    if (timeoutHandle) clearTimeout(timeoutHandle);
+  }
+}
+
+main();

package/src/token-usage.mjs

@@ -0,0 +1,147 @@
+/**
+ * D11.4: Token Usage 多路获取
+ *
+ * 不同 Engine 上报 token 使用量的方式不同，
+ * 按优先级尝试多条路径：
+ *   Layer 1: 事件流中的 usage 事件（primary_event）
+ *   Layer 2: 扫描 Engine session log 文件（session_log_scan）
+ *   Fallback: usage=null，标记 unknown
+ *
+ * 参考 Multica 对 Codex 的三层 fallback 设计。
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * 从事件数组中提取 token usage（Layer 1: primary_event）
+ *
+ * 优先使用最后一个 usage 事件（因为 Engine 可能在 Run 结束时才上报最终 usage）
+ *
+ * @param {Object[]} events - EngineProgressEvent envelope 数组
+ * @returns {Object|null}
+ */
+export function extractUsageFromEvents(events) {
+  if (!events || events.length === 0) return null;
+
+  // 从后往前找最后一个 usage 事件
+  for (let i = events.length - 1; i >= 0; i--) {
+    const envelope = events[i];
+    const event = envelope.event || envelope;
+
+    if (event.type === 'usage' && event.usage) {
+      return {
+        ...event.usage,
+        source: 'primary_event',
+        raw: event.usage,
+      };
+    }
+
+    // Claude result 事件中也包含 usage
+    if (event.type === 'result' && event.result?.usage) {
+      return {
+        ...event.result.usage,
+        source: 'primary_event',
+        raw: event.result.usage,
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Layer 2: 从 Codex session log 中扫描 token 计数
+ *
+ * Codex 在 $CODEX_HOME/sessions/ 下写 JSONL rollout 文件，
+ * 其中包含 token_count 事件。
+ *
+ * @param {string} [codexHome] - CODEX_HOME 路径，默认 ~/.codex
+ * @param {string} [sessionId] - 指定 session 过滤，可选
+ * @returns {Object|null}
+ */
+export function extractUsageFromCodexSessionLog(codexHome, sessionId) {
+  const home = codexHome || process.env.CODEX_HOME || join(process.env.HOME || '', '.codex');
+  const sessionsDir = join(home, 'sessions');
+
+  if (!existsSync(sessionsDir)) return null;
+
+  try {
+    const files = readdirSync(sessionsDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .sort() // 按文件名排序，取最新的
+      .reverse();
+
+    for (const file of files.slice(0, 5)) { // 只扫描最近 5 个文件
+      const filePath = join(sessionsDir, file);
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+
+        // 如果指定了 sessionId，检查文件是否匹配
+        if (sessionId && !file.includes(sessionId) && !content.includes(sessionId)) {
+          continue;
+        }
+
+        // 从后往前找 token_count 事件
+        for (let i = lines.length - 1; i >= 0; i--) {
+          try {
+            const entry = JSON.parse(lines[i]);
+            if (entry.type === 'token_count' || entry.event_type === 'token_count') {
+              return {
+                inputTokens: entry.input_tokens || entry.inputTokens || 0,
+                outputTokens: entry.output_tokens || entry.outputTokens || 0,
+                totalTokens: (entry.input_tokens || entry.inputTokens || 0) +
+                             (entry.output_tokens || entry.outputTokens || 0),
+                source: 'session_log_scan',
+                raw: entry,
+              };
+            }
+          } catch {
+            // 跳过解析失败的行
+          }
+        }
+      } catch {
+        // 跳过无法读取的文件
+      }
+    }
+  } catch {
+    // sessions 目录不可读
+  }
+
+  return null;
+}
+
+/**
+ * 多路获取 token usage 的统一入口
+ *
+ * 按优先级尝试：
+ * 1. primary_event: 从事件流中提取
+ * 2. session_log_scan: 从 Engine session log 文件扫描
+ * 3. unknown: 返回 null
+ *
+ * @param {Object[]} events - EngineProgressEvent envelope 数组
+ * @param {Object} options
+ * @param {string} options.engineId
+ * @param {string} [options.sessionId]
+ * @param {string} [options.codexHome]
+ * @returns {Object|null}
+ */
+export function extractTokenUsage(events, options = {}) {
+  const { engineId, sessionId, codexHome } = options;
+
+  // Layer 1: 从事件流提取
+  const fromEvents = extractUsageFromEvents(events);
+  if (fromEvents) return fromEvents;
+
+  // Layer 2: Engine 特定的 session log 扫描
+  if (engineId === 'codex') {
+    const fromLog = extractUsageFromCodexSessionLog(codexHome, sessionId);
+    if (fromLog) return fromLog;
+  }
+
+  // 其他 Engine 的 Layer 2 可以在此扩展
+
+  // Fallback: unknown
+  return null;
+}