chatccc 0.2.252 → 0.2.254

package/dist/src/chatgpt-subscription.js

@@ -0,0 +1,199 @@
+import WebSocket from "ws";
+import { config } from "./config.js";
+import { probeChromeCdp } from "./chrome-devtools-guard.js";
+const CDP_HOST = "127.0.0.1";
+const DEFAULT_CDP_PORT = 15166;
+const CDP_TIMEOUT_MS = 10_000;
+const CHATGPT_URL = "https://chatgpt.com/";
+function normalizePort(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : DEFAULT_CDP_PORT;
+}
+function cdpBaseUrl(port) {
+    return `http://${CDP_HOST}:${port}`;
+}
+function maskEmail(value) {
+    if (typeof value !== "string" || !value.includes("@"))
+        return undefined;
+    const [name, domain] = value.split("@");
+    if (!name || !domain)
+        return undefined;
+    return `${name.slice(0, 2)}***@${domain}`;
+}
+function calculateRemainingDays(expiresAt, now) {
+    if (!expiresAt)
+        return null;
+    const expires = new Date(expiresAt).getTime();
+    if (!Number.isFinite(expires))
+        return null;
+    return Math.max(0, Math.ceil((expires - now.getTime()) / 86_400_000));
+}
+async function fetchJson(url, fetchImpl, init) {
+    const response = await fetchImpl(url, init);
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+}
+async function listCdpPages(port, fetchImpl) {
+    const pages = await fetchJson(`${cdpBaseUrl(port)}/json/list`, fetchImpl);
+    return Array.isArray(pages)
+        ? pages.flatMap((raw) => {
+            if (!raw || typeof raw !== "object")
+                return [];
+            const page = raw;
+            if (typeof page.id !== "string" || typeof page.type !== "string" || typeof page.url !== "string")
+                return [];
+            return [{
+                    id: page.id,
+                    type: page.type,
+                    title: typeof page.title === "string" ? page.title : undefined,
+                    url: page.url,
+                    webSocketDebuggerUrl: typeof page.webSocketDebuggerUrl === "string" ? page.webSocketDebuggerUrl : undefined,
+                }];
+        })
+        : [];
+}
+async function createChatGptPage(port, fetchImpl) {
+    const url = `${cdpBaseUrl(port)}/json/new?${encodeURIComponent(CHATGPT_URL)}`;
+    const response = await fetchImpl(url, { method: "PUT" });
+    if (!response.ok)
+        return null;
+    const page = await response.json();
+    if (typeof page.id !== "string" || typeof page.webSocketDebuggerUrl !== "string")
+        return null;
+    return {
+        id: page.id,
+        type: typeof page.type === "string" ? page.type : "page",
+        title: typeof page.title === "string" ? page.title : undefined,
+        url: typeof page.url === "string" ? page.url : CHATGPT_URL,
+        webSocketDebuggerUrl: page.webSocketDebuggerUrl,
+    };
+}
+async function closeCdpPage(port, pageId, fetchImpl) {
+    try {
+        await fetchImpl(`${cdpBaseUrl(port)}/json/close/${encodeURIComponent(pageId)}`);
+    }
+    catch {
+        // Closing a temporary tab is best effort and must not change the query result.
+    }
+}
+function subscriptionProbeExpression() {
+    return `(async()=>{try{const sResp=await fetch('/api/auth/session',{credentials:'include',headers:{Accept:'application/json'}});const sText=await sResp.text();let s=null;try{s=JSON.parse(sText)}catch{}const token=s&&typeof s.accessToken==='string'?s.accessToken:'';const email=s&&s.user&&typeof s.user.email==='string'?s.user.email:'';let account=null;if(token){const r=await fetch('/backend-api/accounts/check/v4-2023-04-27?timezone_offset_min=-480',{credentials:'include',headers:{Accept:'application/json',Authorization:'Bearer '+token}});const text=await r.text();let data=null;try{data=JSON.parse(text)}catch{}const accounts=data&&data.accounts&&typeof data.accounts==='object'?data.accounts:null;const keys=accounts?Object.keys(accounts):[];const acc=accounts&&(accounts.default||accounts[keys[0]]);const ent=acc&&acc.entitlement;const last=acc&&acc.last_active_subscription;account={status:r.status,ok:r.ok,entitlement:ent?{has_active_subscription:ent.has_active_subscription,subscription_plan:ent.subscription_plan,expires_at:ent.expires_at}:null,last_active_subscription:last?{will_renew:last.will_renew,purchase_origin_platform:last.purchase_origin_platform}:null,detail:data&&data.detail?data.detail:undefined,bodyPrefix:data?undefined:text.slice(0,120)};}return {sessionStatus:sResp.status,sessionOk:sResp.ok,hasAccessToken:!!token,maskedEmail:(${maskEmail.toString()})(email),sessionExpires:s&&s.expires,account};}catch(e){return {error:String(e&&e.message||e)}}})()`;
+}
+async function evaluateInPage(webSocketDebuggerUrl, expression) {
+    return await new Promise((resolve, reject) => {
+        const ws = new WebSocket(webSocketDebuggerUrl);
+        const id = 1;
+        const timer = setTimeout(() => {
+            ws.close();
+            reject(new Error("CDP Runtime.evaluate timed out"));
+        }, CDP_TIMEOUT_MS);
+        ws.on("open", () => {
+            ws.send(JSON.stringify({
+                id,
+                method: "Runtime.evaluate",
+                params: { expression, awaitPromise: true, returnByValue: true },
+            }));
+        });
+        ws.on("message", (data) => {
+            const msg = JSON.parse(String(data));
+            if (msg.id !== id)
+                return;
+            clearTimeout(timer);
+            ws.close();
+            if (msg.error) {
+                reject(new Error(JSON.stringify(msg.error)));
+            }
+            else {
+                resolve(msg.result?.result?.value);
+            }
+        });
+        ws.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+function failure(code, reason, chromeCdp, extra = {}) {
+    return { ok: false, code, reason, chromeCdp, ...extra };
+}
+export function isExpectedSubscriptionFailure(code) {
+    return code !== "chatgpt_subscription_failed";
+}
+export async function getChatGptSubscriptionStatus(deps = {}) {
+    const cfg = config.chromeDevtools;
+    const port = normalizePort(cfg.port);
+    const baseChromeCdp = { enabled: cfg.enabled, port };
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    if (!cfg.enabled) {
+        return failure("chrome_cdp_disabled", "Chrome CDP guard is disabled in ChatCCC config.", {
+            ...baseChromeCdp,
+            status: "skipped",
+        });
+    }
+    const probe = await (deps.probeChromeCdpImpl ?? probeChromeCdp)(port, { fetchImpl });
+    const chromeCdp = { ...baseChromeCdp, status: probe };
+    if (probe === "unreachable") {
+        return failure("chrome_cdp_unreachable", `Chrome CDP endpoint is unreachable on port ${port}.`, chromeCdp);
+    }
+    if (probe === "occupied") {
+        return failure("chrome_cdp_occupied", `Port ${port} is reachable but is not a healthy Chrome CDP endpoint.`, chromeCdp);
+    }
+    let temporaryPage = null;
+    try {
+        const existingPages = await listCdpPages(port, fetchImpl);
+        let page = existingPages.find((p) => p.type === "page" &&
+            p.webSocketDebuggerUrl &&
+            p.url.startsWith(CHATGPT_URL)) ?? null;
+        if (!page) {
+            temporaryPage = await createChatGptPage(port, fetchImpl);
+            page = temporaryPage;
+        }
+        if (!page?.webSocketDebuggerUrl) {
+            return failure("chatgpt_page_missing", "No usable chatgpt.com page is available from Chrome CDP.", chromeCdp);
+        }
+        const raw = await (deps.evaluateInPage ?? evaluateInPage)(page.webSocketDebuggerUrl, subscriptionProbeExpression());
+        if (!raw || typeof raw !== "object") {
+            return failure("chatgpt_subscription_failed", "Chrome CDP returned an empty subscription probe result.", chromeCdp);
+        }
+        if (raw.error) {
+            return failure("chatgpt_subscription_failed", raw.error, chromeCdp);
+        }
+        const chatgpt = {
+            sessionOk: raw.sessionOk === true,
+            maskedEmail: raw.maskedEmail || undefined,
+            sessionExpiresAt: typeof raw.sessionExpires === "string" ? raw.sessionExpires : undefined,
+        };
+        if (!raw.hasAccessToken) {
+            return failure("chatgpt_session_missing", "ChatGPT browser session has no access token.", chromeCdp, { chatgpt });
+        }
+        if (!raw.account?.ok || !raw.account.entitlement) {
+            return failure("chatgpt_subscription_failed", `ChatGPT account check failed${raw.account?.status ? ` with HTTP ${raw.account.status}` : ""}.`, chromeCdp, { chatgpt });
+        }
+        const entitlement = raw.account.entitlement;
+        const last = raw.account.last_active_subscription;
+        const expiresAt = typeof entitlement.expires_at === "string" ? entitlement.expires_at : null;
+        return {
+            ok: true,
+            code: "ok",
+            chromeCdp,
+            chatgpt,
+            subscription: {
+                active: entitlement.has_active_subscription === true,
+                plan: typeof entitlement.subscription_plan === "string" ? entitlement.subscription_plan : null,
+                expiresAt,
+                willRenew: typeof last?.will_renew === "boolean" ? last.will_renew : null,
+                purchaseOriginPlatform: typeof last?.purchase_origin_platform === "string" ? last.purchase_origin_platform : null,
+                remainingDays: calculateRemainingDays(expiresAt, deps.now?.() ?? new Date()),
+            },
+        };
+    }
+    catch (err) {
+        return failure("chatgpt_subscription_failed", err.message, chromeCdp);
+    }
+    finally {
+        if (temporaryPage) {
+            await closeCdpPage(port, temporaryPage.id, fetchImpl);
+        }
+    }
+}

package/dist/src/chrome-devtools-guard.js

@@ -0,0 +1,238 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { appendStartupTrace } from "./shared.js";
+import { config, ts, USER_DATA_DIR } from "./config.js";
+const CDP_HOST = "127.0.0.1";
+const DEFAULT_CDP_PORT = 15166;
+const HEALTH_TIMEOUT_MS = 3000;
+const START_VERIFY_ATTEMPTS = 10;
+const START_VERIFY_DELAY_MS = 500;
+const GUARD_INTERVAL_MS = 60_000;
+let guardTimer = null;
+let ensureInFlight = null;
+function normalizePort(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : DEFAULT_CDP_PORT;
+}
+function chromeCandidates(platform, env) {
+    if (platform === "win32") {
+        return [
+            env.ProgramFiles ? join(env.ProgramFiles, "Google", "Chrome", "Application", "chrome.exe") : "",
+            env["ProgramFiles(x86)"] ? join(env["ProgramFiles(x86)"], "Google", "Chrome", "Application", "chrome.exe") : "",
+            env.LOCALAPPDATA ? join(env.LOCALAPPDATA, "Google", "Chrome", "Application", "chrome.exe") : "",
+        ].filter(Boolean);
+    }
+    if (platform === "darwin") {
+        return ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"];
+    }
+    return [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+    ];
+}
+export function resolveChromeExecutable(chromePath, deps = {}) {
+    const exists = deps.existsSyncImpl ?? existsSync;
+    const explicit = chromePath?.trim();
+    if (explicit)
+        return exists(explicit) ? explicit : null;
+    for (const candidate of chromeCandidates(deps.platform ?? process.platform, deps.env ?? process.env)) {
+        if (exists(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function resolveChromeUserDataDir(port, env = process.env) {
+    const root = env.LOCALAPPDATA ? join(env.LOCALAPPDATA, "chatccc") : join(USER_DATA_DIR, "chrome-cdp");
+    return join(root, `chrome-cdp-${port}`);
+}
+async function fetchWithTimeout(url, fetchImpl, timeoutMs, init = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchImpl(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function probeChromeCdp(port, deps = {}) {
+    const normalizedPort = normalizePort(port);
+    try {
+        const response = await fetchWithTimeout(`http://${CDP_HOST}:${normalizedPort}/json/version`, deps.fetchImpl ?? fetch, HEALTH_TIMEOUT_MS);
+        if (!response.ok)
+            return "occupied";
+        const data = await response.json();
+        return typeof data.Browser === "string" || typeof data.webSocketDebuggerUrl === "string"
+            ? "healthy"
+            : "occupied";
+    }
+    catch {
+        return "unreachable";
+    }
+}
+export async function isChromeCdpHealthy(port, deps = {}) {
+    return (await probeChromeCdp(port, deps)) === "healthy";
+}
+function startChromeForCdp(cfg, deps = {}) {
+    const port = normalizePort(cfg.port);
+    const chromeExe = resolveChromeExecutable(cfg.chromePath, deps);
+    if (!chromeExe) {
+        return { ok: false, error: "Cannot find chrome executable. Configure chromeDevtools.chromePath." };
+    }
+    const userDataDir = resolveChromeUserDataDir(port, deps.env ?? process.env);
+    try {
+        (deps.mkdirSyncImpl ?? mkdirSync)(userDataDir, { recursive: true });
+    }
+    catch (err) {
+        return { ok: false, error: `Cannot create Chrome user data dir: ${err.message}` };
+    }
+    const args = [
+        `--remote-debugging-address=${CDP_HOST}`,
+        `--remote-debugging-port=${port}`,
+        `--user-data-dir=${userDataDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--new-window",
+        "about:blank",
+    ];
+    try {
+        const child = (deps.spawnImpl ?? spawn)(chromeExe, args, {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        child.unref();
+        return { ok: true, child };
+    }
+    catch (err) {
+        return { ok: false, error: `Failed to start Chrome: ${err.message}` };
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function cdpBaseUrl(port) {
+    return `http://${CDP_HOST}:${port}`;
+}
+function isChatcccPageUrl(value, chatcccPort) {
+    if (!value)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" &&
+            (url.hostname === "localhost" || url.hostname === CDP_HOST) &&
+            url.port === String(chatcccPort);
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureChatcccPageOpen(cdpPort, chatcccPort, deps = {}) {
+    const normalizedCdpPort = normalizePort(cdpPort);
+    const normalizedChatcccPort = normalizePort(chatcccPort);
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    try {
+        const listResponse = await fetchWithTimeout(`${cdpBaseUrl(normalizedCdpPort)}/json/list`, fetchImpl, HEALTH_TIMEOUT_MS);
+        if (!listResponse.ok) {
+            return { ok: false, opened: false, error: `Cannot list Chrome CDP pages: HTTP ${listResponse.status}` };
+        }
+        const pages = await listResponse.json();
+        if (Array.isArray(pages) && pages.some((page) => isChatcccPageUrl(page?.url, normalizedChatcccPort))) {
+            return { ok: true, opened: false };
+        }
+        const targetUrl = `http://localhost:${normalizedChatcccPort}/`;
+        const openResponse = await fetchWithTimeout(`${cdpBaseUrl(normalizedCdpPort)}/json/new?${encodeURIComponent(targetUrl)}`, fetchImpl, HEALTH_TIMEOUT_MS, { method: "PUT" });
+        if (!openResponse.ok) {
+            return { ok: false, opened: false, error: `Cannot open ${targetUrl}: HTTP ${openResponse.status}` };
+        }
+        return { ok: true, opened: true };
+    }
+    catch (err) {
+        return { ok: false, opened: false, error: err.message };
+    }
+}
+export async function ensureChromeCdpRunning(cfg = config.chromeDevtools, deps = {}) {
+    const port = normalizePort(cfg.port);
+    if (!cfg.enabled)
+        return { ok: true, started: false, port };
+    const probe = await probeChromeCdp(port, deps);
+    if (probe === "healthy") {
+        return { ok: true, started: false, port };
+    }
+    if (probe === "occupied") {
+        return {
+            ok: false,
+            started: false,
+            port,
+            error: `Port ${port} is reachable but is not a healthy Chrome CDP endpoint.`,
+        };
+    }
+    const started = startChromeForCdp({ ...cfg, port }, deps);
+    if (!started.ok)
+        return { ok: false, started: false, port, error: started.error };
+    for (let i = 0; i < START_VERIFY_ATTEMPTS; i++) {
+        await sleep(START_VERIFY_DELAY_MS);
+        if (await isChromeCdpHealthy(port, deps)) {
+            return { ok: true, started: true, port };
+        }
+    }
+    return { ok: false, started: true, port, error: "Chrome started but CDP endpoint is not healthy yet." };
+}
+async function runGuardOnce(reason, deps = {}) {
+    if (ensureInFlight)
+        return;
+    const log = deps.log ?? ((message) => console.log(message));
+    ensureInFlight = ensureChromeCdpRunning(config.chromeDevtools, deps);
+    try {
+        const result = await ensureInFlight;
+        const chatcccPage = config.chromeDevtools.enabled && result.ok
+            ? await ensureChatcccPageOpen(result.port, config.port, deps)
+            : null;
+        appendStartupTrace("chrome-devtools-guard: ensure result", {
+            reason,
+            enabled: config.chromeDevtools.enabled,
+            port: result.port,
+            ok: result.ok,
+            started: result.started,
+            error: result.error,
+            chatcccPage,
+        });
+        if (!config.chromeDevtools.enabled)
+            return;
+        if (result.ok && result.started) {
+            log(`[${ts()}] [Chrome CDP] Started Chrome for http://${CDP_HOST}:${result.port}/json/version`);
+        }
+        else if (!result.ok) {
+            log(`[${ts()}] [Chrome CDP] Guard failed: ${result.error}`);
+        }
+        if (chatcccPage?.opened) {
+            log(`[${ts()}] [Chrome CDP] Opened ChatCCC page http://localhost:${config.port}/`);
+        }
+        else if (chatcccPage && !chatcccPage.ok) {
+            log(`[${ts()}] [Chrome CDP] Failed to ensure ChatCCC page: ${chatcccPage.error}`);
+        }
+    }
+    finally {
+        ensureInFlight = null;
+    }
+}
+export function startChromeDevtoolsGuard(deps = {}) {
+    stopChromeDevtoolsGuard();
+    if (!config.chromeDevtools.enabled) {
+        appendStartupTrace("chrome-devtools-guard: disabled");
+        return;
+    }
+    void runGuardOnce("startup", deps);
+    guardTimer = setInterval(() => {
+        void runGuardOnce("interval", deps);
+    }, GUARD_INTERVAL_MS);
+}
+export function stopChromeDevtoolsGuard() {
+    if (guardTimer) {
+        clearInterval(guardTimer);
+        guardTimer = null;
+    }
+}

package/dist/src/claude-sdk-installer.js

@@ -0,0 +1,249 @@
+// =============================================================================
+// claude-sdk-installer.ts — Claude Code 引擎（Agent SDK）按需安装器
+// =============================================================================
+// 背景：@anthropic-ai/claude-agent-sdk 通过 optionalDependencies 内置各平台
+// 的原生 CLI 二进制（Windows 上 claude.exe 约 215MB），若作为 chatccc 的硬依赖，
+// 所有用户（包括不用 Claude Code 的）都要白白下载 220MB+。
+//
+// 方案：把 SDK 从 chatccc 的 dependencies 中移除，改为**按需安装**到
+// `~/.chatccc/claude-sdk/`：
+//   - 用户未启用 Claude Code → 完全不下载，npm 包体积大幅下降；
+//   - 用户在设置页打开 Claude Code 开关时，点「安装引擎」触发后台安装，
+//     带进度条（状态式：检测环境 → 下载中 → 安装中 → 完成/失败）。
+//
+// 设计约束：
+//   - **不 import config.ts**（config.ts 顶层有 loadConfig 副作用，web-ui.ts
+//     依赖本模块，间接 import config.ts 会污染依赖 web-ui.ts 的单测）。
+//   - 始终使用 SDK 内置的 CLI 二进制（用户拍板档位 b），不依赖用户自装 CLI。
+//   - 安装目录可注入（dir 参数），便于单测用临时目录，不碰真实用户目录。
+// =============================================================================
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** 与当前代码配套的 SDK 版本（package.json 移除依赖后此常量成为唯一版本来源） */
+export const CLAUDE_SDK_VERSION = "0.2.133";
+/** 按需安装目录：~/.chatccc/claude-sdk */
+export const CLAUDE_SDK_DIR = join(homedir(), ".chatccc", "claude-sdk");
+const SDK_PKG_REL = join("node_modules", "@anthropic-ai", "claude-agent-sdk", "package.json");
+const SDK_ENTRY_REL = join("node_modules", "@anthropic-ai", "claude-agent-sdk", "sdk.mjs");
+const LOCK_FILE = ".installing";
+/** 估算的完整安装体积（含内置 CLI 二进制），用于进度条展示 */
+export const CLAUDE_SDK_EXPECTED_BYTES = 240 * 1024 * 1024;
+// ---------------------------------------------------------------------------
+// 状态查询
+// ---------------------------------------------------------------------------
+/** SDK 入口文件绝对路径（供动态 import） */
+export function getClaudeSdkEntryPath(dir = CLAUDE_SDK_DIR) {
+    return join(dir, SDK_ENTRY_REL);
+}
+/** 是否已安装（node_modules 里存在 SDK package.json 即视为已装） */
+export function isClaudeSdkInstalled(dir = CLAUDE_SDK_DIR) {
+    return existsSync(join(dir, SDK_PKG_REL));
+}
+/** 已安装版本号；未安装/解析失败返回 null */
+export function getClaudeSdkInstalledVersion(dir = CLAUDE_SDK_DIR) {
+    try {
+        const raw = readFileSync(join(dir, SDK_PKG_REL), "utf8");
+        const pkg = JSON.parse(raw);
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 是否正在安装（锁文件存在且 pid 存活）；pid 已死视为过期锁并自动清理 */
+export function isClaudeSdkInstalling(dir = CLAUDE_SDK_DIR) {
+    const lockPath = join(dir, LOCK_FILE);
+    if (!existsSync(lockPath))
+        return false;
+    try {
+        const pid = Number.parseInt(readFileSync(lockPath, "utf8").trim(), 10);
+        if (Number.isFinite(pid) && pid > 0 && isPidAlive(pid))
+            return true;
+    }
+    catch {
+        // 锁文件损坏 → 按过期处理，走清理
+    }
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // 清理失败不阻塞判断
+    }
+    return false;
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+// ---------------------------------------------------------------------------
+// 安装（后台任务 + 进度）
+// ---------------------------------------------------------------------------
+/** 最近一次安装的进度快照，供 web-ui 轮询 */
+let lastProgress = { phase: "idle", percent: 0, message: "" };
+let installInProgress = false;
+export function getLastInstallProgress() {
+    return { ...lastProgress, ...(lastProgress.error ? { error: lastProgress.error } : {}) };
+}
+export function isInstallRunning() {
+    return installInProgress;
+}
+function setProgress(p, onProgress) {
+    lastProgress = { ...p };
+    onProgress?.(lastProgress);
+}
+/**
+ * 启动按需安装。返回 Promise，安装完成 resolve、失败 reject。
+ * 调用方通常不 await（后台执行），通过 onProgress / getLastInstallProgress() 获取进度。
+ */
+export async function installClaudeSdk(options = {}) {
+    const dir = options.dir ?? CLAUDE_SDK_DIR;
+    const npmCommand = options.npmCommand ?? "npm";
+    const expected = options.expectedVersion ?? CLAUDE_SDK_VERSION;
+    const onProgress = options.onProgress;
+    if (installInProgress) {
+        throw new Error("Claude Code 引擎正在安装中，请等待完成后再试。");
+    }
+    if (isClaudeSdkInstalling(dir)) {
+        throw new Error("检测到另一个安装任务正在进行（锁文件存在），请稍后再试。");
+    }
+    const installedVersion = isClaudeSdkInstalled(dir) ? getClaudeSdkInstalledVersion(dir) : null;
+    if (installedVersion === expected) {
+        setProgress({ phase: "done", percent: 100, message: `已安装 v${installedVersion}` }, onProgress);
+        return;
+    }
+    if (installedVersion !== null && installedVersion !== expected) {
+        setProgress({
+            phase: "detecting",
+            percent: 3,
+            message: `已装 v${installedVersion} ≠ 期望 v${expected}，开始重装…`,
+        }, onProgress);
+    }
+    installInProgress = true;
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, LOCK_FILE), String(process.pid), "utf8");
+    setProgress({ phase: "detecting", percent: 2, message: "检测环境…" }, onProgress);
+    return new Promise((resolve, reject) => {
+        const child = spawn(npmCommand, [
+            "install",
+            "--prefix",
+            dir,
+            `@anthropic-ai/claude-agent-sdk@${expected}`,
+            "--no-audit",
+            "--no-fund",
+            "--loglevel=http",
+        ], {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+            // Windows 下 npm 是 npm.cmd，需要 shell 才能解析
+            shell: process.platform === "win32",
+        });
+        let stderrBuf = "";
+        let requestCount = 0;
+        let sizeTimer = null;
+        const updateBySize = () => {
+            const size = dirSizeBytes(dir);
+            const sizePercent = Math.min((size / CLAUDE_SDK_EXPECTED_BYTES) * 90, 90);
+            const requestPercent = Math.min(5 + requestCount * 4, 70);
+            const percent = Math.max(sizePercent, requestPercent);
+            const mb = (size / 1048576).toFixed(0);
+            setProgress({
+                phase: "downloading",
+                percent: Math.min(percent, 94),
+                message: `下载中… 已下载 ${mb} MB / 约 220 MB`,
+            }, onProgress);
+        };
+        child.stdout.on("data", (chunk) => {
+            const text = chunk.toString();
+            // npm --loglevel=http 每完成一个请求输出一行 "npm http fetch GET 200 ..."
+            requestCount += (text.match(/http fetch GET|GET \d{3}/g) ?? []).length;
+            updateBySize();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderrBuf += chunk.toString();
+        });
+        child.on("error", (err) => {
+            cleanupAfterFailure(dir, err, onProgress, () => {
+                installInProgress = false;
+                reject(err);
+            });
+        });
+        child.on("close", (code) => {
+            if (sizeTimer)
+                clearInterval(sizeTimer);
+            if (code === 0 && isClaudeSdkInstalled(dir)) {
+                const version = getClaudeSdkInstalledVersion(dir);
+                installInProgress = false;
+                try {
+                    unlinkSync(join(dir, LOCK_FILE));
+                }
+                catch {
+                    // 锁文件不存在可忽略
+                }
+                setProgress({ phase: "done", percent: 100, message: `安装完成（v${version ?? expected}）` }, onProgress);
+                resolve();
+            }
+            else {
+                const tail = stderrBuf.trim().split("\n").slice(-5).join(" | ");
+                const detail = code !== 0 ? `npm 退出码 ${code}` : "安装后校验未通过";
+                const message = tail ? `${detail}：${tail.slice(0, 400)}` : detail;
+                cleanupAfterFailure(dir, new Error(message), onProgress, () => {
+                    installInProgress = false;
+                    reject(new Error(message));
+                });
+            }
+        });
+        // 定期按目录体积刷新进度（大文件下载时 stdout 事件稀疏）
+        sizeTimer = setInterval(() => {
+            if (installInProgress)
+                updateBySize();
+        }, 400);
+        if (typeof sizeTimer.unref === "function")
+            sizeTimer.unref();
+    });
+}
+function cleanupAfterFailure(dir, err, onProgress, after) {
+    setProgress({ phase: "error", percent: 0, message: "安装失败", error: err.message.slice(0, 500) }, onProgress);
+    try {
+        rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // 清理失败不阻塞
+    }
+    after();
+}
+function dirSizeBytes(dir) {
+    let total = 0;
+    const stack = [dir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile()) {
+                try {
+                    total += statSync(full).size;
+                }
+                catch {
+                    // 文件被并发删除可忽略
+                }
+            }
+        }
+    }
+    return total;
+}