larkin 0.2.70

package/dist/dashboard/dashboard-config-controller.mjs

@@ -0,0 +1,525 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { configApplyState, loadConfig, loadRuntimeModels, markConfigApplied, mutateConfig, resolveMentionPolicy, runtimeConfigSignature, safeConfigView } from "../platform/config.mjs";
+import { requestAgentUpsert } from "../app/local-control.mjs";
+import { discoverClaudeModelCatalog } from "../runtime/claude-model-catalog.mjs";
+import { discoverCodexModelCatalog } from "../runtime/codex-model-catalog.mjs";
+import { discoverPiModelCatalog } from "../runtime/pi-model-catalog.mjs";
+import { managedOfficialLarkCli } from "../app/agent-lark-cli-workspace.mjs";
+function pruneCache(cache, expired, maxEntries) {
+    for (const [key, value] of cache)
+        if (expired(value))
+            cache.delete(key);
+    while (cache.size >= maxEntries) {
+        const oldest = cache.keys().next().value;
+        if (!oldest)
+            break;
+        cache.delete(oldest);
+    }
+}
+function knownChatAliases(map, configuredChatIds) {
+    const aliases = new Map();
+    for (const [alias, value] of Object.entries(map)) {
+        if (typeof value !== "string" || !/^oc_[A-Za-z0-9_-]+$/.test(value))
+            continue;
+        const current = aliases.get(value) || [];
+        current.push(alias);
+        aliases.set(value, current);
+    }
+    for (const chatId of configuredChatIds)
+        if (!aliases.has(chatId))
+            aliases.set(chatId, []);
+    return Object.fromEntries([...aliases.entries()].map(([chatId, values]) => {
+        const groupAliases = values.filter((value) => value.startsWith("#") && !value.includes(":"));
+        const readable = groupAliases
+            .map((value) => value.slice(1).trim())
+            .filter((value) => value.length > 0 && !/^[a-f0-9]{11}$/i.test(value))
+            .sort((left, right) => left.length - right.length || left.localeCompare(right, "zh-CN"))[0] || null;
+        const directOnly = values.some((value) => value.startsWith("dm:")) && groupAliases.length === 0;
+        return [chatId, { chatId, displayName: readable, kind: directOnly ? "direct" : "group" }];
+    }));
+}
+function cleanChatName(value) {
+    if (typeof value !== "string")
+        return null;
+    const cleaned = value
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]+/g, "")
+        .replace(/[\t\n\r]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 120);
+    return cleaned || null;
+}
+function chatList(value) {
+    const rows = value?.data?.chats;
+    if (!Array.isArray(rows))
+        return [];
+    return rows.flatMap((item) => {
+        const row = item;
+        const name = cleanChatName(row.name);
+        return typeof row.chat_id === "string" && name ? [{ chatId: row.chat_id, name }] : [];
+    });
+}
+function chatName(value) {
+    const data = value?.data;
+    return cleanChatName(data?.name ?? data?.chat?.name);
+}
+function assertLarkSuccess(value) {
+    if (value?.ok === false)
+        throw new Error("directory unavailable");
+}
+async function runLarkJson(call) {
+    return await new Promise((resolve, reject) => {
+        execFile(call.command, call.args, { env: call.env, maxBuffer: call.maxBuffer, timeout: call.timeout }, (error, stdout) => {
+            if (error)
+                return reject(new Error("directory unavailable"));
+            try {
+                resolve(JSON.parse(stdout));
+            }
+            catch {
+                reject(new Error("directory unavailable"));
+            }
+        });
+    });
+}
+export function createChatDirectoryResolver(options = {}) {
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? 5 * 60_000;
+    const maxStaleMs = options.maxStaleMs ?? 60_000;
+    const execute = options.runLarkJson ?? runLarkJson;
+    const resolveManagedCli = options.managedCli ?? managedOfficialLarkCli;
+    const cache = new Map();
+    const inFlight = new Map();
+    return {
+        async resolve(input) {
+            const chatIds = [...new Set(input.chatIds)].sort();
+            if (chatIds.length === 0)
+                return {};
+            const key = [input.agentId, input.profile, input.configDir, ...chatIds].join("\u0000");
+            pruneCache(cache, (entry) => now() > entry.staleUntil, 128);
+            const cached = cache.get(key);
+            if (cached && now() < cached.expiresAt)
+                return cached.value;
+            let pending = inFlight.get(key);
+            if (!pending) {
+                pending = (async () => {
+                    const managed = resolveManagedCli({ agentId: input.agentId, feishuAppId: input.agentId,
+                        stateDir: path.dirname(input.configDir), larkConfigDir: input.configDir }, process.env);
+                    const common = {
+                        command: managed.command.command,
+                        env: managed.env,
+                        maxBuffer: 1024 * 1024,
+                        timeout: 15_000,
+                    };
+                    const names = {};
+                    const requested = new Set(chatIds);
+                    let listSucceeded = false;
+                    try {
+                        const listed = await execute({ ...common, args: [...managed.command.argsPrefix, "im", "+chat-list", "--as", "bot", "--page-size", "100", "--json"] });
+                        assertLarkSuccess(listed);
+                        listSucceeded = true;
+                        for (const chat of chatList(listed))
+                            if (requested.has(chat.chatId))
+                                names[chat.chatId] = chat.name;
+                    }
+                    catch { /* fall back to isolated per-chat reads */ }
+                    let detailSucceeded = false;
+                    for (const chatId of chatIds) {
+                        if (names[chatId])
+                            continue;
+                        try {
+                            const detail = await execute({ ...common, args: [...managed.command.argsPrefix, "im", "chats", "get", "--chat-id", chatId, "--as", "bot", "--json"] });
+                            assertLarkSuccess(detail);
+                            detailSucceeded = true;
+                            const name = chatName(detail);
+                            if (name)
+                                names[chatId] = name;
+                        }
+                        catch { /* one deleted or inaccessible group must not erase other resolved names */ }
+                    }
+                    if (!listSucceeded && !detailSucceeded)
+                        throw new Error("directory unavailable");
+                    const expiresAt = now() + ttlMs;
+                    cache.set(key, { expiresAt, staleUntil: expiresAt + maxStaleMs, value: names });
+                    return names;
+                })();
+                inFlight.set(key, pending);
+                void pending.finally(() => inFlight.delete(key)).catch(() => undefined);
+            }
+            try {
+                return await pending;
+            }
+            catch {
+                if (cached && now() <= cached.staleUntil)
+                    return cached.value;
+                throw new Error("directory unavailable");
+            }
+        },
+    };
+}
+export function createPiModelDirectoryResolver(options = {}) {
+    const discover = options.discoverPiModelCatalog ?? discoverPiModelCatalog;
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? 5 * 60_000;
+    // Dashboard polls status every 3s. A short negative cache avoids repeating expensive local
+    // catalog/auth discovery on every poll while still recovering promptly after login/config fixes.
+    const negativeTtlMs = options.negativeTtlMs ?? 30_000;
+    const cache = new Map();
+    const failures = new Map();
+    const inFlight = new Map();
+    return {
+        async resolve(input) {
+            const key = [input.agentId, input.cwd, input.agentDir ?? ""].join("\u0000");
+            pruneCache(cache, (entry) => now() >= entry.expiresAt, 64);
+            pruneCache(failures, (entry) => now() >= entry.expiresAt, 64);
+            const cached = cache.get(key);
+            if (cached && now() < cached.expiresAt)
+                return cached.value;
+            if (failures.has(key))
+                throw new Error("Pi model catalog unavailable");
+            let pending = inFlight.get(key);
+            if (!pending) {
+                pending = (async () => {
+                    try {
+                        const catalog = await discover({ cwd: input.cwd, ...(input.agentDir ? { agentDir: input.agentDir } : {}) });
+                        const models = [
+                            { id: "default", label: `default: ${catalog.effectiveModel}` },
+                            ...catalog.models.map(({ id, label, contextWindow, supportedReasoningEfforts, defaultReasoningEffort }) => ({
+                                id, label, ...(contextWindow ? { contextWindow } : {}), supportedReasoningEfforts, ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+                            })),
+                        ];
+                        failures.delete(key);
+                        cache.set(key, { expiresAt: now() + ttlMs, value: models });
+                        return models;
+                    }
+                    catch (error) {
+                        failures.set(key, { expiresAt: now() + negativeTtlMs });
+                        throw error;
+                    }
+                })();
+                inFlight.set(key, pending);
+                void pending.finally(() => inFlight.delete(key)).catch(() => undefined);
+            }
+            return await pending;
+        },
+    };
+}
+export function createCodexModelDirectoryResolver(options = {}) {
+    const discover = options.discoverCodexModelCatalog ?? discoverCodexModelCatalog;
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? 5 * 60_000;
+    const cache = new Map();
+    const inFlight = new Map();
+    return {
+        async resolve(input) {
+            const key = [input.agentId, input.cwd, input.env.CODEX_HOME ?? ""].join("\u0000");
+            pruneCache(cache, (entry) => now() >= entry.expiresAt, 64);
+            const cached = cache.get(key);
+            if (cached && now() < cached.expiresAt)
+                return cached.value;
+            let pending = inFlight.get(key);
+            if (!pending) {
+                pending = (async () => {
+                    const catalog = await discover({ cwd: input.cwd, env: input.env });
+                    const models = [
+                        { id: "default", label: `default: ${catalog.effectiveModel}` },
+                        ...catalog.models.map(({ id, label, supportedReasoningEfforts, defaultReasoningEffort }) => ({
+                            id, label, supportedReasoningEfforts, ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+                        })),
+                    ];
+                    cache.set(key, { expiresAt: now() + ttlMs, value: models });
+                    return models;
+                })();
+                inFlight.set(key, pending);
+                void pending.finally(() => inFlight.delete(key)).catch(() => undefined);
+            }
+            return await pending;
+        },
+    };
+}
+export function createClaudeModelDirectoryResolver(options = {}) {
+    const discover = options.discoverClaudeModelCatalog ?? discoverClaudeModelCatalog;
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? 5 * 60_000;
+    const cache = new Map();
+    const inFlight = new Map();
+    return {
+        async resolve(input) {
+            const key = [input.agentId, input.cwd, input.env.CLAUDE_CONFIG_DIR ?? ""].join("\u0000");
+            pruneCache(cache, (entry) => now() >= entry.expiresAt, 64);
+            const cached = cache.get(key);
+            if (cached && now() < cached.expiresAt)
+                return cached.value;
+            let pending = inFlight.get(key);
+            if (!pending) {
+                pending = (async () => {
+                    const catalog = await discover({ cwd: input.cwd, env: input.env });
+                    const models = [
+                        { id: "default", label: `default: ${catalog.effectiveModel}` },
+                        ...catalog.models.map(({ id, label, supportedReasoningEfforts }) => ({ id, label, supportedReasoningEfforts })),
+                    ];
+                    cache.set(key, { expiresAt: now() + ttlMs, value: models });
+                    return models;
+                })();
+                inFlight.set(key, pending);
+                void pending.finally(() => inFlight.delete(key)).catch(() => undefined);
+            }
+            return await pending;
+        },
+    };
+}
+async function sanitizedView(env, chatDirectoryResolver, onlyAgentId, chatId) {
+    const { config } = loadConfig(env);
+    const view = safeConfigView(config, onlyAgentId, chatId, configApplyState(env, config));
+    for (const item of view.agents) {
+        const agentId = String(item.agentId);
+        const agent = config.agents[agentId];
+        let map = {};
+        try {
+            const file = path.join(agent.stateDir, "feishu-map.json");
+            if (fs.statSync(file).size <= 256 * 1024) {
+                const value = JSON.parse(fs.readFileSync(file, "utf8"));
+                if (value && typeof value === "object" && !Array.isArray(value))
+                    map = value;
+            }
+        }
+        catch { /* no known chat map yet */ }
+        const configuredChatIds = Object.keys(agent?.chatMentionPolicies || {});
+        const aliases = knownChatAliases(map, configuredChatIds);
+        let directory = {};
+        try {
+            directory = await chatDirectoryResolver.resolve({
+                agentId,
+                chatIds: configuredChatIds,
+                configDir: agent.larkConfigDir,
+                profile: agent.feishuProfile,
+            });
+        }
+        catch { /* explicit configuration remains visible without a resolved name */ }
+        item.knownChats = configuredChatIds.sort((left, right) => left.localeCompare(right, "en")).map((configuredChatId) => ({
+            ...(aliases[configuredChatId] ?? { chatId: configuredChatId, displayName: null, kind: "group" }),
+            displayName: directory[configuredChatId] ?? aliases[configuredChatId]?.displayName ?? null,
+        })).map((knownChat) => ({
+            ...knownChat,
+            override: agent.chatMentionPolicies?.[knownChat.chatId] ?? "inherit",
+            ...resolveMentionPolicy(config, agentId, knownChat.chatId),
+        }));
+    }
+    return view;
+}
+function json(res, status, value) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(value));
+}
+function assertWriteRequest(req, csrfCapability) {
+    const host = String(req.headers.host || "");
+    if (!/^(?:localhost|127\.0\.0\.1):\d+$/.test(host))
+        throw new Error("invalid host");
+    const expectedOrigin = `http://${host}`;
+    const origin = String(req.headers.origin || "");
+    const referer = String(req.headers.referer || "");
+    if (origin ? origin !== expectedOrigin : !referer.startsWith(`${expectedOrigin}/`))
+        throw new Error("same-origin required");
+    if (req.headers["x-larkin-csrf"] !== csrfCapability)
+        throw new Error("csrf rejected");
+    if (!String(req.headers["content-type"] || "").toLowerCase().startsWith("application/json"))
+        throw new Error("application/json required");
+}
+function assertPrivateReadRequest(req, csrfCapability) {
+    const host = String(req.headers.host || "");
+    if (!/^(?:localhost|127\.0\.0\.1):\d+$/.test(host))
+        throw new Error("invalid host");
+    if (req.headers["x-larkin-csrf"] !== csrfCapability)
+        throw new Error("capability rejected");
+}
+async function boundedJson(req) {
+    const declaredLength = Number(req.headers["content-length"] || 0);
+    if (Number.isFinite(declaredLength) && declaredLength > 16 * 1024)
+        throw new Error("request too large");
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const bytes = Buffer.from(chunk);
+        size += bytes.length;
+        if (size > 16 * 1024)
+            throw new Error("request too large");
+        chunks.push(bytes);
+    }
+    const body = Buffer.concat(chunks);
+    if (body.byteLength > 16 * 1024)
+        throw new Error("request too large");
+    const value = JSON.parse(body.toString("utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("JSON object required");
+    return value;
+}
+function dashboardMutation(value) {
+    const operation = String(value.operation || "");
+    const allowed = {
+        "set-global-mention": ["operation", "value"], "set-agent-mention": ["operation", "agentId", "value"],
+        "set-chat-mention": ["operation", "agentId", "chatId", "value"], "set-agent-runtime": ["operation", "agentId", "runtime", "model"],
+        "set-agent-model": ["operation", "agentId", "model"], "set-agent-effort": ["operation", "agentId", "effort"],
+    };
+    if (!allowed[operation] || Object.keys(value).some((key) => !allowed[operation].includes(key)))
+        throw new Error("unsupported operation");
+    if (operation === "set-global-mention")
+        return { kind: operation, value: String(value.value) };
+    const agentId = String(value.agentId || "");
+    if (operation === "set-agent-mention")
+        return { kind: operation, agentId, value: String(value.value) };
+    if (operation === "set-chat-mention")
+        return { kind: operation, agentId, chatId: String(value.chatId || ""), value: String(value.value) };
+    if (operation === "set-agent-runtime")
+        return { kind: operation, agentId, runtime: String(value.runtime || ""), ...(value.model ? { model: String(value.model) } : {}) };
+    if (operation === "set-agent-model")
+        return { kind: operation, agentId, model: String(value.model || "") };
+    return { kind: "set-agent-effort", agentId, effort: value.effort === null || value.effort === "default" ? null : String(value.effort || "") };
+}
+export function createDashboardConfigController({ csrfCapability, env = process.env, requestUpsert = requestAgentUpsert, chatDirectoryResolver = createChatDirectoryResolver(), claudeModelDirectoryResolver = createClaudeModelDirectoryResolver(), codexModelDirectoryResolver = createCodexModelDirectoryResolver(), piModelDirectoryResolver = createPiModelDirectoryResolver(), }) {
+    const resolveModelDirectory = async (runtime, agentId) => {
+        const { config } = loadConfig(env);
+        const agent = config.agents[agentId];
+        if (!agent)
+            throw new Error("unknown agent");
+        if (runtime === "pi")
+            return await piModelDirectoryResolver.resolve({
+                agentId, cwd: agent.workspaceDir, ...(env.PI_CODING_AGENT_DIR ? { agentDir: env.PI_CODING_AGENT_DIR } : {}),
+            });
+        if (runtime === "codex")
+            return await codexModelDirectoryResolver.resolve({ agentId, cwd: agent.workspaceDir, env });
+        if (runtime === "claude")
+            return await claudeModelDirectoryResolver.resolve({ agentId, cwd: agent.workspaceDir, env });
+        const authored = loadRuntimeModels()[runtime];
+        if (!authored)
+            throw new Error("unknown runtime");
+        return authored;
+    };
+    const assertDirectoryMutation = async (mutation) => {
+        if (mutation.kind !== "set-agent-runtime" && mutation.kind !== "set-agent-model" && mutation.kind !== "set-agent-effort")
+            return;
+        const { config } = loadConfig(env);
+        const agent = config.agents[mutation.agentId];
+        if (!agent)
+            throw new Error("unknown agent");
+        const runtime = mutation.kind === "set-agent-runtime" ? mutation.runtime : agent.runtime;
+        const model = mutation.kind === "set-agent-runtime" ? mutation.model || "default"
+            : mutation.kind === "set-agent-model" ? mutation.model : agent.model;
+        if (mutation.kind === "set-agent-effort" && mutation.effort === null)
+            return;
+        const directory = await resolveModelDirectory(runtime, mutation.agentId);
+        const selected = directory.find((candidate) => candidate.id === model);
+        if (!selected)
+            throw new Error("model is not in current runtime directory");
+        if (mutation.kind === "set-agent-effort") {
+            const efforts = Array.isArray(selected.supportedReasoningEfforts) ? selected.supportedReasoningEfforts : [];
+            if (!efforts.includes(mutation.effort))
+                throw new Error("effort is not in current model directory");
+        }
+    };
+    return {
+        async handle(req, res, requestUrl) {
+            if (requestUrl.pathname === "/api/config" && req.method === "GET") {
+                try {
+                    assertPrivateReadRequest(req, csrfCapability);
+                    json(res, 200, { ...await sanitizedView(env, chatDirectoryResolver, requestUrl.searchParams.get("agent") || undefined, requestUrl.searchParams.get("chat") || undefined), runtimeModels: loadRuntimeModels() });
+                }
+                catch (error) {
+                    json(res, error instanceof Error && /host|capability/.test(error.message) ? 403 : 500, { error: "configuration unavailable" });
+                }
+                return true;
+            }
+            if (requestUrl.pathname === "/api/models/pi" && req.method === "GET") {
+                try {
+                    assertPrivateReadRequest(req, csrfCapability);
+                    const agentId = requestUrl.searchParams.get("agent") || "";
+                    const { config } = loadConfig(env);
+                    const agent = config.agents[agentId];
+                    if (!agent)
+                        throw new Error("unknown agent");
+                    const models = await piModelDirectoryResolver.resolve({
+                        agentId,
+                        cwd: agent.workspaceDir,
+                        ...(env.PI_CODING_AGENT_DIR ? { agentDir: env.PI_CODING_AGENT_DIR } : {}),
+                    });
+                    json(res, 200, { models });
+                }
+                catch (error) {
+                    json(res, error instanceof Error && /host|capability/.test(error.message) ? 403 : 500, { error: "Pi model directory unavailable" });
+                }
+                return true;
+            }
+            if (requestUrl.pathname === "/api/models/codex" && req.method === "GET") {
+                try {
+                    assertPrivateReadRequest(req, csrfCapability);
+                    const agentId = requestUrl.searchParams.get("agent") || "";
+                    const { config } = loadConfig(env);
+                    const agent = config.agents[agentId];
+                    if (!agent)
+                        throw new Error("unknown agent");
+                    const models = await codexModelDirectoryResolver.resolve({ agentId, cwd: agent.workspaceDir, env });
+                    json(res, 200, { models });
+                }
+                catch (error) {
+                    json(res, error instanceof Error && /host|capability/.test(error.message) ? 403 : 500, { error: "Codex model directory unavailable" });
+                }
+                return true;
+            }
+            if (requestUrl.pathname === "/api/models/claude" && req.method === "GET") {
+                try {
+                    assertPrivateReadRequest(req, csrfCapability);
+                    const agentId = requestUrl.searchParams.get("agent") || "";
+                    const { config } = loadConfig(env);
+                    const agent = config.agents[agentId];
+                    if (!agent)
+                        throw new Error("unknown agent");
+                    const models = await claudeModelDirectoryResolver.resolve({ agentId, cwd: agent.workspaceDir, env });
+                    json(res, 200, { models });
+                }
+                catch (error) {
+                    json(res, error instanceof Error && /host|capability/.test(error.message) ? 403 : 500, { error: "Claude model directory unavailable" });
+                }
+                return true;
+            }
+            if (requestUrl.pathname === "/api/config" && req.method === "PATCH") {
+                try {
+                    assertWriteRequest(req, csrfCapability);
+                    const mutation = dashboardMutation(await boundedJson(req));
+                    await assertDirectoryMutation(mutation);
+                    const result = mutateConfig(env, mutation, { kind: "user" });
+                    json(res, 200, { ok: true, revision: result.revision, persisted: true, applyState: result.applyState, changedScope: result.changedScope });
+                }
+                catch {
+                    json(res, 400, { error: "configuration update rejected" });
+                }
+                return true;
+            }
+            if (requestUrl.pathname === "/api/config/apply" && req.method === "POST") {
+                try {
+                    assertWriteRequest(req, csrfCapability);
+                    const body = await boundedJson(req);
+                    if (Object.keys(body).sort().join(",") !== "agentId" || !/^cli_[A-Za-z0-9]+$/.test(String(body.agentId || "")))
+                        throw new Error("invalid apply request");
+                    const { config } = loadConfig(env);
+                    const agentId = String(body.agentId);
+                    if (!config.agents[agentId])
+                        throw new Error("unknown agent");
+                    const expectedSignature = runtimeConfigSignature(config, agentId);
+                    const result = await requestUpsert({ larkinHome: config.larkinHome, agentId });
+                    if (!result.ok) {
+                        json(res, 409, { error: result.error || "configuration saved but apply failed",
+                            ...(result.readiness ? { readiness: result.readiness } : {}) });
+                        return true;
+                    }
+                    markConfigApplied(env, agentId, expectedSignature);
+                    json(res, 200, { ok: true, agentId, applyState: "applied" });
+                }
+                catch {
+                    json(res, 409, { error: "configuration saved but apply failed" });
+                }
+                return true;
+            }
+            return false;
+        },
+    };
+}

package/dist/dashboard/dashboard-lifecycle.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardBuildFingerprint = dashboardBuildFingerprint;
+exports.dashboardReuseDecision = dashboardReuseDecision;
+exports.reconcileDashboardRecord = reconcileDashboardRecord;
+exports.prepareDashboardLaunch = prepareDashboardLaunch;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const process_state_js_1 = require("../platform/process-state.cjs");
+const internal_command_js_1 = require("../app/internal-command.cjs");
+const PUBLISHED_RUNTIME_DIRS = ["dist", "assets"];
+const RUNTIME_EXTENSIONS = new Set([".cjs", ".mjs", ".js", ".css", ".json", ".node", ".svg", ".wasm"]);
+function publishedRuntimeFiles(root) {
+    const files = [];
+    const visit = (directory) => {
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name, "en"));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name.endsWith(".tmp") || entry.name.endsWith(".tgz"))
+                continue;
+            const absolute = node_path_1.default.join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(absolute);
+            else if (entry.isFile() && RUNTIME_EXTENSIONS.has(node_path_1.default.extname(entry.name)))
+                files.push(node_path_1.default.relative(root, absolute));
+        }
+    };
+    for (const directory of PUBLISHED_RUNTIME_DIRS)
+        visit(node_path_1.default.join(root, directory));
+    return files.sort((a, b) => a.localeCompare(b, "en"));
+}
+/** Same semver can contain a different local build, so hash every published shell runtime byte. */
+function dashboardBuildFingerprint(root) {
+    const hash = node_crypto_1.default.createHash("sha256");
+    for (const relative of publishedRuntimeFiles(root)) {
+        hash.update(relative);
+        hash.update("\0");
+        hash.update(node_fs_1.default.readFileSync(node_path_1.default.join(root, relative)));
+        hash.update("\0");
+    }
+    return `sha256:${hash.digest("hex")}`;
+}
+function dashboardReuseDecision(record, currentFingerprint) {
+    if (record.state === "dead")
+        return { action: "start", reason: "dashboard not running" };
+    if (record.state === "unknown")
+        return { action: "refuse", reason: "dashboard process ownership unknown" };
+    if (record.state === "mismatch")
+        return { action: "refuse", reason: "dashboard process ownership mismatch" };
+    if (record.buildFingerprint === currentFingerprint)
+        return { action: "reuse", reason: "owned dashboard build matches" };
+    return {
+        action: "replace",
+        reason: typeof record.buildFingerprint === "string"
+            ? "owned dashboard build fingerprint differs"
+            : "owned dashboard has no build fingerprint",
+    };
+}
+async function reconcileDashboardRecord(record, currentFingerprint, dependencies = {}) {
+    const decision = dashboardReuseDecision(record, currentFingerprint);
+    if (decision.action === "refuse") {
+        throw new Error(`dashboard PID ${record.pid ?? "?"} ${decision.reason}（${record.reason || "no detail"}）；拒绝复用、替换或并行启动`);
+    }
+    if (decision.action !== "replace")
+        return decision;
+    const terminate = dependencies.terminate || ((owned) => (0, process_state_js_1.terminateOwnedProcess)(owned, "SIGTERM"));
+    const wait = dependencies.wait || ((owned) => (0, process_state_js_1.waitForProcessExit)(owned));
+    terminate(record);
+    if (!await wait(record))
+        throw new Error(`旧 dashboard（pid ${record.pid}）10 秒内未退出；拒绝并行启动`);
+    return { action: "start", reason: decision.reason };
+}
+/**
+ * Serialize inspect/replace/start decisions. The caller keeps the lock through listen(),
+ * preventing two internal dashboard children from both passing the first-run gap.
+ */
+async function prepareDashboardLaunch(larkinHome, currentFingerprint, lockCommandToken = (0, internal_command_js_1.processCommandToken)("dashboard", "app/dashboard.mjs")) {
+    const lock = (0, process_state_js_1.acquireProcessLock)(node_path_1.default.join(larkinHome, "dashboard-launch.lock.json"), lockCommandToken);
+    try {
+        const record = (0, process_state_js_1.readProcessState)(larkinHome).dashboard;
+        const result = await reconcileDashboardRecord(record, currentFingerprint);
+        return { action: result.action, reason: result.reason, record, release: lock.release };
+    }
+    catch (error) {
+        lock.release();
+        throw error;
+    }
+}