autowonder 0.2.138 → 0.2.140

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.138 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.140 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.138 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
+npx -y autowonder@0.2.140 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
 
 # Claude Code
-npx -y autowonder@0.2.138 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider claude
+npx -y autowonder@0.2.140 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider claude
 
 # Codex CLI
-npx -y autowonder@0.2.138 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.140 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 登录状态。
@@ -24,6 +24,8 @@ npx -y autowonder@0.2.138 connect --ws-url <wss-endpoint> --token <executor-toke
 
 Qoder 的 Context Window 只能使用 `1000000`、`400000` 或 `260000`，Reasoning Effort 只能使用 `none`、`low`、`medium`、`high`、`xhigh` 或 `max`。建议直接复制 AutoWonder 执行器页面生成的命令，避免把模型展示名称误当成 provider model ID。
 
+给 `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 一并停止。
+
 ## 自动更新
 
 安装首个支持自动更新的正式版本后，daemon 会直接查询 npm 的 `autowonder/latest`。首次检查会随机分散在启动后的 30～90 秒，之后约每 5 分钟检查一次并加入随机抖动；npm 临时错误会指数退避，HTTP 429/503 的 `Retry-After` 会被遵循。发现更高的稳定版本时，它会在后台下载 npm tarball，校验 SHA-512 SRI、包版本和平台二进制；只有在没有运行/恢复任务且结果 outbox 已收到服务端确认时，才会暂停接单、原子切换二进制并自动重启。启动失败会恢复上一个二进制。
@@ -62,7 +64,7 @@ mv "$queue/.assignment.tmp" "$queue/assignment.json"
 也可以直接提交到本地 API：
 
 ```bash
-npx -y autowonder@0.2.138 dispatch ./assignment.json
+npx -y autowonder@0.2.140 dispatch ./assignment.json
 ```
 
 ## 上传工单附件
@@ -70,7 +72,7 @@ npx -y autowonder@0.2.138 dispatch ./assignment.json
 把本地需求/设计文档直接上传到工单，避免在会话里传递大文件：
 
 ```bash
-npx -y autowonder@0.2.138 workitem upload --server-url <autowonder-server-url> --workitem-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.2.140 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）。
@@ -78,8 +80,8 @@ npx -y autowonder@0.2.138 workitem upload --server-url <autowonder-server-url> -
 ## 管理 daemon
 
 ```bash
-npx -y autowonder@0.2.138 status
-npx -y autowonder@0.2.138 stop
+npx -y autowonder@0.2.140 status
+npx -y autowonder@0.2.140 stop
 ```
 
 默认 API 是 `http://127.0.0.1:34989`，日志位于 `~/.autowonder/daemon.log`。npm 包不包含任何 agent、MCP 或服务端凭证。
@@ -87,7 +89,7 @@ npx -y autowonder@0.2.138 stop
 ## 调试
 
 ```bash
-npx -y autowonder@0.2.138 connect ... --debug
+npx -y autowonder@0.2.140 connect ... --debug
 ```
 
 `--debug` 会让 CLI 以 `AUTOWONDER_DEBUG=1` 启动 daemon，把完整的 daemon 与 agent 活动（runtime 事件流、provider 事件解码、重试退避与会话门等待、空闲时的阻塞点）同时输出到控制台和会话调试日志。调试日志不做脱敏，仅用于本机排障；不传 `--debug` 时该环境变量不会注入。

package/bin/cli.js

@@ -331,7 +331,7 @@ function buildFromSource() {
 // ─── Commands ────────────────────────────────────────────────────────
 
 async function cmdConnect(args) {
-  const flags = parseFlags(args, ["ws-url", "token", "executor-id", "provider", "name", "max-tasks", "model", "reasoning-effort", "context-window", "memory-mode", "settings"]);
+  const flags = parseFlags(args, ["ws-url", "token", "executor-id", "provider", "name", "max-tasks", "model", "reasoning-effort", "context-window", "memory-mode", "settings", "token-aware-enable"]);
 
   if (!flags["ws-url"] || !flags.token || !flags["executor-id"]) {
     error("Usage: autowonder connect --ws-url <url> --token <token> --executor-id <id> [--provider qoder|qodercn]");
@@ -427,10 +427,59 @@ async function cmdConnect(args) {
   if (config.claudeSettingsPath) env.AUTOWONDER_CLAUDE_SETTINGS = config.claudeSettingsPath;
   if (flags.debug) env.AUTOWONDER_DEBUG = "1";
 
+  // --token-aware-enable: start token-proxy as a sidecar (bypass, non-blocking)
+  let tokenProxyChild = null;
+  if (flags["token-aware-enable"]) {
+    const tokenProxyScript = path.join(__dirname, "token-proxy.js");
+    if (fs.existsSync(tokenProxyScript)) {
+      const proxyPort = parseInt(process.env.TOKEN_PROXY_PORT || "19876", 10);
+      const caCertPath = path.join(AUTOWONDER_HOME, "token-tap", "ca-cert.pem");
+      try {
+        tokenProxyChild = spawn(process.execPath, [tokenProxyScript, "start", "--port", String(proxyPort)], {
+          detached: true,
+          stdio: ["ignore", "ignore", "ignore"],
+        });
+        tokenProxyChild.unref();
+
+        // Wait up to 3s for CA cert to appear (proxy generates it on first start)
+        const deadline = Date.now() + 3000;
+        while (Date.now() < deadline && !fs.existsSync(caCertPath)) {
+          spawnSync(process.execPath, ["-e", "setTimeout(()=>{},200)"], { stdio: "ignore" }); // cross-platform sleep
+        }
+
+        if (fs.existsSync(caCertPath)) {
+          // Pass proxy config to daemon via env. The daemon will set per-dispatch
+          // HTTPS_PROXY=http://d-{dispatchId}:x@host:port for each qodercli process,
+          // so the proxy can tag token records with the exact dispatch ID.
+          env.AUTOWONDER_TOKEN_PROXY_PORT = String(proxyPort);
+          env.AUTOWONDER_TOKEN_PROXY_CA = caCertPath;
+          env.NODE_EXTRA_CA_CERTS = caCertPath;
+          log(`Token tracking enabled (proxy pid=${tokenProxyChild.pid}, port=${proxyPort})`);
+        } else {
+          log("WARN: token-proxy CA cert not ready, continuing without token tracking");
+        }
+      } catch (e) {
+        log(`WARN: token-proxy start failed (${e.message}), continuing without token tracking`);
+      }
+    } else {
+      log(`WARN: token-proxy.js not found at ${tokenProxyScript}, --token-aware-enable ignored`);
+    }
+  }
+
   const child = spawn(DAEMON_BIN, [], { env, stdio: "inherit" });
-  child.on("exit", (code) => process.exit(code || 0));
-  process.on("SIGINT", () => { child.kill("SIGINT"); });
-  process.on("SIGTERM", () => { child.kill("SIGTERM"); });
+  child.on("exit", (code) => {
+    // Stop token-proxy when daemon exits
+    if (tokenProxyChild) { try { process.kill(tokenProxyChild.pid); } catch (_) {} }
+    process.exit(code || 0);
+  });
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    if (tokenProxyChild) { try { process.kill(tokenProxyChild.pid); } catch (_) {} }
+  });
+  process.on("SIGTERM", () => {
+    child.kill("SIGTERM");
+    if (tokenProxyChild) { try { process.kill(tokenProxyChild.pid); } catch (_) {} }
+  });
 }
 
 async function cmdStart(args) {

package/bin/qoder-bootstrap.js

@@ -25,6 +25,7 @@ const QODER_FAMILY_PROFILES = {
     defaultConfigRootName: ".qoder",
     managedBinName: "qodercli",
     windowsShimName: "qodercli.cmd",
+    windowsInstallDirNames: ["Qoder CLI", "QoderCLI"],
     unixCandidateRelPaths: [
       [".local", "bin", "qodercli"],
       [".qoder", "bin", "qodercli", "qodercli"],
@@ -41,6 +42,7 @@ const QODER_FAMILY_PROFILES = {
     defaultConfigRootName: ".qoder-cn",
     managedBinName: "qodercn",
     windowsShimName: "qodercn.cmd",
+    windowsInstallDirNames: ["Qoder CN CLI", "QoderCNCLI"],
     unixCandidateRelPaths: [[".local", "bin", "qodercn"]],
   },
 };
@@ -63,10 +65,127 @@ function isQoderFamilyProvider(provider) {
   return provider === "qoder" || provider === "qodercn";
 }
 
+// Quotes one argument for cmd.exe. Paths containing spaces must stay a single
+// token when a .cmd shim is launched through ComSpec.
+function quoteWindowsArg(arg) {
+  if (arg && !/[\s"]/.test(arg)) return arg;
+  return `"${String(arg).replace(/"/g, '\\"')}"`;
+}
+
 function spawnQoderSync(executable, args, options = {}) {
   // npm exposes package binaries as .cmd shims on Windows. CreateProcess
-  // cannot execute those shims directly, so let ComSpec resolve them.
-  return spawnSync(executable, args, { ...options, shell: IS_WIN32 });
+  // cannot execute those shims directly, but shell:true would join the
+  // executable and its arguments with bare spaces and shred any path that
+  // contains a space (e.g. "...\Qoder CN CLI\..."). Launch ComSpec ourselves
+  // with an explicitly quoted command line instead; everything else runs as a
+  // plain argument array with no shell involved.
+  if (IS_WIN32 && /\.(cmd|bat)$/i.test(executable)) {
+    const comspec = process.env.ComSpec || "cmd.exe";
+    const command = [quoteWindowsArg(executable), ...args.map(quoteWindowsArg)].join(" ");
+    return spawnSync(comspec, ["/d", "/s", "/c", command], options);
+  }
+  return spawnSync(executable, args, { ...options, shell: false });
+}
+
+// Roots that hold user-level installers on Windows. Kept env-driven so the
+// probe logic stays testable off Windows.
+function windowsInstallRoots(env) {
+  const roots = [];
+  if (env.LOCALAPPDATA) roots.push(path.join(env.LOCALAPPDATA, "Programs"));
+  if (env.PROGRAMFILES) roots.push(env.PROGRAMFILES);
+  if (env["PROGRAMFILES(X86)"]) roots.push(env["PROGRAMFILES(X86)"]);
+  if (env.USERPROFILE) roots.push(env.USERPROFILE);
+  return roots;
+}
+
+// Matches a directory inside `parent` against the wanted names
+// case-insensitively, also accepting the space-free spelling, so casing or
+// spacing drift cannot hide an existing install.
+function matchInstallDir(parent, wantedNames, probed) {
+  let entries;
+  try { entries = fs.readdirSync(parent); } catch { return ""; }
+  const wanted = new Set(wantedNames.map((name) => name.toLowerCase()));
+  for (const entry of entries) {
+    const lower = entry.toLowerCase();
+    if (!wanted.has(lower) && !wanted.has(lower.replace(/\s+/g, ""))) continue;
+    const candidate = path.join(parent, entry);
+    probed.push(candidate);
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {}
+  }
+  return "";
+}
+
+// Relative locations of the CLI executable inside an install directory.
+function windowsExeRelPaths(profile) {
+  const exe = profile.executable;
+  return [
+    `${exe}.exe`,
+    exe,
+    `${exe}.cmd`,
+    path.join("bin", `${exe}.exe`),
+    path.join("bin", exe),
+    path.join("bin", `${exe}.cmd`),
+  ];
+}
+
+// Probes the known install directories with the filesystem only; PATH entries
+// and install paths are always treated as whole strings, never split on
+// spaces. Returns the executable plus every location that was probed so a
+// miss can be explained to the operator.
+function findInInstallDirs(provider, env = process.env) {
+  const profile = QODER_FAMILY_PROFILES[provider];
+  const probed = [];
+  const roots = windowsInstallRoots(env);
+  roots.push(path.join(os.homedir(), profile.defaultConfigRootName));
+  for (const root of roots) {
+    const dir = matchInstallDir(root, profile.windowsInstallDirNames, probed);
+    if (!dir) {
+      for (const name of profile.windowsInstallDirNames) probed.push(path.join(root, name));
+      continue;
+    }
+    for (const rel of windowsExeRelPaths(profile)) {
+      const candidate = path.join(dir, rel);
+      probed.push(candidate);
+      try {
+        fs.accessSync(candidate, fs.constants.F_OK);
+        if (!fs.statSync(candidate).isDirectory()) return { found: candidate, probed };
+      } catch {}
+    }
+  }
+  return { found: "", probed };
+}
+
+// Everything a "not installed" report must show: the install candidates, the
+// managed shim and any PATH entry that mentions the CLI family.
+function qoderSearchSummary(provider) {
+  const profile = QODER_FAMILY_PROFILES[provider];
+  const paths = qoderPaths(profile);
+  const probed = [];
+  for (const root of windowsInstallRoots(process.env)) {
+    for (const name of profile.windowsInstallDirNames) probed.push(path.join(root, name));
+  }
+  probed.push(path.join(os.homedir(), profile.defaultConfigRootName));
+  probed.push(path.join(paths.managedDir, "node_modules", ".bin", profile.windowsShimName));
+  for (const rel of profile.unixCandidateRelPaths) probed.push(path.join(os.homedir(), ...rel));
+  const needle = "qoder";
+  const pathHints = (process.env.PATH || "").split(path.delimiter)
+    .filter((entry) => entry && entry.toLowerCase().includes(needle));
+  return { probed, pathHints };
+}
+
+function reportQoderNotFound(provider) {
+  const profile = QODER_FAMILY_PROFILES[provider];
+  const { probed, pathHints } = qoderSearchSummary(provider);
+  error(`${profile.displayName} was not found. Probed locations (PATH entries were scanned as whole strings):`);
+  probed.forEach((location) => error(`  - ${location}`));
+  if (pathHints.length) {
+    error("PATH entries mentioning qoder:");
+    pathHints.forEach((entry) => error(`  - ${entry}`));
+  } else {
+    error(`no PATH entry mentions "${profile.executable}".`);
+  }
 }
 
 function findQoderExecutable(provider) {
@@ -85,6 +204,8 @@ function findQoderExecutable(provider) {
   const onPath = findOnPath(profile.executable);
   if (onPath) return onPath;
   if (IS_WIN32) {
+    const { found } = findInInstallDirs(provider);
+    if (found) return found;
     const shim = path.join(paths.managedDir, "node_modules", ".bin", profile.windowsShimName);
     try { fs.accessSync(shim, fs.constants.F_OK); return shim; } catch {}
     return "";
@@ -137,6 +258,10 @@ function qoderBinaryVersion(executable) {
     stdio: ["ignore", "pipe", "pipe"],
     timeout: 20000,
   });
+  // "missing" means the file itself is absent; "unknown" means the file is
+  // there but produced no version, so the two failure classes never collapse
+  // into one misleading answer.
+  if (result.error && result.error.code === "ENOENT") return "missing";
   // stdout wins so a warning on stderr cannot masquerade as the version and
   // make the identity comparison see a change that did not happen.
   const firstLine = (stream) => (stream || "").split(/\r?\n/).map((line) => line.trim()).find(Boolean);
@@ -385,6 +510,9 @@ function reportQoderDiagnostics(profile, info) {
   const { executable, version, configRoot, rootSource, verdict, identityChanged, previous } = info;
   error(`--- ${profile.displayName} bootstrap diagnostics ---`);
   error(`executable      : ${executable}`);
+  if (/\s/.test(executable)) {
+    error("note            : the executable path contains spaces; it is launched as an argument array / quoted command line");
+  }
   error(`version         : ${version}`);
   error(`config root     : ${configRoot} (${rootSource})`);
   error(`verdict         : ${verdict.state} - ${verdict.reason || "no further detail"}`);
@@ -456,6 +584,7 @@ async function ensureQoderReady(provider, options = {}) {
   // reinstall the package that just landed.
   let refreshed = false;
   if (!executable) {
+    reportQoderNotFound(provider);
     executable = installQoderCLI(provider);
     refreshed = true;
   }
@@ -564,13 +693,17 @@ async function ensureQoderReady(provider, options = {}) {
 module.exports = {
   QODER_FAMILY_PROFILES,
   ensureQoderReady,
+  findInInstallDirs,
   findQoderExecutable,
   inspectQoderHealth,
   isQoderFamilyProvider,
   qoderBinaryVersion,
   qoderPaths,
+  qoderSearchSummary,
+  quoteWindowsArg,
   readQoderState,
   reportQoderDiagnostics,
+  reportQoderNotFound,
   selectQoderConfigRoot,
   spawnQoderSync,
   waitForQoderLogin,

package/bin/shared.js

@@ -1,6 +1,5 @@
 "use strict";
 
-const { spawnSync } = require("child_process");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
@@ -25,11 +24,24 @@ function resolveUserPath(value) {
   return path.resolve(value);
 }
 
+// Scans PATH entry by entry with the filesystem instead of shelling out to
+// where/which: each entry stays a single string, so directories containing
+// spaces can never be split or misquoted by a shell.
 function findOnPath(name) {
-  const finder = process.platform === "win32" ? "where" : "which";
-  const found = spawnSync(finder, [name], { encoding: "utf8", timeout: 3000 });
-  if (found.status !== 0) return "";
-  return (found.stdout || "").split(/\r?\n/).map((value) => value.trim()).find(Boolean) || "";
+  const isWin32 = process.platform === "win32";
+  const suffixes = isWin32 ? ["", ".exe", ".cmd", ".bat", ".com"] : [""];
+  const entries = (process.env.PATH || process.env.Path || "").split(path.delimiter);
+  for (const entry of entries) {
+    if (!entry) continue;
+    for (const suffix of suffixes) {
+      const candidate = path.join(entry, name + suffix);
+      try {
+        fs.accessSync(candidate, isWin32 ? fs.constants.F_OK : fs.constants.X_OK);
+        if (!fs.statSync(candidate).isDirectory()) return candidate;
+      } catch {}
+    }
+  }
+  return "";
 }
 
 module.exports = { ensureDir, error, findOnPath, log, resolveUserPath };

package/bin/token-proxy.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+/**
+ * token-proxy.js — Qoder/QoderCN token usage 旁路采集 proxy
+ *
+ * 单文件,零 npm 依赖,仅用 Node 内置模块。
+ * 作为 HTTPS forward proxy 运行,透传所有流量,从 Qoder API 的 SSE 响应中
+ * 提取 token usage 数据写入 JSONL 文件。
+ *
+ * 用法:
+ *   node token-proxy.js start [--port 19876]     启动 proxy
+ *   node token-proxy.js query [--since 1h]       查询 token 汇总
+ *   node token-proxy.js query --json             JSON 格式输出
+ *
+ * 降级策略:
+ *   - 所有解析逻辑被 try-catch 包裹,解析失败只丢 token 数据,不断流量
+ *   - proxy 启动失败时,wrapper 不注入 HTTPS_PROXY,daemon 正常直连
+ *   - proxy 运行中崩溃时,Node HTTPS 模块遇到 ECONNREFUSED 会忽略 proxy 直连
+ */
+
+'use strict';
+
+const http = require('http');
+const net = require('net');
+const tls = require('tls');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+const DEFAULT_PORT = 19876;
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB, then rotate
+const DATA_DIR = path.join(os.homedir(), '.autowonder', 'token-tap');
+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');
+
+// 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',
+  // QoderCN (China)
+  'gateway.qoder.com.cn',
+  'api3.qodercn.com', 'api2.qodercn.com', 'api.qodercn.com',
+]);
+
+// ─── CA Certificate (auto-generated, only for this proxy) ────────────────────
+
+function ensureCA() {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  if (fs.existsSync(CA_KEY_PATH) && fs.existsSync(CA_CERT_PATH)) {
+    return { key: fs.readFileSync(CA_KEY_PATH), cert: fs.readFileSync(CA_CERT_PATH) };
+  }
+
+  const { privateKey } = crypto.generateKeyPairSync('rsa', {
+    modulusLength: 2048,
+    publicKeyEncoding: { type: 'spki', format: 'pem' },
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+  });
+
+  // Write key first — openssl needs it on disk
+  fs.writeFileSync(CA_KEY_PATH, privateKey, { mode: 0o600 });
+
+  // Generate self-signed CA cert
+  const cert = generateCACert(privateKey);
+  fs.writeFileSync(CA_CERT_PATH, cert, { mode: 0o644 });
+  return { key: privateKey, cert };
+}
+
+function generateCACert(privateKey) {
+  const { execFileSync } = require('child_process');
+  const subject = '/CN=AutoWonder Token Tap CA';
+
+  // Try openssl at various paths (macOS/Linux/Windows-Git)
+  const candidates = ['openssl', '/usr/bin/openssl', '/opt/homebrew/bin/openssl',
+    'C:\\Program Files\\Git\\usr\\bin\\openssl.exe', 'C:\\Program Files\\OpenSSL-Win64\\bin\\openssl.exe'];
+  for (const cmd of candidates) {
+    try {
+      execFileSync(cmd, [
+        'req', '-new', '-x509', '-key', CA_KEY_PATH,
+        '-out', CA_CERT_PATH, '-days', '3650', '-subj', subject,
+      ], { stdio: 'pipe' });
+      return fs.readFileSync(CA_CERT_PATH, 'utf8');
+    } catch (_) { continue; }
+  }
+  throw new Error('Cannot generate CA certificate: openssl not found. Install openssl or use Node 22+.');
+}
+
+// ─── Per-host TLS certificate (signed by our CA) ─────────────────────────────
+
+const hostCertCache = new Map();
+
+function isCertExpired(certPath) {
+  try {
+    const stat = fs.statSync(certPath);
+    // Cert is valid for 365 days; renew when older than 300 days
+    const ageMs = Date.now() - stat.mtimeMs;
+    return ageMs > 300 * 86400000;
+  } catch (_) { return true; }
+}
+
+function getHostCert(hostname, ca) {
+  if (hostCertCache.has(hostname)) return hostCertCache.get(hostname);
+
+  const certPath = path.join(DATA_DIR, `${hostname}.pem`);
+  const keyPath = path.join(DATA_DIR, `${hostname}-key.pem`);
+
+  // Return cached cert from disk if still valid
+  if (fs.existsSync(certPath) && fs.existsSync(keyPath) && !isCertExpired(certPath)) {
+    const result = { key: fs.readFileSync(keyPath), cert: fs.readFileSync(certPath) };
+    hostCertCache.set(hostname, result);
+    return result;
+  }
+
+  const { privateKey } = crypto.generateKeyPairSync('rsa', {
+    modulusLength: 2048,
+    publicKeyEncoding: { type: 'spki', format: 'pem' },
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+  });
+
+  const { execFileSync } = require('child_process');
+  const csrPath = path.join(DATA_DIR, `${hostname}.csr`);
+  fs.writeFileSync(keyPath, privateKey, { mode: 0o600 });
+
+  try {
+    execFileSync('openssl', ['req', '-new', '-key', keyPath, '-out', csrPath, '-subj', `/CN=${hostname}`], { stdio: 'pipe' });
+    execFileSync('openssl', [
+      'x509', '-req', '-in', csrPath, '-CA', CA_CERT_PATH, '-CAkey', CA_KEY_PATH,
+      '-CAcreateserial', '-out', certPath, '-days', '365',
+      '-extfile', '/dev/stdin', '-extensions', 'v3_ext',
+    ], { input: `[v3_ext]\nsubjectAltName=DNS:${hostname}\n`, stdio: ['pipe', 'pipe', 'pipe'] });
+  } catch (_) {
+    // Windows fallback: without SAN extension
+    try {
+      execFileSync('openssl', ['req', '-new', '-key', keyPath, '-out', csrPath, '-subj', `/CN=${hostname}`], { stdio: 'pipe' });
+      execFileSync('openssl', [
+        'x509', '-req', '-in', csrPath, '-CA', CA_CERT_PATH, '-CAkey', CA_KEY_PATH,
+        '-CAcreateserial', '-out', certPath, '-days', '365',
+      ], { stdio: 'pipe' });
+    } catch (e2) {
+      // Cannot generate host cert — fall back to blind tunnel (no sniffing)
+      hostCertCache.set(hostname, null);
+      return null;
+    }
+  }
+
+  const result = { key: fs.readFileSync(keyPath), cert: fs.readFileSync(certPath) };
+  hostCertCache.set(hostname, result);
+  // Cleanup temp files
+  try { fs.unlinkSync(csrPath); } catch (_) {}
+  try { fs.unlinkSync(path.join(DATA_DIR, 'ca-cert.srl')); } catch (_) {}
+  return result;
+}
+
+// ─── Usage extraction from Qoder SSE ────────────────────────────────────────
+
+function extractUsageFromResponse(buffer) {
+  // Supports multiple response formats:
+  //   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.
+  try {
+    const text = buffer.toString('utf8');
+    const lines = text.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line.includes('prompt_tokens')) continue;
+
+      // Strategy 1: Qoder nested SSE — data:{"headers":...,"body":"<escaped json>"}
+      if (line.startsWith('data:')) {
+        const usage = tryQoderNestedSSE(line.slice(5));
+        if (usage) return usage;
+        // Strategy 2: Standard OpenAI SSE — data: {"choices":...,"usage":{...}}
+        const usage2 = tryDirectJSON(line.slice(5).trim());
+        if (usage2) return usage2;
+      }
+
+      // Strategy 3: Plain JSON line (NDJSON or single response)
+      const usage3 = tryDirectJSON(line);
+      if (usage3) return usage3;
+    }
+  } catch (_) {
+    // Silent: parsing failure only loses token data, never breaks traffic
+  }
+  return null;
+}
+
+function tryQoderNestedSSE(data) {
+  try {
+    const outer = JSON.parse(data);
+    if (!outer || !outer.body || outer.body === '[DONE]') return null;
+    const inner = JSON.parse(outer.body);
+    if (inner && inner.usage) return buildUsageRecord(inner.usage, inner.model);
+  } catch (_) {}
+  return null;
+}
+
+function tryDirectJSON(data) {
+  try {
+    const obj = JSON.parse(data);
+    if (obj && obj.usage) return buildUsageRecord(obj.usage, obj.model);
+  } catch (_) {}
+  return null;
+}
+
+function buildUsageRecord(u, model) {
+  return {
+    ts: new Date().toISOString(),
+    input_tokens: u.prompt_tokens || u.input_tokens || 0,
+    output_tokens: u.completion_tokens || u.output_tokens || 0,
+    cached_tokens: (u.prompt_tokens_details || {}).cached_tokens || u.cache_read_input_tokens || 0,
+    reasoning_tokens: (u.completion_tokens_details || {}).reasoning_tokens || 0,
+    credits: u.credits || 0,
+    model: model || 'unknown',
+  };
+}
+
+function appendUsage(usage) {
+  try {
+    // Rotate if over max size
+    try {
+      const stat = fs.statSync(USAGE_LOG_PATH);
+      if (stat.size > MAX_LOG_SIZE) {
+        try { fs.unlinkSync(USAGE_LOG_OLD); } catch (_) {}
+        fs.renameSync(USAGE_LOG_PATH, USAGE_LOG_OLD);
+      }
+    } catch (_) {} // file doesn't exist yet, fine
+
+    fs.appendFileSync(USAGE_LOG_PATH, JSON.stringify(usage) + '\n');
+  } catch (_) {
+    // Silent: write failure only loses token data
+  }
+}
+
+// ─── Dispatch 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")>
+  const auth = req.headers['proxy-authorization'] || '';
+  if (!auth.startsWith('Basic ')) return 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);
+  } catch (_) {}
+  return null;
+}
+
+// ─── Forward Proxy (CONNECT method) ─────────────────────────────────────────
+
+function startProxy(port) {
+  const ca = ensureCA();
+
+  const server = http.createServer((req, res) => {
+    // Non-CONNECT requests: reject (we only handle CONNECT tunnels)
+    res.writeHead(405);
+    res.end('Only CONNECT supported');
+  });
+
+  server.on('connect', (req, clientSocket, head) => {
+    const [hostname, portStr] = req.url.split(':');
+    const remotePort = parseInt(portStr) || 443;
+    const shouldSniff = SNIFF_HOSTS.has(hostname);
+    const dispatchId = extractDispatchId(req);
+
+    if (!shouldSniff) {
+      // Blind tunnel: don't MITM, just pipe through
+      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 (_) {} });
+      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
+      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 (_) {} });
+      return;
+    }
+
+    // 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');
+
+    const tlsClient = new tls.TLSSocket(clientSocket, {
+      isServer: true,
+      key: hostCert.key,
+      cert: hostCert.cert,
+    });
+
+    // Connect to real upstream
+    const tlsUpstream = tls.connect({ host: hostname, port: remotePort, servername: hostname });
+
+    let responseBuffer = Buffer.alloc(0);
+    let usageExtracted = false;
+
+    tlsUpstream.on('data', (chunk) => {
+      try { tlsClient.write(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;
+          }
+        }
+      } catch (_) {}
+    });
+
+    tlsClient.on('data', (chunk) => {
+      try { tlsUpstream.write(chunk); } catch (_) {}
+    });
+
+    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);
+      try { tlsClient.end(); } catch (_) {}
+      try { tlsUpstream.end(); } catch (_) {}
+    };
+
+    tlsClient.on('end', cleanup);
+    tlsClient.on('error', () => { cleanup(); });
+    tlsUpstream.on('end', cleanup);
+    tlsUpstream.on('error', () => { cleanup(); });
+
+    if (head.length > 0) tlsClient.emit('data', head);
+  });
+
+  server.on('error', (err) => {
+    console.error(`[token-proxy] server error: ${err.message}`);
+    process.exit(1);
+  });
+
+  server.listen(port, '127.0.0.1', () => {
+    console.log(`[token-proxy] listening on 127.0.0.1:${port}`);
+    console.log(`[token-proxy] CA cert: ${CA_CERT_PATH}`);
+    console.log(`[token-proxy] Usage log: ${USAGE_LOG_PATH}`);
+    console.log(`[token-proxy] Sniffing hosts: ${[...SNIFF_HOSTS].join(', ')}`);
+  });
+
+  // Graceful shutdown
+  process.on('SIGINT', () => { server.close(); process.exit(0); });
+  process.on('SIGTERM', () => { server.close(); process.exit(0); });
+}
+
+// ─── Query command ──────────────────────────────────────────────────────────
+
+function queryUsage(opts) {
+  if (!fs.existsSync(USAGE_LOG_PATH)) {
+    console.log('No token usage data found.');
+    console.log(`(Expected at: ${USAGE_LOG_PATH})`);
+    process.exit(0);
+  }
+
+  const lines = fs.readFileSync(USAGE_LOG_PATH, 'utf8').trim().split('\n').filter(Boolean);
+  let records = lines.map(l => { try { return JSON.parse(l); } catch (_) { return null; } }).filter(Boolean);
+
+  // Filter by time
+  if (opts.since) {
+    const ms = parseDuration(opts.since);
+    const cutoff = new Date(Date.now() - ms).toISOString();
+    records = records.filter(r => r.ts >= cutoff);
+  }
+
+  if (records.length === 0) {
+    console.log('No token usage data in the specified time range.');
+    process.exit(0);
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(records, null, 2));
+    return;
+  }
+
+  // Pretty print
+  const total = { input: 0, output: 0, cached: 0, reasoning: 0, credits: 0, calls: 0 };
+  console.log(`${'Time'.padEnd(22)} ${'Input'.padStart(10)} ${'Output'.padStart(8)} ${'Cached'.padStart(10)} ${'Credits'.padStart(8)} Model`);
+  console.log('-'.repeat(72));
+  for (const r of records) {
+    total.input += r.input_tokens || 0;
+    total.output += r.output_tokens || 0;
+    total.cached += r.cached_tokens || 0;
+    total.reasoning += r.reasoning_tokens || 0;
+    total.credits += r.credits || 0;
+    total.calls++;
+    const ts = (r.ts || '').slice(0, 19);
+    console.log(`${ts.padEnd(22)} ${fmt(r.input_tokens).padStart(10)} ${fmt(r.output_tokens).padStart(8)} ${fmt(r.cached_tokens).padStart(10)} ${(r.credits || 0).toFixed(2).padStart(8)} ${r.model || ''}`);
+  }
+  console.log('-'.repeat(72));
+  console.log(`${'TOTAL (' + total.calls + ' calls)'.padEnd(22)} ${fmt(total.input).padStart(10)} ${fmt(total.output).padStart(8)} ${fmt(total.cached).padStart(10)} ${total.credits.toFixed(2).padStart(8)}`);
+  console.log(`\n  Non-cached input: ${fmt(total.input - total.cached)} tokens`);
+  console.log(`  Cache hit rate:   ${total.input > 0 ? (total.cached / total.input * 100).toFixed(1) : 0}%`);
+}
+
+function fmt(n) { return (n || 0).toLocaleString(); }
+
+function parseDuration(s) {
+  const m = s.match(/^(\d+)(h|m|d|s)?$/);
+  if (!m) return 3600000; // default 1h
+  const val = parseInt(m[1]);
+  switch (m[2]) {
+    case 'd': return val * 86400000;
+    case 'h': return val * 3600000;
+    case 'm': return val * 60000;
+    case 's': return val * 1000;
+    default: return val * 3600000;
+  }
+}
+
+// ─── CLI ─────────────────────────────────────────────────────────────────────
+
+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}`);
+}

package/package.json

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