@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/runner-host/dist/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { ConfigStore, VERSION } from "@codebridge/core";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--version") || args.includes("-V")) {
+        console.log(VERSION);
+        return;
+    }
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log("Usage: codebridge-runner [-c <config.yaml>] [--version] [--help]");
+        return;
+    }
+    const configFlag = args.indexOf("-c");
+    const configFile = configFlag >= 0 ? args[configFlag + 1] : undefined;
+    if (configFile) {
+        process.env.DATA_DIR = path.dirname(path.resolve(configFile));
+    }
+    // The Runner only needs its own token; never fail on Feishu/Telegram secrets it does not use.
+    const store = new ConfigStore({ resolve: ["runner.token"] });
+    const config = store.reload();
+    const listen = config.runnerHost?.listen ??
+        process.env.RUNNER_LISTEN ??
+        "127.0.0.1:19789";
+    const [hostname, portStr] = listen.split(":");
+    const port = Number(portStr);
+    const { serve } = await import("@hono/node-server");
+    const { createRunnerApp, RunnerHost } = await import("./server.js");
+    const runnerHost = new RunnerHost({
+        token: config.runner.token,
+        config,
+        maxConcurrentRuns: config.runnerHost?.maxConcurrentRuns,
+        dataDir: path.dirname(store.path),
+        deploymentMcpServerPath: fileURLToPath(new URL("./deployment-mcp-server.js", import.meta.url)),
+    });
+    const app = createRunnerApp(runnerHost, config.runner.token);
+    console.log(`codebridge-runner listening on http://${hostname}:${port}`);
+    serve({ fetch: app.fetch, hostname, port });
+    // 适配器子进程是 detached（自成进程组），不会随 runner 死——退出前必须同步清场
+    //（池内空闲进程 + 在飞 run），否则每次 stop/重启都会留孤儿。start.sh 的
+    // SIGTERM→0.5s→SIGKILL 窗口内同步 kill 来得及。
+    const shutdown = () => {
+        try {
+            runnerHost.shutdown();
+        }
+        finally {
+            process.exit(0);
+        }
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/node_modules/@codebridge/runner-host/dist/codex-session-ownership.d.ts

@@ -0,0 +1,13 @@
+type ExecFileResult = {
+    stdout: string;
+};
+type ExecFileRunner = (file: string, args: string[]) => Promise<ExecFileResult>;
+export interface CodexSessionOwnershipOptions {
+    codexHome?: string;
+    platform?: NodeJS.Platform;
+    execFile?: ExecFileRunner;
+}
+export declare function filterForeignOwnerPids(pids: number[], allowedProcessGroups: ReadonlySet<number>, processGroupOf: (pid: number) => Promise<number | undefined>): Promise<number[]>;
+export declare function inspectForeignCodexSessionOwners(sessionId: string, allowedProcessGroups: ReadonlySet<number>, options?: CodexSessionOwnershipOptions): Promise<number[]>;
+export {};
+//# sourceMappingURL=codex-session-ownership.d.ts.map

package/node_modules/@codebridge/runner-host/dist/codex-session-ownership.js

@@ -0,0 +1,79 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const defaultExecFile = async (file, args) => {
+    const { stdout } = await execFileAsync(file, args);
+    return { stdout: String(stdout) };
+};
+export async function filterForeignOwnerPids(pids, allowedProcessGroups, processGroupOf) {
+    const foreign = [];
+    for (const pid of pids) {
+        const group = await processGroupOf(pid);
+        if (group === undefined || !allowedProcessGroups.has(group))
+            foreign.push(pid);
+    }
+    return foreign;
+}
+async function findRolloutPath(directory, suffix, depth) {
+    if (depth < 0)
+        return undefined;
+    const entries = await fs
+        .readdir(directory, { withFileTypes: true })
+        .catch(() => undefined);
+    if (!entries)
+        return undefined;
+    for (const entry of entries) {
+        const candidate = path.join(directory, entry.name);
+        if (entry.isFile() && entry.name.endsWith(suffix))
+            return candidate;
+        if (entry.isDirectory()) {
+            const found = await findRolloutPath(candidate, suffix, depth - 1);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+async function processGroupOf(pid, run) {
+    try {
+        const { stdout } = await run("ps", ["-o", "pgid=", "-p", String(pid)]);
+        const value = Number.parseInt(stdout.trim(), 10);
+        return Number.isFinite(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function inspectForeignCodexSessionOwners(sessionId, allowedProcessGroups, options = {}) {
+    if ((options.platform ?? process.platform) !== "darwin")
+        return [];
+    const codexHome = options.codexHome ?? path.join(os.homedir(), ".codex");
+    const run = options.execFile ?? defaultExecFile;
+    const suffix = `-${sessionId}.jsonl`;
+    const rolloutPath = (await findRolloutPath(path.join(codexHome, "sessions"), suffix, 4)) ??
+        (await findRolloutPath(path.join(codexHome, "archived_sessions"), suffix, 1));
+    if (!rolloutPath)
+        return [];
+    let stdout = "";
+    try {
+        ({ stdout } = await run("lsof", ["-t", rolloutPath]));
+    }
+    catch (error) {
+        const result = error;
+        if (result.code === 1 || result.code === "ENOENT")
+            return [];
+        if (typeof result.stdout === "string")
+            stdout = result.stdout;
+        else
+            throw error;
+    }
+    const pids = [...new Set(stdout
+            .split(/\s+/)
+            .map((value) => Number.parseInt(value, 10))
+            .filter((value) => Number.isFinite(value)))];
+    return filterForeignOwnerPids(pids, allowedProcessGroups, (pid) => processGroupOf(pid, run));
+}
+//# sourceMappingURL=codex-session-ownership.js.map

package/node_modules/@codebridge/runner-host/dist/deployment-mcp-server.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { StdioMcpServerConfig } from "@codebridge/core";
+export interface DeploymentMcpContext {
+    api: string;
+    token: string;
+    runId: string;
+}
+export declare function createDeploymentMcpServer(deployment?: DeploymentMcpContext): McpServer;
+export declare function createDeploymentMcpServerConfig(scriptPath: string, deployment: DeploymentMcpContext): StdioMcpServerConfig;
+//# sourceMappingURL=deployment-mcp-server.d.ts.map

package/node_modules/@codebridge/runner-host/dist/deployment-mcp-server.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { z } from "zod";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+const DeploymentInputSchema = z.object({
+    action: z.enum(["prepare", "publish", "status", "cancel", "rollback"]),
+    ref: z.string().optional(),
+    releaseId: z.string().optional(),
+    publishAfterPrepare: z.boolean().optional(),
+}).strict();
+export function createDeploymentMcpServer(deployment) {
+    const server = new McpServer({ name: "codebridge-internal", version: "1.0.0" });
+    if (deployment)
+        server.registerTool("codebridge_deploy", {
+            description: "CodeBridge 安全发布：准备候选、按用户明确授权上线、查询状态、取消或回滚。身份由当前任务绑定；无需 shell 网络或放宽沙箱。发布与回滚仍由 Bridge 校验飞书原始授权。",
+            inputSchema: DeploymentInputSchema,
+            annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+        }, async (input) => {
+            if (!deployment.runId || !deployment.token || !deployment.api) {
+                return { isError: true, content: [{ type: "text", text: "发布工具缺少当前任务身份或连接配置，已拒绝执行。" }] };
+            }
+            try {
+                const response = await fetch(`${deployment.api}/deploy/command`, {
+                    method: "POST",
+                    headers: { authorization: `Bearer ${deployment.token}`, "content-type": "application/json" },
+                    body: JSON.stringify({ ...DeploymentInputSchema.parse(input), runId: deployment.runId }),
+                    signal: AbortSignal.timeout(15_000),
+                });
+                const text = await response.text();
+                return { isError: !response.ok, content: [{ type: "text", text }] };
+            }
+            catch {
+                return { isError: true, content: [{ type: "text", text: "暂时联系不上本机 Bridge 发布接口，请稍后重试。" }] };
+            }
+        });
+    return server;
+}
+export function createDeploymentMcpServerConfig(scriptPath, deployment) {
+    if (!path.isAbsolute(scriptPath))
+        throw new Error("Internal MCP server path must be absolute");
+    return { name: "codebridge-internal", command: process.execPath, args: [scriptPath],
+        env: { FCB_API: deployment.api, FCB_TOKEN: deployment.token, FCB_RUN_ID: deployment.runId } };
+}
+async function main() {
+    const server = createDeploymentMcpServer(process.env.FCB_API === undefined ? undefined : {
+        api: process.env.FCB_API, token: process.env.FCB_TOKEN ?? "", runId: process.env.FCB_RUN_ID ?? "",
+    });
+    await server.connect(new StdioServerTransport());
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch((error) => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });
+}
+//# sourceMappingURL=deployment-mcp-server.js.map

package/node_modules/@codebridge/runner-host/dist/fcb-script.d.ts

@@ -0,0 +1,3 @@
+/** 把 fcb 写入 <dataDir>/bin/fcb 并加执行位，返回 bin 目录 */
+export declare function writeFcbScript(dataDir: string): Promise<string>;
+//# sourceMappingURL=fcb-script.d.ts.map

package/node_modules/@codebridge/runner-host/dist/fcb-script.js

@@ -0,0 +1,99 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * fcb — 注入到 Agent 子进程 PATH 的小命令，通过 Bridge 出站 API
+ * 把文件/消息发回当前飞书聊天。纯 node 实现，无外部依赖。
+ */
+const FCB_SCRIPT = `#!/usr/bin/env node
+// fcb — 在 CodeBridge Agent 任务里把文件/消息发回当前聊天
+// 用法: fcb send <文件路径> | fcb say <消息> | fcb mention <对象引用> <消息> | fcb alert status <状态> <证据或待办> | fcb deploy prepare [--publish] [--ref <commit>] | fcb deploy apply/status/cancel/rollback [release]
+const path = require("node:path");
+const fs = require("node:fs");
+
+const api = process.env.FCB_API;
+const token = process.env.FCB_TOKEN;
+// Destination is resolved by Bridge from FCB_RUN_ID; never use FCB_CHAT_ID to send.
+const runId = process.env.FCB_RUN_ID;
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
+async function post(route, body) {
+  const res = await fetch(api + route, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: "Bearer " + token,
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await res.text();
+  if (!res.ok) fail("fcb: " + res.status + " " + text);
+  console.log(text);
+}
+
+async function main() {
+  if (!api || !token || !runId) {
+    fail("fcb: 缺少 FCB_API/FCB_TOKEN/FCB_RUN_ID（仅在 CodeBridge 任务中可用）");
+  }
+  const [cmd, ...rest] = process.argv.slice(2);
+  if (cmd === "deploy") {
+    if (!runId) fail("fcb: 发布操作缺少当前任务身份，不能执行");
+    const actions = {prepare: "prepare", apply: "publish", status: "status", cancel: "cancel", rollback: "rollback"};
+    const action = actions[rest[0]];
+    if (!action) fail("fcb: 发布操作支持 prepare/apply/status/cancel/rollback");
+    const body = {runId, action};
+    const args = rest.slice(1);
+    if (action === "prepare") {
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--publish") body.publishAfterPrepare = true;
+        else if (args[i] === "--ref" && args[i + 1] && !args[i + 1].startsWith("-")) body.ref = args[++i];
+        else fail("fcb: 未识别的发布参数 " + args[i]);
+      }
+    } else {
+      if (args.length > 1 || (args[0] && args[0].startsWith("-"))) fail("fcb: 请只提供一个发布编号或省略");
+      if (args[0]) body.releaseId = args[0];
+    }
+    await post("/deploy/command", body);
+  } else if (cmd === "send" && rest[0]) {
+    await post("/outbound/file", {
+      runId,
+      path: path.resolve(rest[0]),
+    });
+  } else if (cmd === "say" && rest.length) {
+    await post("/outbound/markdown", {
+      runId,
+      markdown: rest.join(" "),
+    });
+  } else if (cmd === "mention" && rest[0] && rest.length > 1) {
+    await post("/outbound/mention", {
+      runId,
+      ref: rest[0],
+      text: rest.slice(1).join(" "),
+    });
+  } else if (cmd === "alert" && rest[0] === "status" && rest[1] && rest.length > 2) {
+    await post("/outbound/alert-status", {runId, status: rest[1], summary: rest.slice(2).join(" ")});
+  } else {
+    fail("用法: fcb send <文件路径> | fcb say <消息> | fcb mention <对象引用> <消息> | fcb alert status <状态> <证据或待办> | fcb deploy prepare [--publish] [--ref <commit>] | fcb deploy apply/status/cancel/rollback [release]");
+  }
+}
+
+main().catch((err) => {
+  if (process.argv[2] === "deploy" && ["EPERM", "EACCES"].includes(err.cause?.code)) {
+    fail("fcb: 当前执行沙箱禁止本机网络，请使用 codebridge_deploy MCP 工具；不要关闭沙箱或重启服务。");
+  }
+  fail("fcb: " + (err instanceof Error ? err.message : String(err)));
+});
+`;
+/** 把 fcb 写入 <dataDir>/bin/fcb 并加执行位，返回 bin 目录 */
+export async function writeFcbScript(dataDir) {
+    const binDir = path.join(dataDir, "bin");
+    await fs.mkdir(binDir, { recursive: true });
+    const file = path.join(binDir, "fcb");
+    await fs.writeFile(file, FCB_SCRIPT, { mode: 0o755 });
+    await fs.chmod(file, 0o755);
+    return binDir;
+}
+//# sourceMappingURL=fcb-script.js.map

package/node_modules/@codebridge/runner-host/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { RunnerHost, createRunnerApp } from "./server.js";
+export type { RunnerHostOptions } from "./server.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/runner-host/dist/index.js

@@ -0,0 +1,2 @@
+export { RunnerHost, createRunnerApp } from "./server.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/runner-host/dist/materialize-attachments.d.ts

@@ -0,0 +1,4 @@
+import type { LocalMediaPath, RunAttachment } from "@codebridge/core";
+export declare function materializeAttachments(dataDir: string, runId: string, attachments?: RunAttachment[]): Promise<LocalMediaPath[]>;
+export declare function cleanupAttachments(dataDir: string, runId: string): Promise<void>;
+//# sourceMappingURL=materialize-attachments.d.ts.map

package/node_modules/@codebridge/runner-host/dist/materialize-attachments.js

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+function truncateUtf8(value, maxBytes) {
+    let bytes = 0;
+    const characters = [];
+    for (const character of value) {
+        bytes += Buffer.byteLength(character, "utf8");
+        if (bytes > maxBytes)
+            break;
+        characters.push(character);
+    }
+    return characters.join("");
+}
+export async function materializeAttachments(dataDir, runId, attachments) {
+    if (!attachments?.length)
+        return [];
+    const dir = path.join(dataDir, "attachments", runId);
+    await fs.mkdir(dir, { recursive: true });
+    const out = [];
+    const usedNames = new Set();
+    try {
+        for (let i = 0; i < attachments.length; i++) {
+            const att = attachments[i];
+            const basename = path.posix.basename((att.name || "").replace(/\\/g, "/"));
+            const sanitized = basename.normalize("NFC")
+                .replace(/[\x00-\x1f\x7f<>:"|?*]/g, "_")
+                .replace(/[. ]+$/g, "");
+            const originalName = sanitized || `attachment-${i + 1}.bin`;
+            const originalExtension = path.extname(originalName);
+            // Keep normal format extensions; an oversized suffix is filename content.
+            const extension = Buffer.byteLength(originalExtension, "utf8") <= 32
+                ? originalExtension
+                : "";
+            const stem = originalName.slice(0, originalName.length - extension.length);
+            const stemBudget = 255 - Buffer.byteLength(extension, "utf8");
+            let safeName = `${truncateUtf8(stem, stemBudget)}${extension}`;
+            let suffix = 2;
+            while (usedNames.has(safeName.toLowerCase())) {
+                const collisionSuffix = `-${suffix++}`;
+                safeName = `${truncateUtf8(stem, stemBudget - collisionSuffix.length)}${collisionSuffix}${extension}`;
+            }
+            usedNames.add(safeName.toLowerCase());
+            const filePath = path.join(dir, safeName);
+            await fs.writeFile(filePath, Buffer.from(att.dataBase64, "base64"));
+            out.push({
+                path: filePath,
+                mimeType: att.mimeType,
+                name: safeName,
+            });
+        }
+    }
+    catch (error) {
+        await cleanupAttachments(dataDir, runId);
+        throw error;
+    }
+    return out;
+}
+export async function cleanupAttachments(dataDir, runId) {
+    const dir = path.join(dataDir, "attachments", runId);
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => { });
+}
+//# sourceMappingURL=materialize-attachments.js.map

package/node_modules/@codebridge/runner-host/dist/server.d.ts

@@ -0,0 +1,150 @@
+import { AgentSetupService, forkPiSession, SkillControlPlane, type AgentAuthProbe, type AgentSetupInstallResult, type AgentSetupRecord, type CliSessionSummary, type PiSession, type PiSessionLifecycleResult, type ProviderSessionHistoryEvent, type SkillAgentId, type SkillCatalogSnapshot, type SkillMutationPlan, type SkillMutationResult } from "@codebridge/backends";
+import type { AgentAvailableCommand, AgentEvent, AppConfig, BackendConfigOption, RunContext, RunRequest } from "@codebridge/core";
+import { Hono } from "hono";
+export interface RunnerHostOptions {
+    token: string;
+    config: AppConfig;
+    maxConcurrentRuns?: number;
+    dataDir?: string;
+    agentSetupService?: AgentSetupService;
+    /** Test/embedding hook; production uses the native Pi Node SDK factory. */
+    piSessionFactory?: (ctx: RunContext) => Promise<PiSession>;
+    /** Test/embedding hook for provider-native session fork. */
+    piSessionForker?: typeof forkPiSession;
+    inspectSessionOwners?: (sessionId: string, allowedProcessGroups: ReadonlySet<number>) => Promise<number[]>;
+    /** Host-native directory chooser. Production uses the macOS folder panel. */
+    directoryPicker?: () => Promise<string | null>;
+    /** Test/embedding hook for Codex app-server Skill discovery. */
+    codexSkillLister?: (cwd: string) => Promise<AgentAvailableCommand[]>;
+    /** Absolute built entrypoint for the Bridge-owned read-only MCP server. */
+    deploymentMcpServerPath?: string;
+    /** Test/embedding hook; production owns local Skill filesystem projection here. */
+    skillControlPlane?: Pick<SkillControlPlane, "scan" | "addSource" | "previewAdopt" | "previewAssignment" | "previewGlobalState" | "previewUnmanage" | "applyPlan">;
+}
+export declare class RunnerHost {
+    private readonly options;
+    private readonly registry;
+    private readonly active;
+    private readonly runLifecycles;
+    private readonly maxConcurrent;
+    private readonly dataDir;
+    private readonly acpPermissionPolicy;
+    private readonly acpRunOptions;
+    private readonly fcbBinDir;
+    private readonly sessionLeases;
+    private readonly inspectSessionOwners;
+    /** 长驻 ACP 会话池：同会话消息复用适配器进程（kill switch: runnerHost.acpSessionPool） */
+    private readonly sessionPool;
+    private readonly agentSetup;
+    private readonly skillControlPlane;
+    /**
+     * prompt_feishu：每个 run 的挂起权限请求队列（FIFO）。claude 通常一次只挂一个，
+     * 但并行工具可能并发请求——用队列而非单槽，避免互相覆盖、/approve 只回给最早的那个。
+     */
+    private readonly pendingPermissions;
+    private readonly deploymentMcpServerPath;
+    constructor(options: RunnerHostOptions);
+    /** Agent 子进程环境：fcb 出站 API 凭据 + 把 fcb 挂到 PATH */
+    private buildAgentEnv;
+    get registryIds(): string[];
+    doctor(): Promise<{
+        ok: boolean;
+        checks: Array<{
+            name: string;
+            ok: boolean;
+            message?: string;
+        }>;
+        version: string;
+        backends: string[];
+        authProbes: Record<string, AgentAuthProbe>;
+    }>;
+    /**
+     * 每个已配置的 ACP 后端各探一次登录状态，纯展示用：探测失败/未知也照样返回，绝不让
+     * doctor 整体失败，调用方也绝不能拿这个当拦截运行的硬门槛（见 AgentAuthProbe 注释）。
+     */
+    private probeConfiguredBackendAuth;
+    listAgentSetup(): Promise<AgentSetupRecord[]>;
+    detectAgent(agentId: string): Promise<AgentSetupRecord>;
+    installAgent(agentId: string, strategyId: string): Promise<AgentSetupInstallResult>;
+    cancel(runId: string): boolean;
+    cancelAndWait(runId: string): Promise<boolean>;
+    private createRunLifecycle;
+    steer(runId: string, prompt: string): Promise<{
+        ok: boolean;
+        outcome?: string;
+        error?: string;
+    }>;
+    listSessions(backendId: string, cwd: string, options?: {
+        limit?: number;
+        all?: boolean;
+    }): Promise<{
+        sessions: CliSessionSummary[];
+        error?: string;
+    }>;
+    loadSessionHistory(backendId: string, rawCwd: string, sessionId: string, additionalDirectories?: string[]): Promise<ProviderSessionHistoryEvent[]>;
+    authorizeDirectory(rawPath: string): Promise<{
+        ok: boolean;
+        path?: string;
+        error?: string;
+    }>;
+    listDirectory(rawRoot: string, relativePath?: string): Promise<{
+        ok: boolean;
+        root?: string;
+        path?: string;
+        relativePath?: string;
+        entries?: Array<{
+            name: string;
+            path: string;
+            absolutePath: string;
+            kind: "directory" | "file";
+        }>;
+        error?: string;
+    }>;
+    pickDirectory(): Promise<{
+        ok: boolean;
+        path?: string;
+        cancelled?: boolean;
+        error?: string;
+    }>;
+    closeSession(backendId: string, cwd: string, sessionId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    deleteSession(backendId: string, cwd: string, sessionId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    forkSession(backendId: string, cwd: string, sessionId: string, targetCwd: string): Promise<PiSessionLifecycleResult>;
+    private manageSession;
+    /** /model 动态列表：拉取 ACP 适配器 advertise 的会话配置项 */
+    listConfigOptions(backendId: string, cwd: string, model?: string | null): Promise<{
+        options: BackendConfigOption[];
+        error?: string;
+    }>;
+    listCommands(backendId: string, cwd: string): Promise<{
+        commands: AgentAvailableCommand[];
+        error?: string;
+    }>;
+    scanSkills(): SkillCatalogSnapshot;
+    addSkillSource(sourcePath: string): SkillCatalogSnapshot;
+    previewSkillAdopt(skillId: string, actorId: string): SkillMutationPlan;
+    previewSkillAssignment(input: {
+        skill_id: string;
+        agent_id: SkillAgentId;
+        enabled: boolean;
+        actor_id: string;
+    }): SkillMutationPlan;
+    previewSkillGlobalState(skillId: string, enabled: boolean, actorId: string): SkillMutationPlan;
+    previewSkillUnmanage(skillId: string, actorId: string): SkillMutationPlan;
+    applySkillPlan(planId: string, actorId: string): SkillMutationResult;
+    executeRun(request: RunRequest): AsyncGenerator<AgentEvent>;
+    private executeRunInner;
+    private executeAcpRun;
+    private executePiRun;
+    /** runner 退出前清场：杀池内空闲进程 + 取消在飞 run（子进程 detached，不清就孤儿） */
+    shutdown(): void;
+    /** /approve /deny：回应当前 run 最早挂起的权限请求（FIFO） */
+    resolvePermission(runId: string, approve: boolean): boolean;
+}
+export declare function createRunnerApp(host: RunnerHost, token: string): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=server.d.ts.map