openclaw-manager 0.1.1

package/dist/lib/utils.js

@@ -0,0 +1,31 @@
+export function parsePort(value) {
+    if (!value)
+        return null;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return null;
+    if (parsed <= 0 || parsed > 65535)
+        return null;
+    return parsed;
+}
+export function parsePositiveInt(value) {
+    if (!value)
+        return null;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return null;
+    if (parsed <= 0)
+        return null;
+    return Math.floor(parsed);
+}
+export function parseOrigins(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/middlewares/auth.js

@@ -0,0 +1,23 @@
+import { resolveAuthState, verifyAuthHeader } from "../lib/auth.js";
+export function createAuthMiddleware(deps) {
+    return async (c, next) => {
+        const pathName = c.req.path;
+        if (pathName.startsWith("/api/auth/")) {
+            return next();
+        }
+        if (deps.auth.disabled) {
+            return next();
+        }
+        const authState = resolveAuthState(deps.auth.disabled);
+        if (!authState.configured) {
+            if (deps.auth.allowUnconfigured)
+                return next();
+            return c.json({ ok: false, error: "auth not configured" }, 401);
+        }
+        const header = c.req.header("authorization");
+        if (!header || !verifyAuthHeader(header, authState)) {
+            return c.json({ ok: false, error: "unauthorized" }, 401);
+        }
+        return next();
+    };
+}

package/dist/routes/auth.js

@@ -0,0 +1,5 @@
+import { createAuthLoginHandler, createAuthStatusHandler } from "../controllers/auth.controller.js";
+export function registerAuthRoutes(app, deps) {
+    app.get("/api/auth/status", createAuthStatusHandler(deps));
+    app.post("/api/auth/login", createAuthLoginHandler(deps));
+}

package/dist/routes/cli.js

@@ -0,0 +1,4 @@
+import { createCliInstallHandler } from "../controllers/cli.controller.js";
+export function registerCliRoutes(app, deps) {
+    app.post("/api/cli/install", createCliInstallHandler(deps));
+}

package/dist/routes/discord.js

@@ -0,0 +1,5 @@
+import { createDiscordPairingHandler, createDiscordTokenHandler } from "../controllers/discord.controller.js";
+export function registerDiscordRoutes(app, deps) {
+    app.post("/api/discord/token", createDiscordTokenHandler(deps));
+    app.post("/api/discord/pairing", createDiscordPairingHandler(deps));
+}

package/dist/routes/health.js

@@ -0,0 +1,9 @@
+export function registerHealthRoutes(app) {
+    app.get("/health", (c) => {
+        return c.json({
+            ok: true,
+            time: new Date().toISOString(),
+            version: "clawdbot-manager-api"
+        });
+    });
+}

package/dist/routes/index.js

@@ -0,0 +1,18 @@
+import { registerAuthRoutes } from "./auth.js";
+import { registerCliRoutes } from "./cli.js";
+import { registerDiscordRoutes } from "./discord.js";
+import { registerHealthRoutes } from "./health.js";
+import { registerJobRoutes } from "./jobs.js";
+import { registerProcessRoutes } from "./processes.js";
+import { registerQuickstartRoutes } from "./quickstart.js";
+import { registerStatusRoutes } from "./status.js";
+export function registerRoutes(app, deps) {
+    registerHealthRoutes(app);
+    registerAuthRoutes(app, deps);
+    registerStatusRoutes(app, deps);
+    registerProcessRoutes(app, deps);
+    registerCliRoutes(app, deps);
+    registerDiscordRoutes(app, deps);
+    registerQuickstartRoutes(app, deps);
+    registerJobRoutes(app, deps);
+}

package/dist/routes/jobs.js

@@ -0,0 +1,11 @@
+import { createAiAuthJobHandler, createCliInstallJobHandler, createDiscordPairingJobHandler, createDiscordPairingWaitJobHandler, createJobStatusHandler, createJobStreamHandler, createQuickstartJobHandler, createResourceDownloadJobHandler } from "../controllers/jobs.controller.js";
+export function registerJobRoutes(app, deps) {
+    app.post("/api/jobs/cli-install", createCliInstallJobHandler(deps));
+    app.post("/api/jobs/quickstart", createQuickstartJobHandler(deps));
+    app.post("/api/jobs/discord/pairing", createDiscordPairingJobHandler(deps));
+    app.post("/api/jobs/discord/pairing/wait", createDiscordPairingWaitJobHandler(deps));
+    app.post("/api/jobs/resources/download", createResourceDownloadJobHandler(deps));
+    app.post("/api/jobs/ai/auth", createAiAuthJobHandler(deps));
+    app.get("/api/jobs/:id", createJobStatusHandler(deps));
+    app.get("/api/jobs/:id/stream", createJobStreamHandler(deps));
+}

package/dist/routes/processes.js

@@ -0,0 +1,6 @@
+import { createProcessListHandler, createProcessStartHandler, createProcessStopHandler } from "../controllers/process.controller.js";
+export function registerProcessRoutes(app, deps) {
+    app.get("/api/processes", createProcessListHandler(deps));
+    app.post("/api/processes/start", createProcessStartHandler(deps));
+    app.post("/api/processes/stop", createProcessStopHandler(deps));
+}

package/dist/routes/quickstart.js

@@ -0,0 +1,4 @@
+import { createQuickstartHandler } from "../controllers/quickstart.controller.js";
+export function registerQuickstartRoutes(app, deps) {
+    app.post("/api/quickstart", createQuickstartHandler(deps));
+}

package/dist/routes/status.js

@@ -0,0 +1,4 @@
+import { createStatusHandler } from "../controllers/status.controller.js";
+export function registerStatusRoutes(app, deps) {
+    app.get("/api/status", createStatusHandler(deps));
+}

package/dist/services/auth.service.js

@@ -0,0 +1,24 @@
+import { resolveAuthState } from "../lib/auth.js";
+export function getAuthStatus(authDisabled) {
+    const authState = resolveAuthState(authDisabled);
+    return {
+        required: !authDisabled,
+        configured: authState.configured
+    };
+}
+export function loginWithCredentials(authDisabled, username, password) {
+    if (authDisabled) {
+        return { ok: true, disabled: true };
+    }
+    const authState = resolveAuthState(authDisabled);
+    if (!authState.configured) {
+        return { ok: false, error: "auth not configured", status: 400 };
+    }
+    if (!username || !password) {
+        return { ok: false, error: "missing credentials", status: 400 };
+    }
+    if (!authState.verify(username, password)) {
+        return { ok: false, error: "invalid credentials", status: 401 };
+    }
+    return { ok: true };
+}

package/dist/services/cli.service.js

@@ -0,0 +1,21 @@
+import { getCliStatus } from "../lib/system.js";
+import { parsePositiveInt } from "../lib/utils.js";
+export async function installCli(runCommand) {
+    const cli = await getCliStatus(runCommand);
+    if (cli.installed) {
+        return { ok: true, alreadyInstalled: true, version: cli.version };
+    }
+    const timeoutMs = parsePositiveInt(process.env.MANAGER_CLI_INSTALL_TIMEOUT_MS) ?? 600_000;
+    try {
+        await runCommand("npm", ["i", "-g", "clawdbot@latest"], timeoutMs, {
+            ...process.env,
+            NPM_CONFIG_AUDIT: "false",
+            NPM_CONFIG_FUND: "false"
+        });
+        const updated = await getCliStatus(runCommand);
+        return { ok: true, version: updated.version };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/services/discord.service.js

@@ -0,0 +1,38 @@
+export async function saveDiscordToken(runCommand, token) {
+    const args = ["config", "set", "channels.discord.token", token];
+    try {
+        await runCommand("clawdbot", args, 8000);
+        await ensureDiscordDmAllow(runCommand);
+        return { ok: true };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+export async function approveDiscordPairing(runCommand, code) {
+    const args = ["pairing", "approve", "discord", code];
+    return runCommand("clawdbot", args, 8000)
+        .then(() => ({ ok: true }))
+        .catch((err) => ({
+        ok: false,
+        error: err instanceof Error ? err.message : String(err)
+    }));
+}
+async function ensureDiscordDmAllow(runCommand) {
+    const value = await runCommand("clawdbot", ["config", "get", "channels.discord.dm.allowFrom", "--json"], 4000).catch(() => null);
+    if (value) {
+        try {
+            const parsed = JSON.parse(value);
+            if (parsed === "*" || (Array.isArray(parsed) && parsed.length > 0)) {
+                return;
+            }
+        }
+        catch {
+            // ignore parse failure and attempt to set
+        }
+    }
+    await runCommand("clawdbot", ["config", "set", "channels.discord.dm.allowFrom", "*"], 8000);
+}

package/dist/services/jobs.service.js

@@ -0,0 +1,307 @@
+import { getCliStatus } from "../lib/system.js";
+import { runCommandWithLogs } from "../lib/runner.js";
+import { parsePositiveInt, sleep } from "../lib/utils.js";
+import { runQuickstart } from "./quickstart.service.js";
+import { downloadResource } from "./resource.service.js";
+const MINIMAX_CN_BASE_URL = "https://api.minimaxi.com/anthropic";
+const DEFAULT_PAIRING_WAIT_TIMEOUT_MS = 180_000;
+const DEFAULT_PAIRING_POLL_MS = 3000;
+const DEFAULT_PAIRING_APPROVE_TIMEOUT_MS = 8000;
+export function createCliInstallJob(deps) {
+    const job = deps.jobStore.createJob("Install Clawdbot CLI");
+    deps.jobStore.startJob(job.id);
+    deps.jobStore.appendLog(job.id, "开始安装 Clawdbot CLI...");
+    const timeoutMs = parsePositiveInt(process.env.MANAGER_CLI_INSTALL_TIMEOUT_MS) ?? 600_000;
+    void (async () => {
+        const current = await getCliStatus(deps.runCommand);
+        if (current.installed) {
+            deps.jobStore.appendLog(job.id, `CLI 已安装${current.version ? `（${current.version}）` : ""}。`);
+            deps.jobStore.completeJob(job.id, { version: current.version ?? null });
+            return;
+        }
+        await runCommandWithLogs("npm", ["i", "-g", "clawdbot@latest"], {
+            cwd: deps.repoRoot,
+            env: {
+                ...process.env,
+                NPM_CONFIG_AUDIT: "false",
+                NPM_CONFIG_FUND: "false"
+            },
+            timeoutMs,
+            onLog: (line) => deps.jobStore.appendLog(job.id, line)
+        });
+        const cli = await getCliStatus(deps.runCommand);
+        if (cli.version) {
+            deps.jobStore.appendLog(job.id, `CLI 版本: ${cli.version}`);
+        }
+        deps.jobStore.completeJob(job.id, { version: cli.version ?? null });
+    })().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.jobStore.appendLog(job.id, `安装失败: ${message}`);
+        deps.jobStore.failJob(job.id, message);
+    });
+    return job.id;
+}
+export function createQuickstartJob(deps, body) {
+    const job = deps.jobStore.createJob("Quickstart");
+    deps.jobStore.startJob(job.id);
+    deps.jobStore.appendLog(job.id, "开始执行快速启动...");
+    void runQuickstart(deps, body, (line) => deps.jobStore.appendLog(job.id, line))
+        .then((result) => {
+        if (!result.ok) {
+            deps.jobStore.appendLog(job.id, `快速启动失败: ${result.error}`);
+            deps.jobStore.failJob(job.id, result.error);
+            return;
+        }
+        deps.jobStore.appendLog(job.id, "快速启动完成。");
+        deps.jobStore.completeJob(job.id, {
+            gatewayReady: result.gatewayReady,
+            probeOk: result.probeOk ?? null
+        });
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.jobStore.appendLog(job.id, `快速启动失败: ${message}`);
+        deps.jobStore.failJob(job.id, message);
+    });
+    return job.id;
+}
+export function createDiscordPairingJob(deps, code) {
+    const job = deps.jobStore.createJob("Discord Pairing");
+    deps.jobStore.startJob(job.id);
+    deps.jobStore.appendLog(job.id, "开始处理配对请求...");
+    void runCommandWithLogs("clawdbot", ["pairing", "approve", "discord", code], {
+        cwd: deps.repoRoot,
+        env: process.env,
+        timeoutMs: 8000,
+        onLog: (line) => deps.jobStore.appendLog(job.id, line)
+    })
+        .then(() => {
+        deps.jobStore.appendLog(job.id, "配对已提交。");
+        deps.jobStore.completeJob(job.id, { code });
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.jobStore.appendLog(job.id, `配对失败: ${message}`);
+        deps.jobStore.failJob(job.id, message);
+    });
+    return job.id;
+}
+export function createDiscordPairingWaitJob(deps, options) {
+    const job = deps.jobStore.createJob("Discord Pairing Wait");
+    deps.jobStore.startJob(job.id);
+    deps.jobStore.appendLog(job.id, "等待配对请求...");
+    const timeoutMs = parsePositiveInt(toOptionalString(options.timeoutMs)) ??
+        parsePositiveInt(process.env.MANAGER_PAIRING_TIMEOUT_MS) ??
+        DEFAULT_PAIRING_WAIT_TIMEOUT_MS;
+    const pollMs = parsePositiveInt(toOptionalString(options.pollMs)) ??
+        parsePositiveInt(process.env.MANAGER_PAIRING_POLL_MS) ??
+        DEFAULT_PAIRING_POLL_MS;
+    const notify = Boolean(options.notify);
+    void (async () => {
+        const startedAt = Date.now();
+        let lastCount = -1;
+        while (Date.now() - startedAt < timeoutMs) {
+            const snapshot = await fetchDiscordPairings(deps);
+            if (snapshot.error) {
+                deps.jobStore.appendLog(job.id, `读取配对请求失败: ${snapshot.error}`);
+            }
+            if (snapshot.count !== lastCount) {
+                deps.jobStore.appendLog(job.id, `待处理配对请求: ${snapshot.count}`);
+                lastCount = snapshot.count;
+            }
+            if (snapshot.code) {
+                deps.jobStore.appendLog(job.id, "发现配对请求，开始批准...");
+                const args = notify
+                    ? ["pairing", "approve", "--notify", "discord", snapshot.code]
+                    : ["pairing", "approve", "discord", snapshot.code];
+                await runCommandWithLogs("clawdbot", args, {
+                    cwd: deps.repoRoot,
+                    env: process.env,
+                    timeoutMs: DEFAULT_PAIRING_APPROVE_TIMEOUT_MS,
+                    onLog: (line) => deps.jobStore.appendLog(job.id, line)
+                });
+                deps.jobStore.appendLog(job.id, "配对已提交。");
+                deps.jobStore.completeJob(job.id, { approved: true, notified: notify });
+                return;
+            }
+            await sleep(pollMs);
+        }
+        deps.jobStore.appendLog(job.id, "等待配对超时。");
+        deps.jobStore.failJob(job.id, "pairing timeout");
+    })().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.jobStore.appendLog(job.id, `配对失败: ${message}`);
+        deps.jobStore.failJob(job.id, message);
+    });
+    return job.id;
+}
+export function createResourceDownloadJob(deps, options) {
+    const job = deps.jobStore.createJob("Download Resources");
+    deps.jobStore.startJob(job.id);
+    const envUrl = process.env.MANAGER_RESOURCE_URL;
+    const url = options.url?.trim() || envUrl?.trim() || "";
+    const dir = process.env.MANAGER_RESOURCE_DIR;
+    const payload = {
+        url,
+        filename: options.filename,
+        dir: dir?.trim() || undefined
+    };
+    if (!payload.url) {
+        deps.jobStore.appendLog(job.id, "未配置资源地址。");
+        deps.jobStore.failJob(job.id, "resource url missing");
+        return job.id;
+    }
+    void downloadResource(payload, (line) => deps.jobStore.appendLog(job.id, line))
+        .then((result) => {
+        deps.jobStore.completeJob(job.id, result);
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.jobStore.appendLog(job.id, `下载失败: ${message}`);
+        deps.jobStore.failJob(job.id, message);
+    });
+    return job.id;
+}
+function toOptionalString(value) {
+    if (typeof value === "number")
+        return String(value);
+    if (typeof value === "string")
+        return value;
+    return undefined;
+}
+async function fetchDiscordPairings(deps) {
+    try {
+        const output = await deps.runCommand("clawdbot", ["pairing", "list", "--channel", "discord", "--json"], 8000);
+        const parsed = JSON.parse(output);
+        const requests = Array.isArray(parsed?.requests) ? parsed.requests : [];
+        const first = requests[0];
+        const codeRaw = typeof first?.code === "string" ? first.code : first?.pairingCode;
+        const code = typeof codeRaw === "string" && codeRaw.trim() ? codeRaw.trim() : null;
+        return { code, count: requests.length };
+    }
+    catch (err) {
+        return {
+            code: null,
+            count: 0,
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+export function createAiAuthJob(deps, options) {
+    const job = deps.jobStore.createJob("Configure AI Provider");
+    deps.jobStore.startJob(job.id);
+    deps.jobStore.appendLog(job.id, "开始配置 AI 凭证...");
+    const provider = options.provider.trim().toLowerCase();
+    const config = resolveAiProviderConfig(provider);
+    if (!config) {
+        deps.jobStore.appendLog(job.id, `不支持的 provider: ${provider}`);
+        deps.jobStore.failJob(job.id, "unsupported provider");
+        return job.id;
+    }
+    const apiKey = options.apiKey.trim();
+    if (!apiKey) {
+        deps.jobStore.appendLog(job.id, "API Key 为空。");
+        deps.jobStore.failJob(job.id, "missing api key");
+        return job.id;
+    }
+    const timeoutMs = parsePositiveInt(process.env.MANAGER_AI_AUTH_TIMEOUT_MS) ?? 120_000;
+    const args = [
+        "onboard",
+        "--non-interactive",
+        "--accept-risk",
+        "--flow",
+        "manual",
+        "--mode",
+        "local",
+        "--auth-choice",
+        config.authChoice,
+        "--skip-channels",
+        "--skip-skills",
+        "--skip-health",
+        "--skip-ui",
+        "--skip-daemon"
+    ];
+    void (async () => {
+        await runCommandWithLogs("clawdbot", args, {
+            cwd: deps.repoRoot,
+            env: {
+                ...process.env,
+                [config.envVar]: apiKey
+            },
+            timeoutMs,
+            onLog: (line) => deps.jobStore.appendLog(job.id, line)
+        });
+        if (provider === "minimax-cn") {
+            await applyMinimaxCnConfig(deps, job.id, timeoutMs);
+        }
+        deps.jobStore.appendLog(job.id, "AI 凭证配置完成。");
+        deps.jobStore.completeJob(job.id, { provider });
+    })().catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.jobStore.appendLog(job.id, `AI 配置失败: ${message}`);
+        deps.jobStore.failJob(job.id, message);
+    });
+    return job.id;
+}
+function resolveAiProviderConfig(provider) {
+    if (provider === "anthropic") {
+        return { authChoice: "apiKey", envVar: "ANTHROPIC_API_KEY" };
+    }
+    if (provider === "openai") {
+        return { authChoice: "openai-api-key", envVar: "OPENAI_API_KEY" };
+    }
+    if (provider === "openrouter") {
+        return { authChoice: "openrouter-api-key", envVar: "OPENROUTER_API_KEY" };
+    }
+    if (provider === "ai-gateway") {
+        return { authChoice: "ai-gateway-api-key", envVar: "AI_GATEWAY_API_KEY" };
+    }
+    if (provider === "gemini") {
+        return { authChoice: "gemini-api-key", envVar: "GEMINI_API_KEY" };
+    }
+    if (provider === "zai") {
+        return { authChoice: "zai-api-key", envVar: "ZAI_API_KEY" };
+    }
+    if (provider === "moonshot") {
+        return { authChoice: "moonshot-api-key", envVar: "MOONSHOT_API_KEY" };
+    }
+    if (provider === "kimi-code") {
+        return { authChoice: "kimi-code-api-key", envVar: "KIMI_CODE_API_KEY" };
+    }
+    if (provider === "minimax") {
+        return { authChoice: "minimax-api", envVar: "MINIMAX_API_KEY" };
+    }
+    if (provider === "minimax-cn") {
+        return { authChoice: "minimax-api", envVar: "MINIMAX_API_KEY" };
+    }
+    if (provider === "minimax-lightning") {
+        return { authChoice: "minimax-api-lightning", envVar: "MINIMAX_API_KEY" };
+    }
+    if (provider === "venice") {
+        return { authChoice: "venice-api-key", envVar: "VENICE_API_KEY" };
+    }
+    if (provider === "synthetic") {
+        return { authChoice: "synthetic-api-key", envVar: "SYNTHETIC_API_KEY" };
+    }
+    if (provider === "opencode-zen") {
+        return { authChoice: "opencode-zen", envVar: "OPENCODE_ZEN_API_KEY" };
+    }
+    return null;
+}
+async function applyMinimaxCnConfig(deps, jobId, timeoutMs) {
+    deps.jobStore.appendLog(jobId, "配置 MiniMax 国内 API 地址...");
+    await runCommandWithLogs("clawdbot", ["config", "set", "models.providers.minimax.baseUrl", MINIMAX_CN_BASE_URL], {
+        cwd: deps.repoRoot,
+        env: process.env,
+        timeoutMs,
+        onLog: (line) => deps.jobStore.appendLog(jobId, line)
+    });
+    deps.jobStore.appendLog(jobId, "配置 MiniMax 国内鉴权头...");
+    await runCommandWithLogs("clawdbot", ["config", "set", "models.providers.minimax.authHeader", "true", "--json"], {
+        cwd: deps.repoRoot,
+        env: process.env,
+        timeoutMs,
+        onLog: (line) => deps.jobStore.appendLog(jobId, line)
+    });
+    deps.jobStore.appendLog(jobId, "MiniMax 国内配置完成。");
+}

package/dist/services/process.service.js

@@ -0,0 +1,9 @@
+export function listProcesses(deps) {
+    return deps.processManager.listProcesses();
+}
+export function startProcess(deps, id) {
+    return deps.processManager.startProcess(id);
+}
+export function stopProcess(deps, id) {
+    return deps.processManager.stopProcess(id);
+}

package/dist/services/quickstart.service.js

@@ -0,0 +1,124 @@
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT } from "../lib/constants.js";
+import { checkGateway, waitForGateway } from "../lib/gateway.js";
+import { runCommandWithLogs } from "../lib/runner.js";
+import { getCliStatus } from "../lib/system.js";
+import { parsePort, parsePositiveInt, sleep } from "../lib/utils.js";
+import { setLastProbe } from "../lib/onboarding.js";
+export async function runQuickstart(deps, body, log) {
+    const runProbe = Boolean(body?.runProbe);
+    const startGateway = body?.startGateway !== false;
+    const gatewayHost = typeof body?.gatewayHost === "string" ? body.gatewayHost : DEFAULT_GATEWAY_HOST;
+    const gatewayPort = typeof body?.gatewayPort === "string"
+        ? parsePort(body.gatewayPort) ?? DEFAULT_GATEWAY_PORT
+        : DEFAULT_GATEWAY_PORT;
+    let gatewayReady = false;
+    let probeOk;
+    const gatewayTimeoutMs = parsePositiveInt(process.env.MANAGER_GATEWAY_TIMEOUT_MS) ?? 60_000;
+    log?.(`网关参数: host=${gatewayHost} port=${gatewayPort} timeout=${gatewayTimeoutMs}ms`);
+    log?.("检查 CLI 环境...");
+    const cli = await getCliStatus(deps.runCommand);
+    if (!cli.installed) {
+        log?.("未检测到 CLI。");
+        return { ok: false, error: "clawdbot CLI not installed", status: 400 };
+    }
+    if (cli.path) {
+        log?.(`CLI 路径: ${cli.path}`);
+    }
+    if (cli.version) {
+        log?.(`CLI 版本: ${cli.version}`);
+    }
+    if (startGateway) {
+        log?.("初始化网关配置...");
+        await runCommandWithLogs("clawdbot", ["config", "set", "gateway.mode", "local"], {
+            cwd: deps.repoRoot,
+            env: process.env,
+            timeoutMs: 8000,
+            onLog: (line) => log?.(`[config] ${line}`)
+        });
+        const gatewayArgs = [
+            "gateway",
+            "run",
+            "--allow-unconfigured",
+            "--bind",
+            "loopback",
+            "--port",
+            String(gatewayPort),
+            "--force"
+        ];
+        log?.("启动网关中...");
+        log?.(`启动命令: clawdbot ${gatewayArgs.join(" ")}`);
+        const started = deps.processManager.startProcess("gateway-run", {
+            args: gatewayArgs,
+            onLog: (line) => log?.(`[gateway] ${line}`)
+        });
+        if (!started.ok) {
+            return { ok: false, error: started.error ?? "unknown", status: 500 };
+        }
+        await sleep(500);
+        const earlySnapshot = deps.processManager
+            .listProcesses()
+            .find((process) => process.id === "gateway-run");
+        if (earlySnapshot && !earlySnapshot.running) {
+            if (earlySnapshot.lastLines.length) {
+                log?.("网关进程已退出，输出如下：");
+                for (const line of earlySnapshot.lastLines) {
+                    log?.(`[gateway] ${line}`);
+                }
+            }
+            return { ok: false, error: "gateway process exited", status: 500 };
+        }
+        gatewayReady = await waitForGateway(gatewayHost, gatewayPort, gatewayTimeoutMs);
+        if (!gatewayReady) {
+            log?.("网关启动超时。");
+            const probe = await checkGateway(gatewayHost, gatewayPort);
+            log?.(`网关探测结果: ok=${probe.ok} error=${probe.error ?? "none"} latency=${probe.latencyMs ?? "n/a"}ms`);
+            const snapshot = deps.processManager
+                .listProcesses()
+                .find((process) => process.id === "gateway-run");
+            if (snapshot?.lastLines?.length) {
+                log?.("网关进程输出（最近日志）：");
+                for (const line of snapshot.lastLines) {
+                    log?.(`[gateway] ${line}`);
+                }
+            }
+            if (snapshot && snapshot.exitCode !== null) {
+                log?.(`网关进程已退出，exit code: ${snapshot.exitCode}`);
+            }
+            if (snapshot) {
+                log?.(`网关进程状态: running=${snapshot.running} pid=${snapshot.pid ?? "?"}`);
+            }
+            log?.(`排查建议: 确认端口 ${gatewayPort} 未被占用，或执行 clawdbot logs --follow 查看网关日志。`);
+            return { ok: false, error: "gateway not ready", status: 504 };
+        }
+        log?.("网关已就绪。");
+    }
+    else {
+        log?.("检查网关状态...");
+        const snapshot = await checkGateway(gatewayHost, gatewayPort);
+        gatewayReady = snapshot.ok;
+        if (!gatewayReady) {
+            log?.(`网关未就绪: error=${snapshot.error ?? "none"} latency=${snapshot.latencyMs ?? "n/a"}ms`);
+        }
+        else {
+            log?.("网关已就绪。");
+        }
+    }
+    if (runProbe) {
+        const probeAttempts = parsePositiveInt(process.env.MANAGER_PROBE_ATTEMPTS) ?? 3;
+        const probeDelayMs = parsePositiveInt(process.env.MANAGER_PROBE_DELAY_MS) ?? 2000;
+        log?.("执行通道探测...");
+        for (let attempt = 1; attempt <= probeAttempts; attempt += 1) {
+            probeOk = await deps
+                .runCommand("clawdbot", ["channels", "status", "--probe"], 12_000)
+                .then(() => true)
+                .catch(() => false);
+            if (probeOk || attempt >= probeAttempts)
+                break;
+            log?.(`通道探测未通过，${probeDelayMs}ms 后重试 (${attempt}/${probeAttempts})...`);
+            await sleep(probeDelayMs);
+        }
+        setLastProbe(Boolean(probeOk));
+        log?.(probeOk ? "通道探测通过。" : "通道探测未通过。");
+    }
+    return { ok: true, gatewayReady, probeOk };
+}