autowonder 0.2.144 → 0.2.145

package/README.md

@@ -6,16 +6,16 @@ AutoWonder 本地 agent runtime。安装后启动 daemon，持续轮询本地 as
 
 ```bash
 # Qoder CLI（模型使用 provider model ID；Context Window 使用固定档位）
-npx -y autowonder@0.2.144 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qoder --model qmodel_latest --reasoning-effort medium --context-window 260000
+npx -y autowonder@0.2.145 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qoder --model qmodel_latest --reasoning-effort medium --context-window 260000
 
 # Qoder CLI CN
-npx -y autowonder@0.2.144 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
+npx -y autowonder@0.2.145 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
 
 # Claude Code
-npx -y autowonder@0.2.144 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider claude
+npx -y autowonder@0.2.145 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider claude
 
 # Codex CLI
-npx -y autowonder@0.2.144 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider codex --model gpt-5.5 --reasoning-effort medium
+npx -y autowonder@0.2.145 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider codex --model gpt-5.5 --reasoning-effort medium
 ```
 
 `connect` 会安装当前 npm 包内置的 daemon，并使用页面生成的 WebSocket endpoint、Token 和执行器 ID 建立连接。选择 Qoder 时需要 Node.js 20+；runtime 会在缺少 `qodercli` 时自动通过 npm 安装，并在尚未登录时打开 Qoder 浏览器登录。Claude Code 和 Codex CLI 仍需提前安装并登录。runtime 会继承当前用户的 HOME、环境变量和 CLI 登录状态。
@@ -66,7 +66,7 @@ mv "$queue/.assignment.tmp" "$queue/assignment.json"
 也可以直接提交到本地 API：
 
 ```bash
-npx -y autowonder@0.2.144 dispatch ./assignment.json
+npx -y autowonder@0.2.145 dispatch ./assignment.json
 ```
 
 ## 上传工单附件
@@ -74,7 +74,7 @@ npx -y autowonder@0.2.144 dispatch ./assignment.json
 把本地需求/设计文档直接上传到工单，避免在会话里传递大文件：
 
 ```bash
-npx -y autowonder@0.2.144 workitem upload --server-url <autowonder-server-url> --workitem-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.2.145 workitem upload --server-url <autowonder-server-url> --workitem-id <id> --file <filepath-1> --file <filepath-2> --json
 ```
 
 上传令牌通过 MCP 工具 `autowonder.workitem_cli_upload_token` 签发，经 `--token` 或 `AUTOWONDER_UPLOAD_TOKEN` 环境变量传入。`--file` 可重复指定多个文件；`--json` 输出机器可读结果。失败时按错误类型返回不同退出码（401→3、403→4、404→5、409→6、413→7、其他 4xx→8、网络/重定向→9）。
@@ -84,7 +84,7 @@ npx -y autowonder@0.2.144 workitem upload --server-url <autowonder-server-url> -
 把需求/设计文档上传到 7x24 定时任务，用法与工单附件一致（同一套上传令牌与预检规则）：
 
 ```bash
-npx -y autowonder@0.2.144 scheduled-task upload --server-url <autowonder-server-url> --scheduled-task-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.2.145 scheduled-task upload --server-url <autowonder-server-url> --scheduled-task-id <id> --file <filepath-1> --file <filepath-2> --json
 ```
 
 上传令牌同样通过 `autowonder.workitem_cli_upload_token` 签发（令牌为用户级，对当前可修改的任意定时任务生效），经 `--token` 或 `AUTOWONDER_UPLOAD_TOKEN` 传入；退出码约定与 `workitem upload` 相同。
@@ -92,8 +92,8 @@ npx -y autowonder@0.2.144 scheduled-task upload --server-url <autowonder-server-
 ## 管理 daemon
 
 ```bash
-npx -y autowonder@0.2.144 status
-npx -y autowonder@0.2.144 stop
+npx -y autowonder@0.2.145 status
+npx -y autowonder@0.2.145 stop
 ```
 
 默认 API 是 `http://127.0.0.1:34989`，日志位于 `~/.autowonder/daemon.log`。npm 包不包含任何 agent、MCP 或服务端凭证。
@@ -101,7 +101,7 @@ npx -y autowonder@0.2.144 stop
 ## 调试
 
 ```bash
-npx -y autowonder@0.2.144 connect ... --debug
+npx -y autowonder@0.2.145 connect ... --debug
 ```
 
 `--debug` 会让 CLI 以 `AUTOWONDER_DEBUG=1` 启动 daemon，把完整的 daemon 与 agent 活动（runtime 事件流、provider 事件解码、重试退避与会话门等待、空闲时的阻塞点）同时输出到控制台和会话调试日志。调试日志不做脱敏，仅用于本机排障；不传 `--debug` 时该环境变量不会注入。

package/bin/cli.js

@@ -438,9 +438,16 @@ async function cmdConnect(args) {
       const proxyPort = parseInt(process.env.TOKEN_PROXY_PORT || "19876", 10);
       const caCertPath = path.join(AUTOWONDER_HOME, "token-tap", "ca-cert.pem");
       try {
+        const proxyLogPath = path.join(AUTOWONDER_HOME, "token-tap", "proxy-diag.log");
+        const proxyStdio = flags.debug
+          ? ["ignore", fs.openSync(proxyLogPath, "a"), fs.openSync(proxyLogPath, "a")]
+          : ["ignore", "ignore", "ignore"];
+        const proxyEnv = { ...process.env };
+        if (flags.debug) proxyEnv.AUTOWONDER_DEBUG = "1";
         tokenProxyChild = spawn(process.execPath, [tokenProxyScript, "start", "--port", String(proxyPort)], {
           detached: true,
-          stdio: ["ignore", "ignore", "ignore"],
+          stdio: proxyStdio,
+          env: proxyEnv,
         });
         tokenProxyChild.unref();
 
@@ -913,12 +920,17 @@ function ensureWindowsUTF8() {
   process.env.PYTHONUTF8 = process.env.PYTHONUTF8 || "1";
   process.env.JAVA_TOOL_OPTIONS = process.env.JAVA_TOOL_OPTIONS || "-Dfile.encoding=UTF-8";
   if (!process.env.GIT_CONFIG_COUNT) {
-    process.env.GIT_CONFIG_COUNT = "2";
+    process.env.GIT_CONFIG_COUNT = "3";
     process.env.GIT_CONFIG_KEY_0 = "i18n.logOutputEncoding";
     process.env.GIT_CONFIG_VALUE_0 = "utf-8";
     process.env.GIT_CONFIG_KEY_1 = "i18n.commitEncoding";
     process.env.GIT_CONFIG_VALUE_1 = "utf-8";
+    process.env.GIT_CONFIG_KEY_2 = "core.longpaths";
+    process.env.GIT_CONFIG_VALUE_2 = "true";
   }
+  // Persist core.longpaths in git global config so all git operations
+  // (including checkpoint restore) can handle paths > MAX_PATH (260 chars).
+  spawnSync("git", ["config", "--global", "core.longpaths", "true"], { stdio: "ignore", timeout: 5000 });
 }
 
 // ─── Main ────────────────────────────────────────────────────────────

package/bin/token-proxy.js

@@ -36,15 +36,17 @@ const CA_KEY_PATH = path.join(DATA_DIR, 'ca-key.pem');
 const CA_CERT_PATH = path.join(DATA_DIR, 'ca-cert.pem');
 const USAGE_LOG_PATH = path.join(DATA_DIR, 'token-usage.jsonl');
 const USAGE_LOG_OLD = path.join(DATA_DIR, 'token-usage.old.jsonl');
+const RAW_LOG_DIR = path.join(DATA_DIR, 'raw');
+const DEBUG = process.env.AUTOWONDER_DEBUG === '1';
 
 // Qoder/QoderCN LLM API hosts to sniff (others are tunneled without inspection).
 // Only LLM endpoints are listed — non-LLM APIs (openapi.*) are excluded to avoid
 // unnecessary MITM overhead on high-frequency config/auth calls.
 const SNIFF_HOSTS = new Set([
   // Qoder (international)
-  'api3.qoder.sh', 'api2.qoder.sh', 'api.qoder.sh',
+  'api3.qoder.sh', 'api2.qoder.sh', 'api.qoder.sh', 'openapi.qoder.sh',
   // QoderCN (China)
-  'gateway.qoder.com.cn',
+  'gateway.qoder.com.cn', 'openapi.qoder.com.cn',
   'api3.qodercn.com', 'api2.qodercn.com', 'api.qodercn.com',
 ]);
 
@@ -163,15 +165,16 @@ function extractUsageFromResponse(buffer) {
   //   1. Qoder SSE (current): data:{"headers":{...},"body":"{...\"usage\":{...}}"}
   //   2. Standard OpenAI SSE: data: {"choices":[...],"usage":{...}}
   //   3. NDJSON streaming: {"choices":[...],"usage":{...}}\n
-  //   4. Single JSON response: {"choices":[...],"usage":{...}}
-  //
-  // Strategy: scan lines backwards for "prompt_tokens", try multiple parse strategies.
+  //   4. Single JSON response (non-streaming): {"choices":[...],"usage":{...}}
+  //   5. Regex extraction: find "usage":{...} anywhere in buffer
   try {
     const text = buffer.toString('utf8');
     const lines = text.split('\n');
+
+    // Strategy 1-3: line-based parsing (backwards scan)
     for (let i = lines.length - 1; i >= 0; i--) {
       const line = lines[i].trim();
-      if (!line.includes('prompt_tokens')) continue;
+      if (!line.includes('"usage"') && !line.includes('\\"usage\\"')) continue;
 
       // Strategy 1: Qoder nested SSE — data:{"headers":...,"body":"<escaped json>"}
       if (line.startsWith('data:')) {
@@ -182,16 +185,67 @@ function extractUsageFromResponse(buffer) {
         if (usage2) return usage2;
       }
 
-      // Strategy 3: Plain JSON line (NDJSON or single response)
+      // Strategy 3: Qoder nested without "data:" prefix — {"headers":...,"body":"..."}
+      if (line.startsWith('{') && line.includes('"body"')) {
+        const usage3a = tryQoderNestedSSE(line);
+        if (usage3a) return usage3a;
+      }
+
+      // Strategy 4: Plain JSON line (NDJSON or single response)
       const usage3 = tryDirectJSON(line);
       if (usage3) return usage3;
     }
+
+    // Strategy 4: Regex extraction — find usage JSON object directly in buffer
+    // Handles cases where the response is not line-delimited or spans multiple chunks
+    const usageMatch = text.match(/"usage"\s*:\s*\{[^}]*"prompt_tokens"\s*:\s*\d+[^}]*\}/);
+    if (usageMatch) {
+      const usage4 = tryExtractUsageObject(usageMatch[0], text);
+      if (usage4) return usage4;
+    }
+    // Also check input_tokens variant
+    const usageMatch2 = text.match(/"usage"\s*:\s*\{[^}]*"input_tokens"\s*:\s*\d+[^}]*\}/);
+    if (usageMatch2) {
+      const usage5 = tryExtractUsageObject(usageMatch2[0], text);
+      if (usage5) return usage5;
+    }
   } catch (_) {
     // Silent: parsing failure only loses token data, never breaks traffic
   }
   return null;
 }
 
+function tryExtractUsageObject(usageStr, fullText) {
+  // Extract usage from a regex-matched "usage":{...} fragment
+  // Handle nested objects like prompt_tokens_details by using a greedy match
+  try {
+    // Try to parse just the usage value (strip the key prefix)
+    let jsonStr = usageStr.replace(/^"usage"\s*:\s*/, '');
+    // Handle nested braces (prompt_tokens_details, completion_tokens_details)
+    // Re-extract with nested brace awareness
+    const startIdx = fullText.indexOf(usageStr);
+    if (startIdx >= 0) {
+      const usageStart = fullText.indexOf('{', startIdx + 7);
+      if (usageStart >= 0) {
+        let depth = 0, end = usageStart;
+        for (let i = usageStart; i < fullText.length && i < usageStart + 2000; i++) {
+          if (fullText[i] === '{') depth++;
+          else if (fullText[i] === '}') { depth--; if (depth === 0) { end = i; break; } }
+        }
+        jsonStr = fullText.slice(usageStart, end + 1);
+      }
+    }
+    const u = JSON.parse(jsonStr);
+    if (u && (u.prompt_tokens !== undefined || u.input_tokens !== undefined)) {
+      // Try to find model from nearby context
+      const modelMatch = fullText.match(/"model"\s*:\s*"([^"]+)"/);
+      const model = modelMatch ? modelMatch[1] : 'unknown';
+      return buildUsageRecord(u, model);
+    }
+  } catch (_) {}
+  return null;
+}
+
 function tryQoderNestedSSE(data) {
   try {
     const outer = JSON.parse(data);
@@ -239,25 +293,32 @@ function appendUsage(usage) {
   }
 }
 
-// ─── Dispatch ID extraction from Proxy-Authorization ─────────────────────────
+// ─── Dispatch/Step ID extraction from Proxy-Authorization ───────────────────
 
-function extractDispatchId(req) {
-  // daemon sets HTTPS_PROXY=http://d-{dispatchId}:x@host:port
-  // → client sends Proxy-Authorization: Basic <base64("d-{id}:x")>
+function extractDispatchInfo(req) {
+  // daemon sets HTTPS_PROXY=http://d-{dispatchId}-s-{stepId}:x@host:port
+  // → client sends Proxy-Authorization: Basic <base64("d-{id}-s-{step}:x")>
   const auth = req.headers['proxy-authorization'] || '';
-  if (!auth.startsWith('Basic ')) return null;
+  if (!auth.startsWith('Basic ')) return { dispatchId: null, stepId: null };
   try {
     const decoded = Buffer.from(auth.slice(6), 'base64').toString('utf8');
     const [user] = decoded.split(':');
-    if (user && user.startsWith('d-')) return user.slice(2);
+    if (!user || !user.startsWith('d-')) return { dispatchId: null, stepId: null };
+    const payload = user.slice(2); // remove "d-" prefix
+    const stepIdx = payload.indexOf('-s-');
+    if (stepIdx >= 0) {
+      return { dispatchId: payload.slice(0, stepIdx), stepId: payload.slice(stepIdx + 3) };
+    }
+    return { dispatchId: payload, stepId: null };
   } catch (_) {}
-  return null;
+  return { dispatchId: null, stepId: null };
 }
 
 // ─── Forward Proxy (CONNECT method) ─────────────────────────────────────────
 
 function startProxy(port) {
   const ca = ensureCA();
+  const dbg = DEBUG ? (...args) => console.log(...args) : () => {};
 
   const server = http.createServer((req, res) => {
     // Non-CONNECT requests: reject (we only handle CONNECT tunnels)
@@ -265,40 +326,47 @@ function startProxy(port) {
     res.end('Only CONNECT supported');
   });
 
+  let connSeq = 0;
   server.on('connect', (req, clientSocket, head) => {
+    const seq = ++connSeq;
+    const ts = () => new Date().toISOString().slice(11, 23);
     const [hostname, portStr] = req.url.split(':');
     const remotePort = parseInt(portStr) || 443;
     const shouldSniff = SNIFF_HOSTS.has(hostname);
-    const dispatchId = extractDispatchId(req);
+    const { dispatchId, stepId } = extractDispatchInfo(req);
+
+    dbg(`[${ts()}] CONNECT #${seq} ${hostname}:${remotePort} sniff=${shouldSniff} dispatch=${dispatchId || 'none'} step=${stepId || 'none'}`);
 
     if (!shouldSniff) {
-      // Blind tunnel: don't MITM, just pipe through
+      dbg(`[${ts()}] #${seq} → BLIND TUNNEL (not in SNIFF_HOSTS)`);
       const upstream = net.connect(remotePort, hostname, () => {
         clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
         upstream.write(head);
         upstream.pipe(clientSocket);
         clientSocket.pipe(upstream);
       });
-      upstream.on('error', () => { try { clientSocket.end(); } catch (_) {} });
-      clientSocket.on('error', () => { try { upstream.end(); } catch (_) {} });
+      upstream.on('error', (e) => { dbg(`[${ts()}] #${seq} blind upstream err: ${e.message}`); try { clientSocket.end(); } catch (_) {} });
+      clientSocket.on('error', (e) => { dbg(`[${ts()}] #${seq} blind client err: ${e.message}`); try { upstream.end(); } catch (_) {} });
       return;
     }
 
     // MITM for Qoder API hosts: decrypt, sniff usage, re-encrypt
     const hostCert = getHostCert(hostname, ca);
     if (!hostCert) {
-      // Cannot generate cert — fall back to blind tunnel
+      dbg(`[${ts()}] #${seq} → BLIND TUNNEL (cert generation failed for ${hostname})`);
       const upstream = net.connect(remotePort, hostname, () => {
         clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
         upstream.write(head);
         upstream.pipe(clientSocket);
         clientSocket.pipe(upstream);
       });
-      upstream.on('error', () => { try { clientSocket.end(); } catch (_) {} });
-      clientSocket.on('error', () => { try { upstream.end(); } catch (_) {} });
+      upstream.on('error', (e) => { dbg(`[${ts()}] #${seq} cert-fail upstream err: ${e.message}`); try { clientSocket.end(); } catch (_) {} });
+      clientSocket.on('error', (e) => { dbg(`[${ts()}] #${seq} cert-fail client err: ${e.message}`); try { upstream.end(); } catch (_) {} });
       return;
     }
 
+    dbg(`[${ts()}] #${seq} → MITM (cert OK for ${hostname})`);
+
     // Accept TLS from client (presenting our per-host cert signed by our CA)
     clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
 
@@ -308,26 +376,71 @@ function startProxy(port) {
       cert: hostCert.cert,
     });
 
+    let tlsClientReady = false;
+    tlsClient.on('secure', () => { tlsClientReady = true; dbg(`[${ts()}] #${seq} TLS-client handshake OK`); });
+
     // Connect to real upstream
     const tlsUpstream = tls.connect({ host: hostname, port: remotePort, servername: hostname });
 
+    let tlsUpstreamReady = false;
+    tlsUpstream.on('secureConnect', () => { tlsUpstreamReady = true; dbg(`[${ts()}] #${seq} TLS-upstream handshake OK → ${hostname}`); });
+
     let responseBuffer = Buffer.alloc(0);
-    let usageExtracted = false;
+    let usageCount = 0;
+    let totalBytes = 0;
+    let rawFd = null;
+
+    // Raw response logging: only in debug mode to avoid disk bloat
+    if (DEBUG) {
+      try {
+        fs.mkdirSync(RAW_LOG_DIR, { recursive: true });
+        const rawFile = path.join(RAW_LOG_DIR, `${new Date().toISOString().slice(0,10)}_${seq}_${hostname}.raw`);
+        rawFd = fs.openSync(rawFile, 'w');
+      } catch (_) {}
+    }
+
+    // Precise trigger: "usage" must co-occur with "prompt_tokens"/"input_tokens"
+    // This avoids false positives when model output TEXT contains "prompt_tokens"
+    function hasUsageSignal(text) {
+      if (!text.includes('"usage"') && !text.includes('\\"usage\\"')) return false;
+      return text.includes('prompt_tokens') || text.includes('input_tokens');
+    }
+
+    // lineBuffer accumulates complete lines; incomplete trailing data stays for next chunk
+    let lineRemainder = '';
+
+    function processLines(lines) {
+      // Extract ALL usage records from a batch of complete lines (not just the last one)
+      for (const line of lines.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        if (!hasUsageSignal(trimmed)) continue;
+        const buf = Buffer.from(trimmed, 'utf8');
+        const usage = extractUsageFromResponse(buf);
+        if (usage) {
+          usageCount++;
+          if (dispatchId) usage.dispatch_id = dispatchId;
+            if (stepId) usage.step_id = stepId;
+          appendUsage(usage);
+          console.log(`[${ts()}] #${seq} ✓ USAGE CAPTURED (#${usageCount}) credits=${usage.credits} model=${usage.model} in=${usage.input_tokens} out=${usage.output_tokens}`);
+        }
+      }
+    }
 
     tlsUpstream.on('data', (chunk) => {
+      totalBytes += chunk.length;
       try { tlsClient.write(chunk); } catch (_) {}
+      if (rawFd !== null) { try { fs.writeSync(rawFd, chunk); } catch (_) {} }
       try {
-        // Keep last 8KB of response for usage extraction
-        responseBuffer = Buffer.concat([responseBuffer.slice(-8192), chunk]);
-        // Try to extract usage eagerly (the usage chunk arrives before connection close)
-        if (!usageExtracted && chunk.toString('utf8').includes('prompt_tokens')) {
-          const usage = extractUsageFromResponse(responseBuffer);
-          if (usage) {
-            if (dispatchId) usage.dispatch_id = dispatchId;
-            appendUsage(usage);
-            usageExtracted = true;
-          }
+        const text = lineRemainder + chunk.toString('utf8');
+        const lastNL = text.lastIndexOf('\n');
+        if (lastNL === -1) {
+          lineRemainder = text.length > 65536 ? text.slice(-65536) : text;
+          return;
         }
+        const complete = text.slice(0, lastNL);
+        lineRemainder = text.slice(lastNL + 1);
+        processLines(complete);
       } catch (_) {}
     });
 
@@ -336,25 +449,21 @@ function startProxy(port) {
     });
 
     const cleanup = () => {
-      // Final attempt to extract usage if not already done
-      if (!usageExtracted) {
-        try {
-          const usage = extractUsageFromResponse(responseBuffer);
-          if (usage) {
-            if (dispatchId) usage.dispatch_id = dispatchId;
-            appendUsage(usage);
-          }
-        } catch (_) {}
-      }
-      responseBuffer = Buffer.alloc(0);
+      // Final extraction from any remaining data (lineRemainder may hold last line without trailing \n)
+      try {
+        if (lineRemainder) processLines(lineRemainder);
+      } catch (_) {}
+      lineRemainder = '';
+      dbg(`[${ts()}] #${seq} CLOSED ${hostname} bytes=${totalBytes} usages=${usageCount} tlsClient=${tlsClientReady} tlsUpstream=${tlsUpstreamReady}`);
+      if (rawFd !== null) { try { fs.closeSync(rawFd); } catch (_) {} rawFd = null; }
       try { tlsClient.end(); } catch (_) {}
       try { tlsUpstream.end(); } catch (_) {}
     };
 
     tlsClient.on('end', cleanup);
-    tlsClient.on('error', () => { cleanup(); });
+    tlsClient.on('error', (e) => { dbg(`[${ts()}] #${seq} TLS-client ERROR: ${e.message}`); cleanup(); });
     tlsUpstream.on('end', cleanup);
-    tlsUpstream.on('error', () => { cleanup(); });
+    tlsUpstream.on('error', (e) => { dbg(`[${ts()}] #${seq} TLS-upstream ERROR: ${e.message}`); cleanup(); });
 
     if (head.length > 0) tlsClient.emit('data', head);
   });
@@ -467,3 +576,7 @@ Files:
   CA cert:    ${CA_CERT_PATH}
   Usage log:  ${USAGE_LOG_PATH}`);
 }
+
+if (require.main !== module) {
+  module.exports = { extractUsageFromResponse, extractDispatchInfo, buildUsageRecord };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autowonder",
-  "version": "0.2.144",
+  "version": "0.2.145",
   "description": "AutoWonder local runtime — execute AI agent dispatch packages on your machine",
   "bin": {
     "autowonder": "bin/cli.js"