larkin 0.2.70

package/dist/app/runtime-agent-config.mjs

@@ -0,0 +1,416 @@
+import { spawn, spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { acquireProcessLock } from "../platform/process-state.mjs";
+import { assertSecureBotsDirectory, readSecureBotCredential, validCredentialRecord, } from "../setup/run-credential-preflight.mjs";
+import { resolveOfficialLarkCli } from "./official-lark-cli.mjs";
+import { internalCommandSpec } from "./internal-command.mjs";
+import { assertAgentWorkspaceBound, larkChannelSourceConfigPath, larkChannelWorkspaceConfigPath, managedLarkCliEnv, } from "./agent-lark-cli-workspace.mjs";
+function assertSecureProfileDirectory(directory) {
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()
+        || (typeof process.getuid === "function" && stat.uid !== process.getuid())
+        || (stat.mode & 0o777) !== 0o700)
+        throw new Error("lark-cli profile 目录不安全");
+}
+function captureProfileSnapshot(file) {
+    let fd = null;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile()
+            || (typeof process.getuid === "function" && stat.uid !== process.getuid())
+            || (stat.mode & 0o077) !== 0)
+            throw new Error("lark-cli config.json 不安全");
+        const raw = fs.readFileSync(fd);
+        const value = JSON.parse(raw.toString("utf8"));
+        if (!value || typeof value !== "object" || (value.apps !== undefined && !Array.isArray(value.apps))) {
+            throw new Error("lark-cli config.json schema 无效");
+        }
+        return { value, raw, mode: stat.mode & 0o777 };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+}
+function atomicPublishProfile(file, bytes, mode = 0o600) {
+    const directory = path.dirname(file);
+    assertSecureProfileDirectory(directory);
+    const canonical = path.join(path.resolve(directory), "config.json");
+    if (path.resolve(file) !== canonical || path.basename(file) !== "config.json") {
+        throw new Error("lark-cli config 发布路径无效");
+    }
+    const temporary = path.join(directory, `.config.${process.pid}.${crypto.randomUUID()}.publish`);
+    const fd = fs.openSync(temporary, "wx", 0o600);
+    try {
+        fs.writeFileSync(fd, bytes);
+        fs.fchmodSync(fd, mode);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    try {
+        let current = null;
+        try {
+            current = fs.lstatSync(file);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (current) {
+            if (typeof process.getuid === "function" && current.uid !== process.getuid()) {
+                throw new Error("config.json 不属于当前用户");
+            }
+            if (current.isDirectory()) {
+                try {
+                    fs.rmdirSync(file);
+                }
+                catch (error) {
+                    if (["ENOTEMPTY", "EEXIST"].includes(String(error.code || ""))) {
+                        throw new Error("config.json 已被替换为非空目录");
+                    }
+                    throw error;
+                }
+            }
+            else if (!current.isFile() && !current.isSymbolicLink()) {
+                throw new Error("config.json 已被替换为不安全文件类型");
+            }
+        }
+        fs.renameSync(temporary, file);
+    }
+    catch (error) {
+        throw new Error(`${error instanceof Error ? error.message : String(error)}；待发布内容保留于 ${temporary}`);
+    }
+}
+function containsUserToken(value) {
+    if (Array.isArray(value))
+        return value.some(containsUserToken);
+    if (!value || typeof value !== "object")
+        return false;
+    return Object.entries(value).some(([key, nested]) => (/token/i.test(key) && nested !== null && nested !== "" && nested !== undefined) || containsUserToken(nested));
+}
+function validStoredAppSecret(value, appId) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const reference = value;
+    return reference.source === "keychain" && reference.id === `appsecret:${appId}`;
+}
+function validateExclusiveBotProfile(snapshot, agent) {
+    const apps = snapshot.value.apps;
+    if (!Array.isArray(apps) || apps.length !== 1)
+        throw new Error("lark-cli profile 必须只包含当前 Agent App");
+    const app = apps[0];
+    if (app.appId !== agent.feishuAppId || (app.name !== undefined && app.name !== agent.feishuAppId)) {
+        throw new Error("lark-cli profile App identity 与当前 Agent 不一致");
+    }
+    if (!validStoredAppSecret(app.appSecret, agent.feishuAppId))
+        throw new Error("lark-cli workspace App Secret 必须是当前 App 的 keychain 引用");
+    if (app.defaultAs !== "bot" || app.strictMode !== "bot")
+        throw new Error("lark-channel workspace 未锁定 bot-only identity policy");
+    if (Array.isArray(app.users) ? app.users.length !== 0
+        : app.users && typeof app.users === "object" ? Object.keys(app.users).length !== 0 : app.users !== undefined && app.users !== null) {
+        throw new Error("lark-cli profile 不得保留 user identity");
+    }
+    if (containsUserToken(snapshot.value))
+        throw new Error("lark-cli profile 不得保留 user token");
+}
+export function hydrateRuntimeAgent(configDir, agent) {
+    const botsDir = path.join(configDir, "bots");
+    assertSecureBotsDirectory(botsDir);
+    const record = readSecureBotCredential(botsDir, agent.feishuAppId);
+    if (!validCredentialRecord(record, agent.feishuAppId)) {
+        throw new Error(`Agent ${agent.agentId} 的 bot 凭证无效或与 App ID 不一致`);
+    }
+    const credential = record;
+    // updatedAt is the authoritative secret-rotation revision. Other credential metadata
+    // (owner/callback capability) must never cause a keychain write on the next startup.
+    // Legacy records are rebound once by setup and remain on a stable non-secret sentinel.
+    const credentialRevision = credential.updatedAt ? `updated:${credential.updatedAt}` : "legacy-unversioned";
+    return {
+        ...agent,
+        feishuAppSecret: credential.appSecret,
+        feishuDomain: credential.tenant === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn",
+        credentialRevision,
+    };
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function assertSecureRuntimeCommandDirectory(commandDir) {
+    fs.mkdirSync(commandDir, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(commandDir);
+    if (!stat.isDirectory() || stat.isSymbolicLink()
+        || (typeof process.getuid === "function" && stat.uid !== process.getuid())) {
+        throw new Error("Runtime command shim 目录不安全");
+    }
+    fs.chmodSync(commandDir, 0o700);
+}
+function runOfficialLarkCli(command, args, options, dependencies) {
+    return dependencies.runOfficialCli
+        ? dependencies.runOfficialCli(command, args, options)
+        : spawnSync(command.command, [...command.argsPrefix, ...args], options);
+}
+function officialFailure(label, result, secret) {
+    const stderr = String(result.stderr || "").replaceAll(secret, "<redacted>").trim().slice(0, 400);
+    const detail = [result.error?.message, stderr].filter(Boolean).join(": ");
+    return new Error(`${label} failed (exit=${result.status ?? "none"})${detail ? `: ${detail}` : ""}`);
+}
+function runOfficialLarkCliAsync(command, args, env, dependencies) {
+    const timeoutMs = dependencies.timeoutMs ?? 60_000;
+    const maxOutputBytes = dependencies.maxOutputBytes ?? 64 * 1024;
+    return new Promise((resolve, reject) => {
+        const child = spawn(command.command, [...command.argsPrefix, ...args], { env, stdio: ["ignore", "pipe", "pipe"] });
+        dependencies.onChild?.(child);
+        const stdout = [];
+        const stderr = [];
+        let outputBytes = 0;
+        let failure = null;
+        let settled = false;
+        let killTimer = null;
+        const terminate = (error) => {
+            if (failure)
+                return;
+            failure = error;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => { if (child.exitCode === null && child.signalCode === null)
+                child.kill("SIGKILL"); }, 1_000);
+            killTimer.unref?.();
+        };
+        const collect = (target, chunk) => {
+            outputBytes += chunk.length;
+            if (outputBytes > maxOutputBytes) {
+                terminate(new Error("official lark-cli output exceeded the bounded limit"));
+                return;
+            }
+            target.push(Buffer.from(chunk));
+        };
+        child.stdout?.on("data", (chunk) => collect(stdout, chunk));
+        child.stderr?.on("data", (chunk) => collect(stderr, chunk));
+        const timeout = setTimeout(() => terminate(new Error("official lark-cli config bind timed out")), timeoutMs);
+        timeout.unref?.();
+        const abort = () => terminate(new Error("official lark-cli config bind cancelled"));
+        if (dependencies.signal?.aborted)
+            abort();
+        else
+            dependencies.signal?.addEventListener("abort", abort, { once: true });
+        child.once("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (killTimer)
+                clearTimeout(killTimer);
+            dependencies.signal?.removeEventListener("abort", abort);
+            dependencies.onChild?.(null);
+            reject(error);
+        });
+        child.once("exit", (status) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (killTimer)
+                clearTimeout(killTimer);
+            dependencies.signal?.removeEventListener("abort", abort);
+            dependencies.onChild?.(null);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            resolve({ status, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+        });
+    });
+}
+export function installRuntimeCommandShims(agent) {
+    const stateDir = path.resolve(agent.stateDir);
+    const commandDir = path.join(stateDir, "runtime-bin");
+    assertSecureRuntimeCommandDirectory(commandDir);
+    const standalone = process.env.LARKIN_STANDALONE === "1";
+    const binaryEntry = fileURLToPath(new URL("./binary-entry.mjs", import.meta.url));
+    for (const [name, argumentsPrefix] of [["larkin", standalone ? [] : [binaryEntry]]]) {
+        const file = path.join(commandDir, name);
+        const temporary = path.join(commandDir, `.${name}.${process.pid}.${crypto.randomUUID()}.tmp`);
+        const command = [process.execPath, ...argumentsPrefix].map(shellQuote).join(" ");
+        fs.writeFileSync(temporary, `#!/bin/sh\nexec ${command} "$@"\n`, { mode: 0o700, flag: "wx" });
+        fs.renameSync(temporary, file);
+        fs.chmodSync(file, 0o700);
+    }
+    return commandDir;
+}
+function sourceProjection(agent, env) {
+    const configDir = path.resolve(env.LARKIN_CONFIG_DIR || "");
+    if (!configDir)
+        throw new Error("LARKIN_CONFIG_DIR required for lark-channel source projection");
+    const provider = internalCommandSpec("lark-channel-secret", [], {
+        ...env,
+        LARKIN_BINARY_ENTRY_PATH: fileURLToPath(new URL("./binary-entry.mjs", import.meta.url)),
+    });
+    return {
+        credentialRevision: agent.credentialRevision,
+        accounts: { app: {
+                id: agent.feishuAppId,
+                secret: { source: "exec", provider: "larkin-bot-credential", id: agent.feishuAppId },
+                tenant: agent.feishuDomain === "https://open.larksuite.com" ? "lark" : "feishu",
+            } },
+        secrets: { providers: { "larkin-bot-credential": {
+                    source: "exec", command: provider.command, args: provider.args,
+                    noOutputTimeoutMs: 5_000, maxOutputBytes: 16 * 1024, jsonOnly: true,
+                    env: {
+                        LARKIN_CONFIG_DIR: configDir,
+                        LARKIN_AGENT_ID: agent.agentId,
+                        LARKIN_SECRET_PROVIDER_CONTEXT: "bind",
+                    },
+                } } },
+    };
+}
+function validateSourceProjection(file, agent) {
+    const snapshot = captureProfileSnapshot(file);
+    if (!snapshot)
+        throw new Error(`Agent ${agent.agentId} lark-channel source projection missing`);
+    const root = snapshot.value;
+    const app = root.accounts?.app;
+    const provider = root.secrets?.providers?.["larkin-bot-credential"];
+    if (app?.id !== agent.feishuAppId || app?.secret?.source !== "exec"
+        || app?.secret?.provider !== "larkin-bot-credential" || app?.secret?.id !== agent.feishuAppId) {
+        throw new Error(`Agent ${agent.agentId} lark-channel source projection identity mismatch`);
+    }
+    if (provider?.source !== "exec" || typeof provider.command !== "string" || !path.isAbsolute(provider.command)
+        || !Array.isArray(provider.args) || provider.env?.LARKIN_AGENT_ID !== agent.agentId
+        || provider.env?.LARKIN_SECRET_PROVIDER_CONTEXT !== "bind") {
+        throw new Error(`Agent ${agent.agentId} lark-channel source projection provider invalid`);
+    }
+    if (JSON.stringify(snapshot.value).includes("appSecret"))
+        throw new Error("lark-channel source projection 不得包含 plaintext secret 字段");
+    if (root.credentialRevision !== agent.credentialRevision)
+        throw new Error(`Agent ${agent.agentId} lark-channel credential revision mismatch`);
+}
+export function syncAgentProfile(agent, env, dependencies = {}) {
+    const expected = path.join(path.resolve(env.LARKIN_CONFIG_DIR || ""), "state", "agents", agent.agentId, "lark-cli-config");
+    if (path.resolve(agent.larkConfigDir) !== expected)
+        throw new Error("lark-cli profile 路径不是 canonical contained 路径");
+    fs.mkdirSync(expected, { recursive: true, mode: 0o700 });
+    assertSecureProfileDirectory(expected);
+    const sourceFile = larkChannelSourceConfigPath(agent);
+    const sourceDir = path.dirname(sourceFile);
+    fs.mkdirSync(sourceDir, { recursive: true, mode: 0o700 });
+    assertSecureProfileDirectory(sourceDir);
+    const lock = acquireProcessLock(path.join(expected, ".larkin-profile-sync.lock.json"), path.basename(process.argv[1] || "node"));
+    const workspaceFile = larkChannelWorkspaceConfigPath(agent);
+    const stagedSource = path.join(sourceDir, `.config.${process.pid}.${crypto.randomUUID()}.bind-source`);
+    try {
+        // Parse/security failures are pre-bind failures; a merely stale valid state may be rebound.
+        captureProfileSnapshot(sourceFile);
+        captureProfileSnapshot(workspaceFile);
+        fs.writeFileSync(stagedSource, `${JSON.stringify(sourceProjection(agent, env), null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        validateSourceProjection(stagedSource, agent);
+        installRuntimeCommandShims(agent);
+        if (!dependencies.forceRebind) {
+            try {
+                validateSourceProjection(sourceFile, agent);
+                const existingWorkspace = captureProfileSnapshot(workspaceFile);
+                if (!existingWorkspace)
+                    throw new Error("workspace missing");
+                validateExclusiveBotProfile(existingWorkspace, agent);
+                assertAgentWorkspaceBound(agent);
+                return;
+            }
+            catch { /* stale, absent, or mismatched state requires exactly one bind */ }
+        }
+        const profileEnv = { ...managedLarkCliEnv(agent, env), LARK_CHANNEL_CONFIG: stagedSource };
+        try {
+            const official = dependencies.resolveOfficialCli?.(profileEnv) ?? resolveOfficialLarkCli({ env: profileEnv });
+            const sync = runOfficialLarkCli(official, ["config", "bind", "--source", "lark-channel", "--identity", "bot-only"], {
+                encoding: "utf8", env: profileEnv,
+            }, dependencies);
+            if (sync.status !== 0 || sync.error)
+                throw officialFailure(`Agent ${agent.agentId} lark-channel bind`, sync, agent.feishuAppSecret);
+            const workspace = captureProfileSnapshot(workspaceFile);
+            if (!workspace)
+                throw new Error(`Agent ${agent.agentId} lark-channel workspace config missing`);
+            validateExclusiveBotProfile(workspace, agent);
+            atomicPublishProfile(sourceFile, fs.readFileSync(stagedSource), 0o600);
+            assertAgentWorkspaceBound(agent);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : `Agent ${agent.agentId} lark-channel bind failed`;
+            throw new Error(`${message}；官方 bind/keychain 结果未被证明可回滚，当前 Agent 保持 fail-closed，请重跑 larkin setup`);
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(stagedSource);
+        }
+        catch { /* renamed/absent */ }
+        lock.release();
+    }
+}
+/** Async setup-only profile sync. Existing runtime callers retain the synchronous contract above. */
+export async function syncAgentProfileAsync(agent, env, dependencies = {}) {
+    const expected = path.join(path.resolve(env.LARKIN_CONFIG_DIR || ""), "state", "agents", agent.agentId, "lark-cli-config");
+    if (path.resolve(agent.larkConfigDir) !== expected)
+        throw new Error("lark-cli profile 路径不是 canonical contained 路径");
+    fs.mkdirSync(expected, { recursive: true, mode: 0o700 });
+    assertSecureProfileDirectory(expected);
+    const sourceFile = larkChannelSourceConfigPath(agent);
+    const sourceDir = path.dirname(sourceFile);
+    fs.mkdirSync(sourceDir, { recursive: true, mode: 0o700 });
+    assertSecureProfileDirectory(sourceDir);
+    const lock = acquireProcessLock(path.join(expected, ".larkin-profile-sync.lock.json"), path.basename(process.argv[1] || "node"));
+    const workspaceFile = larkChannelWorkspaceConfigPath(agent);
+    const stagedSource = path.join(sourceDir, `.config.${process.pid}.${crypto.randomUUID()}.bind-source`);
+    try {
+        captureProfileSnapshot(sourceFile);
+        captureProfileSnapshot(workspaceFile);
+        fs.writeFileSync(stagedSource, `${JSON.stringify(sourceProjection(agent, env), null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        validateSourceProjection(stagedSource, agent);
+        installRuntimeCommandShims(agent);
+        if (!dependencies.forceRebind) {
+            try {
+                validateSourceProjection(sourceFile, agent);
+                const existingWorkspace = captureProfileSnapshot(workspaceFile);
+                if (!existingWorkspace)
+                    throw new Error("workspace missing");
+                validateExclusiveBotProfile(existingWorkspace, agent);
+                assertAgentWorkspaceBound(agent);
+                return;
+            }
+            catch { /* stale, absent, or mismatched state requires exactly one bind */ }
+        }
+        const profileEnv = { ...managedLarkCliEnv(agent, env), LARK_CHANNEL_CONFIG: stagedSource };
+        try {
+            const official = dependencies.resolveOfficialCli?.(profileEnv) ?? resolveOfficialLarkCli({ env: profileEnv });
+            const result = await runOfficialLarkCliAsync(official, ["config", "bind", "--source", "lark-channel", "--identity", "bot-only"], profileEnv, dependencies);
+            if (result.status !== 0) {
+                const stderr = result.stderr.replaceAll(agent.feishuAppSecret, "<redacted>").trim().slice(0, 400);
+                throw new Error(`Agent ${agent.agentId} lark-channel bind failed (exit=${result.status ?? "none"})${stderr ? `: ${stderr}` : ""}`);
+            }
+            const workspace = captureProfileSnapshot(workspaceFile);
+            if (!workspace)
+                throw new Error(`Agent ${agent.agentId} lark-channel workspace config missing`);
+            validateExclusiveBotProfile(workspace, agent);
+            atomicPublishProfile(sourceFile, fs.readFileSync(stagedSource), 0o600);
+            assertAgentWorkspaceBound(agent);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : `Agent ${agent.agentId} lark-channel bind failed`;
+            throw new Error(`${message}；官方 bind/keychain 结果未被证明可回滚，当前 Agent 保持 fail-closed，请重跑 larkin setup`);
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(stagedSource);
+        }
+        catch { /* renamed/absent */ }
+        lock.release();
+    }
+}

package/dist/app/runtime-model-directory.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverClaudeModelCatalog } from "../runtime/claude-model-catalog.mjs";
+import { discoverCodexModelCatalog } from "../runtime/codex-model-catalog.mjs";
+import { discoverPiModelCatalog } from "../runtime/pi-model-catalog.mjs";
+function readTestModelDirectory(env) {
+    const fixture = env?.LARKIN_TEST_RUNTIME_MODEL_DIRECTORY_FILE;
+    if (!fixture)
+        return undefined;
+    const parsed = JSON.parse(fs.readFileSync(fixture, "utf8"));
+    if (!Array.isArray(parsed.models))
+        throw new Error("runtime model directory test fixture is invalid");
+    return parsed.models;
+}
+export async function discoverRuntimeModelDirectory(input) {
+    const testDirectory = readTestModelDirectory(input.env);
+    if (testDirectory)
+        return testDirectory;
+    if (input.runtime === "codex") {
+        const catalog = await discoverCodexModelCatalog({ cwd: input.cwd, env: input.env });
+        return [
+            { id: "default", label: `default: ${catalog.effectiveModel}` },
+            ...catalog.models.map(({ id, label, supportedReasoningEfforts, defaultReasoningEffort }) => ({
+                id, label, supportedReasoningEfforts, ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+            })),
+        ];
+    }
+    if (input.runtime === "claude") {
+        const catalog = await discoverClaudeModelCatalog({ cwd: input.cwd, env: input.env });
+        return [
+            { id: "default", label: `default: ${catalog.effectiveModel}` },
+            ...catalog.models.map(({ id, label, supportedReasoningEfforts }) => ({ id, label, supportedReasoningEfforts })),
+        ];
+    }
+    if (input.runtime === "pi") {
+        const catalog = await discoverPiModelCatalog({ cwd: input.cwd, ...(input.agentDir ? { agentDir: input.agentDir } : {}) });
+        if (!catalog.effectiveModel)
+            throw new Error("Pi 模型目录未解析出默认模型");
+        return [
+            { id: "default", label: `default: ${catalog.effectiveModel}` },
+            ...catalog.models.map(({ id, label, supportedReasoningEfforts, defaultReasoningEffort }) => ({
+                id, label, supportedReasoningEfforts, ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+            })),
+        ];
+    }
+    throw new Error(`未知 runtime：${input.runtime}`);
+}
+function isMainEntry(argvPath = process.argv[1]) {
+    if (!argvPath)
+        return false;
+    try {
+        return fs.realpathSync(argvPath) === fs.realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return path.resolve(argvPath) === path.resolve(fileURLToPath(import.meta.url));
+    }
+}
+export async function main() {
+    const runtime = process.argv[2] || "";
+    const cwd = process.argv[3] || "";
+    if (!runtime || !cwd)
+        throw new Error("runtime model directory requires runtime and cwd");
+    const models = await discoverRuntimeModelDirectory({
+        runtime,
+        cwd,
+        env: process.env,
+        ...(process.env.PI_CODING_AGENT_DIR ? { agentDir: process.env.PI_CODING_AGENT_DIR } : {}),
+    });
+    process.stdout.write(`${JSON.stringify({ models })}\n`);
+}
+if (isMainEntry()) {
+    main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/app/runtime-process.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createHostShell } from "../feishu/host-shell.mjs";
+import { ContextPromptBuilder } from "../agent/context-prompt.mjs";
+import { createNativeRuntimeAdapter } from "../runtime/runtime-adapters.mjs";
+import { createRuntimeHost } from "../runtime/runtime-host.mjs";
+import { createAgentStateStore } from "../agent/agent-state-store.mjs";
+import { loadConfig, markConfigApplied, runtimeConfigSignature } from "../platform/config.mjs";
+import { createAgentControlServer } from "./local-control.mjs";
+import { hydrateRuntimeAgent, syncAgentProfile } from "./runtime-agent-config.mjs";
+import { loadTelemetryConfig } from "../platform/telemetry-config.mjs";
+import { telemetrySingleton } from "../platform/telemetry-tracing.mjs";
+import { packageVersion } from "../platform/build-info.mjs";
+export function loadAndSyncRuntimeAgent(env, agentId, dependencies = {}) {
+    const loaded = loadConfig(env);
+    const stored = loaded.config.agents[agentId];
+    if (!stored)
+        throw new Error(`Agent ${agentId} 不存在于 canonical config`);
+    const agent = hydrateRuntimeAgent(loaded.configDir, stored);
+    syncAgentProfile(agent, { ...env, LARKIN_CONFIG_DIR: loaded.configDir }, dependencies);
+    return agent;
+}
+export async function markConfigAppliedAfterRuntimeReady(env, runningAgents, runtimeReady) {
+    await runtimeReady;
+    try {
+        const loaded = loadConfig(env);
+        for (const running of runningAgents) {
+            const current = loaded.config.agents[running.agentId];
+            if (!current || current.runtime !== running.runtime || current.model !== running.model
+                || (current.piDistribution || "external") !== (running.piDistribution || "external")
+                || (current.effort || null) !== (running.effort || null))
+                continue;
+            markConfigApplied(env, running.agentId, runtimeConfigSignature(loaded.config, running.agentId));
+        }
+    }
+    catch { /* Runtime is ready; apply projection stays pending on a concurrent config change. */ }
+}
+export async function main(env = process.env, overrides = {}) {
+    let telemetry = telemetrySingleton();
+    try {
+        const configured = JSON.parse(env.LARKIN_AGENTS_CONFIG || "[]");
+        const stateDirs = new Map(configured.flatMap((agent) => agent.agentId && agent.stateDir ? [[agent.agentId, agent.stateDir]] : []));
+        const sourceRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+        telemetry = telemetrySingleton(loadTelemetryConfig(env), { stateDirFor: (agentId) => stateDirs.get(agentId),
+            stateDirs: [...stateDirs.values()], serviceVersion: packageVersion(sourceRoot) });
+    }
+    catch (error) {
+        process.stderr.write(`[telemetry] disabled after initialization failure: ${error instanceof Error ? error.name : "unknown"}\n`);
+    }
+    let channelPackage = overrides.channelPackage;
+    if (!channelPackage && env.LARKIN_FEISHU_DRYRUN === "1" && env.LARKIN_TEST_CHANNEL_MODULE) {
+        channelPackage = await import(pathToFileURL(path.resolve(env.LARKIN_TEST_CHANNEL_MODULE)).href);
+    }
+    const adapters = new Map();
+    const runtimeHost = overrides.runtimeHost ?? createRuntimeHost({
+        promptBuilder: new ContextPromptBuilder(),
+        stateStoreFor(agentId) {
+            if (!env.LARKIN_HOME)
+                throw new Error("LARKIN_HOME is required for Runtime delivery state");
+            return createAgentStateStore(env.LARKIN_HOME, agentId);
+        },
+        adapterFor(runtime) {
+            let adapter = adapters.get(runtime);
+            if (!adapter) {
+                adapter = createNativeRuntimeAdapter(runtime, { env,
+                    ...(runtime === "codex" && env.LARKIN_CODEX_COMMAND ? { codexCommand: env.LARKIN_CODEX_COMMAND } : {}),
+                    ...(runtime === "codex" && env.LARKIN_CODEX_MODEL ? { codexModelOverride: env.LARKIN_CODEX_MODEL } : {}) });
+                adapters.set(runtime, adapter);
+            }
+            return adapter;
+        },
+        log: (...parts) => process.stderr.write(`[runtime] ${parts.join(" ")}\n`),
+        telemetry,
+    });
+    let controlServer = null;
+    const hostShell = createHostShell({
+        env,
+        runtimeHost,
+        ...(channelPackage ? { channelPackage } : {}),
+        ...(overrides.eventSourceStartDelayMs !== undefined ? { eventSourceStartDelayMs: overrides.eventSourceStartDelayMs } : {}),
+        ...(overrides.channelDisconnectTimeoutMs !== undefined ? { channelDisconnectTimeoutMs: overrides.channelDisconnectTimeoutMs } : {}),
+        onOrderedShutdownComplete: (exitCode) => {
+            void Promise.allSettled([controlServer?.close(), telemetry.shutdown()]).finally(() => {
+                (overrides.exitProcess ?? ((code) => process.exit(code)))(exitCode);
+            });
+        },
+        telemetry,
+    });
+    if (!env.LARKIN_HOME || !env.LARKIN_CONFIG_DIR)
+        throw new Error("LARKIN_HOME/LARKIN_CONFIG_DIR required");
+    if (!env.LARKIN_CONTROL_AUTHORIZATION)
+        throw new Error("LARKIN_CONTROL_AUTHORIZATION required");
+    controlServer = createAgentControlServer({
+        larkinHome: env.LARKIN_HOME,
+        authorityToken: env.LARKIN_CONTROL_AUTHORIZATION,
+        async upsert(request) {
+            const agent = loadAndSyncRuntimeAgent(env, request.agentId);
+            // Only the selected profile is synchronized; active profiles and their directory
+            // are never quarantined or rebuilt during hot attach.
+            await hostShell.upsertAgent(agent);
+        },
+        async resetSession(request) {
+            const result = await hostShell.resetSession(request.agentId, request.waitReadyMs);
+            return { ok: result.readyForFreshScenario, agentId: request.agentId, ...result };
+        },
+    });
+    await controlServer.start();
+    await markConfigAppliedAfterRuntimeReady(env, hostShell.agents, hostShell.start());
+}
+if (path.resolve(process.argv[1] || "") === path.resolve(fileURLToPath(import.meta.url))) {
+    main().catch((error) => { console.error(`✗ ${error instanceof Error ? error.message : String(error)}`); process.exit(1); });
+}