@geminilight/mindos 1.0.10 → 1.0.29

package/dist/server/handlers/agent-runtimes.js

@@ -0,0 +1,690 @@
+import { detectLocalAcpAgents as defaultDetectLocalAcpAgents, resolveCommandPath, } from '../../protocols/acp/index.js';
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errorResponse, json, privateCacheHeaders } from '../response.js';
+const mindosCapabilities = {
+    ownsModelSelection: true,
+    supportsResume: true,
+    supportsFreshSession: true,
+    supportsListSessions: true,
+    supportsAttachExisting: false,
+    supportsFork: false,
+    supportsArchive: false,
+    supportsInterrupt: true,
+    supportsModelList: true,
+    supportsApprovals: false,
+    supportsUserInput: true,
+    supportsToolEvents: true,
+    supportsRuntimeStatus: true,
+    supportsDiffs: false,
+    supportsCheckpoints: false,
+    supportsBackgroundRuns: false,
+    supportsMcpConfig: true,
+};
+const nativeBaseCapabilities = {
+    ownsModelSelection: true,
+    supportsResume: true,
+    supportsFreshSession: true,
+    supportsListSessions: false,
+    supportsAttachExisting: false,
+    supportsFork: false,
+    supportsArchive: false,
+    supportsInterrupt: true,
+    supportsModelList: false,
+    supportsApprovals: true,
+    supportsUserInput: true,
+    supportsToolEvents: true,
+    supportsRuntimeStatus: true,
+    supportsDiffs: false,
+    supportsCheckpoints: false,
+    supportsBackgroundRuns: false,
+    supportsMcpConfig: true,
+};
+const codexCapabilities = {
+    ...nativeBaseCapabilities,
+    supportsListSessions: true,
+    supportsAttachExisting: true,
+    supportsFork: true,
+    supportsArchive: true,
+};
+const claudeCapabilities = {
+    ...nativeBaseCapabilities,
+};
+const acpCapabilities = {
+    ownsModelSelection: true,
+    supportsResume: false,
+    supportsFreshSession: false,
+    supportsListSessions: false,
+    supportsAttachExisting: false,
+    supportsFork: false,
+    supportsArchive: false,
+    supportsInterrupt: true,
+    supportsModelList: false,
+    supportsApprovals: false,
+    supportsUserInput: false,
+    supportsToolEvents: true,
+    supportsRuntimeStatus: false,
+    supportsDiffs: false,
+    supportsCheckpoints: false,
+    supportsBackgroundRuns: false,
+    supportsMcpConfig: false,
+};
+const RUNTIME_DETECTION_TIMEOUT_MS = 5000;
+const NATIVE_HEALTH_TIMEOUT_MS = 20000;
+const nativeRuntimeDefinitions = [
+    { id: 'codex-acp', name: 'Codex', runtime: 'codex', command: 'codex', installCmd: 'npm install -g @openai/codex' },
+    { id: 'claude', name: 'Claude Code', runtime: 'claude', command: 'claude', installCmd: 'npm install -g @anthropic-ai/claude-code' },
+];
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function classifyRuntimeFailure(message) {
+    const normalized = message.trim() || 'Runtime failed to start.';
+    if (/\b(login|log in|signin|sign in|auth|authentication|unauthori[sz]ed|credential|api key|token)\b/i.test(normalized)) {
+        return { status: 'signed-out', reason: normalized };
+    }
+    if (/missing environment variable/i.test(normalized)) {
+        return { status: 'signed-out', reason: normalized };
+    }
+    return { status: 'error', reason: normalized };
+}
+function isResolvedCommandSource(value) {
+    return value === 'user-override' || value === 'descriptor' || value === 'registry';
+}
+function isInstalledRuntimeStatus(value) {
+    return value === 'available' || value === 'signed-out' || value === 'error';
+}
+function isMissingRuntimeStatus(value) {
+    return value === 'missing' || value === 'error';
+}
+function normalizeResolvedCommand(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.cmd !== 'string' || !Array.isArray(value.args) || !value.args.every((arg) => typeof arg === 'string'))
+        return null;
+    if (!isResolvedCommandSource(value.source))
+        return null;
+    return {
+        cmd: value.cmd,
+        args: value.args,
+        source: value.source,
+    };
+}
+function normalizeDiagnosticHints(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const hints = value
+        .filter((hint) => typeof hint === 'string' && hint.trim().length > 0)
+        .map((hint) => hint.trim());
+    return hints.length > 0 ? Array.from(new Set(hints)) : undefined;
+}
+function normalizeInstalled(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== 'string' || typeof value.name !== 'string' || typeof value.binaryPath !== 'string')
+        return null;
+    const resolved = normalizeResolvedCommand(value.resolvedCommand);
+    const diagnosticHints = normalizeDiagnosticHints(value.diagnosticHints);
+    return {
+        id: value.id,
+        name: value.name,
+        binaryPath: value.binaryPath,
+        ...(resolved ? { resolvedCommand: resolved } : {}),
+        ...(isInstalledRuntimeStatus(value.status) ? { status: value.status } : {}),
+        ...(typeof value.reason === 'string' && value.reason.trim() ? { reason: value.reason } : {}),
+        ...(diagnosticHints ? { diagnosticHints } : {}),
+    };
+}
+function normalizeMissing(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== 'string' || typeof value.name !== 'string' || typeof value.installCmd !== 'string')
+        return null;
+    const diagnosticHints = normalizeDiagnosticHints(value.diagnosticHints);
+    return {
+        id: value.id,
+        name: value.name,
+        installCmd: value.installCmd,
+        ...(typeof value.packageName === 'string' ? { packageName: value.packageName } : {}),
+        ...(isMissingRuntimeStatus(value.status) ? { status: value.status } : {}),
+        ...(typeof value.reason === 'string' && value.reason.trim() ? { reason: value.reason } : {}),
+        ...(diagnosticHints ? { diagnosticHints } : {}),
+    };
+}
+function isCodexAgent(agent) {
+    const name = agent.name.toLowerCase();
+    return agent.id === 'codex' || agent.id === 'codex-acp' || name === 'codex' || name.includes('codex');
+}
+function isClaudeAgent(agent) {
+    const name = agent.name.toLowerCase();
+    return agent.id === 'claude' || agent.id === 'claude-code' || name.includes('claude');
+}
+function nativeDescriptor(input) {
+    const status = input.source ? input.source.status ?? 'available' : input.missing?.status ?? 'missing';
+    const reason = input.source?.reason ?? input.missing?.reason;
+    const diagnosticHints = Array.from(new Set([
+        ...(input.source?.diagnosticHints ?? input.missing?.diagnosticHints ?? []),
+        ...nativeRuntimeDiagnosticHints({
+            id: input.id,
+            name: input.name,
+            status,
+            reason,
+            binaryPath: input.source?.binaryPath,
+            installCmd: input.missing?.installCmd,
+        }),
+    ]));
+    return {
+        id: input.id,
+        name: input.name,
+        kind: input.id,
+        adapter: input.id === 'codex' ? 'codex-app-server' : 'claude-sdk',
+        modelOwner: 'external',
+        authOwner: 'external',
+        permissionOwner: 'external',
+        sessionOwner: 'external',
+        status,
+        capabilities: input.id === 'codex' ? codexCapabilities : claudeCapabilities,
+        description: input.id === 'codex'
+            ? 'Local Codex app-server runtime. Model, approval, and thread behavior are owned by Codex.'
+            : 'Local Claude Code runtime. Model, permission, and session behavior are owned by Claude Code.',
+        aliases: input.id === 'codex' ? ['codex-acp'] : ['claude-code', 'claude'],
+        ...(input.id === 'codex' ? { mcpAgentKey: 'codex' } : { mcpAgentKey: 'claude-code' }),
+        ...(input.source ? {
+            sourceAgentId: input.source.id,
+            canonicalAgentId: input.source.id,
+            binaryPath: input.source.binaryPath,
+            ...(input.source.resolvedCommand ? { resolvedCommand: input.source.resolvedCommand } : {}),
+        } : {}),
+        ...(!input.source && input.missing ? {
+            sourceAgentId: input.missing.id,
+            canonicalAgentId: input.missing.id,
+            installCmd: input.missing.installCmd,
+            ...(input.missing.packageName ? { packageName: input.missing.packageName } : {}),
+        } : {}),
+        availability: {
+            checkedAt: input.checkedAt,
+            sources: ['native-health'],
+            ...(reason
+                ? { reason }
+                : !input.source
+                    ? { reason: `${input.name} executable was not detected.` }
+                    : {}),
+            ...(diagnosticHints.length > 0 ? { diagnosticHints } : {}),
+        },
+    };
+}
+function nativeRuntimeDiagnosticHints(input) {
+    if (input.status === 'available')
+        return [];
+    const command = input.id === 'codex' ? 'codex' : 'claude';
+    const hints = [];
+    if (input.status === 'missing') {
+        hints.push(`MindOS checked command "${command}" on the server PATH.`);
+        hints.push(input.installCmd
+            ? `Install it or add it to the PATH used to start MindOS: ${input.installCmd}`
+            : `Install ${input.name} or add it to the PATH used to start MindOS.`);
+        return hints;
+    }
+    if (input.binaryPath) {
+        hints.push(`MindOS detected ${input.name} at ${input.binaryPath}.`);
+    }
+    if (input.status === 'signed-out') {
+        hints.push(input.id === 'codex'
+            ? 'Run "codex login status" from the same environment that starts MindOS.'
+            : 'Run Claude Code once from the same environment that starts MindOS.');
+    }
+    else {
+        hints.push(input.id === 'codex'
+            ? 'Run "codex app-server --help" from the MindOS server environment.'
+            : 'Run "claude --version" from the MindOS server environment.');
+    }
+    if (input.reason && /(environment variable|cannot see|env)/i.test(input.reason)) {
+        hints.push('Restart MindOS after exporting the required environment variable so the server process inherits it.');
+    }
+    return hints;
+}
+export function buildAgentRuntimesPayload(input) {
+    const installed = input.installed.map(normalizeInstalled).filter((agent) => !!agent);
+    const notInstalled = input.notInstalled.map(normalizeMissing).filter((agent) => !!agent);
+    const codexInstalled = installed.find(isCodexAgent);
+    const claudeInstalled = installed.find(isClaudeAgent);
+    const codexMissing = notInstalled.find(isCodexAgent);
+    const claudeMissing = notInstalled.find(isClaudeAgent);
+    const runtimes = [
+        {
+            id: 'mindos',
+            name: 'MindOS',
+            kind: 'mindos',
+            adapter: 'mindos',
+            modelOwner: 'mindos',
+            authOwner: 'mindos',
+            permissionOwner: 'mindos',
+            sessionOwner: 'mindos',
+            status: 'available',
+            capabilities: mindosCapabilities,
+            description: 'MindOS internal agent using the selected provider and model.',
+            availability: { checkedAt: input.checkedAt, sources: ['settings'] },
+        },
+        nativeDescriptor({
+            id: 'codex',
+            name: 'Codex',
+            checkedAt: input.checkedAt,
+            ...(codexInstalled ? { source: codexInstalled } : {}),
+            ...(codexMissing ? { missing: codexMissing } : {}),
+        }),
+        nativeDescriptor({
+            id: 'claude',
+            name: 'Claude Code',
+            checkedAt: input.checkedAt,
+            ...(claudeInstalled ? { source: claudeInstalled } : {}),
+            ...(claudeMissing ? { missing: claudeMissing } : {}),
+        }),
+        ...installed
+            .filter((agent) => !isCodexAgent(agent) && !isClaudeAgent(agent))
+            .map((agent) => ({
+            id: agent.id,
+            name: agent.name,
+            kind: 'acp',
+            adapter: 'acp',
+            modelOwner: 'external',
+            authOwner: 'external',
+            permissionOwner: 'external',
+            sessionOwner: 'external',
+            status: agent.status ?? 'available',
+            capabilities: acpCapabilities,
+            description: 'ACP agent selected as the Chat Panel runtime.',
+            sourceAgentId: agent.id,
+            canonicalAgentId: agent.id,
+            binaryPath: agent.binaryPath,
+            ...(agent.resolvedCommand ? { resolvedCommand: agent.resolvedCommand } : {}),
+            availability: {
+                checkedAt: input.checkedAt,
+                sources: agent.status && agent.status !== 'available' ? ['acp-detect', 'native-health'] : ['acp-detect'],
+                ...(agent.reason ? { reason: agent.reason } : {}),
+            },
+        })),
+    ];
+    return { runtimes, installed, notInstalled };
+}
+function buildAcpScopedPayload(input) {
+    const installed = input.installed
+        .map(normalizeInstalled)
+        .filter((agent) => !!agent && !isCodexAgent(agent) && !isClaudeAgent(agent));
+    const notInstalled = input.notInstalled
+        .map(normalizeMissing)
+        .filter((agent) => !!agent && !isCodexAgent(agent) && !isClaudeAgent(agent));
+    const runtimes = installed.map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        kind: 'acp',
+        adapter: 'acp',
+        modelOwner: 'external',
+        authOwner: 'external',
+        permissionOwner: 'external',
+        sessionOwner: 'external',
+        status: agent.status ?? 'available',
+        capabilities: acpCapabilities,
+        description: 'ACP agent selected as the Chat Panel runtime.',
+        sourceAgentId: agent.id,
+        canonicalAgentId: agent.id,
+        binaryPath: agent.binaryPath,
+        ...(agent.resolvedCommand ? { resolvedCommand: agent.resolvedCommand } : {}),
+        availability: {
+            checkedAt: input.checkedAt,
+            sources: agent.status && agent.status !== 'available' ? ['acp-detect', 'native-health'] : ['acp-detect'],
+            ...(agent.reason ? { reason: agent.reason } : {}),
+        },
+    }));
+    return { runtimes, installed, notInstalled };
+}
+async function checkProcessVersion(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let done = false;
+        const finish = (result) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (!child.killed)
+                child.kill();
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            finish({ status: 'error', reason: `${command} health check timed out after ${timeoutMs}ms.` });
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+        child.once('error', (error) => finish(classifyRuntimeFailure(error.message)));
+        child.once('exit', (code) => {
+            if (code === 0) {
+                finish({ status: 'available' });
+                return;
+            }
+            finish(classifyRuntimeFailure((stderr || stdout || `${command} exited with code ${code ?? 'unknown'}`).trim()));
+        });
+    });
+}
+async function checkCodexCliRuntime(command, timeoutMs) {
+    const appServerHelp = await checkProcessVersion(command, ['app-server', '--help'], timeoutMs);
+    if (appServerHelp.status !== 'available')
+        return appServerHelp;
+    const providerEnvironment = checkCodexProviderEnvironment();
+    if (providerEnvironment.status !== 'available')
+        return providerEnvironment;
+    const loginStatus = await checkProcessVersion(command, ['login', 'status'], timeoutMs);
+    return mergeCodexProviderAndLoginHealth(providerEnvironment, loginStatus);
+}
+export function mergeCodexProviderAndLoginHealth(providerEnvironment, loginStatus) {
+    if (providerEnvironment.status !== 'available')
+        return providerEnvironment;
+    if (loginStatus.status === 'available')
+        return providerEnvironment;
+    const hints = [
+        ...(providerEnvironment.diagnosticHints ?? []),
+        'Codex app-server is available. If this Codex profile uses account login, run "codex login status" from the same environment that starts MindOS.',
+        ...(loginStatus.reason ? [`codex login status returned: ${loginStatus.reason}`] : []),
+    ];
+    return {
+        status: 'available',
+        diagnosticHints: hints,
+    };
+}
+export function checkCodexProviderEnvironment(input = {}) {
+    const env = input.env ?? process.env;
+    const configText = input.configText ?? readCodexConfigText(input.configPath, env);
+    if (!configText)
+        return { status: 'available' };
+    const provider = extractTomlStringValue(configText, 'model_provider');
+    if (!provider)
+        return { status: 'available' };
+    const providerSection = extractTomlSection(configText, `model_providers.${provider}`);
+    const envKey = providerSection ? extractTomlStringValue(providerSection, 'env_key') : undefined;
+    if (!envKey || env[envKey])
+        return { status: 'available' };
+    return {
+        status: 'signed-out',
+        reason: `Codex model provider "${provider}" requires ${envKey}, but MindOS cannot see that environment variable. Export ${envKey} before starting MindOS, or switch Codex to a provider that does not require it.`,
+    };
+}
+function readCodexConfigText(configPath, env) {
+    const resolvedPath = configPath ?? join(env.CODEX_HOME || join(homedir(), '.codex'), 'config.toml');
+    try {
+        if (!existsSync(resolvedPath))
+            return undefined;
+        return readFileSync(resolvedPath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractTomlStringValue(text, key) {
+    const escapedKey = escapeRegExp(key);
+    const match = text.match(new RegExp(`^\\s*${escapedKey}\\s*=\\s*"([^"]*)"\\s*$`, 'm'));
+    return match?.[1]?.trim() || undefined;
+}
+function extractTomlSection(text, sectionName) {
+    const lines = text.split(/\r?\n/);
+    const targetHeader = `[${sectionName}]`;
+    const sectionLines = [];
+    let inSection = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            if (inSection)
+                break;
+            inSection = trimmed === targetHeader;
+            continue;
+        }
+        if (inSection)
+            sectionLines.push(line);
+    }
+    return inSection ? sectionLines.join('\n') : undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export async function defaultCheckNativeRuntimeHealth(input) {
+    const timeoutMs = input.timeoutMs ?? NATIVE_HEALTH_TIMEOUT_MS;
+    if (input.runtime === 'codex') {
+        return checkCodexCliRuntime(input.agent.binaryPath, timeoutMs);
+    }
+    return checkClaudeSdkRuntime(input.agent.binaryPath, timeoutMs);
+}
+async function checkClaudeSdkRuntime(binaryPath, timeoutMs) {
+    try {
+        await withTimeout(import('@anthropic-ai/claude-agent-sdk'), timeoutMs, `Claude Agent SDK health check timed out after ${timeoutMs}ms.`);
+        return {
+            status: 'available',
+            diagnosticHints: [
+                binaryPath.startsWith('sdk:')
+                    ? 'Claude Agent SDK is bundled with MindOS; a global claude command is optional.'
+                    : `Claude CLI was also detected at ${binaryPath}; MindOS uses Claude Agent SDK first and falls back to CLI if needed.`,
+            ],
+        };
+    }
+    catch (error) {
+        if (!binaryPath.startsWith('sdk:')) {
+            const fallback = await checkProcessVersion(binaryPath, ['--version'], timeoutMs);
+            return {
+                ...fallback,
+                diagnosticHints: [
+                    ...(fallback.diagnosticHints ?? []),
+                    `Claude Agent SDK is unavailable; MindOS will use CLI fallback. ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            };
+        }
+        throw error;
+    }
+}
+async function applyNativeRuntimeHealth(installed, services) {
+    const checkNativeRuntimeHealth = services.checkNativeRuntimeHealth ?? defaultCheckNativeRuntimeHealth;
+    const normalized = installed.map((agent) => ({ raw: agent, detected: normalizeInstalled(agent) }));
+    const enriched = await Promise.all(normalized.map(async ({ raw, detected }) => {
+        if (!detected)
+            return raw;
+        const runtime = isCodexAgent(detected) ? 'codex' : isClaudeAgent(detected) ? 'claude' : null;
+        if (!runtime)
+            return raw;
+        if (detected.status)
+            return raw;
+        try {
+            const health = await checkNativeRuntimeHealth({
+                runtime,
+                agent: detected,
+                timeoutMs: NATIVE_HEALTH_TIMEOUT_MS,
+            });
+            return {
+                ...(isRecord(raw) ? raw : detected),
+                status: health.status,
+                ...(health.reason ? { reason: health.reason } : {}),
+                ...(health.diagnosticHints ? { diagnosticHints: health.diagnosticHints } : {}),
+            };
+        }
+        catch (error) {
+            const result = classifyRuntimeFailure(error instanceof Error ? error.message : String(error));
+            return {
+                ...(isRecord(raw) ? raw : detected),
+                status: result.status,
+                ...(result.reason ? { reason: result.reason } : {}),
+            };
+        }
+    }));
+    return enriched;
+}
+async function detectNativeRuntimeDefinition(candidate, services) {
+    const checkNativeRuntimeHealth = services.checkNativeRuntimeHealth ?? defaultCheckNativeRuntimeHealth;
+    const resolveRuntimeCommand = services.resolveRuntimeCommand ?? resolveCommandPath;
+    const binaryPath = await resolveRuntimeCommand(candidate.command);
+    if (!binaryPath) {
+        if (candidate.runtime === 'claude') {
+            const sdkBinaryPath = 'sdk:@anthropic-ai/claude-agent-sdk';
+            try {
+                const health = await checkNativeRuntimeHealth({
+                    runtime: candidate.runtime,
+                    agent: { id: candidate.id, name: candidate.name, binaryPath: sdkBinaryPath },
+                    timeoutMs: NATIVE_HEALTH_TIMEOUT_MS,
+                });
+                return {
+                    id: candidate.id,
+                    name: candidate.name,
+                    binaryPath: sdkBinaryPath,
+                    status: health.status,
+                    reason: health.reason,
+                    diagnosticHints: [
+                        ...(health.diagnosticHints ?? []),
+                        'Global claude command was not detected; CLI fallback will be unavailable until it is installed or on MindOS server PATH.',
+                    ],
+                };
+            }
+            catch (error) {
+                const result = classifyRuntimeFailure(error instanceof Error ? error.message : String(error));
+                return {
+                    id: candidate.id,
+                    name: candidate.name,
+                    installCmd: candidate.installCmd,
+                    packageName: candidate.installCmd.match(/npm install -g (.+)/)?.[1],
+                    status: 'error',
+                    reason: `Claude Agent SDK is unavailable and the global claude command was not detected. ${result.reason ?? ''}`.trim(),
+                };
+            }
+        }
+        return {
+            id: candidate.id,
+            name: candidate.name,
+            installCmd: candidate.installCmd,
+            packageName: candidate.installCmd.match(/npm install -g (.+)/)?.[1],
+            status: 'missing',
+            reason: `${candidate.name} executable was not detected.`,
+        };
+    }
+    try {
+        const health = await checkNativeRuntimeHealth({
+            runtime: candidate.runtime,
+            agent: { id: candidate.id, name: candidate.name, binaryPath },
+            timeoutMs: NATIVE_HEALTH_TIMEOUT_MS,
+        });
+        return {
+            id: candidate.id,
+            name: candidate.name,
+            binaryPath,
+            resolvedCommand: { cmd: candidate.command, args: [], source: 'descriptor' },
+            status: health.status,
+            ...(health.reason ? { reason: health.reason } : {}),
+            ...(health.diagnosticHints ? { diagnosticHints: health.diagnosticHints } : {}),
+        };
+    }
+    catch (error) {
+        const result = classifyRuntimeFailure(error instanceof Error ? error.message : String(error));
+        return {
+            id: candidate.id,
+            name: candidate.name,
+            binaryPath,
+            resolvedCommand: { cmd: candidate.command, args: [], source: 'descriptor' },
+            status: result.status,
+            ...(result.reason ? { reason: result.reason } : {}),
+        };
+    }
+}
+async function detectNativeRuntimes(services) {
+    const results = await Promise.all(nativeRuntimeDefinitions.map((candidate) => detectNativeRuntimeDefinition(candidate, services)));
+    return {
+        installed: results.filter((agent) => 'binaryPath' in agent),
+        notInstalled: results.filter((agent) => 'installCmd' in agent),
+    };
+}
+function isNativeRuntimeId(value) {
+    return value === 'codex' || value === 'claude';
+}
+async function detectSingleNativeRuntime(runtime, services) {
+    const candidate = nativeRuntimeDefinitions.find((definition) => definition.runtime === runtime);
+    if (!candidate)
+        throw new Error(`Unsupported native runtime: ${runtime}`);
+    const result = await detectNativeRuntimeDefinition(candidate, services);
+    const checkedAt = new Date(services.now?.() ?? Date.now()).toISOString();
+    return nativeDescriptor({
+        id: runtime,
+        name: candidate.name,
+        checkedAt,
+        ...('binaryPath' in result ? { source: result } : { missing: result }),
+    });
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function handleAgentRuntimesGet(searchParams, services = {}) {
+    try {
+        const scope = searchParams.get('scope');
+        if (scope && scope !== 'acp') {
+            return json({ error: `Unsupported scope: ${scope}` }, { status: 400 });
+        }
+        const runtime = searchParams.get('runtime');
+        if (runtime) {
+            if (!isNativeRuntimeId(runtime)) {
+                return json({ error: `Unsupported runtime: ${runtime}` }, { status: 400 });
+            }
+            const descriptor = await detectSingleNativeRuntime(runtime, services);
+            return json({ runtime: descriptor }, { headers: { 'Cache-Control': 'no-store' } });
+        }
+        const detectLocalAcpAgents = services.detectLocalAcpAgents ?? defaultDetectLocalAcpAgents;
+        if (scope === 'acp') {
+            const acpDetection = await withTimeout(detectLocalAcpAgents({ overrides: services.readSettings?.().acpAgents }), RUNTIME_DETECTION_TIMEOUT_MS, `Agent runtime detection timed out after ${RUNTIME_DETECTION_TIMEOUT_MS}ms.`);
+            return json(buildAcpScopedPayload({
+                installed: Array.isArray(acpDetection.installed) ? acpDetection.installed : [],
+                notInstalled: Array.isArray(acpDetection.notInstalled) ? acpDetection.notInstalled : [],
+                checkedAt: new Date(services.now?.() ?? Date.now()).toISOString(),
+            }), { headers: searchParams.get('force') === '1' ? { 'Cache-Control': 'no-store' } : privateCacheHeaders(1800) });
+        }
+        const nativeDetectionPromise = detectNativeRuntimes(services);
+        const acpDetectionPromise = (async () => {
+            try {
+                return await withTimeout(detectLocalAcpAgents({ overrides: services.readSettings?.().acpAgents }), RUNTIME_DETECTION_TIMEOUT_MS, `Agent runtime detection timed out after ${RUNTIME_DETECTION_TIMEOUT_MS}ms.`);
+            }
+            catch {
+                return { installed: [], notInstalled: [] };
+            }
+        })();
+        const [nativeDetection, acpDetection] = await Promise.all([nativeDetectionPromise, acpDetectionPromise]);
+        const acpInstalled = Array.isArray(acpDetection.installed) ? acpDetection.installed : [];
+        const acpNotInstalled = Array.isArray(acpDetection.notInstalled) ? acpDetection.notInstalled : [];
+        const acpRuntimeInstalled = acpInstalled.filter((agent) => {
+            const normalized = normalizeInstalled(agent);
+            return !normalized || (!isCodexAgent(normalized) && !isClaudeAgent(normalized));
+        });
+        const acpRuntimeNotInstalled = acpNotInstalled.filter((agent) => {
+            const normalized = normalizeMissing(agent);
+            return !normalized || (!isCodexAgent(normalized) && !isClaudeAgent(normalized));
+        });
+        const installed = await applyNativeRuntimeHealth([...nativeDetection.installed, ...acpRuntimeInstalled], services);
+        const payload = buildAgentRuntimesPayload({
+            installed,
+            notInstalled: [...nativeDetection.notInstalled, ...acpRuntimeNotInstalled],
+            checkedAt: new Date(services.now?.() ?? Date.now()).toISOString(),
+        });
+        return json({
+            ...payload,
+            installed: acpInstalled.map(normalizeInstalled).filter((agent) => !!agent),
+            notInstalled: acpNotInstalled.map(normalizeMissing).filter((agent) => !!agent),
+        }, { headers: searchParams.get('force') === '1' ? { 'Cache-Control': 'no-store' } : privateCacheHeaders(1800) });
+    }
+    catch (error) {
+        return errorResponse(error);
+    }
+}
+//# sourceMappingURL=agent-runtimes.js.map