@super-coding/cli 0.0.0-stage → 0.2.0

package/dist/daemon/agent/materialize.js

@@ -0,0 +1,220 @@
+// 把合并后的 agent 物化到会话目录：原生 agent 定义 + 主会话指令块 + MCP 配置。
+// 幂等：内容一致就不写盘；清理只删「上一轮写过且未被用户改动」的文件。
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { buildManifest, readManifest, sha256, writeManifest, } from "./manifest.js";
+import { renderClaudeAgentDoc } from "./renderers/claude-code.js";
+import { renderCursorAgentDoc } from "./renderers/cursor.js";
+import { removeBlock, sessionBlock, upsertBlock } from "./renderers/common.js";
+import { renderGenericAgentDoc } from "./renderers/generic.js";
+import { assertInside } from "./slug.js";
+import { AgentError } from "./types.js";
+const AGENT_FILE_MODE = 0o644;
+const SECRET_FILE_MODE = 0o600;
+const exists = async (path) => {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+async function readText(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 原子写：tmp + rename（rename 会带上 tmp 的权限位） */
+async function writeAtomic(abs, content, mode) {
+    await mkdir(dirname(abs), { recursive: true });
+    const tmp = `${abs}.tmp-${process.pid}`;
+    await writeFile(tmp, content, { encoding: "utf8", mode });
+    await rename(tmp, abs);
+}
+async function syncManaged(workdir, rel, content, fileMode) {
+    const abs = assertInside(workdir, rel);
+    const current = await readText(abs);
+    if (current === content)
+        return false;
+    await writeAtomic(abs, content, fileMode);
+    return true;
+}
+async function syncBlock(workdir, rel, block) {
+    const abs = assertInside(workdir, rel);
+    const current = (await readText(abs)) ?? "";
+    const next = upsertBlock(current, block);
+    if (next === current)
+        return { content: next, changed: false };
+    await writeAtomic(abs, next, AGENT_FILE_MODE);
+    return { content: next, changed: true };
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+ * 合并项目级 MCP 配置（cursor 只能写 .cursor/mcp.json，无法与用户全局完全隔离）。
+ * 只覆盖同名 key；本轮取消的 key 仅在「值仍是我们上次写入的值」时删除，避免误删用户改动。
+ */
+async function mergeMcpJson(workdir, rel, servers, previous) {
+    const abs = assertInside(workdir, rel);
+    const raw = await readText(abs);
+    let doc = {};
+    if (raw?.trim()) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (!isRecord(parsed))
+                throw new Error("not an object");
+            doc = parsed;
+        }
+        catch {
+            throw new AgentError("agent_materialize_failed", `${rel} 不是合法 JSON，拒绝覆盖`);
+        }
+    }
+    const currentServers = isRecord(doc["mcpServers"]) ? { ...doc["mcpServers"] } : {};
+    for (const [name, value] of Object.entries(previous ?? {})) {
+        if (name in servers)
+            continue;
+        if (JSON.stringify(currentServers[name]) === JSON.stringify(value))
+            delete currentServers[name];
+    }
+    Object.assign(currentServers, servers);
+    doc["mcpServers"] = currentServers;
+    const content = `${JSON.stringify(doc, null, 2)}\n`;
+    if (raw === content)
+        return { content, changed: false };
+    await writeAtomic(abs, content, SECRET_FILE_MODE);
+    return { content, changed: true };
+}
+/** 清理上一轮 manifest 里、本轮不再产出的条目 */
+async function cleanupStale(workdir, previous, nextPaths) {
+    if (!previous)
+        return;
+    for (const file of previous.files) {
+        if (nextPaths.has(file.path) || file.mode === "merge")
+            continue;
+        const abs = assertInside(workdir, file.path);
+        const current = await readText(abs);
+        if (current === undefined)
+            continue;
+        if (file.mode === "managed") {
+            if (sha256(current) === file.sha256) {
+                await rm(abs, { force: true });
+            }
+            else {
+                console.warn(`[daemon] 保留被修改过的托管文件（不清理）：${file.path}`);
+            }
+            continue;
+        }
+        // block：只摘掉托管块，保留用户内容
+        const stripped = removeBlock(current);
+        if (stripped !== current)
+            await writeAtomic(abs, stripped, AGENT_FILE_MODE);
+    }
+}
+function planFor(input) {
+    const { runner, agent, agentFlag } = input;
+    const slug = agent.slug;
+    if (runner === "claude-code") {
+        const agentDocPath = `.claude/agents/${slug}.md`;
+        const planned = [
+            { rel: agentDocPath, mode: "managed", content: renderClaudeAgentDoc(agent), fileMode: AGENT_FILE_MODE },
+        ];
+        if (Object.keys(agent.mcp_servers).length) {
+            planned.push({
+                rel: `.super-coding/agent/${slug}.mcp.json`,
+                mode: "managed",
+                content: `${JSON.stringify({ mcpServers: agent.mcp_servers }, null, 2)}\n`,
+                fileMode: SECRET_FILE_MODE,
+            });
+        }
+        return {
+            planned,
+            agentDocPath,
+            launch: {
+                ...(agentFlag ? { agentName: slug } : {}),
+                ...(Object.keys(agent.mcp_servers).length
+                    ? { mcpConfigPath: assertInside(input.workdir, `.super-coding/agent/${slug}.mcp.json`) }
+                    : {}),
+                ...(agent.tools.deny?.length ? { disallowedTools: agent.tools.deny } : {}),
+            },
+        };
+    }
+    if (runner === "cursor") {
+        const agentDocPath = `.cursor/agents/${slug}.md`;
+        return {
+            planned: [
+                { rel: agentDocPath, mode: "managed", content: renderCursorAgentDoc(agent), fileMode: AGENT_FILE_MODE },
+            ],
+            agentDocPath,
+            launch: {},
+        };
+    }
+    const agentDocPath = `.super-coding/agent/${slug}.md`;
+    return {
+        planned: [
+            { rel: agentDocPath, mode: "managed", content: renderGenericAgentDoc(agent), fileMode: AGENT_FILE_MODE },
+        ],
+        agentDocPath,
+        // 未知 runner 不保证读 AGENTS.md：把指令前缀到 prompt，语义不丢
+        launch: { promptPrefix: agent.instructions },
+    };
+}
+export async function materializeAgent(input) {
+    const { workdir, runner, agent } = input;
+    const previous = await readManifest(workdir);
+    const { planned, agentDocPath, launch } = planFor(input);
+    // 主会话指令文件（claude/cursor 优先各自生态，其余用 AGENTS.md）
+    const instructionFile = runner === "claude-code" ? "CLAUDE.md" : "AGENTS.md";
+    const block = sessionBlock(agent, { pointer: runner === "claude-code" && !!input.agentFlag, agentDocPath });
+    const files = [];
+    let changed = false;
+    for (const file of planned) {
+        const wrote = await syncManaged(workdir, file.rel, file.content, file.fileMode);
+        changed = changed || wrote;
+        files.push({ path: file.rel, mode: file.mode, sha256: sha256(file.content) });
+    }
+    const blockResult = await syncBlock(workdir, instructionFile, block);
+    changed = changed || blockResult.changed;
+    files.push({ path: instructionFile, mode: "block", sha256: sha256(blockResult.content) });
+    // MCP：claude 已在上面的 planned 里落文件；cursor 需要合并项目级 .cursor/mcp.json
+    if (runner === "cursor" && Object.keys(agent.mcp_servers).length) {
+        const merged = await mergeMcpJson(workdir, ".cursor/mcp.json", agent.mcp_servers, previous?.resolved.mcp_servers);
+        changed = changed || merged.changed;
+        files.push({ path: ".cursor/mcp.json", mode: "merge", sha256: sha256(merged.content) });
+    }
+    const nextPaths = new Set(files.map((f) => f.path));
+    await cleanupStale(workdir, previous, nextPaths);
+    const nextManifest = buildManifest(runner, agent, files);
+    const manifestChanged = !previous ||
+        previous.config_hash !== nextManifest.config_hash ||
+        JSON.stringify(previous.files) !== JSON.stringify(nextManifest.files);
+    if (manifestChanged)
+        await writeManifest(workdir, nextManifest);
+    return {
+        files: files.map((f) => f.path).sort(),
+        unchanged: !changed && !manifestChanged,
+        launch,
+        manifest: nextManifest,
+    };
+}
+/** reattach 用：从会话目录恢复上一轮的启动参数（daemon 重启后没有 run:start payload） */
+export async function restoreAgentLaunch(workdir) {
+    const manifest = await readManifest(workdir);
+    if (!manifest)
+        return undefined;
+    const slug = manifest.resolved.slug;
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(slug))
+        return undefined;
+    const mcpRel = manifest.runner === "claude-code" ? `.super-coding/agent/${slug}.mcp.json` : undefined;
+    const mcpConfigPath = mcpRel && (await exists(join(workdir, mcpRel))) ? assertInside(workdir, mcpRel) : undefined;
+    return {
+        manifest,
+        launch: {
+            ...(mcpConfigPath ? { mcpConfigPath } : {}),
+            ...(manifest.resolved.tools.deny?.length ? { disallowedTools: manifest.resolved.tools.deny } : {}),
+        },
+    };
+}

package/dist/daemon/agent/renderers/claude-code.js

@@ -0,0 +1,16 @@
+import { yamlScalar } from "./common.js";
+/** claude-code 原生 agent 定义（.claude/agents/<slug>.md） */
+export function renderClaudeAgentDoc(agent) {
+    const head = [
+        "---",
+        `name: ${agent.slug}`,
+        `description: ${yamlScalar(agent.description)}`,
+        ...(agent.tools.allow?.length ? [`tools: ${agent.tools.allow.join(", ")}`] : []),
+        ...(agent.tools.deny?.length ? [`disallowedTools: ${agent.tools.deny.join(", ")}`] : []),
+        ...(agent.model ? [`model: ${yamlScalar(agent.model)}`] : []),
+        ...(agent.permission_mode ? [`permissionMode: ${yamlScalar(agent.permission_mode)}`] : []),
+        "---",
+        "",
+    ];
+    return `${head.join("\n")}${agent.instructions.trim()}\n`;
+}

package/dist/daemon/agent/renderers/common.js

@@ -0,0 +1,61 @@
+export const BLOCK_BEGIN = "<!-- super-coding:agent:begin -->";
+export const BLOCK_END = "<!-- super-coding:agent:end -->";
+/** 需要引号时用 JSON 字符串（YAML 双引号语法兼容），否则原样输出 */
+export function yamlScalar(value) {
+    const oneLine = value.replace(/\r?\n/g, " ").trim();
+    if (/[:#\n"'&*!?|>%@`]|^\s|\s$/.test(oneLine))
+        return JSON.stringify(oneLine);
+    return oneLine;
+}
+/** 工具约束的文字说明（runner 不支持结构化工具字段时作为软约束） */
+export function toolsNote(tools) {
+    const lines = [];
+    if (tools.allow?.length)
+        lines.push(`- 只使用这些工具：${tools.allow.join(", ")}`);
+    if (tools.deny?.length)
+        lines.push(`- 禁止使用这些工具：${tools.deny.join(", ")}`);
+    return lines.length ? `## 工具约束\n\n${lines.join("\n")}` : "";
+}
+export function skillsNote(agent) {
+    if (agent.skills.length === 0)
+        return "";
+    const lines = agent.skills.map((skill) => {
+        const description = skill.description ? `：${skill.description}` : "";
+        return `- \`${skill.slug}\`${description}（${skill.relativePath}）`;
+    });
+    return `### 可用技能\n\n${lines.join("\n")}`;
+}
+/** 主会话指令块：只维护 marker 之间内容，保留用户已有的 CLAUDE.md/AGENTS.md */
+export function sessionBlock(agent, opts) {
+    const head = `## Super Coding Agent：${agent.name}`;
+    if (opts.pointer) {
+        return [
+            BLOCK_BEGIN,
+            head,
+            "",
+            `本会话由平台注入的原生 agent \`${agent.slug}\` 执行，定义与系统指令见 \`${opts.agentDocPath}\`。`,
+            "请始终以该 agent 的身份与约束工作。",
+            ...(skillsNote(agent) ? ["", skillsNote(agent)] : []),
+            BLOCK_END,
+        ].join("\n");
+    }
+    return [BLOCK_BEGIN, head, "", agent.instructions, "", BLOCK_END].join("\n");
+}
+/** 把托管块写入既有文件内容（保留块外内容，重复调用结果稳定） */
+export function upsertBlock(existing, block) {
+    const start = existing.indexOf(BLOCK_BEGIN);
+    const end = existing.indexOf(BLOCK_END);
+    if (start >= 0 && end > start) {
+        return `${existing.slice(0, start)}${block}${existing.slice(end + BLOCK_END.length)}`;
+    }
+    const trimmed = existing.replace(/\s*$/, "");
+    return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
+}
+/** 去掉托管块（换 runner / 清理时用），保留用户内容 */
+export function removeBlock(existing) {
+    const start = existing.indexOf(BLOCK_BEGIN);
+    const end = existing.indexOf(BLOCK_END);
+    if (start < 0 || end <= start)
+        return existing;
+    return `${existing.slice(0, start)}${existing.slice(end + BLOCK_END.length)}`.replace(/\n{3,}/g, "\n\n").replace(/^\s+/, "");
+}

package/dist/daemon/agent/renderers/cursor.js

@@ -0,0 +1,13 @@
+import { toolsNote, yamlScalar } from "./common.js";
+export function renderCursorAgentDoc(agent) {
+    const head = [
+        "---",
+        `name: ${agent.slug}`,
+        `description: ${yamlScalar(agent.description)}`,
+        ...(agent.model ? [`model: ${yamlScalar(agent.model)}`] : []),
+        "---",
+        "",
+    ];
+    const note = toolsNote(agent.tools);
+    return `${head.join("\n")}${note ? `${note}\n\n` : ""}${agent.instructions.trim()}\n`;
+}

package/dist/daemon/agent/renderers/generic.js

@@ -0,0 +1,5 @@
+import { toolsNote } from "./common.js";
+export function renderGenericAgentDoc(agent) {
+    const note = toolsNote(agent.tools);
+    return `# ${agent.name}\n\n${note ? `${note}\n\n` : ""}${agent.instructions.trim()}\n`;
+}

package/dist/daemon/agent/resolve.js

@@ -0,0 +1,212 @@
+import { renderTemplate } from "./builtin/parse.js";
+import { builtinDefaults } from "./builtin/load.js";
+import { agentSlug } from "./slug.js";
+import { AgentError } from "./types.js";
+/** claude 侧接受的权限模式；bypassPermissions 默认拒绝（可用环境变量显式放行） */
+const PERMISSION_MODES = new Set(["default", "acceptEdits", "auto", "dontAsk", "plan", "bypassPermissions"]);
+const ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ENV_DENY_KEYS = new Set(["PATH", "HOME", "SHELL", "PWD", "NODE_OPTIONS", "NODE_PATH"]);
+const ENV_DENY_PREFIXES = ["SC_", "DAEMON_", "NEXUS_", "LD_", "DYLD_"];
+const MAX_ENV_ENTRIES = 64;
+const MAX_ENV_VALUE = 8 * 1024;
+const MAX_MCP_SERVERS = 32;
+const MAX_INSTRUCTIONS = 100_000;
+const MAX_SKILLS = 64;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function stringList(value, field) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new AgentError("agent_config_invalid", `${field} 必须是字符串数组`);
+    }
+    return [...new Set(value.map((item) => item.trim()).filter(Boolean))];
+}
+function normalizeTools(value) {
+    if (value === undefined)
+        return {};
+    if (Array.isArray(value))
+        return { allow: stringList(value, "config.tools") };
+    if (!isRecord(value))
+        throw new AgentError("agent_config_invalid", "config.tools 必须是数组或 {allow,deny}");
+    const tools = {};
+    const allow = stringList(value["allow"], "config.tools.allow");
+    const deny = stringList(value["deny"], "config.tools.deny");
+    if (allow.length)
+        tools.allow = allow;
+    if (deny.length)
+        tools.deny = deny;
+    return tools;
+}
+function normalizeEnv(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new AgentError("agent_config_invalid", "config.env 必须是对象");
+    const entries = Object.entries(value);
+    if (entries.length > MAX_ENV_ENTRIES) {
+        throw new AgentError("agent_config_invalid", `config.env 超过 ${MAX_ENV_ENTRIES} 项`);
+    }
+    const env = {};
+    for (const [key, raw] of entries) {
+        if (!ENV_KEY.test(key) || key === "__proto__" || key === "constructor" || key === "prototype") {
+            throw new AgentError("agent_config_invalid", `config.env 非法变量名：${key}`);
+        }
+        if (ENV_DENY_KEYS.has(key.toUpperCase())) {
+            throw new AgentError("agent_config_invalid", `config.env 不允许覆盖 ${key}`);
+        }
+        const upper = key.toUpperCase();
+        if (ENV_DENY_PREFIXES.some((prefix) => upper.startsWith(prefix))) {
+            throw new AgentError("agent_config_invalid", `config.env 不允许使用 ${key} 前缀`);
+        }
+        if (typeof raw !== "string")
+            throw new AgentError("agent_config_invalid", `config.env.${key} 必须是字符串`);
+        if (raw.length > MAX_ENV_VALUE) {
+            throw new AgentError("agent_config_invalid", `config.env.${key} 超过 ${MAX_ENV_VALUE} 字符`);
+        }
+        env[key] = raw;
+    }
+    return env;
+}
+function normalizeMcp(value) {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new AgentError("agent_config_invalid", "config.mcp_servers 必须是对象");
+    const entries = Object.entries(value);
+    if (entries.length > MAX_MCP_SERVERS) {
+        throw new AgentError("agent_config_invalid", `config.mcp_servers 超过 ${MAX_MCP_SERVERS} 个`);
+    }
+    const servers = {};
+    for (const [name, raw] of entries) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+            throw new AgentError("agent_config_invalid", `config.mcp_servers 非法名称：${name}`);
+        }
+        if (!isRecord(raw))
+            throw new AgentError("agent_config_invalid", `config.mcp_servers.${name} 必须是对象`);
+        const type = raw["type"];
+        if (type !== undefined && type !== "stdio" && type !== "sse" && type !== "http") {
+            throw new AgentError("agent_config_invalid", `config.mcp_servers.${name}.type 不支持：${String(type)}`);
+        }
+        const command = typeof raw["command"] === "string" ? raw["command"].trim() : "";
+        const url = typeof raw["url"] === "string" ? raw["url"].trim() : "";
+        if (!command && !url) {
+            throw new AgentError("agent_config_invalid", `config.mcp_servers.${name} 需要 command 或 url`);
+        }
+        const args = raw["args"];
+        if (args !== undefined && (!Array.isArray(args) || args.some((a) => typeof a !== "string"))) {
+            throw new AgentError("agent_config_invalid", `config.mcp_servers.${name}.args 必须是字符串数组`);
+        }
+        const head = raw["headers"];
+        const processEnv = raw["env"];
+        for (const [field, value2] of [["env", processEnv], ["headers", head]]) {
+            if (value2 === undefined)
+                continue;
+            if (!isRecord(value2))
+                throw new AgentError("agent_config_invalid", `config.mcp_servers.${name}.${field} 必须是对象`);
+            for (const [k, v] of Object.entries(value2)) {
+                if (typeof v !== "string" || v.length > MAX_ENV_VALUE) {
+                    throw new AgentError("agent_config_invalid", `config.mcp_servers.${name}.${field}.${k} 非法`);
+                }
+            }
+        }
+        servers[name] = {
+            ...(type ? { type } : { type: command ? "stdio" : "http" }),
+            ...(command ? { command } : {}),
+            ...(Array.isArray(args) ? { args: args } : {}),
+            ...(processEnv ? { env: processEnv } : {}),
+            ...(url ? { url } : {}),
+            ...(head ? { headers: head } : {}),
+        };
+    }
+    return servers;
+}
+function permissionMode(value, env) {
+    const mode = value?.trim();
+    if (!mode)
+        return undefined;
+    if (!PERMISSION_MODES.has(mode)) {
+        throw new AgentError("agent_config_invalid", `permission_mode 不支持：${mode}`);
+    }
+    // daemon 是无人值守执行器，权限审批无人应答；bypass 默认放开（deny_tools 仍生效），
+    // 需要收紧的平台可用 SC_ALLOW_BYPASS_PERMISSIONS=0 关闭。
+    if (mode === "bypassPermissions" && env["SC_ALLOW_BYPASS_PERMISSIONS"] === "0") {
+        throw new AgentError("agent_config_invalid", "permission_mode=bypassPermissions 已被 SC_ALLOW_BYPASS_PERMISSIONS=0 禁用");
+    }
+    return mode;
+}
+/** {{skills}} 的正文：只列名称与路径，具体步骤由执行器读 SKILL.md */
+export function renderSkills(skills) {
+    if (skills.length === 0)
+        return "当前会话没有关联任何技能，按通用工程实践执行即可。";
+    const lines = skills.slice(0, MAX_SKILLS).map((skill) => {
+        const description = skill.description ? `：${skill.description}` : "";
+        return `- \`${skill.slug}\`${description}（${skill.relativePath}）`;
+    });
+    return ["当前会话已挂载以下技能：", ...lines].join("\n");
+}
+function mergedInstructions(builtin, vars, user) {
+    const base = renderTemplate(builtin.instructions, vars).trim();
+    const extra = user?.trim();
+    if (!extra)
+        return base;
+    if (extra.length > MAX_INSTRUCTIONS) {
+        throw new AgentError("agent_config_invalid", `instructions 超过 ${MAX_INSTRUCTIONS} 字符`);
+    }
+    // 内置在前：安全基线不可被用户指令覆盖，只做追加
+    return `${base}\n\n---\n\n## 业务 Agent 补充指令\n\n${extra}`;
+}
+export function resolveAgent(input) {
+    const { builtin, runner, workdir, businessAgent, skills } = input;
+    const env = input.env ?? process.env;
+    if (businessAgent) {
+        if (businessAgent.runner && businessAgent.runner !== runner) {
+            throw new AgentError("agent_runner_mismatch", `agent ${businessAgent.id} 绑定 ${businessAgent.runner}，当前会话执行器为 ${runner}`);
+        }
+        if (businessAgent.status && businessAgent.status !== "enabled") {
+            throw new AgentError("agent_disabled", `agent ${businessAgent.id} 状态为 ${businessAgent.status}`);
+        }
+    }
+    const config = businessAgent?.config;
+    if (config !== undefined && !isRecord(config)) {
+        throw new AgentError("agent_config_invalid", "agent.config 必须是对象");
+    }
+    const cfg = (config ?? {});
+    const name = businessAgent?.name?.trim() || builtin.name;
+    const description = businessAgent?.description?.trim() || builtin.description;
+    const slug = businessAgent ? agentSlug(businessAgent.id, name) : "sc-builtin-agent";
+    const userTools = normalizeTools(cfg.tools);
+    const tools = {
+        ...(userTools.allow?.length ? { allow: userTools.allow } : {}),
+        deny: [...new Set([...builtin.deny_tools, ...(userTools.deny ?? [])])],
+    };
+    if (!tools.deny?.length)
+        delete tools.deny;
+    const mcpServers = {
+        ...normalizeMcp(cfg.mcp_servers ?? cfg.mcpServers),
+    };
+    const instructions = mergedInstructions(builtin, {
+        name,
+        description,
+        workdir,
+        runner,
+        slug,
+        skills: renderSkills(skills),
+        repo_url: builtin.repo_url?.trim() || builtinDefaults.DEFAULT_REPO_URL,
+    }, typeof cfg.instructions === "string" ? cfg.instructions : undefined);
+    const model = input.options?.model?.trim() || cfg.model?.trim() || builtin.model;
+    const mode = permissionMode(input.options?.permission_mode ?? cfg.permission_mode ?? builtin.permission_mode, env);
+    return {
+        slug,
+        name,
+        description,
+        instructions,
+        ...(model ? { model } : {}),
+        ...(mode ? { permission_mode: mode } : {}),
+        tools,
+        mcp_servers: mcpServers,
+        env: normalizeEnv(cfg.env),
+        skills,
+        ...(businessAgent ? { businessAgent } : {}),
+        builtinSource: builtin.source,
+    };
+}

package/dist/daemon/agent/slug.js

@@ -0,0 +1,27 @@
+// agent 在会话目录里的文件名：必须是 ASCII 安全 slug（执行器按目录名/文件名识别）。
+// 用户配置里的 name 可能是中文或带空格，这里统一归一化后追加 id 短哈希避免重名。
+import { createHash } from "node:crypto";
+import { resolve, sep } from "node:path";
+import { AgentError } from "./types.js";
+const MAX_BASE = 32;
+export function agentSlug(id, name) {
+    const base = name
+        .normalize("NFKD")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, MAX_BASE)
+        .replace(/-+$/g, "") || "agent";
+    // 名字也参与哈希：中文名归一化后都退化成 agent，仅用 id 会让改名拿不到新 slug（旧文件清不掉）
+    const hash = createHash("sha256").update(`${id}\u0000${name}`).digest("hex").slice(0, 8);
+    return `sc-${base}-${hash}`;
+}
+/** 解析相对路径并确保仍在会话目录内（防路径逃逸） */
+export function assertInside(workdir, relative) {
+    const root = resolve(workdir);
+    const abs = resolve(root, relative);
+    if (abs !== root && !abs.startsWith(root + sep)) {
+        throw new AgentError("agent_config_invalid", `路径越界：${relative}`);
+    }
+    return abs;
+}

package/dist/daemon/agent/types.js

@@ -0,0 +1,8 @@
+export class AgentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AgentError";
+    }
+}

package/dist/daemon/device-store.js

@@ -0,0 +1,61 @@
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const defaultDir = () => process.env.SC_HOME ?? join(homedir(), ".super-coding");
+const file = (dir) => join(dir, "daemon.json");
+const backup = (dir) => join(dir, "daemon.json.bak");
+export function loadDevice(dir = defaultDir()) {
+    if (!existsSync(file(dir)))
+        return null;
+    return JSON.parse(readFileSync(file(dir), "utf8"));
+}
+export function saveDevice(cfg, dir = defaultDir()) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(file(dir), JSON.stringify(cfg, null, 2), { mode: 0o600 });
+    chmodSync(file(dir), 0o600);
+}
+/**
+ * 删除本地设备凭证。
+ * keepBackup=true（默认，4401 自愈路径）：删前备份 daemon.json.bak，启动时可自动恢复；
+ * keepBackup=false（真解绑 device:unpair）：连备份一并清除，不复活已解绑凭证。
+ */
+export function removeDevice(dir = defaultDir(), opts = {}) {
+    const keepBackup = opts.keepBackup ?? true;
+    if (existsSync(file(dir))) {
+        if (keepBackup) {
+            try {
+                copyFileSync(file(dir), backup(dir));
+            }
+            catch {
+                /* 备份失败不阻塞删除 */
+            }
+        }
+        rmSync(file(dir), { force: true });
+    }
+    if (!keepBackup)
+        rmSync(backup(dir), { force: true });
+}
+/** 从 daemon.json.bak 恢复凭证（4401 误删自愈）；无备份返 null */
+export function restoreDeviceBackup(dir = defaultDir()) {
+    if (existsSync(file(dir)) || !existsSync(backup(dir)))
+        return null;
+    try {
+        copyFileSync(backup(dir), file(dir));
+        chmodSync(file(dir), 0o600);
+        return loadDevice(dir);
+    }
+    catch {
+        return null;
+    }
+}
+export function loadDaemonConfig(dir = defaultDir()) {
+    const path = join(dir, "config.json");
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}