autowonder 0.3.5 → 0.3.6

package/README.md

@@ -6,10 +6,10 @@ AutoWonder 本地 agent runtime。安装后启动 daemon，持续轮询本地 as
 
 ```bash
 # Qoder CLI（模型使用 provider model ID；Context Window 使用固定档位）
-npx -y autowonder@0.3.5 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.3.6 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.3.5 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
+npx -y autowonder@0.3.6 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
 ```
 
 `connect` 会安装当前 npm 包内置的 daemon，并使用页面生成的 WebSocket endpoint、Token 和执行器 ID 建立连接。客户端只支持通过 Qoder 系列 CLI 启动（`qoder` 对应 `qodercli`，`qodercn` 对应 `qodercn`），其他 `--provider` 取值会在启动 daemon 前直接报错拦截并提示 `Unsupported provider`。选择 Qoder CLI 或 Qoder CLI CN 时需要 Node.js 20+；runtime 会在缺少对应 CLI 时自动通过 npm 安装，并在尚未登录时打开浏览器登录。runtime 会继承当前用户的 HOME、环境变量和 CLI 登录状态。
@@ -37,7 +37,7 @@ daemon 会响应服务端的 `QODER_MODEL_CATALOG_REQUEST` 帧，用当前 provi
 
 daemon 还会响应服务端的 `CONVERSATION_COMMANDS_PROBE` 帧，用独立会话抓取该会话工作目录下可用的斜杠命令，回传 `CONVERSATION_COMMANDS_RESULT` 帧，让会话面板在用户输入 `/` 时列出真实可用的命令。该探测与回合执行完全隔离：任何失败只产生 `FAILED` / `TIMEOUT` 帧，不影响进行中的会话；provider 后端不支持抓取时同样降级为 `FAILED` 帧。帧里的 `executorId` 与本机不一致或非正数时直接忽略，避免在别的执行器工作区里建目录或启动 CLI。daemon 侧给整个探测 25 秒硬上限，刻意长于 agent 侧的 20 秒预算，使 agent 自己的超时先触发并可被归类。
 
-给 `connect` 追加 `--token-aware-enable` 可开启 qoder / qodercn 的 token 用量采集：CLI 会以 sidecar 方式启动本地 HTTPS 转发代理（`bin/token-proxy.js`），从 Qoder API 的 SSE 响应流中提取 usage 数据并按 dispatch ID 归属上报。该功能旁路设计、不阻塞任务执行，代理启动失败时仅告警并继续。代理端口可用 `TOKEN_PROXY_PORT` 环境变量调整（默认 19876）；CA 证书位于 `~/.autowonder/token-tap/ca-cert.pem`。daemon 退出时 sidecar 一并停止。
+给 `connect` 追加 `--token-aware-enable` 可开启 qoder / qodercn 的 token 用量采集：CLI 会以 sidecar 方式启动本地 HTTPS 转发代理（`bin/token-proxy.js`），从 Qoder API 的 SSE 响应流中提取 usage 数据并按 dispatch ID 归属上报。usage 解析失败只丢失计量数据；代理启动失败时仅告警并继续。启用后模型流量经过代理，连接失败由客户端处理重试，不保证自动直连。代理端口可用 `TOKEN_PROXY_PORT` 环境变量调整（默认 19876）；CA 证书位于 `~/.autowonder/token-tap/ca-cert.pem`。daemon 退出时 sidecar 一并停止。代理对 TCP 建连和两端 TLS 握手设置 15 秒期限，对无读写活动的连接设置 120 秒空闲期限；超时、报错或任一端关闭时释放两端连接。持续有数据的 SSE 流不受总时长限制，连续静默超过 120 秒的流会断开。
 
 `connect` 支持 `--workspace-root <path>` 指定 dispatch 仓库与任务工作区所在目录（默认 `~/autowonder_workspaces`）。该参数会转发给 daemon，等价于设置 `AUTOWONDER_WORKSPACE_ROOT` 环境变量，适合把工作区放在非默认路径的执行机上（如 Windows 的 `D:\autowonder`）。
 
@@ -158,7 +158,7 @@ mv "$queue/.assignment.tmp" "$queue/assignment.json"
 也可以直接提交到本地 API：
 
 ```bash
-npx -y autowonder@0.3.5 dispatch ./assignment.json
+npx -y autowonder@0.3.6 dispatch ./assignment.json
 ```
 
 ## 上传工单附件
@@ -166,7 +166,7 @@ npx -y autowonder@0.3.5 dispatch ./assignment.json
 把本地需求/设计文档直接上传到工单，避免在会话里传递大文件：
 
 ```bash
-npx -y autowonder@0.3.5 workitem upload --server-url <autowonder-server-url> --workitem-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.3.6 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）。
@@ -176,7 +176,7 @@ npx -y autowonder@0.3.5 workitem upload --server-url <autowonder-server-url> --w
 把工单上已有的需求/设计文档下载到本地目录，再用本地文件工具阅读，避免把大文件或二进制附件搬进会话上下文：
 
 ```bash
-npx -y autowonder@0.3.5 workitem download --server-url <autowonder-server-url> --workitem-id <id> --file <name-or-id> --output-dir <dir> --json
+npx -y autowonder@0.3.6 workitem download --server-url <autowonder-server-url> --workitem-id <id> --file <name-or-id> --output-dir <dir> --json
 ```
 
 下载令牌通过 MCP 工具 `autowonder.workitem_cli_download_token` 签发（与上传令牌相互独立），经 `--token` 或 `AUTOWONDER_DOWNLOAD_TOKEN` 环境变量传入。`--file` 可重复指定文档名或 artifact id，省略则下载该工单的全部附件；`--output-dir` 默认为当前目录；`--json` 输出机器可读结果，含每个文件的 `id`、`name`、`path`、`size`。退出码约定与 `workitem upload` 相同（401→3、403→4、404→5、409→6、413→7、其他 4xx→8、网络/重定向→9）。
@@ -186,7 +186,7 @@ npx -y autowonder@0.3.5 workitem download --server-url <autowonder-server-url> -
 把需求/设计文档上传到 7x24 定时任务，用法与工单附件一致（同一套上传令牌与预检规则）：
 
 ```bash
-npx -y autowonder@0.3.5 scheduled-task upload --server-url <autowonder-server-url> --scheduled-task-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.3.6 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` 相同。
@@ -194,8 +194,8 @@ npx -y autowonder@0.3.5 scheduled-task upload --server-url <autowonder-server-ur
 ## 管理 daemon
 
 ```bash
-npx -y autowonder@0.3.5 status
-npx -y autowonder@0.3.5 stop
+npx -y autowonder@0.3.6 status
+npx -y autowonder@0.3.6 stop
 ```
 
 默认 API 是 `http://127.0.0.1:34989`，日志位于 `~/.autowonder/daemon.log`。npm 包不包含任何 agent、MCP 或服务端凭证。
@@ -203,7 +203,7 @@ npx -y autowonder@0.3.5 stop
 ## 调试
 
 ```bash
-npx -y autowonder@0.3.5 connect ... --debug
+npx -y autowonder@0.3.6 connect ... --debug
 ```
 
 `--debug` 会让 CLI 以 `AUTOWONDER_DEBUG=1` 启动 daemon，把完整的 daemon 与 agent 活动（runtime 事件流、provider 事件解码、重试退避与会话门等待、空闲时的阻塞点）同时输出到控制台和会话调试日志。调试日志不做脱敏，仅用于本机排障；不传 `--debug` 时该环境变量不会注入。

package/bin/token-proxy.js

@@ -14,7 +14,7 @@
  * 降级策略:
  *   - 所有解析逻辑被 try-catch 包裹,解析失败只丢 token 数据,不断流量
  *   - proxy 启动失败时,wrapper 不注入 HTTPS_PROXY,daemon 正常直连
- *   - proxy 运行中崩溃时,Node HTTPS 模块遇到 ECONNREFUSED 会忽略 proxy 直连
+ *   - 运行中的代理连接失败会关闭隧道,由客户端处理重试;不承诺自动直连
  */
 
 'use strict';
@@ -316,8 +316,53 @@ function extractDispatchInfo(req) {
 
 // ─── Forward Proxy (CONNECT method) ─────────────────────────────────────────
 
-function startProxy(port) {
-  const ca = ensureCA();
+// Bound connection setup separately from idle time: a peer can trickle bytes
+// during TLS negotiation, so a socket inactivity timeout alone is insufficient.
+function guardConnection(sockets, { readyEvents, connectTimeoutMs = 15000,
+  idleTimeoutMs = 120000, onCleanup = () => {}, onError = () => {} }) {
+  let closed = false;
+  const pending = new Set(sockets);
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    clearTimeout(connectTimer);
+    for (const socket of sockets) {
+      socket.setTimeout(0);
+      socket.destroy();
+    }
+    onCleanup();
+  };
+  const connectTimer = setTimeout(() => {
+    onError(new Error('proxy connection setup timed out'));
+    cleanup();
+  }, connectTimeoutMs);
+  connectTimer.unref();
+  sockets.forEach((socket, i) => {
+    socket.setTimeout(idleTimeoutMs);
+    socket.on('timeout', () => {
+      onError(new Error('proxy connection idle timeout'));
+      cleanup();
+    });
+    socket.on('close', cleanup);
+    socket.on('error', error => { onError(error); cleanup(); });
+    // Flush queued bytes before closing the other half. The idle timer still
+    // bounds a peer that never completes shutdown.
+    socket.on('end', () => {
+      for (const peer of sockets) if (peer !== socket) peer.end();
+    });
+    const readyEvent = readyEvents[i];
+    if (!readyEvent) pending.delete(socket);
+    else socket.once(readyEvent, () => {
+      pending.delete(socket);
+      if (!pending.size) clearTimeout(connectTimer);
+    });
+  });
+  if (!pending.size) clearTimeout(connectTimer);
+  return cleanup;
+}
+
+function createProxyServer({ ca = ensureCA(), hostCertificate = getHostCert,
+  connectTimeoutMs = 15000, idleTimeoutMs = 120000, sniffHosts = SNIFF_HOSTS } = {}) {
   const dbg = DEBUG ? (...args) => console.log(...args) : () => {};
 
   const server = http.createServer((req, res) => {
@@ -332,36 +377,26 @@ function startProxy(port) {
     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 shouldSniff = sniffHosts.has(hostname);
     const { dispatchId, stepId } = extractDispatchInfo(req);
 
     dbg(`[${ts()}] CONNECT #${seq} ${hostname}:${remotePort} sniff=${shouldSniff} dispatch=${dispatchId || 'none'} step=${stepId || 'none'}`);
 
-    if (!shouldSniff) {
-      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', (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);
+    const hostCert = shouldSniff ? hostCertificate(hostname, ca) : null;
     if (!hostCert) {
-      dbg(`[${ts()}] #${seq} → BLIND TUNNEL (cert generation failed for ${hostname})`);
-      const upstream = net.connect(remotePort, hostname, () => {
+      dbg(`[${ts()}] #${seq} → BLIND TUNNEL`);
+      const upstream = net.connect(remotePort, hostname);
+      guardConnection([clientSocket, upstream], {
+        readyEvents: [null, 'connect'], connectTimeoutMs, idleTimeoutMs,
+        onError: e => dbg(`[${ts()}] #${seq} tunnel error: ${e.message}`),
+      });
+      upstream.once('connect', () => {
+        if (clientSocket.destroyed) return;
         clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
-        upstream.write(head);
+        if (head.length) upstream.write(head);
         upstream.pipe(clientSocket);
         clientSocket.pipe(upstream);
       });
-      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;
     }
 
@@ -370,6 +405,8 @@ function startProxy(port) {
     // 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');
 
+    // CONNECT head contains encrypted TLS bytes, not plaintext HTTP.
+    if (head.length) clientSocket.unshift(head);
     const tlsClient = new tls.TLSSocket(clientSocket, {
       isServer: true,
       key: hostCert.key,
@@ -385,7 +422,6 @@ function startProxy(port) {
     let tlsUpstreamReady = false;
     tlsUpstream.on('secureConnect', () => { tlsUpstreamReady = true; dbg(`[${ts()}] #${seq} TLS-upstream handshake OK → ${hostname}`); });
 
-    let responseBuffer = Buffer.alloc(0);
     let usageCount = 0;
     let totalBytes = 0;
     let rawFd = null;
@@ -429,7 +465,6 @@ function startProxy(port) {
 
     tlsUpstream.on('data', (chunk) => {
       totalBytes += chunk.length;
-      try { tlsClient.write(chunk); } catch (_) {}
       if (rawFd !== null) { try { fs.writeSync(rawFd, chunk); } catch (_) {} }
       try {
         const text = lineRemainder + chunk.toString('utf8');
@@ -444,9 +479,9 @@ function startProxy(port) {
       } catch (_) {}
     });
 
-    tlsClient.on('data', (chunk) => {
-      try { tlsUpstream.write(chunk); } catch (_) {}
-    });
+    // pipe() handles backpressure; accounting only observes the stream.
+    tlsUpstream.pipe(tlsClient);
+    tlsClient.pipe(tlsUpstream);
 
     const cleanup = () => {
       // Final extraction from any remaining data (lineRemainder may hold last line without trailing \n)
@@ -456,18 +491,24 @@ function startProxy(port) {
       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', (e) => { dbg(`[${ts()}] #${seq} TLS-client ERROR: ${e.message}`); cleanup(); });
-    tlsUpstream.on('end', cleanup);
-    tlsUpstream.on('error', (e) => { dbg(`[${ts()}] #${seq} TLS-upstream ERROR: ${e.message}`); cleanup(); });
+    const closeConnection = guardConnection([tlsClient, tlsUpstream], {
+      readyEvents: ['secure', 'secureConnect'], connectTimeoutMs, idleTimeoutMs,
+      onCleanup: cleanup,
+      onError: e => dbg(`[${ts()}] #${seq} TLS error: ${e.message}`),
+    });
+    // Also fence an aborted raw CONNECT socket during TLS setup.
+    clientSocket.on('close', closeConnection);
+    clientSocket.on('error', closeConnection);
 
-    if (head.length > 0) tlsClient.emit('data', head);
   });
 
+  return server;
+}
+
+function startProxy(port) {
+  const server = createProxyServer();
   server.on('error', (err) => {
     console.error(`[token-proxy] server error: ${err.message}`);
     process.exit(1);
@@ -554,29 +595,30 @@ function parseDuration(s) {
 const args = process.argv.slice(2);
 const command = args[0];
 
-if (command === 'start') {
-  const portIdx = args.indexOf('--port');
-  const port = portIdx >= 0 ? parseInt(args[portIdx + 1]) : DEFAULT_PORT;
-  startProxy(port);
-} else if (command === 'query') {
-  const jsonFlag = args.includes('--json');
-  const sinceIdx = args.indexOf('--since');
-  const since = sinceIdx >= 0 ? args[sinceIdx + 1] : '24h';
-  queryUsage({ json: jsonFlag, since });
-} else {
-  console.log(`Usage:
-  node token-proxy.js start [--port ${DEFAULT_PORT}]   Start the proxy
-  node token-proxy.js query [--since 1h] [--json]      Query token usage
-
-Environment (set before starting daemon):
-  HTTPS_PROXY=http://127.0.0.1:${DEFAULT_PORT}
-  NODE_EXTRA_CA_CERTS=${CA_CERT_PATH}
-
-Files:
-  CA cert:    ${CA_CERT_PATH}
-  Usage log:  ${USAGE_LOG_PATH}`);
+if (require.main === module) {
+  if (command === 'start') {
+    const portIdx = args.indexOf('--port');
+    const port = portIdx >= 0 ? parseInt(args[portIdx + 1]) : DEFAULT_PORT;
+    startProxy(port);
+  } else if (command === 'query') {
+    const jsonFlag = args.includes('--json');
+    const sinceIdx = args.indexOf('--since');
+    const since = sinceIdx >= 0 ? args[sinceIdx + 1] : '24h';
+    queryUsage({ json: jsonFlag, since });
+  } else {
+    console.log(`Usage:
+    node token-proxy.js start [--port ${DEFAULT_PORT}]   Start the proxy
+    node token-proxy.js query [--since 1h] [--json]      Query token usage
+
+  Environment (set before starting daemon):
+    HTTPS_PROXY=http://127.0.0.1:${DEFAULT_PORT}
+    NODE_EXTRA_CA_CERTS=${CA_CERT_PATH}
+
+  Files:
+    CA cert:    ${CA_CERT_PATH}
+    Usage log:  ${USAGE_LOG_PATH}`);
+  }
 }
 
-if (require.main !== module) {
-  module.exports = { extractUsageFromResponse, extractDispatchInfo, buildUsageRecord };
-}
+module.exports = { extractUsageFromResponse, extractDispatchInfo, buildUsageRecord,
+  guardConnection, createProxyServer };

package/package.json

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