@super-coding/cli 0.0.0-stage → 0.1.0

package/dist/daemon/index.js

@@ -0,0 +1,280 @@
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { loadBuiltinAgent } from "./agent/index.js";
+import { detectRunnerFeatures } from "./adapters/features.js";
+import { adapters, agentBinaries } from "./adapters/registry.js";
+import { loadDaemonConfig, loadDevice, removeDevice, restoreDeviceBackup } from "./device-store.js";
+import { logFile } from "./paths.js";
+import { Orchestrator } from "./orchestrator.js";
+import { runPairing, PairingTimeoutError } from "./pairing.js";
+import { RpcException, RpcRouter } from "./rpc.js";
+import { ClaudeConfigProvider } from "./services/claude-provider.js";
+import { CursorConfigProvider } from "./services/cursor-provider.js";
+import { LogBuffer } from "./services/log-buffer.js";
+import { RunStore } from "./session/store.js";
+import { DaemonWsClient } from "./transport/ws-client.js";
+const pkg = createRequire(import.meta.url)("../../package.json");
+// 默认连公共中转（集中化 remote）；DAEMON_SERVER_URL 可覆盖（本地调试指 ws://127.0.0.1:3000/daemon）
+const WS_URL = process.env.DAEMON_SERVER_URL ?? "wss://super-coding-api.icezeros.com/daemon";
+const HTTP_URL = process.env.DAEMON_SERVER_HTTP_URL ?? WS_URL.replace(/^ws/, "http").replace(/\/daemon$/, "");
+// agent 注入总开关（SC_AGENT_INJECTION=off 保留旧行为：不写 agent 文件、不声明能力）
+const AGENT_INJECTION_ENABLED = process.env["SC_AGENT_INJECTION"] !== "off";
+/** 与 packages/protocol 的 DAEMON_FEATURE_BUSINESS_AGENT 一致；内联避免依赖 dist 新鲜度 */
+const DAEMON_FEATURES = AGENT_INJECTION_ENABLED ? ["business_agent_v1"] : [];
+/** 对每个已注册 agent 跑 `<bin> --version`，失败（未安装/超时 3s）则不上报 */
+async function detectAgents() {
+    const probes = [...adapters.keys()].map((id) => new Promise((resolve) => {
+        const bin = agentBinaries[id];
+        if (!bin)
+            return resolve(null);
+        execFile(bin, ["--version"], { timeout: 3_000 }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            resolve({ id, version: stdout.trim().split("\n")[0] || "unknown" });
+        });
+    }));
+    const results = await Promise.all(probes);
+    return results.filter((r) => r !== null);
+}
+export async function runDaemon() {
+    const logBuffer = new LogBuffer();
+    logBuffer.instrumentConsole(logFile()); // 前台模式同时落盘 daemon.log（后台由 stdio 重定向承载）
+    // 信号处理提前注册：配对/探测/reattach 期间收到 stop 也要优雅收尾（否则默认信号直接杀进程）
+    let orchRef;
+    let wsClient;
+    let presenceTimer;
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log(`[daemon] received ${signal}, shutting down...`);
+        if (presenceTimer)
+            clearInterval(presenceTimer);
+        await orchRef?.shutdown();
+        wsClient?.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
+    const daemonConfig = loadDaemonConfig();
+    // 4401 误删自愈：daemon.json 缺失时从备份恢复（真解绑走 device:unpair 会连备份清除）
+    let device = loadDevice() ?? restoreDeviceBackup();
+    if (device) {
+        console.log("[daemon] 已从备份恢复设备凭证");
+    }
+    if (!device) {
+        try {
+            device = await runPairing(HTTP_URL);
+        }
+        catch (err) {
+            if (err instanceof PairingTimeoutError) {
+                console.error(`[daemon] ${err.message}`);
+                process.exit(err.exitCode);
+            }
+            console.error(`[daemon] 配对失败：${err instanceof Error ? err.message : String(err)}`);
+            process.exit(2);
+        }
+    }
+    const agents = await detectAgents();
+    console.log(`[daemon] detected agents: ${agents.map((a) => `${a.id}@${a.version}`).join(", ") || "(none)"}`);
+    // 启动即自检内置 agent 定义：打包漏文件/语法错误在日志里暴露，而不是等用户任务失败
+    if (AGENT_INJECTION_ENABLED) {
+        const builtin = loadBuiltinAgent();
+        const level = builtin.source === "file" ? "[daemon]" : "[daemon][warn]";
+        console.log(`${level} builtin agent: ${builtin.name} (${builtin.source}) ${builtin.path}`);
+    }
+    const store = new RunStore();
+    const router = new RpcRouter();
+    // 配置面 provider：每 agent 一个，直接读写各自配置文件
+    const providers = new Map([new ClaudeConfigProvider(), new CursorConfigProvider()].map((p) => [p.agent_id, p]));
+    const providerOf = (agent) => {
+        const p = providers.get(agent);
+        if (!p)
+            throw new RpcException("agent_unavailable", `unknown agent: ${agent}`);
+        return p;
+    };
+    // agent:list：已注册 adapter 全集；installed/version 来自启动时探测
+    router.register("agent:list", async () => {
+        const detected = new Map(agents.map((a) => [a.id, a.version]));
+        const list = [];
+        for (const adapter of adapters.values()) {
+            const provider = providers.get(adapter.id);
+            const config = await provider?.getConfig();
+            list.push({
+                id: adapter.id,
+                version: detected.get(adapter.id) ?? "",
+                installed: detected.has(adapter.id),
+                capabilities: adapter.capabilities,
+                default_model: config?.model,
+                available_models: provider?.available_models ?? [],
+            });
+        }
+        return { agents: list };
+    });
+    router
+        .register("config:get", (p) => providerOf(p.agent).getConfig().then((config) => ({ config })))
+        .register("config:set", (p) => {
+        const { agent, patch } = p;
+        return providerOf(agent).setConfig(patch).then((config) => ({ config }));
+    })
+        .register("skill:list", async (p) => {
+        const provider = providerOf(p.agent);
+        try {
+            return { supported: true, skills: await provider.listSkills() };
+        }
+        catch (err) {
+            // unsupported 也结构化返回，便于前端灰化
+            if (err instanceof RpcException && err.code === "unsupported")
+                return { supported: false, skills: [] };
+            throw err;
+        }
+    })
+        .register("skill:install", async (p) => {
+        const { agent, name, content } = p;
+        await providerOf(agent).installSkill(name, content);
+        return { ok: true };
+    })
+        .register("skill:remove", async (p) => {
+        const { agent, name } = p;
+        await providerOf(agent).removeSkill(name);
+        return { ok: true };
+    })
+        .register("mcp:list", async (p) => ({ servers: await providerOf(p.agent).listMcp() }))
+        .register("mcp:add", async (p) => {
+        const { agent, name, spec } = p;
+        await providerOf(agent).addMcp(name, spec);
+        return { ok: true };
+    })
+        .register("mcp:remove", async (p) => {
+        const { agent, name } = p;
+        await providerOf(agent).removeMcp(name);
+        return { ok: true };
+    })
+        .register("memory:get", (p) => {
+        const { agent, scope, cwd } = p;
+        return providerOf(agent).getMemory(scope, cwd);
+    })
+        .register("memory:put", async (p) => {
+        const { agent, scope, cwd, content } = p;
+        await providerOf(agent).putMemory(scope, content, cwd);
+        return { ok: true };
+    })
+        .register("run:list", () => ({
+        // RunRecord（SQLite 行，run_id/createdAt）→ RunListItem 契约（id/created_at）
+        runs: store.listRuns().map((t) => ({
+            id: t.run_id,
+            agent: t.agent,
+            cwd: t.cwd,
+            status: t.status,
+            ...(t.native_session_id !== undefined ? { native_session_id: t.native_session_id } : {}),
+            created_at: t.createdAt,
+        })),
+    }))
+        .register("log:tail", (p) => ({ lines: logBuffer.tail(p.limit) }))
+        .register("device:unpair", () => {
+        // 先回包再退出：延迟触发，让 rpc:result 有机会发出
+        setTimeout(() => {
+            removeDevice(undefined, { keepBackup: false });
+            console.log("[daemon] unpaired, exiting");
+            process.exit(0);
+        }, 100).unref();
+        return { ok: true };
+    });
+    // orch 与 ws 相互依赖：orch 用转发 sender，连接建立后消息才会真正发出
+    let wsRef;
+    const orch = new Orchestrator({ send: (m) => wsRef.send(m) }, store, adapters, router, daemonConfig.allowedCwds, (runner) => detectRunnerFeatures(runner, agentBinaries[runner] ?? runner));
+    orchRef = orch;
+    // 4401 双确认：平台瞬时空读也可能让 auth 回源报「查无此设备」——首次只告警并
+    // 自动退避重连（保留凭证），连续第二次才认定确定性解绑（凭证删前备份见 removeDevice）。
+    // 连接健康（收到任意消息）即清零。
+    let unauth4401Streak = 0;
+    /**
+     * 删凭证前的旁证：服务端/webhook 当前是否健康。
+     * webhook 抖动期可能出现「假 404」，此时删凭证会陷入「配对也走 webhook 所以配不上」的死锁，
+     * 用户只能手动重启——这正是「设备莫名离线、重启就好」的由来。
+     */
+    const probeBackendHealthy = async () => {
+        try {
+            const res = await fetch(`${HTTP_URL}/health/webhook`, { signal: AbortSignal.timeout(3_000) });
+            if (!res.ok)
+                return false;
+            const body = (await res.json());
+            return body.ok !== false;
+        }
+        catch {
+            return false; // 探不到就当不健康：宁可多保留凭证，也不要误删
+        }
+    };
+    const connectWith = (cfg) => {
+        const client = new DaemonWsClient({
+            url: WS_URL,
+            device_token: cfg.device_token,
+            daemon_version: pkg.version,
+            agents,
+            ...(DAEMON_FEATURES.length ? { features: DAEMON_FEATURES } : {}),
+            onMessage: (msg) => {
+                unauth4401Streak = 0;
+                // 必须兜住拒绝：handleMessage 是 async，任一步抛出都会变成 unhandledRejection，
+                // Node 15+ 默认终止进程 → 表现成「daemon 莫名消失」
+                void orch.handleMessage(msg).catch((err) => {
+                    console.error(`[daemon] 处理 ${msg.type} 失败: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            },
+            onClose: (code, reason) => {
+                // 确定性解绑（CES 查无此设备 → 4401 unauthorized）：清凭证就地重新配对。
+                // 覆盖离线解绑/反向通知 RPC 未送达的场景（否则旧凭证残留导致永不出配对码）。
+                // 其余 close（如 4402 auth_unavailable）保留凭证，走自动退避重连。
+                if (code === 4401 && reason === "unauthorized") {
+                    unauth4401Streak += 1;
+                    if (unauth4401Streak < 2) {
+                        console.warn(`[daemon] 鉴权 4401（第 ${unauth4401Streak} 次），保留凭证自动重连；连续两次才判定解绑`);
+                        return; // ws-client 自动退避重连
+                    }
+                    void (async () => {
+                        if (!(await probeBackendHealthy())) {
+                            console.warn("[daemon] 连续 4401，但服务端/webhook 当前不健康，暂不判定解绑（保留凭证继续重连）");
+                            unauth4401Streak = 0;
+                            return; // ws-client 已调度重连
+                        }
+                        client.close(); // 取消自动重连
+                        removeDevice();
+                        unauth4401Streak = 0;
+                        console.log("[daemon] 设备已被解绑（4401 连续确认），重新配对...");
+                        void rePair();
+                    })();
+                }
+            },
+        });
+        wsRef = client;
+        wsClient = client;
+        return client;
+    };
+    const rePair = async () => {
+        try {
+            const cfg = await runPairing(HTTP_URL);
+            const client = connectWith(cfg);
+            client.connect();
+            console.log(`[daemon] connecting to ${WS_URL} ...`);
+        }
+        catch (err) {
+            if (err instanceof PairingTimeoutError) {
+                console.error(`[daemon] ${err.message}`);
+                process.exit(err.exitCode);
+            }
+            console.error(`[daemon] 配对失败：${err instanceof Error ? err.message : String(err)}`);
+            process.exit(2);
+        }
+    };
+    // 先建 client 赋值 wsRef，再 reattach（reattach 的 presence 上报经 wsRef.send）
+    const ws = connectWith(device);
+    // 跨重启重挂：恢复本地 running 任务的会话控制面（--resume native_session_id）
+    await orch.reattach();
+    ws.connect();
+    console.log(`[daemon] connecting to ${WS_URL} ...`);
+    // 周期性 presence（agents/负载心跳）；会话变化由 orchestrator 即时上报
+    presenceTimer = setInterval(() => {
+        wsRef.send({ type: "presence", running: orch.activeRuns(), agents });
+    }, 60_000);
+    presenceTimer.unref();
+}

package/dist/daemon/manage.js

@@ -0,0 +1,183 @@
+// daemon 守护进程管理：start/stop/restart/status/logs + 前台 run。
+// start 以 detached + stdio 重定向方式后台派生 `daemon run`；run（前台）同样写 pidfile，
+// 前后台均可被 stop/status 管理。文件约定见 paths.ts（~/.super-coding/daemon.pid、daemon.log）。
+// pidfile 双写语义：start 先写派生 pid 保证立即可管，run 自注册为自身 pid（dev 下 tsx 包装
+// 进程会派生孙进程，最终 pidfile 以 run 写入的为准）。
+// 日志轮转：超 10MB 时 rename 为 daemon.log.1（一代）。
+import { spawn } from "node:child_process";
+import { closeSync, openSync, readFileSync, readSync, renameSync, statSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { logFile, isAlive, manageDir, readPid, removePid, writePid } from "./paths.js";
+import { mkdirSync } from "node:fs";
+import { runDaemon } from "./index.js";
+const require = createRequire(import.meta.url);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const DEFAULT_SERVER = "wss://super-coding-api.icezeros.com/daemon";
+function childArgs(entry) {
+    // dev（tsx 跑 src/cli.ts）与产物（node dist/cli.js）双模式派生
+    // tsx 的 exports 不开放 ./dist/cli.mjs，须经官方子路径 tsx/cli 解析 CLI 入口
+    return entry.endsWith(".ts")
+        ? [require.resolve("tsx/cli"), entry, "daemon", "run"]
+        : [entry, "daemon", "run"];
+}
+const MAX_LOG_BYTES = 10 * 1024 * 1024;
+function rotateLogIfNeeded() {
+    try {
+        if (statSync(logFile()).size > MAX_LOG_BYTES)
+            renameSync(logFile(), `${logFile()}.1`);
+    }
+    catch {
+        /* 无日志文件，跳过 */
+    }
+}
+export async function startDaemon(opts = {}) {
+    const existing = readPid();
+    if (existing && isAlive(existing.pid)) {
+        console.log(`daemon 已在运行（pid ${existing.pid}）`);
+        return;
+    }
+    rotateLogIfNeeded();
+    mkdirSync(manageDir(), { recursive: true });
+    const logFd = openSync(logFile(), "a");
+    const entry = opts.entry ?? process.argv[1];
+    const spawnImpl = opts.spawnImpl ?? spawn;
+    let child;
+    try {
+        child = spawnImpl(process.execPath, childArgs(entry), {
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            // SC_DAEMON_LOG_VIA_STDIO：stdio 已重定向到日志文件，子进程跳过文件 sink 防双写
+            env: { ...process.env, SC_DAEMON_LOG_VIA_STDIO: "1" },
+        });
+        child.unref();
+    }
+    finally {
+        closeSync(logFd);
+    }
+    if (!child.pid)
+        throw new Error(`daemon 派生失败（日志：${logFile()}）`);
+    writePid(child.pid, { server: process.env.DAEMON_SERVER_URL ?? DEFAULT_SERVER });
+    // 秒退检测：入口即崩/tsx 缺失等场景不能误报"已启动"
+    const died = await new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), 400);
+        child.once("exit", () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+        child.once("error", () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+    if (died) {
+        removePid(child.pid);
+        throw new Error(`daemon 启动失败，进程立即退出（日志：${logFile()}）`);
+    }
+    console.log(`daemon 已后台启动（pid ${child.pid}）`);
+    console.log(`日志：${logFile()}`);
+}
+export async function stopDaemon() {
+    const state = readPid();
+    if (!state || !isAlive(state.pid)) {
+        if (state)
+            removePid(state.pid);
+        console.log("daemon 未在运行");
+        return;
+    }
+    process.kill(state.pid, "SIGTERM");
+    for (let i = 0; i < 50; i += 1) {
+        if (!isAlive(state.pid))
+            break;
+        await sleep(100);
+    }
+    if (isAlive(state.pid)) {
+        process.kill(state.pid, "SIGKILL");
+        await sleep(200);
+    }
+    removePid(state.pid);
+    console.log(`daemon 已停止（pid ${state.pid}）`);
+}
+export async function restartDaemon(opts = {}) {
+    await stopDaemon();
+    await startDaemon(opts);
+}
+export function statusDaemon() {
+    const state = readPid();
+    if (state && isAlive(state.pid)) {
+        const upS = Math.floor((Date.now() - state.started_at) / 1000);
+        console.log(`daemon 运行中（pid ${state.pid}）`);
+        console.log(`  运行时长：${upS}s`);
+        console.log(`  服务地址：${state.server ?? process.env.DAEMON_SERVER_URL ?? DEFAULT_SERVER}`);
+        console.log(`  日志：${logFile()}`);
+    }
+    else {
+        console.log("daemon 未在运行");
+    }
+}
+/** 尾部 n 行（纯函数，便于测试） */
+export function readLogTail(text, n) {
+    const lines = text.split("\n");
+    // 文件常以换行结尾：丢弃末尾空串
+    if (lines.length && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.slice(Math.max(0, lines.length - n));
+}
+/** 按字节读取 [offset, EOF) 追加内容；stat size 是字节，不能用字符串下标切多字节日志 */
+export function readAppend(path, offset) {
+    const size = statSync(path).size;
+    const start = size < offset ? 0 : offset; // 截断/轮转重建后从头读
+    if (size === start)
+        return null;
+    const buf = Buffer.alloc(size - start);
+    const fd = openSync(path, "r");
+    try {
+        let read = 0;
+        while (read < buf.length) {
+            const r = readSync(fd, buf, read, buf.length - read, start + read);
+            if (r <= 0)
+                break;
+            read += r;
+        }
+        return { buf: read === buf.length ? buf : buf.subarray(0, read), offset: start + read };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export async function logsDaemon(opts = {}) {
+    const path = logFile();
+    const n = opts.lines ?? 50;
+    let offset = 0;
+    try {
+        const text = readFileSync(path, "utf8");
+        for (const line of readLogTail(text, n))
+            console.log(line);
+        offset = statSync(path).size;
+    }
+    catch {
+        console.log(`（暂无日志：${path}）`);
+    }
+    if (!opts.follow)
+        return;
+    // 轮询追加（--follow 语义同 tail -f）；按字节 range 读，多字节内容不错位
+    for (;;) {
+        await sleep(500);
+        try {
+            const next = readAppend(path, offset);
+            if (next) {
+                offset = next.offset;
+                process.stdout.write(next.buf);
+            }
+        }
+        catch {
+            /* 文件暂缺时静默等待 */
+        }
+    }
+}
+/** 前台运行（调试/被外部 supervisor 托管时用）：写 pidfile 使 stop/status 可管 */
+export function runDaemonForeground() {
+    rotateLogIfNeeded();
+    writePid(process.pid, { server: process.env.DAEMON_SERVER_URL ?? DEFAULT_SERVER });
+    process.on("exit", () => removePid(process.pid));
+    void runDaemon();
+}