@super-coding/cli 0.0.0-stage → 0.1.0

package/dist/daemon/orchestrator.js

@@ -0,0 +1,364 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { AgentError, prepareAgent, restoreAgentLaunch, validateBusinessAgent } from "./agent/index.js";
+import { promptWithSkills, syncRunSkills } from "./run-skills.js";
+/** 会话目录默认基底（持久位置：目录保留不删，不用 /tmp） */
+const DEFAULT_WORKDIR_BASE = join(homedir(), ".super-coding", "workspaces");
+/**
+ * 任务编排：transport ⇄ adapter ⇄ store 接线。
+ * 事件一律先落盘（分配 seq）再发 server——断线后 server 按 last_seq 请求补发。
+ */
+export class Orchestrator {
+    ws;
+    store;
+    adapters;
+    rpc;
+    allowedCwds;
+    featuresFor;
+    sessions = new Map();
+    /** 本连接已经请求过水位的运行，避免同一批在确认前被反复重放 */
+    syncRequested = new Set();
+    syncInFlight;
+    constructor(ws, store, adapters, rpc, 
+    /** run:start 的 cwd 白名单（前缀匹配）；缺省不限制 */
+    allowedCwds, 
+    /** runner 能力探测（默认按不支持 --agent 处理，测试可注入） */
+    featuresFor) {
+        this.ws = ws;
+        this.store = store;
+        this.adapters = adapters;
+        this.rpc = rpc;
+        this.allowedCwds = allowedCwds;
+        this.featuresFor = featuresFor;
+    }
+    activeRuns() {
+        return [...this.sessions.keys()];
+    }
+    /** 会话集合变化时主动上报 presence（running 列表） */
+    reportPresence() {
+        this.ws.send({ type: "presence", running: this.activeRuns() });
+    }
+    async handleMessage(msg) {
+        switch (msg.type) {
+            case "run:start":
+                await this.startRun(msg);
+                break;
+            case "run:input":
+                await this.sessions.get(msg.run_id)?.sendMessage(msg.text);
+                break;
+            case "run:permission":
+                await this.sessions.get(msg.run_id)?.respondPermission(msg.request_id, msg.decision);
+                break;
+            case "run:interrupt":
+                await this.sessions.get(msg.run_id)?.interrupt();
+                break;
+            case "debug:echo":
+                console.log("[debug]", msg.text);
+                break;
+            case "rpc":
+                await (this.rpc
+                    ? this.rpc.dispatch(msg, (m) => this.ws.send(m))
+                    : Promise.resolve(this.ws.send({
+                        type: "rpc:result",
+                        id: msg.id,
+                        error: { code: "unknown_method", message: "rpc not available" },
+                    })));
+                break;
+            case "resume":
+                this.handleResume(msg);
+                break;
+            default:
+                break; // ping 由 transport 层处理
+        }
+    }
+    /** hello 先复位本连接同步状态；后续每个 sync 响应驱动下一批，覆盖终态运行 */
+    handleResume(msg) {
+        if (!msg.sync_id) {
+            this.syncRequested.clear();
+            this.syncInFlight = undefined;
+        }
+        else {
+            const inFlight = this.syncInFlight;
+            if (inFlight?.id !== msg.sync_id)
+                return; // 迟到/跨连接响应
+            for (const runId of inFlight.runIds)
+                this.syncRequested.add(runId);
+            this.syncInFlight = undefined;
+        }
+        for (const [run_id, last_seq] of Object.entries(msg.runs ?? {})) {
+            this.syncRequested.add(run_id);
+            this.store.acknowledge(run_id, last_seq);
+            for (const { seq, event } of this.store.eventsAfter(run_id, last_seq)) {
+                this.ws.send({ type: "event", run_id, seq, event });
+            }
+        }
+        this.sendNextSync();
+    }
+    /** daemon 驱动补发：remote 无需枚举或持久化运行集合，CES 仍是唯一水位真相源 */
+    sendNextSync() {
+        if (this.syncInFlight)
+            return;
+        const runIds = this.store.pendingSync()
+            .map((r) => r.run_id)
+            .filter((id) => !this.syncRequested.has(id))
+            .slice(0, 50);
+        if (runIds.length === 0)
+            return;
+        const id = randomUUID();
+        this.syncInFlight = { id, runIds };
+        this.ws.send({ type: "sync", sync_id: id, run_ids: runIds });
+    }
+    reject(run_id, reason, code) {
+        this.ws.send({ type: "run:ack", run_id, status: "rejected", reason, ...(code ? { code } : {}) });
+    }
+    rejectAgent(run_id, err) {
+        if (err instanceof AgentError) {
+            this.reject(run_id, err.message, err.code);
+            return;
+        }
+        this.reject(run_id, `agent 注入失败: ${err?.message ?? String(err)}`, "agent_materialize_failed");
+    }
+    async startRun(msg) {
+        const adapter = this.adapters.get(msg.agent);
+        if (!adapter) {
+            this.reject(msg.run_id, `unknown agent: ${msg.agent}`, "unknown_agent");
+            return;
+        }
+        // 安全边界：白名单只校验用户显式传入的基底（不传 = 内部默认基底，跳过）
+        const base = msg.cwd?.trim() ? msg.cwd.trim() : undefined;
+        if (base && this.allowedCwds && !this.allowedCwds.some((dir) => base === dir || base.startsWith(dir.endsWith("/") ? dir : `${dir}/`))) {
+            this.reject(msg.run_id, `cwd not allowed: ${base}`, "cwd_not_allowed");
+            return;
+        }
+        // 同一 run_id 重复下发：进程已在跑就幂等回执，不重复建目录/起进程
+        const existing = this.store.getRun(msg.run_id);
+        if (existing && this.sessions.has(msg.run_id)) {
+            this.ws.send({ type: "run:ack", run_id: msg.run_id, status: "accepted", cwd: existing.cwd });
+            return;
+        }
+        // 纯校验放在建目录之前：禁用/runner 不符不该留下空 session-* 目录
+        const businessAgent = msg.business_agent;
+        const injection = process.env["SC_AGENT_INJECTION"] !== "off";
+        if (injection) {
+            try {
+                validateBusinessAgent(msg.agent, businessAgent);
+                // 续聊沿用原生会话时，绑定关系要回溯到最早的运行（本轮 run_id 还没有记录）
+                const resumeId = msg.options?.resume_session_id;
+                const boundAgentId = existing?.business_agent_id
+                    ?? (resumeId ? this.store.findRunByNativeSession(resumeId, msg.agent)?.business_agent_id : undefined);
+                if (boundAgentId && businessAgent && boundAgentId !== businessAgent.id) {
+                    throw new AgentError("agent_switch_not_allowed", `会话已绑定 agent ${boundAgentId}，不能切换为 ${businessAgent.id}`);
+                }
+            }
+            catch (err) {
+                this.rejectAgent(msg.run_id, err);
+                return;
+            }
+        }
+        const resolved = this.resolveWorkdir(msg, base);
+        if (!resolved.ok) {
+            this.reject(msg.run_id, resolved.reason, "cwd_not_allowed");
+            return;
+        }
+        const workdir = resolved.cwd;
+        // 防御性观测（「续聊分叉」定位）：新建 session 目录时若同 runner 已有活跃 run，
+        // 多半是上游 resume 链路断了（native 未就绪被静默放行/客户端没带 session_id）。
+        // 并行多会话是合法场景，只告警不拒绝。
+        if (!msg.options?.resume_session_id) {
+            for (const activeId of this.sessions.keys()) {
+                if (this.store.getRun(activeId)?.agent === msg.agent) {
+                    console.warn(`[daemon] run ${msg.run_id} 新建 session 目录（同 agent ${msg.agent} 的 run ${activeId} 仍在执行）`
+                        + `——若非预期请检查续聊 resume 链路`);
+                    break;
+                }
+            }
+        }
+        let visible;
+        try {
+            visible = await syncRunSkills(workdir, msg.agent, msg.skills ?? []);
+        }
+        catch (err) {
+            this.reject(msg.run_id, `skill materialize failed: ${err.message}`, "skill_materialize_failed");
+            return;
+        }
+        // 内置 agent 定义 + 用户配置 → 原生 agent 文件 / 主指令 / MCP（失败一律在 ack 前拒绝）
+        let prepared;
+        if (injection) {
+            try {
+                const features = this.featuresFor
+                    ? await this.featuresFor(msg.agent)
+                    : { agentFlag: false, strictMcp: false };
+                prepared = await prepareAgent({
+                    workdir,
+                    runner: msg.agent,
+                    ...(businessAgent ? { businessAgent } : {}),
+                    ...(msg.options ? { options: msg.options } : {}),
+                    skills: visible,
+                    agentFlag: features.agentFlag,
+                });
+            }
+            catch (err) {
+                this.rejectAgent(msg.run_id, err);
+                return;
+            }
+        }
+        let prompt = promptWithSkills(msg.prompt, visible);
+        if (prepared?.launch.promptPrefix) {
+            prompt = prompt ? `${prepared.launch.promptPrefix}\n\n${prompt}` : prepared.launch.promptPrefix;
+        }
+        // 先落库再 ack：失败还能显式 rejected（accepted 之后 remote 会立刻把消息置 running）
+        try {
+            if (!existing) {
+                this.store.createRun({
+                    run_id: msg.run_id,
+                    agent: msg.agent,
+                    cwd: workdir,
+                    ...(businessAgent ? { business_agent_id: businessAgent.id } : {}),
+                    ...(prepared ? { agent_slug: prepared.slug } : {}),
+                });
+            }
+        }
+        catch (err) {
+            this.reject(msg.run_id, `record run failed: ${err.message}`);
+            return;
+        }
+        this.ws.send({ type: "run:ack", run_id: msg.run_id, status: "accepted", cwd: workdir });
+        let session;
+        try {
+            session = await adapter.start({
+                cwd: workdir,
+                prompt,
+                options: { ...(msg.options ?? {}), ...(prepared?.runOptions ?? {}) },
+                ...(prepared?.env ? { env: prepared.env } : {}),
+                ...(prepared?.launch.agentName ? { agentName: prepared.launch.agentName } : {}),
+                ...(prepared?.launch.mcpConfigPath ? { mcpConfigPath: prepared.launch.mcpConfigPath } : {}),
+                ...(prepared?.launch.disallowedTools?.length ? { disallowedTools: prepared.launch.disallowedTools } : {}),
+            });
+        }
+        catch (err) {
+            this.emit(msg.run_id, { kind: "done", status: "failed", final_text: String(err) });
+            return;
+        }
+        this.sessions.set(msg.run_id, session);
+        this.reportPresence();
+        this.consume(msg.run_id, session);
+    }
+    /**
+     * 会话执行目录：resume 续会话复用同目录（按 (agent, native_session_id) 回查；
+     * 查不到则拒绝——换目录 --resume 会错乱/失败，不静默新建）；新会话在基底下建唯一
+     * 子目录 session-<uuid>（保留不删）。基底 resolve 归一化（相对路径不失义）。
+     */
+    resolveWorkdir(msg, base) {
+        const resumeId = msg.options?.resume_session_id;
+        if (resumeId) {
+            const prior = this.store.findCwdByNativeSession(resumeId, msg.agent);
+            if (!prior)
+                return { ok: false, reason: `resume session not found: ${resumeId}` };
+            // 目录可能被外部删除——复用前补建（上下文在 agent 原生会话里，不丢）
+            mkdirSync(prior, { recursive: true });
+            return { ok: true, cwd: prior };
+        }
+        const root = process.env.SC_WORKDIR_BASE ?? DEFAULT_WORKDIR_BASE;
+        const dir = join(resolve(base ?? root), `session-${randomUUID()}`);
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch (err) {
+            return { ok: false, reason: `workdir create failed: ${err.message}` };
+        }
+        return { ok: true, cwd: dir };
+    }
+    /**
+     * 跨重启重挂：daemon 重启后 agent 进程已死，但 claude/cursor 都支持 --resume <native_session_id>
+     * 重建会话控制面（可继续 input/interrupt）；无 native_session_id 的标记 failed。
+     * agent 启动参数从会话目录的 managed-agent.json 恢复（不重新拉 agents 表，配置变更从下一轮生效）。
+     */
+    async reattach() {
+        const injection = process.env["SC_AGENT_INJECTION"] !== "off";
+        for (const run of this.store.listRuns("running")) {
+            const adapter = this.adapters.get(run.agent);
+            if (!run.native_session_id || !adapter) {
+                this.store.setStatus(run.run_id, "failed");
+                continue;
+            }
+            let restored;
+            if (injection) {
+                restored = await restoreAgentLaunch(run.cwd);
+                if (!restored) {
+                    console.error(`[daemon] reattach ${run.run_id} 失败：会话目录缺少 agent 快照（${run.cwd}）`);
+                    this.store.setStatus(run.run_id, "failed");
+                    continue;
+                }
+            }
+            try {
+                const features = this.featuresFor
+                    ? await this.featuresFor(run.agent)
+                    : { agentFlag: false, strictMcp: false };
+                const manifest = restored?.manifest;
+                const session = await adapter.start({
+                    cwd: run.cwd,
+                    prompt: "",
+                    options: {
+                        resume_session_id: run.native_session_id,
+                        ...(manifest?.resolved.model ? { model: manifest.resolved.model } : {}),
+                        ...(manifest?.resolved.permission_mode
+                            ? { permission_mode: manifest.resolved.permission_mode }
+                            : {}),
+                    },
+                    ...(manifest?.resolved.env ? { env: manifest.resolved.env } : {}),
+                    ...(features.agentFlag && manifest ? { agentName: manifest.resolved.slug } : {}),
+                    ...(restored?.launch.mcpConfigPath ? { mcpConfigPath: restored.launch.mcpConfigPath } : {}),
+                    ...(restored?.launch.disallowedTools?.length
+                        ? { disallowedTools: restored.launch.disallowedTools }
+                        : {}),
+                });
+                this.sessions.set(run.run_id, session);
+                this.consume(run.run_id, session);
+                console.log(`[daemon] reattached run ${run.run_id} (session ${run.native_session_id})`);
+            }
+            catch (err) {
+                console.error(`[daemon] reattach ${run.run_id} failed:`, err);
+                this.store.setStatus(run.run_id, "failed");
+            }
+        }
+        this.reportPresence();
+    }
+    /** 后台消费事件流：落盘（分配 seq）→ 上行；done 更新状态 */
+    consume(run_id, session) {
+        void (async () => {
+            try {
+                for await (const event of session) {
+                    if (event.kind === "init") {
+                        this.store.setNativeSessionId(run_id, event.session_id);
+                        // 回显会话执行目录（前端「会话开始」时展示）
+                        const rec = this.store.getRun(run_id);
+                        this.emit(run_id, rec ? { ...event, workdir: rec.cwd } : event);
+                    }
+                    else {
+                        this.emit(run_id, event);
+                    }
+                    if (event.kind === "done") {
+                        this.store.setStatus(run_id, event.status);
+                    }
+                }
+            }
+            catch (err) {
+                this.emit(run_id, { kind: "error", message: String(err), retryable: false });
+            }
+            finally {
+                this.sessions.delete(run_id);
+                this.reportPresence();
+            }
+        })();
+    }
+    /** 先落盘（拿到 seq）再发 */
+    emit(run_id, event) {
+        const seq = this.store.appendEvent(run_id, event);
+        this.ws.send({ type: "event", run_id, seq, event });
+    }
+    async shutdown() {
+        await Promise.all([...this.sessions.values()].map((s) => s.close()));
+    }
+}

package/dist/daemon/pairing.js

@@ -0,0 +1,93 @@
+import { randomInt } from "node:crypto";
+import { hostname } from "node:os";
+import { saveDevice } from "./device-store.js";
+/** 字母表去除易混淆字符（0/O、1/I/L） */
+const ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const CODE_LENGTH = 6;
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1_000; // 10 分钟
+/** 配对超时：CLI 入口应以此 exitCode 退出 */
+export class PairingTimeoutError extends Error {
+    exitCode = 2;
+    constructor(message = "pairing timed out") {
+        super(message);
+        this.name = "PairingTimeoutError";
+    }
+}
+export function generateCode() {
+    let code = "";
+    for (let i = 0; i < CODE_LENGTH; i += 1) {
+        code += ALPHABET[randomInt(ALPHABET.length)];
+    }
+    return code;
+}
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * 配对流程：注册配对码 → 提示用户在应用中输入 → 轮询直到被认领 → 保存设备凭证。
+ * device_token 明文只在 poll 响应中出现一次，立即写入 ~/.super-coding/daemon.json（0600）。
+ * 超时抛出 PairingTimeoutError（exitCode = 2）。
+ */
+export async function runPairing(serverUrl, opts = {}) {
+    const { fetchImpl = fetch, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, timeoutMs = DEFAULT_TIMEOUT_MS, machine_name = hostname(), sleep = defaultSleep, log = console.log, configDir, } = opts;
+    const base = serverUrl.replace(/\/+$/, "");
+    const code = generateCode();
+    // register：remote 重启窗口的瞬时 5xx/网络错误重试，不因一次抖动杀死 daemon
+    let registerRes = null;
+    for (let attempt = 1; attempt <= 5; attempt += 1) {
+        try {
+            registerRes = await fetchImpl(`${base}/pairing/register`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ code, machine_name }),
+            });
+            if (registerRes.ok)
+                break;
+        }
+        catch {
+            registerRes = null; // 网络错误
+        }
+        log(`pairing register 暂时失败（第 ${attempt} 次），2s 后重试...`);
+        await sleep(2_000);
+    }
+    if (!registerRes?.ok) {
+        throw new Error(`pairing register failed: HTTP ${registerRes?.status ?? "network"}`);
+    }
+    log(`请在 Super Coding 应用中输入配对码: ${code.slice(0, 3)} ${code.slice(3)}`);
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (Date.now() >= deadline) {
+            throw new PairingTimeoutError();
+        }
+        await sleep(pollIntervalMs);
+        let pollRes;
+        try {
+            pollRes = await fetchImpl(`${base}/pairing/poll?code=${encodeURIComponent(code)}`);
+        }
+        catch {
+            // 网络抖动：继续轮询（deadline 兜底）
+            continue;
+        }
+        if (pollRes.status === 404) {
+            // code 已过期/被消费
+            throw new PairingTimeoutError("pairing code expired or consumed");
+        }
+        if (!pollRes.ok) {
+            // 瞬时 5xx（如 remote 重启窗口）：继续轮询，不因一次抖动退出
+            log(`pairing poll 暂时失败（HTTP ${pollRes.status}），继续重试...`);
+            continue;
+        }
+        const body = (await pollRes.json());
+        if (body.status === "claimed") {
+            const cfg = {
+                id: body.id,
+                device_token: body.device_token,
+                machine_name,
+                paired_at: Date.now(),
+            };
+            saveDevice(cfg, configDir);
+            log(`配对成功，设备已绑定: ${machine_name} (${body.id})`);
+            return cfg;
+        }
+        // status === "pending" → 继续轮询
+    }
+}

package/dist/daemon/paths.js

@@ -0,0 +1,47 @@
+// daemon 管理面的文件约定与 pidfile：~/.super-coding/daemon.pid、daemon.log。
+// 独立小模块（manage.ts 与 index.ts 都依赖它，避免循环 import）。
+// SC_HOME 可覆盖目录（测试注入）。
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function manageDir() {
+    return process.env.SC_HOME ?? join(homedir(), ".super-coding");
+}
+export function pidFile() {
+    return join(manageDir(), "daemon.pid");
+}
+export function logFile() {
+    return join(manageDir(), "daemon.log");
+}
+export function readPid() {
+    try {
+        const state = JSON.parse(readFileSync(pidFile(), "utf8"));
+        return Number.isFinite(state.pid) && state.pid > 0 ? state : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writePid(pid, extra = {}) {
+    mkdirSync(manageDir(), { recursive: true });
+    // tmp + rename 原子写，杜绝半截 JSON
+    const tmp = `${pidFile()}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ pid, started_at: Date.now(), ...extra }));
+    renameSync(tmp, pidFile());
+}
+/** expectedPid 给定时仅删除匹配的 pidfile（后到的实例不得误删他人的） */
+export function removePid(expectedPid) {
+    if (expectedPid !== undefined && readPid()?.pid !== expectedPid)
+        return;
+    rmSync(pidFile(), { force: true });
+}
+/** 信号 0 探活（无权限/不存在都视为不活） */
+export function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/daemon/rpc.js

@@ -0,0 +1,41 @@
+/** 带 code 的 RPC 错误：handler 抛出时按 code 回包 */
+export class RpcException extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RpcException";
+    }
+}
+/**
+ * daemon 侧 RPC dispatcher：server 经 WS 下发 {type:"rpc", id, method, params}，
+ * 这里按 method 分发到注册的 handler，回 {type:"rpc:result", id, result|error}。
+ */
+export class RpcRouter {
+    handlers = new Map();
+    register(method, handler) {
+        this.handlers.set(method, handler);
+        return this;
+    }
+    async dispatch(msg, send) {
+        const handler = this.handlers.get(msg.method);
+        if (!handler) {
+            send({
+                type: "rpc:result",
+                id: msg.id,
+                error: { code: "unknown_method", message: `unknown rpc method: ${msg.method}` },
+            });
+            return;
+        }
+        try {
+            const result = await handler(msg.params ?? {});
+            send({ type: "rpc:result", id: msg.id, result: result ?? { ok: true } });
+        }
+        catch (err) {
+            const error = err instanceof RpcException
+                ? { code: err.code, message: err.message }
+                : { code: "internal", message: err instanceof Error ? err.message : String(err) };
+            send({ type: "rpc:result", id: msg.id, error });
+        }
+    }
+}