@soloco/cli 0.3.1-canary.0

package/dist/index.js

@@ -0,0 +1,1290 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command } from "commander";
+import pc5 from "picocolors";
+import * as fs from "fs";
+import * as net from "net";
+import * as os2 from "os";
+import * as path2 from "path";
+import * as readline2 from "readline";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// ../packages/local-runtime/src/cloud-auth.ts
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var DEFAULT_CLOUD_BASE_URL = "https://soloco.cloud";
+function resolveDefaultCloudBaseUrl(env = process.env) {
+  return env.SOLOCO_CLOUD_URL?.trim() || DEFAULT_CLOUD_BASE_URL;
+}
+function resolveAuthFilePath(env = process.env) {
+  const home = resolveSolocoHomeDir(env);
+  return path.resolve(home, "auth.json");
+}
+async function loadStoredAuth(filePath = resolveAuthFilePath()) {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isStoredAuth(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveStoredAuth(auth, filePath = resolveAuthFilePath()) {
+  await mkdir(path.dirname(filePath), { recursive: true, mode: 448 });
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(auth, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  try {
+    await rename(tempPath, filePath);
+  } catch (err) {
+    await rm(tempPath, { force: true });
+    throw err;
+  }
+}
+async function clearStoredAuth(filePath = resolveAuthFilePath()) {
+  await rm(filePath, { force: true });
+}
+function normalizeCloudBaseUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) throw new Error("Cloud server URL is required");
+  return assertHttpUrl(trimmed).replace(/\/+$/, "");
+}
+function createCloudAuthClient(rawBaseUrl) {
+  const baseUrl = normalizeCloudBaseUrl(rawBaseUrl);
+  return {
+    baseUrl,
+    start: async (installationName) => requestJson(baseUrl, "/api/soloco/device-auth/start", {
+      method: "POST",
+      body: { installationName }
+    }),
+    poll: async (id) => requestJson(
+      baseUrl,
+      `/api/soloco/device-auth/poll/${encodeURIComponent(id)}`,
+      { method: "GET" },
+      { mapErrorResponse: mapExpiredPollResponse }
+    ),
+    refresh: async (refreshToken) => requestJson(baseUrl, "/api/soloco/device-auth/refresh", {
+      method: "POST",
+      body: { refreshToken }
+    })
+  };
+}
+async function refreshStoredAccessToken(client, auth) {
+  const refreshed = await client.refresh(auth.refreshToken);
+  return {
+    ...auth,
+    accessToken: refreshed.accessToken,
+    accessTokenExpiresAt: refreshed.expiresAt,
+    // Persist a rotated refresh token when the server returns one; otherwise keep
+    // the existing one (launch server does not rotate). Single-use rotation, once
+    // enabled server-side, then works without any further client change.
+    // Note: DeviceAuthRefreshResponse uses `refreshExpiresAt` (no "Token" infix)
+    // while StoredAuth uses `refreshTokenExpiresAt` — intentional asymmetry since
+    // the response DTO mirrors the `expiresAt` / `refreshExpiresAt` pair from the
+    // server contract, whereas StoredAuth disambiguates access vs refresh locally.
+    refreshToken: refreshed.refreshToken ?? auth.refreshToken,
+    refreshTokenExpiresAt: refreshed.refreshExpiresAt ?? auth.refreshTokenExpiresAt,
+    userId: refreshed.userId,
+    installationId: refreshed.installationId
+  };
+}
+async function ensureCloudLogin(options) {
+  const auth = await loadStoredAuth(options.authPath);
+  if (!auth) return runDeviceLogin(options);
+  if (isAccessTokenFresh(auth.accessToken)) return auth;
+  try {
+    const client = (options.clientFactory ?? createCloudAuthClient)(auth.cloudBaseUrl);
+    const refreshed = await refreshStoredAccessToken(client, auth);
+    await saveStoredAuth(refreshed, options.authPath);
+    return refreshed;
+  } catch {
+    return runDeviceLogin({
+      ...options,
+      serverUrl: auth.cloudBaseUrl || options.serverUrl
+    });
+  }
+}
+async function runDeviceLogin(options) {
+  const serverUrl = options.serverUrl ?? resolveDefaultCloudBaseUrl();
+  const client = createCloudAuthClient(serverUrl);
+  const started = await client.start(options.installationName ?? defaultInstallationName());
+  await options.onStarted?.(started);
+  await options.openBrowser(assertHttpUrl(started.authUrl));
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const intervalMs = Math.max(1e3, started.pollIntervalMs ?? 2e3);
+  const deadline = Date.now() + 10 * 6e4;
+  while (Date.now() < deadline) {
+    const polled = await client.poll(started.id);
+    if (polled.status === "authorized") {
+      return saveAuthorizedDeviceAuth(client.baseUrl, polled, options.authPath);
+    }
+    if (polled.status === "expired") {
+      throw new Error("\u767B\u5F55\u6388\u6743\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C soloco login");
+    }
+    await sleep(intervalMs);
+  }
+  throw new Error("\u767B\u5F55\u6388\u6743\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C soloco login");
+}
+async function saveAuthorizedDeviceAuth(cloudBaseUrl, polled, authPath) {
+  const auth = {
+    version: 1,
+    cloudBaseUrl,
+    userId: polled.userId,
+    installationId: polled.installationId,
+    accessToken: polled.accessToken,
+    accessTokenExpiresAt: polled.expiresAt,
+    refreshToken: polled.refreshToken,
+    refreshTokenExpiresAt: polled.refreshExpiresAt,
+    lastLoginAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveStoredAuth(auth, authPath);
+  return auth;
+}
+function isAccessTokenFresh(token, now = Date.now(), refreshBufferMs = 6e4) {
+  const exp = decodeJwtExp(token);
+  if (!exp) return false;
+  return exp * 1e3 - now > refreshBufferMs;
+}
+function resolveSolocoHomeDir(env) {
+  const raw = env.SOLOCO_HOME?.trim();
+  if (!raw) return path.resolve(os.homedir(), ".soloco");
+  if (raw === "~") return os.homedir();
+  if (raw.startsWith("~/")) return path.resolve(os.homedir(), raw.slice(2));
+  return path.resolve(raw);
+}
+function isStoredAuth(value) {
+  return value.version === 1 && isNonEmptyString(value.cloudBaseUrl) && isNonEmptyString(value.userId) && isNonEmptyString(value.installationId) && isNonEmptyString(value.accessToken) && isNonEmptyString(value.accessTokenExpiresAt) && isNonEmptyString(value.refreshToken) && isNonEmptyString(value.lastLoginAt);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+async function requestJson(baseUrl, endpoint, opts, behavior = {}) {
+  const response = await fetch(`${baseUrl}${endpoint}`, {
+    method: opts.method,
+    headers: { "Content-Type": "application/json" },
+    body: opts.body ? JSON.stringify(stripUndefined(opts.body)) : void 0
+  });
+  if (!response.ok) {
+    const mapped = await behavior.mapErrorResponse?.(response);
+    if (mapped) return mapped;
+    const text = await response.text().catch(() => "");
+    throw new Error(`Cloud auth ${opts.method} ${endpoint} failed (${response.status}): ${text}`);
+  }
+  return response.json();
+}
+async function mapExpiredPollResponse(response) {
+  if (response.status !== 410) return null;
+  const payload = await response.json().catch(() => null);
+  return payload?.status === "expired" ? { status: "expired" } : null;
+}
+function stripUndefined(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function decodeJwtExp(token) {
+  const [, encodedPayload] = token.split(".");
+  if (!encodedPayload) return null;
+  try {
+    const payload = JSON.parse(Buffer.from(encodedPayload, "base64url").toString("utf8"));
+    return typeof payload.exp === "number" ? payload.exp : null;
+  } catch {
+    return null;
+  }
+}
+function defaultInstallationName() {
+  return `Soloco CLI (${os.hostname()})`;
+}
+function assertHttpUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new Error(`\u65E0\u6548\u7684\u6388\u6743\u94FE\u63A5\uFF1A${rawUrl}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`\u4E0D\u5B89\u5168\u7684\u6388\u6743\u94FE\u63A5\u534F\u8BAE\uFF1A${parsed.protocol}`);
+  }
+  return rawUrl;
+}
+
+// src/lib/api.ts
+function createApiClient(apiBase) {
+  return async function api(method, endpoint, body) {
+    const url = `${apiBase}${endpoint}`;
+    const res = await fetch(url, {
+      method,
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`API ${method} ${endpoint} failed (${res.status}): ${text}`);
+    }
+    const ct = res.headers.get("content-type") || "";
+    if (ct.includes("application/json")) return res.json();
+    return void 0;
+  };
+}
+
+// src/lib/cloud-login.ts
+import pc from "picocolors";
+async function ensureCloudLogin2(options) {
+  return ensureCloudLogin({
+    ...options,
+    onStarted: printDeviceAuthStart
+  });
+}
+async function runDeviceLogin2(options) {
+  return runDeviceLogin({
+    ...options,
+    onStarted: printDeviceAuthStart
+  });
+}
+function printDeviceAuthStart(started) {
+  console.log(pc.bold("\u6253\u5F00\u6D4F\u89C8\u5668\u5B8C\u6210 Soloco \u767B\u5F55\u6388\u6743"));
+  console.log(pc.dim(started.authUrl));
+}
+
+// src/lib/env.ts
+var DEFAULT_API_BASE = "http://localhost:3100";
+function resolveApiBase(env = process.env) {
+  return env.SOLOCO_API_BASE?.trim() || DEFAULT_API_BASE;
+}
+
+// src/lib/goal-text.ts
+function joinGoalParts(goalParts) {
+  return goalParts.join(" ").trim();
+}
+function extractCurrentGoalId(current) {
+  if (Array.isArray(current)) {
+    return current[0]?.id;
+  }
+  return current?.id;
+}
+function parseLogLimit(raw, fallback = 20) {
+  const parsed = Number.parseInt(raw ?? String(fallback), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+// src/lib/print-goal.ts
+import pc3 from "picocolors";
+
+// src/lib/format.ts
+import pc2 from "picocolors";
+function colorStatus(status) {
+  switch (status) {
+    case "running":
+      return pc2.green(status);
+    case "paused":
+      return pc2.yellow(status);
+    case "completed":
+      return pc2.cyan(status);
+    case "aborted":
+      return pc2.red(status);
+    default:
+      return status;
+  }
+}
+
+// src/lib/print-goal.ts
+function printGoal(goal) {
+  console.log(`  \u76EE\u6807: ${pc3.bold(goal.description || goal.goal || "-")}`);
+  console.log(`  ID:   ${goal.id}`);
+  console.log(`  \u72B6\u6001: ${colorStatus(goal.status || "-")}`);
+  if (goal.progress != null) console.log(`  \u8FDB\u5EA6: ${goal.progress}%`);
+  if (goal.budget != null) console.log(`  \u9884\u7B97: ${goal.budget}`);
+  if (goal.currentCycle != null) console.log(`  \u5FAA\u73AF: \u7B2C ${goal.currentCycle} \u8F6E`);
+}
+
+// src/lib/monitor.ts
+import readline from "node:readline";
+import pc4 from "picocolors";
+async function monitorGoal(goalId, api, apiBase, sleep) {
+  let isRunning = true;
+  let isPrompting = false;
+  const setupRawMode = () => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+      readline.emitKeypressEvents(process.stdin);
+    }
+  };
+  const restoreNormalMode = () => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+  };
+  setupRawMode();
+  const onKeypress = async (str, key) => {
+    if (isPrompting) return;
+    if (key.ctrl && key.name === "c" || key.name === "q") {
+      isRunning = false;
+      restoreNormalMode();
+      process.stdin.off("keypress", onKeypress);
+      console.clear();
+      console.log(pc4.green("\u2714 \u5DF2\u9000\u51FA\u76D1\u63A7\u6A21\u5F0F\u3002\u76EE\u6807\u5728\u540E\u53F0\u7EE7\u7EED\u8FD0\u884C\u3002"));
+      process.exit(0);
+    }
+    try {
+      if (key.name === "p") {
+        console.log(pc4.yellow("\n\u6B63\u5728\u53D1\u9001\u6682\u505C\u8BF7\u6C42..."));
+        await api("POST", `/api/goals/${goalId}/pause`);
+        console.log(pc4.green("\u2714 \u76EE\u6807\u5DF2\u6682\u505C"));
+        await sleep(1e3);
+      } else if (key.name === "r") {
+        console.log(pc4.green("\n\u6B63\u5728\u53D1\u9001\u6062\u590D\u8BF7\u6C42..."));
+        await api("POST", `/api/goals/${goalId}/resume`);
+        console.log(pc4.green("\u2714 \u76EE\u6807\u5DF2\u6062\u590D"));
+        await sleep(1e3);
+      } else if (key.name === "a") {
+        restoreNormalMode();
+        isPrompting = true;
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        rl.question(pc4.red("\n\u786E\u5B9A\u8981\u7EC8\u6B62\u8BE5\u76EE\u6807\u5417\uFF1F(y/N): "), async (answer) => {
+          rl.close();
+          isPrompting = false;
+          setupRawMode();
+          if (answer.toLowerCase() === "y") {
+            console.log(pc4.red("\u6B63\u5728\u53D1\u9001\u7EC8\u6B62\u8BF7\u6C42..."));
+            await api("POST", `/api/goals/${goalId}/abort`);
+            console.log(pc4.green("\u2714 \u76EE\u6807\u5DF2\u7EC8\u6B62"));
+            await sleep(1e3);
+          }
+        });
+      } else if (key.name === "s") {
+        restoreNormalMode();
+        isPrompting = true;
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        rl.question(pc4.cyan("\n\u8BF7\u8F93\u5165\u63D2\u961F/\u8F6C\u5411\u6307\u4EE4\u5185\u5BB9: "), (content) => {
+          if (!content.trim()) {
+            rl.close();
+            isPrompting = false;
+            setupRawMode();
+            return;
+          }
+          rl.question(pc4.yellow("\u662F\u5426\u7ACB\u5373\u5F3A\u5236\u7EC8\u6B62\u5F53\u524D\u6B63\u5728\u8FD0\u884C\u7684\u5B50\u4EFB\u52A1\uFF1F(y/N): "), async (forceKillAns) => {
+            rl.close();
+            isPrompting = false;
+            setupRawMode();
+            const forceKill = forceKillAns.toLowerCase() === "y";
+            console.log(pc4.cyan("\u6B63\u5728\u53D1\u9001\u8F6C\u5411\u6307\u4EE4..."));
+            await api("POST", `/api/goals/${goalId}/steer`, {
+              content,
+              forceKill
+            });
+            console.log(pc4.green("\u2714 \u8F6C\u5411\u6307\u4EE4\u53D1\u9001\u6210\u529F!"));
+            await sleep(1500);
+          });
+        });
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error(pc4.red(`
+\u64CD\u4F5C\u5931\u8D25: ${msg}`));
+      await sleep(2e3);
+    }
+  };
+  process.stdin.on("keypress", onKeypress);
+  while (isRunning) {
+    if (isPrompting) {
+      await sleep(500);
+      continue;
+    }
+    try {
+      const goal = await api("GET", `/api/goals/${goalId}`);
+      const runsRes = await api("GET", `/api/goals/${goalId}/runs`);
+      const runs = runsRes.runs || [];
+      const latestRun = runs[0];
+      let stdoutTail = "";
+      let stderrTail = "";
+      if (latestRun) {
+        try {
+          const logs = await api(
+            "GET",
+            `/api/goals/${goalId}/runs/${latestRun.id}/logs/tail?bytes=4096`
+          );
+          stdoutTail = logs.stdoutTail || "";
+          stderrTail = logs.stderrTail || "";
+        } catch {
+        }
+      }
+      console.clear();
+      drawDashboard(goal, latestRun, stdoutTail, stderrTail);
+    } catch (e) {
+      console.clear();
+      console.log(pc4.red("\u26A0\uFE0F  \u65E0\u6CD5\u8FDE\u63A5\u5230 Soloco \u63A7\u5236\u9762\u670D\u52A1\u5668\uFF0C\u6B63\u5728\u91CD\u8BD5..."));
+      const msg = e instanceof Error ? e.message : String(e);
+      console.log(pc4.dim(`\u9519\u8BEF\u8BE6\u60C5: ${msg}`));
+    }
+    await sleep(1500);
+  }
+}
+function drawDashboard(goal, latestRun, stdoutTail, stderrTail) {
+  const width = process.stdout.columns || 80;
+  const separator = "\u2500".repeat(width);
+  console.log(pc4.bold(pc4.cyan(` Soloco Dev Insider Goal Monitor `).padStart(Math.floor((width + 30) / 2))));
+  console.log(pc4.dim(separator));
+  const budget = (goal.budgetUsd / 100).toFixed(2);
+  const spent = (goal.spentUsdCents / 100).toFixed(2);
+  const progressPercent = Math.round(goal.progressPercent || 0);
+  const progressBar = drawProgressBar(progressPercent, 20);
+  console.log(` ${pc4.bold("\u76EE\u6807\u6807\u9898:")} ${pc4.white(goal.title || goal.description.split("\n")[0])}`);
+  console.log(` ${pc4.bold("\u76EE\u6807 ID:")}   ${pc4.dim(goal.id)}`);
+  console.log(
+    ` ${pc4.bold("\u72B6\u6001:")}      ${colorStatus(goal.status)}    ${pc4.bold("\u6A21\u578B:")} ${pc4.magenta(goal.conductorModel || "-")}`
+  );
+  console.log(
+    ` ${pc4.bold("\u5FAA\u73AF:")}      \u7B2C ${pc4.yellow(goal.currentCycle)} \u8F6E / \u6700\u591A ${goal.maxCycles} \u8F6E`
+  );
+  console.log(
+    ` ${pc4.bold("\u9884\u7B97/\u82B1\u8D39:")} $${pc4.green(spent)} / $${pc4.red(budget)} USD`
+  );
+  console.log(` ${pc4.bold("\u8FDB\u5EA6:")}      ${progressBar} ${pc4.cyan(`${progressPercent}%`)}`);
+  if (goal.status === "initializing" && goal.initializationProgress) {
+    const ip = goal.initializationProgress;
+    console.log(pc4.dim(separator));
+    console.log(pc4.yellow(` \u2699\uFE0F  \u521D\u59CB\u5316\u8FDB\u5EA6: [${ip.state}] \u7B2C ${ip.currentRound}/${ip.maxRounds} \u8F6E\u89C4\u5212\u8BC4\u4F30`));
+    if (ip.lastSummary) {
+      console.log(`   ${pc4.dim("\u6700\u65B0\u6458\u8981:")} ${ip.lastSummary}`);
+    }
+  }
+  console.log(pc4.dim(separator));
+  if (latestRun) {
+    const runDuration = getDuration(latestRun.startedAt, latestRun.endedAt);
+    const runCost = (latestRun.costUsdCents / 100).toFixed(4);
+    console.log(
+      ` ${pc4.bold("\u6700\u65B0\u5B50\u4EFB\u52A1:")} ${pc4.blue(latestRun.command)} ${pc4.dim(latestRun.args.join(" "))}`
+    );
+    console.log(
+      ` ${pc4.bold("\u4EFB\u52A1 ID:")}     ${pc4.dim(latestRun.id)}`
+    );
+    console.log(
+      ` ${pc4.bold("\u4EFB\u52A1\u72B6\u6001:")}   ${colorStatus(latestRun.status)}    ${pc4.bold("\u8017\u65F6:")} ${runDuration}    ${pc4.bold("\u6210\u672C:")} $${runCost}`
+    );
+    console.log(pc4.dim(separator));
+    console.log(` ${pc4.bold("\u{1F4C4} \u4EFB\u52A1\u6807\u51C6\u8F93\u51FA (Stdout Tail):")}`);
+    if (stdoutTail.trim()) {
+      const lines = stdoutTail.split("\n").slice(-12);
+      lines.forEach((line) => {
+        console.log(`   ${pc4.dim(line)}`);
+      });
+    } else {
+      console.log(pc4.dim("   [\u6682\u65E0\u8F93\u51FA\u6216\u6B63\u5728\u542F\u52A8...]"));
+    }
+    if (stderrTail.trim()) {
+      console.log(pc4.dim(separator));
+      console.log(` ${pc4.bold(pc4.red("\u26A0\uFE0F  \u4EFB\u52A1\u9519\u8BEF\u8F93\u51FA (Stderr Tail):"))}`);
+      const lines = stderrTail.split("\n").slice(-5);
+      lines.forEach((line) => {
+        console.log(`   ${pc4.red(line)}`);
+      });
+    }
+  } else {
+    console.log(pc4.dim(" \u2139\uFE0F  \u5F53\u524D\u6682\u65E0\u5B50\u4EFB\u52A1\u8FD0\u884C\u3002"));
+  }
+  console.log(pc4.dim(separator));
+  console.log(
+    ` ${pc4.bold("\u5FEB\u6377\u952E:")}  [${pc4.yellow("p")}] \u6682\u505C  [${pc4.green("r")}] \u6062\u590D  [${pc4.red("a")}] \u7EC8\u6B62  [${pc4.cyan("s")}] \u8F6C\u5411/\u63D2\u961F\u6307\u4EE4  [${pc4.white("q")}] \u9000\u51FA\u76D1\u63A7`
+  );
+}
+function drawProgressBar(percent, size) {
+  const filledSize = Math.round(percent / 100 * size);
+  const emptySize = size - filledSize;
+  return pc4.green("\u2588".repeat(filledSize)) + pc4.dim("\u2591".repeat(emptySize));
+}
+function getDuration(start, end) {
+  if (!start) return "-";
+  const startTime = new Date(start).getTime();
+  const endTime = end ? new Date(end).getTime() : Date.now();
+  const diffMs = endTime - startTime;
+  const secs = Math.floor(diffMs / 1e3) % 60;
+  const mins = Math.floor(diffMs / 6e4);
+  return `${mins}m ${secs}s`;
+}
+
+// src/program.ts
+function createDefaultCliDeps() {
+  const apiBase = resolveApiBase();
+  const sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+  return {
+    apiBase,
+    api: createApiClient(apiBase),
+    ensureCloudLogin: () => ensureCloudLogin2({ openBrowser, sleep }),
+    sleep,
+    openBrowser
+  };
+}
+function createCliProgram(deps = createDefaultCliDeps()) {
+  const { api, apiBase, ensureCloudLogin: ensureCloudLogin3, sleep, openBrowser: openBrowser2 } = deps;
+  const program2 = new Command();
+  program2.name("soloco").description("Soloco CLI \u2014 \u7528\u4E00\u53E5\u8BDD\u542F\u52A8 AI \u76EE\u6807\u5FAA\u73AF").version(resolveCliVersion());
+  program2.command("login").description("\u767B\u5F55 Soloco Cloud\uFF0C\u7528\u4E8E\u540E\u7EED\u672C\u5730\u8FD0\u884C\u65F6\u540C\u6B65").option(
+    "--server-url <url>",
+    "Soloco Cloud URL",
+    resolveDefaultCloudBaseUrl()
+  ).option("--name <name>", "\u5F53\u524D\u8BBE\u5907\u540D\u79F0", defaultInstallationName2()).action(async (opts) => {
+    try {
+      await runDeviceLogin2({
+        installationName: opts.name,
+        openBrowser: openBrowser2,
+        serverUrl: opts.serverUrl,
+        sleep
+      });
+      console.log(pc5.green("\u767B\u5F55\u6210\u529F\uFF0C\u5DF2\u4FDD\u5B58\u672C\u673A Soloco Cloud \u51ED\u8BC1"));
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u767B\u5F55\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("logout").description("\u5220\u9664\u672C\u673A Soloco Cloud \u767B\u5F55\u51ED\u8BC1").action(async () => {
+    await clearStoredAuth();
+    console.log(pc5.green("\u5DF2\u9000\u51FA Soloco Cloud \u767B\u5F55"));
+  });
+  program2.command("whoami").description("\u6821\u9A8C\u5F53\u524D Soloco Cloud \u767B\u5F55\u72B6\u6001").action(async () => {
+    try {
+      const auth = await loadStoredAuth();
+      if (!auth) {
+        console.error(pc5.yellow("\u5C1A\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8FD0\u884C soloco login"));
+        process.exit(1);
+      }
+      const client = createCloudAuthClient(auth.cloudBaseUrl);
+      const refreshed = await refreshStoredAccessToken(client, auth);
+      await saveStoredAuth(refreshed);
+      console.log(`Soloco Cloud: ${pc5.bold(refreshed.cloudBaseUrl)}`);
+      console.log(`User: ${refreshed.userId}`);
+      console.log(`Installation: ${refreshed.installationId}`);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u767B\u5F55\u6821\u9A8C\u5931\u8D25: ${message}`));
+      console.error(pc5.yellow("\u8BF7\u91CD\u65B0\u8FD0\u884C soloco login"));
+      process.exit(1);
+    }
+  });
+  program2.argument("[goal...]", "\u76EE\u6807\u63CF\u8FF0").action(async (goalParts, _opts, cmd) => {
+    const goal = joinGoalParts(goalParts);
+    if (!goal) {
+      cmd.help();
+      return;
+    }
+    console.log(pc5.bold(`\u542F\u52A8\u76EE\u6807: ${goal}`));
+    console.log();
+    let created;
+    try {
+      await ensureCloudLogin3();
+      created = await api("POST", "/api/goals", { description: goal });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u521B\u5EFA\u76EE\u6807\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+    const goalId = created.id;
+    console.log(`\u76EE\u6807\u5DF2\u521B\u5EFA (${pc5.dim(goalId)}), \u5F00\u59CB\u8F6E\u8BE2\u8FDB\u5EA6...`);
+    console.log(pc5.dim("\u6309 Ctrl+C \u9000\u51FA\u8F6E\u8BE2 (\u76EE\u6807\u7EE7\u7EED\u5728\u540E\u53F0\u8FD0\u884C)"));
+    console.log();
+    let lastCycle = -1;
+    while (true) {
+      try {
+        const status = await api("GET", `/api/goals/${goalId}`);
+        if (status.currentCycle !== lastCycle) {
+          lastCycle = status.currentCycle ?? 0;
+          const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+          const summary = status.lastCycleSummary || status.status || "-";
+          console.log(`${pc5.dim(ts)} [\u5FAA\u73AF ${lastCycle}] ${summary}`);
+        }
+        if (["completed", "aborted", "failed"].includes(status.status || "")) {
+          console.log();
+          console.log(pc5.bold("\u76EE\u6807\u7ED3\u675F"));
+          printGoal(status);
+          break;
+        }
+      } catch {
+      }
+      await sleep(3e3);
+    }
+  });
+  program2.command("status").description("\u67E5\u770B\u76EE\u6807\u72B6\u6001 (\u652F\u6301 --url \u89E3\u6790 Dashboard URL, --json \u673A\u5668\u53EF\u8BFB, --watch \u6301\u7EED\u8F6E\u8BE2)").argument("[goal-id-or-url]", "\u76EE\u6807 ID \u6216 Dashboard URL (\u4E0D\u4F20\u5219\u9ED8\u8BA4\u5F53\u524D\u6D3B\u8DC3\u76EE\u6807)").option("--url <url>", "Dashboard URL (\u540C\u4F4D\u7F6E\u53C2\u6570, \u4F18\u5148\u7EA7\u66F4\u9AD8)").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA (\u5355\u6B21\u6216 NDJSON \u6D41)").option("--deep", "\u4F7F\u7528 /snapshot \u805A\u5408\u7AEF\u70B9 (\u5305\u542B runs/pending/events \u7B49)").option("--watch", "\u6301\u7EED\u8F6E\u8BE2\u76F4\u5230\u7EC8\u6B62\u72B6\u6001").option("--interval <seconds>", "\u8F6E\u8BE2\u95F4\u9694\u79D2\u6570 (--watch \u6A21\u5F0F)", "5").action(async (goalIdOrUrl, opts) => {
+    try {
+      await ensureCloudLogin3();
+      let resolvedGoalId;
+      let resolvedApiBase = apiBase;
+      const rawUrl = opts.url ?? goalIdOrUrl;
+      if (rawUrl && (rawUrl.startsWith("http://") || rawUrl.startsWith("https://"))) {
+        try {
+          const parsed = new URL(rawUrl);
+          resolvedApiBase = `${parsed.protocol}//${parsed.host}`;
+          const idParam = parsed.searchParams.get("id");
+          if (idParam) {
+            resolvedGoalId = idParam;
+          } else {
+            const m = parsed.pathname.match(/\/goals?\/([a-f0-9-]{36})/i);
+            if (m) resolvedGoalId = m[1];
+          }
+        } catch {
+        }
+      } else if (rawUrl) {
+        resolvedGoalId = rawUrl;
+      }
+      const resolvedApi = resolvedApiBase !== apiBase ? createApiClient(resolvedApiBase) : api;
+      const fetchSnapshot = async () => {
+        if (!resolvedGoalId) {
+          const current = await resolvedApi("GET", "/api/goals/current");
+          const g = Array.isArray(current) ? current[0] : current;
+          resolvedGoalId = g?.id;
+        }
+        if (!resolvedGoalId) return null;
+        const endpoint = opts.deep ? `/api/goals/${resolvedGoalId}/snapshot` : `/api/goals/${resolvedGoalId}`;
+        return resolvedApi("GET", endpoint);
+      };
+      const printResult = (data) => {
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(data) + "\n");
+        } else {
+          const g = opts.deep ? data.goal ?? data : data;
+          printGoal(g);
+          if (opts.deep) {
+            const snap = data;
+            const pending = snap.pending;
+            const activeRuns = snap.activeRuns;
+            if (activeRuns?.length) {
+              console.log(pc5.dim(`
+\u6D3B\u8DC3 runs: ${activeRuns.length} \u4E2A`));
+            }
+            const pendingCount = (pending?.questions?.length ?? 0) + (pending?.assumptions?.length ?? 0) + (pending?.degradations?.length ?? 0) + (pending?.manualUnlocks?.length ?? 0);
+            if (pendingCount > 0) {
+              console.log(pc5.yellow(`\u5F85\u5904\u7406\u9879: ${pendingCount} \u4E2A`));
+            }
+          }
+        }
+      };
+      const terminalStatuses = /* @__PURE__ */ new Set(["completed", "aborted", "failed"]);
+      if (opts.watch) {
+        const intervalMs = Math.max(1, Number(opts.interval) || 5) * 1e3;
+        while (true) {
+          const data = await fetchSnapshot();
+          if (data) {
+            printResult(data);
+            const status = opts.deep ? data.goal?.status : data.status;
+            if (terminalStatuses.has(status)) break;
+          }
+          await sleep(intervalMs);
+        }
+      } else {
+        const data = await fetchSnapshot();
+        if (!data || Array.isArray(data) && data.length === 0) {
+          if (!opts.json) console.log("\u5F53\u524D\u6CA1\u6709\u6D3B\u8DC3\u76EE\u6807");
+          else process.stdout.write(JSON.stringify(null) + "\n");
+          return;
+        }
+        printResult(data);
+      }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u83B7\u53D6\u72B6\u6001\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("pause").description("\u6682\u505C\u5F53\u524D\u76EE\u6807\u5FAA\u73AF").action(async () => {
+    try {
+      await ensureCloudLogin3();
+      const current = await api("GET", "/api/goals/current");
+      const id = extractCurrentGoalId(current);
+      if (!id) {
+        console.log("\u6CA1\u6709\u53EF\u6682\u505C\u7684\u6D3B\u8DC3\u76EE\u6807");
+        return;
+      }
+      await api("POST", `/api/goals/${id}/pause`);
+      console.log(pc5.yellow("\u76EE\u6807\u5DF2\u6682\u505C"));
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u6682\u505C\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("resume").description("\u6062\u590D\u5DF2\u6682\u505C\u7684\u76EE\u6807\u5FAA\u73AF").action(async () => {
+    try {
+      await ensureCloudLogin3();
+      const current = await api("GET", "/api/goals/current");
+      const id = extractCurrentGoalId(current);
+      if (!id) {
+        console.log("\u6CA1\u6709\u53EF\u6062\u590D\u7684\u76EE\u6807");
+        return;
+      }
+      await api("POST", `/api/goals/${id}/resume`);
+      console.log(pc5.green("\u76EE\u6807\u5DF2\u6062\u590D"));
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u6062\u590D\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("abort").description("\u7EC8\u6B62\u5F53\u524D\u76EE\u6807").action(async () => {
+    try {
+      await ensureCloudLogin3();
+      const current = await api("GET", "/api/goals/current");
+      const id = extractCurrentGoalId(current);
+      if (!id) {
+        console.log("\u6CA1\u6709\u53EF\u7EC8\u6B62\u7684\u76EE\u6807");
+        return;
+      }
+      await api("POST", `/api/goals/${id}/abort`);
+      console.log(pc5.red("\u76EE\u6807\u5DF2\u7EC8\u6B62"));
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u7EC8\u6B62\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("log").description("\u67E5\u770B\u5FAA\u73AF\u5386\u53F2").option("-n, --limit <count>", "\u663E\u793A\u6761\u6570", "20").action(async (opts) => {
+    try {
+      await ensureCloudLogin3();
+      const current = await api("GET", "/api/goals/current");
+      const id = extractCurrentGoalId(current);
+      if (!id) {
+        console.log("\u6CA1\u6709\u6D3B\u8DC3\u76EE\u6807");
+        return;
+      }
+      const limit = parseLogLimit(opts.limit);
+      const cycles = await api("GET", `/api/goals/${id}/cycles?limit=${limit}`);
+      const list = Array.isArray(cycles) ? cycles : cycles?.cycles || [];
+      if (list.length === 0) {
+        console.log("\u6682\u65E0\u5FAA\u73AF\u8BB0\u5F55");
+        return;
+      }
+      for (const c of list) {
+        const ts = c.createdAt ? new Date(c.createdAt).toLocaleString() : "-";
+        console.log(
+          `${pc5.dim(ts)} [\u5FAA\u73AF ${c.cycle ?? c.number ?? "-"}] ${c.summary || c.status || "-"}`
+        );
+      }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u83B7\u53D6\u65E5\u5FD7\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("setup").description("\u9996\u6B21\u914D\u7F6E (API key + \u6A21\u578B)").action(async () => {
+    const rl = readline2.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const ask = (q) => new Promise((resolve2) => rl.question(q, resolve2));
+    console.log(pc5.bold("Soloco \u9996\u6B21\u914D\u7F6E"));
+    console.log();
+    const apiKey = await ask("\u8BF7\u8F93\u5165 QWEN_API_KEY: ");
+    const model = await ask("\u6A21\u578B\u540D\u79F0 (\u9ED8\u8BA4 qwen-plus): ") || "qwen-plus";
+    rl.close();
+    const envPath = path2.resolve(process.cwd(), ".env");
+    const lines = [];
+    if (fs.existsSync(envPath)) {
+      const existing = fs.readFileSync(envPath, "utf-8");
+      for (const line of existing.split("\n")) {
+        if (line.startsWith("QWEN_API_KEY=") || line.startsWith("SOLOCO_MODEL=")) {
+          continue;
+        }
+        lines.push(line);
+      }
+    }
+    lines.push(`QWEN_API_KEY=${apiKey}`);
+    lines.push(`SOLOCO_MODEL=${model}`);
+    fs.writeFileSync(envPath, lines.filter((l) => l.trim() !== "").join("\n") + "\n");
+    console.log(pc5.green(`\u5DF2\u5199\u5165 ${envPath}`));
+    console.log();
+    console.log("\u6D4B\u8BD5 API \u8FDE\u901A\u6027...");
+    try {
+      await fetch(`${apiBase}/api/health`, { signal: AbortSignal.timeout(5e3) });
+      console.log(pc5.green("\u670D\u52A1\u5668\u8FDE\u63A5\u6B63\u5E38"));
+    } catch {
+      console.log(pc5.yellow(`\u65E0\u6CD5\u8FDE\u63A5 ${apiBase} (\u670D\u52A1\u5668\u53EF\u80FD\u672A\u542F\u52A8\uFF0C\u7A0D\u540E\u518D\u8BD5)`));
+    }
+  });
+  program2.command("update").description("\u66F4\u65B0\u76EE\u6807\u7684\u63CF\u8FF0 (Description) \u548C\u6807\u9898 (Title) (Agent Native \u53CB\u597D)").option("-i, --id <goal-id>", "\u76EE\u6807 ID (\u4E0D\u4F20\u5219\u9ED8\u8BA4\u5F53\u524D\u6D3B\u8DC3\u76EE\u6807)").option("-t, --title <title>", "\u65B0\u7684\u76EE\u6807\u6807\u9898").requiredOption("-d, --description <description>", "\u65B0\u7684\u76EE\u6807\u63CF\u8FF0").action(async (opts) => {
+    try {
+      await ensureCloudLogin3();
+      let goalId = opts.id;
+      if (!goalId) {
+        const current = await api("GET", "/api/goals/current");
+        goalId = extractCurrentGoalId(current);
+        if (!goalId) {
+          console.error(pc5.red("\u9519\u8BEF: \u6CA1\u6709\u627E\u5230\u6D3B\u8DC3\u76EE\u6807\uFF0C\u8BF7\u663E\u5F0F\u63D0\u4F9B --id <goal-id>"));
+          process.exit(1);
+        }
+      }
+      const body = { description: opts.description };
+      if (opts.title) {
+        body.title = opts.title;
+      }
+      await api("PATCH", `/api/goals/${goalId}`, body);
+      console.log(pc5.green(`\u76EE\u6807 ${goalId} \u66F4\u65B0\u6210\u529F!`));
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u66F4\u65B0\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("steer").description("\u5411\u8FD0\u884C\u4E2D\u7684\u76EE\u6807\u53D1\u9001\u63D2\u961F/\u8F6C\u5411\u6307\u4EE4\u5E76\u9009\u62E9\u6027\u5F3A\u5236\u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1 (Agent Native \u53CB\u597D)").option("-i, --id <goal-id>", "\u76EE\u6807 ID (\u4E0D\u4F20\u5219\u9ED8\u8BA4\u5F53\u524D\u6D3B\u8DC3\u76EE\u6807)").requiredOption("-c, --content <content>", "\u63D2\u961F/\u8F6C\u5411\u7684\u5177\u4F53\u6307\u4EE4\u5185\u5BB9").option("-f, --force-kill", "\u662F\u5426\u7ACB\u5373\u5F3A\u5236\u7EC8\u6B62\u5F53\u524D\u6B63\u5728\u8FD0\u884C\u7684\u5B50\u4EFB\u52A1 (SIGTERM)").action(async (opts) => {
+    try {
+      await ensureCloudLogin3();
+      let goalId = opts.id;
+      if (!goalId) {
+        const current = await api("GET", "/api/goals/current");
+        goalId = extractCurrentGoalId(current);
+        if (!goalId) {
+          console.error(pc5.red("\u9519\u8BEF: \u6CA1\u6709\u627E\u5230\u6D3B\u8DC3\u76EE\u6807\uFF0C\u8BF7\u663E\u5F0F\u63D0\u4F9B --id <goal-id>"));
+          process.exit(1);
+        }
+      }
+      const body = { content: opts.content };
+      if (opts.forceKill) {
+        body.forceKill = true;
+      }
+      const res = await api(
+        "POST",
+        `/api/goals/${goalId}/steer`,
+        body
+      );
+      console.log(pc5.green(`\u63D2\u961F/\u8F6C\u5411\u6307\u4EE4\u53D1\u9001\u6210\u529F! Message ID: ${res.messageId}`));
+      if (opts.forceKill) {
+        console.log(pc5.yellow("\u5DF2\u89E6\u53D1\u5F3A\u5236\u7EC8\u6B62\u5F53\u524D\u5B50\u4EFB\u52A1\u3002"));
+      }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u53D1\u9001\u63D2\u961F\u6307\u4EE4\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("monitor").description("\u542F\u52A8\u5F00\u53D1\u8005 Dev Insider \u5B9E\u65F6\u76D1\u63A7\u63A7\u5236\u53F0 (\u652F\u6301 URL/ID \u8BC6\u522B\u4E0E\u952E\u76D8\u5FEB\u6377\u952E\u4EA4\u4E92)").argument("[goal-id-or-url]", "\u76EE\u6807 ID \u6216 Dashboard URL (\u4E0D\u4F20\u5219\u9ED8\u8BA4\u5F53\u524D\u6D3B\u8DC3\u76EE\u6807)").action(async (goalIdOrUrl) => {
+    try {
+      await ensureCloudLogin3();
+      let goalId = goalIdOrUrl;
+      if (!goalId) {
+        const current = await api("GET", "/api/goals/current");
+        goalId = extractCurrentGoalId(current);
+        if (!goalId) {
+          console.error(pc5.red("\u9519\u8BEF: \u6CA1\u6709\u627E\u5230\u6D3B\u8DC3\u76EE\u6807\uFF0C\u8BF7\u63D0\u4F9B\u76EE\u6807 ID \u6216 URL"));
+          process.exit(1);
+        }
+      } else if (goalId.startsWith("http://") || goalId.startsWith("https://")) {
+        try {
+          const url = new URL(goalId);
+          const idParam = url.searchParams.get("id");
+          if (idParam) {
+            goalId = idParam;
+          } else {
+            const match = url.pathname.match(/\/goals?\/([a-f0-9-]{36})/i);
+            if (match) {
+              goalId = match[1];
+            }
+          }
+        } catch {
+        }
+      }
+      await monitorGoal(goalId, api, apiBase, sleep);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`\u76D1\u63A7\u542F\u52A8\u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("tail").description("\u5B9E\u65F6\u6D41\u5F0F\u8F93\u51FA\u76EE\u6807 subprocess run \u7684 stdout/stderr (NDJSON \u5230 stdout)").argument("[goal-id-or-url]", "\u76EE\u6807 ID \u6216 Dashboard URL (\u4E0D\u4F20\u5219\u9ED8\u8BA4\u5F53\u524D\u6D3B\u8DC3\u76EE\u6807)").option("--url <url>", "Dashboard URL (\u540C\u4F4D\u7F6E\u53C2\u6570)").action(async (goalIdOrUrl, opts) => {
+    try {
+      await ensureCloudLogin3();
+      let resolvedGoalId;
+      let resolvedApiBase = apiBase;
+      const rawUrl = opts.url ?? goalIdOrUrl;
+      if (rawUrl && (rawUrl.startsWith("http://") || rawUrl.startsWith("https://"))) {
+        try {
+          const parsed = new URL(rawUrl);
+          resolvedApiBase = `${parsed.protocol}//${parsed.host}`;
+          const idParam = parsed.searchParams.get("id");
+          if (idParam) {
+            resolvedGoalId = idParam;
+          } else {
+            const m = parsed.pathname.match(/\/goals?\/([a-f0-9-]{36})/i);
+            if (m) resolvedGoalId = m[1];
+          }
+        } catch {
+        }
+      } else if (rawUrl) {
+        resolvedGoalId = rawUrl;
+      }
+      const resolvedApi = resolvedApiBase !== apiBase ? createApiClient(resolvedApiBase) : api;
+      if (!resolvedGoalId) {
+        const current = await resolvedApi("GET", "/api/goals/current");
+        const g = Array.isArray(current) ? current[0] : current;
+        resolvedGoalId = g?.id;
+      }
+      if (!resolvedGoalId) {
+        console.error(pc5.red("\u9519\u8BEF: \u6CA1\u6709\u627E\u5230\u6D3B\u8DC3\u76EE\u6807\uFF0C\u8BF7\u63D0\u4F9B\u76EE\u6807 ID \u6216 URL"));
+        process.exit(1);
+      }
+      const runsData = await resolvedApi(
+        "GET",
+        `/api/goals/${resolvedGoalId}/runs`
+      );
+      const runs = runsData?.runs ?? [];
+      const active = runs.find((r) => r.status === "running" || r.status === "spawning");
+      const target = active ?? runs[0];
+      if (!target) {
+        console.error(pc5.yellow("\u6CA1\u6709\u627E\u5230 subprocess run"));
+        process.exit(1);
+      }
+      const runId = target.id;
+      const wsBase = resolvedApiBase.replace(/^http/, "ws");
+      const wsUrl = `${wsBase}/api/goals/${resolvedGoalId}/runs/${runId}/logs/ws`;
+      process.stderr.write(pc5.dim(`\u8FDE\u63A5 ${wsUrl}
+`));
+      const ws = new WebSocket(wsUrl);
+      ws.onmessage = (event) => {
+        process.stdout.write(String(event.data));
+        if (!String(event.data).endsWith("\n")) process.stdout.write("\n");
+      };
+      ws.onerror = (err) => {
+        process.stderr.write(pc5.red(`WS \u9519\u8BEF: ${err.message ?? err}
+`));
+      };
+      ws.onclose = () => {
+        process.stderr.write(pc5.dim("\u8FDE\u63A5\u5DF2\u5173\u95ED\n"));
+        process.exit(0);
+      };
+      await new Promise((resolve2) => {
+        ws.onclose = () => resolve2();
+      });
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      console.error(pc5.red(`tail \u5931\u8D25: ${message}`));
+      process.exit(1);
+    }
+  });
+  program2.command("usage").description("\u67E5\u770B AI \u7528\u91CF\u62A5\u544A (\u6309\u65E5/\u5468/\u6708, \u652F\u6301\u6309 model/agent/goal \u5206\u7EC4)").argument("[period]", "\u7EDF\u8BA1\u7C92\u5EA6: daily | weekly | monthly (\u9ED8\u8BA4 daily)", "daily").option("--since <date>", "\u5F00\u59CB\u65E5\u671F (YYYY-MM-DD)").option("--until <date>", "\u7ED3\u675F\u65E5\u671F (YYYY-MM-DD)").option("--by-model", "\u6309\u6A21\u578B\u7EC6\u5206").option("--by-agent", "\u6309 agent \u7EC6\u5206").option("--by-goal", "\u6309\u76EE\u6807\u7EC6\u5206").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action(async (period, opts) => {
+    if (!["daily", "weekly", "monthly"].includes(period)) {
+      console.error(pc5.red(`\u9519\u8BEF: \u7C92\u5EA6\u5FC5\u987B\u662F daily\u3001weekly \u6216 monthly\uFF0C\u6536\u5230: ${period}`));
+      process.exit(1);
+    }
+    let companyId;
+    try {
+      await ensureCloudLogin3();
+      const companies = await api("GET", "/api/companies");
+      const first = Array.isArray(companies) ? companies[0] : null;
+      if (!first?.id) throw new Error("No company found");
+      companyId = first.id;
+    } catch (e) {
+      console.error(pc5.red(`\u83B7\u53D6\u516C\u53F8\u4FE1\u606F\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`));
+      process.exit(1);
+    }
+    const breakdown = opts.byModel ? "model" : opts.byAgent ? "agent" : opts.byGoal ? "goal" : void 0;
+    const qs = new URLSearchParams({ granularity: period });
+    if (opts.since) qs.set("from", opts.since);
+    if (opts.until) qs.set("to", opts.until);
+    if (breakdown) qs.set("breakdown", breakdown);
+    let rows;
+    try {
+      rows = await api(`GET`, `/api/companies/${companyId}/costs/by-period?${qs}`);
+    } catch (e) {
+      console.error(pc5.red(`\u83B7\u53D6\u7528\u91CF\u6570\u636E\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`));
+      process.exit(1);
+    }
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(rows, null, 2) + "\n");
+      return;
+    }
+    if (!rows.length) {
+      console.log(pc5.dim("\u6CA1\u6709\u627E\u5230\u7528\u91CF\u6570\u636E"));
+      return;
+    }
+    const granularityLabel = {
+      daily: "\u65E5\u62A5",
+      weekly: "\u5468\u62A5",
+      monthly: "\u6708\u62A5"
+    };
+    console.log();
+    console.log(pc5.bold(`  Soloco AI \u7528\u91CF\u62A5\u544A \u2014 ${granularityLabel[period] ?? period}`));
+    console.log();
+    const fmtCents = (c) => `$${(c / 100).toFixed(2)}`;
+    const fmtTokens = (t) => t >= 1e6 ? `${(t / 1e6).toFixed(1)}M` : t >= 1e3 ? `${(t / 1e3).toFixed(0)}K` : String(t);
+    const COL = { period: 12, input: 9, output: 9, cost: 9 };
+    const header = [
+      "Period".padEnd(COL.period),
+      "Input".padStart(COL.input),
+      "Output".padStart(COL.output),
+      "Cost".padStart(COL.cost)
+    ].join("  ");
+    const divider = "\u2500".repeat(header.length);
+    console.log(pc5.dim(divider));
+    console.log(pc5.bold(header));
+    console.log(pc5.dim(divider));
+    let totalCostCents = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    for (const row of rows) {
+      totalCostCents += row.totalCostCents;
+      totalInput += row.inputTokens;
+      totalOutput += row.outputTokens;
+      const line = [
+        row.period.padEnd(COL.period),
+        fmtTokens(row.inputTokens).padStart(COL.input),
+        fmtTokens(row.outputTokens).padStart(COL.output),
+        pc5.green(fmtCents(row.totalCostCents)).padStart(COL.cost)
+      ].join("  ");
+      console.log(line);
+      if (row.breakdown?.length) {
+        for (const b of row.breakdown.sort((a, z) => z.costCents - a.costCents)) {
+          const label = `  ${pc5.dim("\u2514")} ${b.key.length > 30 ? b.key.slice(0, 27) + "..." : b.key}`;
+          const bLine = [
+            label.padEnd(COL.period + 14),
+            // account for color escapes
+            fmtTokens(b.inputTokens).padStart(COL.input),
+            fmtTokens(b.outputTokens).padStart(COL.output),
+            pc5.dim(fmtCents(b.costCents)).padStart(COL.cost)
+          ].join("  ");
+          console.log(bLine);
+        }
+      }
+    }
+    console.log(pc5.dim(divider));
+    const totLine = [
+      pc5.bold("Total").padEnd(COL.period),
+      pc5.bold(fmtTokens(totalInput)).padStart(COL.input),
+      pc5.bold(fmtTokens(totalOutput)).padStart(COL.output),
+      pc5.bold(pc5.green(fmtCents(totalCostCents))).padStart(COL.cost)
+    ].join("  ");
+    console.log(totLine);
+    console.log(pc5.dim(divider));
+    console.log();
+  });
+  program2.command("worktree:make <name>").description("\u65B0\u5EFA\u9694\u79BB worktree\uFF08git worktree add + \u72EC\u7ACB\u5B9E\u4F8B\u76EE\u5F55 + \u7A7A\u95F2\u7AEF\u53E3 + \u6700\u5C0F seed\uFF09").action(async (name) => {
+    const slug = slugifyInstanceId(name);
+    if (!slug) {
+      console.error(pc5.red("\u274C name \u53EA\u80FD\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u8FDE\u5B57\u7B26\u3001\u4E0B\u5212\u7EBF"));
+      process.exit(1);
+    }
+    if (slug === "default") {
+      console.error(pc5.red("\u274C 'default' \u662F\u4E3B\u5B9E\u4F8B\u4FDD\u7559\u540D\uFF0C\u8BF7\u6362\u4E00\u4E2A\u540D\u5B57"));
+      process.exit(1);
+    }
+    const cwd = process.cwd();
+    let gitStat = null;
+    try {
+      gitStat = fs.statSync(path2.join(cwd, ".git"));
+    } catch {
+    }
+    if (!gitStat || !gitStat.isDirectory()) {
+      console.error(pc5.red("\u274C \u8BF7\u5728\u4E3B\u4ED3\u5E93\u6839\u76EE\u5F55\uFF08.git \u662F\u76EE\u5F55\uFF09\u6267\u884C worktree:make"));
+      console.error(pc5.dim("  \u5F53\u524D\u76EE\u5F55\uFF1A" + cwd));
+      process.exit(1);
+    }
+    const worktreePath = path2.resolve(cwd, "..", `soloco-${slug}`);
+    if (fs.existsSync(worktreePath)) {
+      console.error(pc5.red(`\u274C \u76EE\u6807\u76EE\u5F55\u5DF2\u5B58\u5728\uFF1A${worktreePath}`));
+      process.exit(1);
+    }
+    let serverPort;
+    let pgPort;
+    try {
+      serverPort = await findFreePort(3101);
+      pgPort = await findFreePort(54331);
+    } catch (e) {
+      console.error(pc5.red("\u274C \u627E\u4E0D\u5230\u7A7A\u95F2\u7AEF\u53E3\uFF1A" + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+    const { execSync } = await import("node:child_process");
+    console.log(pc5.dim(`\u6B63\u5728\u521B\u5EFA worktree\uFF1A${worktreePath}`));
+    try {
+      try {
+        execSync(`git worktree add "${worktreePath}" -b "${slug}"`, { cwd, stdio: "pipe" });
+      } catch {
+        execSync(`git worktree add "${worktreePath}" "${slug}"`, { cwd, stdio: "pipe" });
+      }
+    } catch (e) {
+      console.error(pc5.red("\u274C git worktree add \u5931\u8D25\uFF1A" + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+    try {
+      writeWorktreeIsolation(worktreePath, slug, serverPort, pgPort);
+    } catch (e) {
+      console.error(pc5.red("\u274C \u5199\u5165 .soloco \u914D\u7F6E\u5931\u8D25\uFF1A" + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+    console.log(pc5.green("\u2713 worktree \u5DF2\u521B\u5EFA\u5E76\u5B8C\u6210\u9694\u79BB\u521D\u59CB\u5316"));
+    console.log("");
+    console.log(pc5.bold("  \u8DEF\u5F84\uFF1A") + worktreePath);
+    console.log(pc5.bold("  \u5B9E\u4F8B\uFF1A") + pc5.cyan(slug));
+    console.log(pc5.bold("  \u7AEF\u53E3\uFF1A") + serverPort + pc5.dim("  (PG: " + pgPort + ")"));
+    console.log("");
+    console.log("  \u4E0B\u4E00\u6B65\uFF1A");
+    console.log(pc5.dim(`    cd ${worktreePath}`));
+    console.log(pc5.dim("    pnpm dev"));
+  });
+  program2.command("worktree init").description("\u5728\u5F53\u524D worktree \u76EE\u5F55\u521D\u59CB\u5316\u9694\u79BB\u5B9E\u4F8B\uFF08.soloco/.env + \u72EC\u7ACB\u6570\u636E\u76EE\u5F55\uFF09").action(async () => {
+    const cwd = process.cwd();
+    if (fs.existsSync(path2.join(cwd, ".soloco", ".env"))) {
+      console.log(pc5.yellow("\u2139 \u5F53\u524D\u76EE\u5F55\u5DF2\u521D\u59CB\u5316\uFF08.soloco/.env \u5B58\u5728\uFF09"));
+      console.log(pc5.dim("  SOLOCO_INSTANCE_ID: " + (readEnvKey(path2.join(cwd, ".soloco", ".env"), "SOLOCO_INSTANCE_ID") ?? "(\u672A\u77E5)")));
+      return;
+    }
+    const dirName = path2.basename(cwd);
+    const instanceId = slugifyInstanceId(dirName);
+    if (!instanceId) {
+      console.error(pc5.red("\u274C \u65E0\u6CD5\u4ECE\u76EE\u5F55\u540D '" + dirName + "' \u63A8\u5BFC\u5408\u6CD5\u7684\u5B9E\u4F8B ID\uFF08\u4EC5\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u8FDE\u5B57\u7B26\u3001\u4E0B\u5212\u7EBF\uFF09"));
+      console.error(pc5.dim("  \u8BF7\u624B\u52A8\u4F20\u5165 SOLOCO_INSTANCE_ID \u6216\u91CD\u547D\u540D\u76EE\u5F55\u540E\u91CD\u8BD5"));
+      process.exit(1);
+    }
+    if (instanceId === "default") {
+      console.error(pc5.red("\u274C \u76EE\u5F55\u540D\u6620\u5C04\u5230 'default'\uFF0C\u4E0E\u4E3B\u5B9E\u4F8B\u51B2\u7A81\uFF0C\u8BF7\u91CD\u547D\u540D\u76EE\u5F55\u540E\u91CD\u8BD5"));
+      process.exit(1);
+    }
+    let serverPort;
+    let pgPort;
+    try {
+      serverPort = await findFreePort(3101);
+      pgPort = await findFreePort(54331);
+    } catch (e) {
+      console.error(pc5.red("\u274C \u627E\u4E0D\u5230\u7A7A\u95F2\u7AEF\u53E3\uFF1A" + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+    try {
+      writeWorktreeIsolation(cwd, instanceId, serverPort, pgPort);
+    } catch (e) {
+      console.error(pc5.red("\u274C \u5199\u5165 .soloco \u914D\u7F6E\u5931\u8D25\uFF1A" + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+    console.log(pc5.green("\u2713 \u9694\u79BB\u521D\u59CB\u5316\u5B8C\u6210"));
+    console.log("");
+    console.log(pc5.bold("  \u5B9E\u4F8B\uFF1A") + pc5.cyan(instanceId));
+    console.log(pc5.bold("  \u7AEF\u53E3\uFF1A") + serverPort + pc5.dim("  (PG: " + pgPort + ")"));
+    console.log(pc5.bold("  \u6570\u636E\uFF1A") + path2.join(os2.homedir(), ".soloco", "instances", instanceId));
+    console.log("");
+    console.log("  \u73B0\u5728\u53EF\u4EE5\u8FD0\u884C\uFF1A");
+    console.log(pc5.dim("    pnpm dev"));
+  });
+  program2.command("usage:backfill").description("\u8865\u586B\u5386\u53F2 subprocess_runs \u7684 cost \u6570\u636E\uFF08\u626B\u63CF\u65E5\u5FD7\u6587\u4EF6\u56DE\u586B costUsdCents\uFF09").action(async () => {
+    let companyId;
+    try {
+      await ensureCloudLogin3();
+      const companies = await api("GET", "/api/companies");
+      const first = Array.isArray(companies) ? companies[0] : null;
+      if (!first?.id) throw new Error("No company found");
+      companyId = first.id;
+    } catch (e) {
+      console.error(pc5.red("\u83B7\u53D6\u516C\u53F8\u4FE1\u606F\u5931\u8D25: " + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+    console.log(pc5.dim("\u6B63\u5728\u56DE\u586B\u5386\u53F2\u6210\u672C\u6570\u636E..."));
+    try {
+      const result = await api(
+        "POST",
+        "/api/companies/" + companyId + "/costs/backfill"
+      );
+      console.log(pc5.green("\u56DE\u586B\u5B8C\u6210:") + " \u66F4\u65B0 " + pc5.bold(String(result.updated)) + " \u6761\uFF0C\u8DF3\u8FC7 " + pc5.dim(String(result.skipped)) + " \u6761\uFF08\u5171 " + result.total + " \u6761\uFF09");
+    } catch (e) {
+      console.error(pc5.red("\u56DE\u586B\u5931\u8D25: " + (e instanceof Error ? e.message : String(e))));
+      process.exit(1);
+    }
+  });
+  return program2;
+}
+function resolveCliVersion() {
+  if ("0.3.1-canary.0") return "0.3.1-canary.0";
+  try {
+    const pkgPath = fileURLToPath(new URL("../package.json", import.meta.url));
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function defaultInstallationName2() {
+  return `Soloco CLI (${os2.hostname()})`;
+}
+function slugifyInstanceId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isPortFree(port) {
+  return new Promise((resolve2) => {
+    const srv = net.createServer();
+    let done = false;
+    srv.once("error", () => {
+      if (!done) {
+        done = true;
+        resolve2(false);
+      }
+    });
+    srv.once("listening", () => {
+      if (!done) {
+        done = true;
+        srv.close(() => resolve2(true));
+      }
+    });
+    srv.listen(port, "127.0.0.1");
+  });
+}
+async function findFreePort(start) {
+  for (let p = start; p < start + 200; p++) {
+    if (await isPortFree(p)) return p;
+  }
+  throw new Error(`${start}\u2013${start + 199} \u8303\u56F4\u5185\u6CA1\u6709\u7A7A\u95F2\u7AEF\u53E3`);
+}
+function writeWorktreeIsolation(worktreeRoot, instanceId, serverPort, pgPort) {
+  const solocoDir = path2.join(worktreeRoot, ".soloco");
+  fs.mkdirSync(solocoDir, { recursive: true });
+  const envContent = [
+    `SOLOCO_INSTANCE_ID=${instanceId}`,
+    `PORT=${serverPort}`
+  ].join("\n") + "\n";
+  fs.writeFileSync(path2.join(solocoDir, ".env"), envContent, "utf-8");
+  const instanceBase = `~/.soloco/instances/${instanceId}`;
+  const config = {
+    $meta: { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), source: "onboard" },
+    database: {
+      embeddedPostgresDataDir: `${instanceBase}/db`,
+      embeddedPostgresPort: pgPort,
+      backup: { dir: `${instanceBase}/data/backups` }
+    },
+    logging: {
+      mode: "file",
+      logDir: `${instanceBase}/logs`
+    },
+    storage: {
+      localDisk: { baseDir: `${instanceBase}/data/storage` }
+    },
+    secrets: {
+      localEncrypted: { keyFilePath: `${instanceBase}/secrets/master.key` }
+    }
+  };
+  fs.writeFileSync(path2.join(solocoDir, "config.json"), JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs.mkdirSync(path2.join(os2.homedir(), ".soloco", "instances", instanceId), { recursive: true });
+}
+function readEnvKey(envPath, key) {
+  try {
+    const content = fs.readFileSync(envPath, "utf-8");
+    const m = new RegExp(`^${key}=(.*)$`, "m").exec(content);
+    return m ? m[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
+var program = createCliProgram();
+program.parseAsync().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map