opencara 0.2.0 → 0.2.2

package/dist/commands/agent.js

@@ -1,924 +0,0 @@
-import { Command } from 'commander';
-import WebSocket from 'ws';
-import crypto from 'node:crypto';
-import { DEFAULT_REGISTRY, } from '@opencara/shared';
-import { loadConfig, saveConfig, requireApiKey, resolveAgentLimits, } from '../config.js';
-import { ApiClient } from '../http.js';
-import { calculateDelay, sleep, DEFAULT_RECONNECT_OPTIONS } from '../reconnect.js';
-import { executeReview, DiffTooLargeError } from '../review.js';
-import { executeSummary, InputTooLargeError } from '../summary.js';
-import { resolveCommandTemplate, validateCommandBinary } from '../tool-executor.js';
-import { checkConsumptionLimits, createSessionTracker, recordSessionUsage, formatPostReviewStats, } from '../consumption.js';
-/** Minimum time (ms) a connection must be alive before we reset the attempt counter */
-const CONNECTION_STABILITY_THRESHOLD_MS = 30_000;
-function formatTable(agents, trustLabels) {
-    if (agents.length === 0) {
-        console.log('No agents registered. Run `opencara agent create` to register one.');
-        return;
-    }
-    const header = [
-        'ID'.padEnd(38),
-        'Model'.padEnd(22),
-        'Tool'.padEnd(16),
-        'Status'.padEnd(10),
-        'Trust',
-    ].join('');
-    console.log(header);
-    for (const a of agents) {
-        const trust = trustLabels?.get(a.id) ?? '--';
-        console.log([a.id.padEnd(38), a.model.padEnd(22), a.tool.padEnd(16), a.status.padEnd(10), trust].join(''));
-    }
-}
-function buildWsUrl(platformUrl, agentId, apiKey) {
-    return (platformUrl.replace(/^https:\/\//, 'wss://').replace(/^http:\/\//, 'ws://') +
-        `/ws/agent/${agentId}?token=${encodeURIComponent(apiKey)}`);
-}
-export { buildWsUrl };
-const HEARTBEAT_TIMEOUT_MS = 90_000;
-export const STABILITY_THRESHOLD_MIN_MS = 5_000;
-export const STABILITY_THRESHOLD_MAX_MS = 300_000;
-/** Interval for sending RFC 6455 WebSocket ping frames to keep the proxy layer alive */
-const WS_PING_INTERVAL_MS = 20_000;
-export function startAgent(agentId, platformUrl, apiKey, reviewDeps, consumptionDeps, options) {
-    const verbose = options?.verbose ?? false;
-    const stabilityThreshold = options?.stabilityThresholdMs ?? CONNECTION_STABILITY_THRESHOLD_MS;
-    const repoConfig = options?.repoConfig;
-    let attempt = 0;
-    let intentionalClose = false;
-    let heartbeatTimer = null;
-    let wsPingTimer = null;
-    let currentWs = null;
-    let connectionOpenedAt = null;
-    let stabilityTimer = null;
-    function clearHeartbeatTimer() {
-        if (heartbeatTimer) {
-            clearTimeout(heartbeatTimer);
-            heartbeatTimer = null;
-        }
-    }
-    function clearStabilityTimer() {
-        if (stabilityTimer) {
-            clearTimeout(stabilityTimer);
-            stabilityTimer = null;
-        }
-    }
-    function clearWsPingTimer() {
-        if (wsPingTimer) {
-            clearInterval(wsPingTimer);
-            wsPingTimer = null;
-        }
-    }
-    function shutdown() {
-        intentionalClose = true;
-        clearHeartbeatTimer();
-        clearStabilityTimer();
-        clearWsPingTimer();
-        if (currentWs)
-            currentWs.close();
-        console.log('Disconnected.');
-        process.exit(0);
-    }
-    process.once('SIGINT', shutdown);
-    process.once('SIGTERM', shutdown);
-    function connect() {
-        const url = buildWsUrl(platformUrl, agentId, apiKey);
-        const ws = new WebSocket(url);
-        currentWs = ws;
-        function resetHeartbeatTimer() {
-            clearHeartbeatTimer();
-            heartbeatTimer = setTimeout(() => {
-                console.log('No heartbeat received in 90s. Reconnecting...');
-                ws.terminate();
-            }, HEARTBEAT_TIMEOUT_MS);
-        }
-        ws.on('open', () => {
-            connectionOpenedAt = Date.now();
-            console.log('Connected to platform.');
-            resetHeartbeatTimer();
-            // Send RFC 6455 WebSocket ping frames to keep the Cloudflare proxy layer alive
-            clearWsPingTimer();
-            wsPingTimer = setInterval(() => {
-                try {
-                    if (ws.readyState === WebSocket.OPEN) {
-                        ws.ping();
-                    }
-                }
-                catch {
-                    // Swallow ping errors — socket may be closing
-                }
-            }, WS_PING_INTERVAL_MS);
-            if (verbose) {
-                console.log(`[verbose] Connection opened at ${new Date(connectionOpenedAt).toISOString()}`);
-            }
-            // Deferred attempt reset: only reset after connection is stable
-            clearStabilityTimer();
-            stabilityTimer = setTimeout(() => {
-                if (verbose) {
-                    console.log(`[verbose] Connection stable for ${stabilityThreshold / 1000}s — resetting reconnect counter`);
-                }
-                attempt = 0;
-            }, stabilityThreshold);
-        });
-        ws.on('message', (data) => {
-            let msg;
-            try {
-                msg = JSON.parse(data.toString());
-            }
-            catch {
-                return;
-            }
-            handleMessage(ws, msg, resetHeartbeatTimer, reviewDeps, consumptionDeps, verbose, repoConfig);
-        });
-        ws.on('close', (code, reason) => {
-            if (intentionalClose)
-                return;
-            if (ws !== currentWs)
-                return; // Stale WS — don't clear active timers
-            clearHeartbeatTimer();
-            clearStabilityTimer();
-            clearWsPingTimer();
-            // Log connection lifetime
-            if (connectionOpenedAt) {
-                const lifetimeMs = Date.now() - connectionOpenedAt;
-                const lifetimeSec = (lifetimeMs / 1000).toFixed(1);
-                console.log(`Disconnected (code=${code}, reason=${reason.toString()}). Connection was alive for ${lifetimeSec}s.`);
-            }
-            else {
-                console.log(`Disconnected (code=${code}, reason=${reason.toString()}).`);
-            }
-            if (code === 4002) {
-                console.log('Connection replaced by server — not reconnecting.');
-                return;
-            }
-            connectionOpenedAt = null;
-            reconnect();
-        });
-        ws.on('pong', () => {
-            if (verbose) {
-                console.log(`[verbose] WS pong received at ${new Date().toISOString()}`);
-            }
-        });
-        ws.on('error', (err) => {
-            console.error(`WebSocket error: ${err.message}`);
-        });
-    }
-    async function reconnect() {
-        const delay = calculateDelay(attempt, DEFAULT_RECONNECT_OPTIONS);
-        const delaySec = (delay / 1000).toFixed(1);
-        attempt++;
-        console.log(`Reconnecting in ${delaySec}s... (attempt ${attempt})`);
-        await sleep(delay);
-        connect();
-    }
-    connect();
-}
-function trySend(ws, data) {
-    try {
-        ws.send(JSON.stringify(data));
-    }
-    catch {
-        console.error('Failed to send message — WebSocket may be closed');
-    }
-}
-async function logPostReviewStats(type, verdict, tokensUsed, tokensEstimated, consumptionDeps) {
-    const estimateTag = tokensEstimated ? ' ~' : ' ';
-    if (!consumptionDeps) {
-        if (verdict) {
-            console.log(`${type} complete: ${verdict} (${estimateTag}${tokensUsed} tokens${tokensEstimated ? ', estimated' : ''})`);
-        }
-        else {
-            console.log(`${type} complete (${estimateTag}${tokensUsed} tokens${tokensEstimated ? ', estimated' : ''})`);
-        }
-        return;
-    }
-    recordSessionUsage(consumptionDeps.session, tokensUsed);
-    if (verdict) {
-        console.log(`${type} complete: ${verdict} (${estimateTag}${tokensUsed.toLocaleString()} tokens${tokensEstimated ? ', estimated' : ''})`);
-    }
-    else {
-        console.log(`${type} complete (${estimateTag}${tokensUsed.toLocaleString()} tokens${tokensEstimated ? ', estimated' : ''})`);
-    }
-    console.log(formatPostReviewStats(tokensUsed, consumptionDeps.session, consumptionDeps.limits));
-}
-export function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, verbose, repoConfig) {
-    switch (msg.type) {
-        case 'connected':
-            console.log(`Authenticated. Protocol v${msg.version ?? 'unknown'}`);
-            // Send agent preferences (repo config) to the platform
-            trySend(ws, {
-                type: 'agent_preferences',
-                id: crypto.randomUUID(),
-                timestamp: Date.now(),
-                repoConfig: repoConfig ?? { mode: 'all' },
-            });
-            break;
-        case 'heartbeat_ping':
-            ws.send(JSON.stringify({ type: 'heartbeat_pong', timestamp: Date.now() }));
-            if (verbose) {
-                console.log(`[verbose] Heartbeat ping received, pong sent at ${new Date().toISOString()}`);
-            }
-            if (resetHeartbeat)
-                resetHeartbeat();
-            break;
-        case 'review_request': {
-            const request = msg;
-            console.log(`Review request: task ${request.taskId} for ${request.project.owner}/${request.project.repo}#${request.pr.number}`);
-            if (!reviewDeps) {
-                ws.send(JSON.stringify({
-                    type: 'review_rejected',
-                    id: crypto.randomUUID(),
-                    timestamp: Date.now(),
-                    taskId: request.taskId,
-                    reason: 'Review execution not configured',
-                }));
-                break;
-            }
-            void (async () => {
-                // Check consumption limits before executing
-                if (consumptionDeps) {
-                    const limitResult = await checkConsumptionLimits(consumptionDeps.agentId, consumptionDeps.limits);
-                    if (!limitResult.allowed) {
-                        trySend(ws, {
-                            type: 'review_rejected',
-                            id: crypto.randomUUID(),
-                            timestamp: Date.now(),
-                            taskId: request.taskId,
-                            reason: limitResult.reason ?? 'consumption_limit_exceeded',
-                        });
-                        console.log(`Review rejected: ${limitResult.reason}`);
-                        return;
-                    }
-                }
-                try {
-                    const result = await executeReview({
-                        taskId: request.taskId,
-                        diffContent: request.diffContent,
-                        prompt: request.project.prompt,
-                        owner: request.project.owner,
-                        repo: request.project.repo,
-                        prNumber: request.pr.number,
-                        timeout: request.timeout,
-                        reviewMode: request.reviewMode ?? 'full',
-                    }, reviewDeps);
-                    trySend(ws, {
-                        type: 'review_complete',
-                        id: crypto.randomUUID(),
-                        timestamp: Date.now(),
-                        taskId: request.taskId,
-                        review: result.review,
-                        verdict: result.verdict,
-                        tokensUsed: result.tokensUsed,
-                    });
-                    await logPostReviewStats('Review', result.verdict, result.tokensUsed, result.tokensEstimated, consumptionDeps);
-                }
-                catch (err) {
-                    if (err instanceof DiffTooLargeError) {
-                        trySend(ws, {
-                            type: 'review_rejected',
-                            id: crypto.randomUUID(),
-                            timestamp: Date.now(),
-                            taskId: request.taskId,
-                            reason: err.message,
-                        });
-                    }
-                    else {
-                        trySend(ws, {
-                            type: 'review_error',
-                            id: crypto.randomUUID(),
-                            timestamp: Date.now(),
-                            taskId: request.taskId,
-                            error: err instanceof Error ? err.message : 'Unknown error',
-                        });
-                    }
-                    console.error('Review failed:', err);
-                }
-            })();
-            break;
-        }
-        case 'summary_request': {
-            const summaryRequest = msg;
-            console.log(`Summary request: task ${summaryRequest.taskId} for ${summaryRequest.project.owner}/${summaryRequest.project.repo}#${summaryRequest.pr.number} (${summaryRequest.reviews.length} reviews)`);
-            if (!reviewDeps) {
-                trySend(ws, {
-                    type: 'review_rejected',
-                    id: crypto.randomUUID(),
-                    timestamp: Date.now(),
-                    taskId: summaryRequest.taskId,
-                    reason: 'Review tool not configured',
-                });
-                break;
-            }
-            void (async () => {
-                // Check consumption limits before executing
-                if (consumptionDeps) {
-                    const limitResult = await checkConsumptionLimits(consumptionDeps.agentId, consumptionDeps.limits);
-                    if (!limitResult.allowed) {
-                        trySend(ws, {
-                            type: 'review_rejected',
-                            id: crypto.randomUUID(),
-                            timestamp: Date.now(),
-                            taskId: summaryRequest.taskId,
-                            reason: limitResult.reason ?? 'consumption_limit_exceeded',
-                        });
-                        console.log(`Summary rejected: ${limitResult.reason}`);
-                        return;
-                    }
-                }
-                try {
-                    const result = await executeSummary({
-                        taskId: summaryRequest.taskId,
-                        reviews: summaryRequest.reviews,
-                        prompt: summaryRequest.project.prompt,
-                        owner: summaryRequest.project.owner,
-                        repo: summaryRequest.project.repo,
-                        prNumber: summaryRequest.pr.number,
-                        timeout: summaryRequest.timeout,
-                        diffContent: summaryRequest.diffContent ?? '',
-                    }, reviewDeps);
-                    trySend(ws, {
-                        type: 'summary_complete',
-                        id: crypto.randomUUID(),
-                        timestamp: Date.now(),
-                        taskId: summaryRequest.taskId,
-                        summary: result.summary,
-                        tokensUsed: result.tokensUsed,
-                    });
-                    await logPostReviewStats('Summary', undefined, result.tokensUsed, result.tokensEstimated, consumptionDeps);
-                }
-                catch (err) {
-                    if (err instanceof InputTooLargeError) {
-                        trySend(ws, {
-                            type: 'review_rejected',
-                            id: crypto.randomUUID(),
-                            timestamp: Date.now(),
-                            taskId: summaryRequest.taskId,
-                            reason: err.message,
-                        });
-                    }
-                    else {
-                        trySend(ws, {
-                            type: 'review_error',
-                            id: crypto.randomUUID(),
-                            timestamp: Date.now(),
-                            taskId: summaryRequest.taskId,
-                            error: err instanceof Error ? err.message : 'Summary failed',
-                        });
-                    }
-                    console.error('Summary failed:', err);
-                }
-            })();
-            break;
-        }
-        case 'error':
-            console.error(`Platform error: ${msg.code ?? 'unknown'}`);
-            if (msg.code === 'auth_revoked')
-                process.exit(1);
-            break;
-        default:
-            break;
-    }
-}
-/** Sync a local agent to the server: find existing by model+tool or create new */
-async function syncAgentToServer(client, serverAgents, localAgent) {
-    const existing = serverAgents.find((a) => a.model === localAgent.model && a.tool === localAgent.tool);
-    if (existing) {
-        return { agentId: existing.id, created: false };
-    }
-    const body = { model: localAgent.model, tool: localAgent.tool };
-    if (localAgent.repos) {
-        body.repoConfig = localAgent.repos;
-    }
-    const created = await client.post('/api/agents', body);
-    return { agentId: created.id, created: true };
-}
-/** Resolve the effective command template for a local agent */
-function resolveLocalAgentCommand(localAgent, globalAgentCommand) {
-    const effectiveCommand = localAgent.command ?? globalAgentCommand;
-    return resolveCommandTemplate(effectiveCommand);
-}
-export { syncAgentToServer, resolveLocalAgentCommand };
-export const agentCommand = new Command('agent').description('Manage review agents');
-agentCommand
-    .command('create')
-    .description('Add an agent to local config (interactive or via flags)')
-    .option('--model <model>', 'AI model name (e.g., claude-opus-4-6)')
-    .option('--tool <tool>', 'Review tool name (e.g., claude-code)')
-    .option('--command <cmd>', 'Custom command template (bypasses registry lookup)')
-    .action(async (opts) => {
-    const config = loadConfig();
-    requireApiKey(config);
-    let model;
-    let tool;
-    let command = opts.command;
-    if (opts.model && opts.tool) {
-        // Non-interactive mode
-        model = opts.model;
-        tool = opts.tool;
-    }
-    else if (opts.model || opts.tool) {
-        console.error('Both --model and --tool are required in non-interactive mode.');
-        process.exit(1);
-    }
-    else {
-        // Interactive mode: fetch registry and prompt
-        const client = new ApiClient(config.platformUrl, config.apiKey);
-        let registry;
-        try {
-            registry = await client.get('/api/registry');
-        }
-        catch {
-            console.warn('Could not fetch registry from server. Using built-in defaults.');
-            registry = DEFAULT_REGISTRY;
-        }
-        const { search, input } = await import('@inquirer/prompts');
-        const searchTheme = {
-            style: {
-                keysHelpTip: (keys) => keys.map(([key, action]) => `${key} ${action}`).join(', ') + ', ^C exit',
-            },
-        };
-        const existingAgents = config.agents ?? [];
-        const toolChoices = registry.tools.map((t) => ({
-            name: t.displayName,
-            value: t.name,
-        }));
-        try {
-            // Loop: select tool → select model → check duplicate → if dup, restart
-            while (true) {
-                // Step 1: Select tool
-                tool = await search({
-                    message: 'Select a tool:',
-                    theme: searchTheme,
-                    source: (term) => {
-                        const q = (term ?? '').toLowerCase();
-                        return toolChoices.filter((c) => c.name.toLowerCase().includes(q) || c.value.toLowerCase().includes(q));
-                    },
-                });
-                // Step 2: Select model — compatible first, others dimmed
-                const compatible = registry.models.filter((m) => m.tools.includes(tool));
-                const incompatible = registry.models.filter((m) => !m.tools.includes(tool));
-                const modelChoices = [
-                    ...compatible.map((m) => ({
-                        name: m.displayName,
-                        value: m.name,
-                    })),
-                    ...incompatible.map((m) => ({
-                        name: `\x1b[38;5;249m${m.displayName}\x1b[0m`,
-                        value: m.name,
-                    })),
-                ];
-                model = await search({
-                    message: 'Select a model:',
-                    theme: searchTheme,
-                    source: (term) => {
-                        const q = (term ?? '').toLowerCase();
-                        return modelChoices.filter((c) => c.value.toLowerCase().includes(q) || c.name.toLowerCase().includes(q));
-                    },
-                });
-                // Check duplicate before proceeding
-                const isDup = existingAgents.some((a) => a.model === model && a.tool === tool);
-                if (isDup) {
-                    console.warn(`"${model}" / "${tool}" already exists in config. Choose again.`);
-                    continue;
-                }
-                // Warn if model isn't compatible with selected tool
-                const modelEntry = registry.models.find((m) => m.name === model);
-                if (modelEntry && !modelEntry.tools.includes(tool)) {
-                    console.warn(`Warning: "${model}" is not listed as compatible with "${tool}".`);
-                }
-                break;
-            }
-            // Step 3: Resolve default command and let user edit it
-            const toolEntry = registry.tools.find((t) => t.name === tool);
-            const defaultCommand = toolEntry
-                ? toolEntry.commandTemplate.replaceAll('${MODEL}', model)
-                : `${tool} --model ${model} -p \${PROMPT}`;
-            command = await input({
-                message: 'Command:',
-                default: defaultCommand,
-                prefill: 'editable',
-            });
-        }
-        catch (err) {
-            if (err && typeof err === 'object' && 'name' in err && err.name === 'ExitPromptError') {
-                console.log('Cancelled.');
-                return;
-            }
-            throw err;
-        }
-    }
-    // Resolve command from registry if not set (non-interactive mode)
-    if (!command) {
-        const toolEntry = DEFAULT_REGISTRY.tools.find((t) => t.name === tool);
-        if (toolEntry) {
-            command = toolEntry.commandTemplate.replaceAll('${MODEL}', model);
-        }
-        else {
-            console.error(`No command template for tool "${tool}". Use --command to specify one.`);
-            process.exit(1);
-        }
-    }
-    // Validate binary
-    if (validateCommandBinary(command)) {
-        console.log(`Verifying... binary found.`);
-    }
-    else {
-        console.warn(`Warning: binary for command "${command.split(' ')[0]}" not found on this machine.`);
-    }
-    // Write to local config
-    const newAgent = { model, tool, command };
-    if (config.agents === null) {
-        config.agents = [];
-    }
-    const isDuplicate = config.agents.some((a) => a.model === model && a.tool === tool);
-    if (isDuplicate) {
-        console.error(`Agent with model "${model}" and tool "${tool}" already exists in config.`);
-        process.exit(1);
-    }
-    config.agents.push(newAgent);
-    saveConfig(config);
-    console.log('Agent added to config:');
-    console.log(`  Model:   ${model}`);
-    console.log(`  Tool:    ${tool}`);
-    console.log(`  Command: ${command}`);
-});
-agentCommand
-    .command('init')
-    .description('Import server-side agents into local config')
-    .action(async () => {
-    const config = loadConfig();
-    const apiKey = requireApiKey(config);
-    const client = new ApiClient(config.platformUrl, apiKey);
-    let res;
-    try {
-        res = await client.get('/api/agents');
-    }
-    catch (err) {
-        console.error('Failed to list agents:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-    if (res.agents.length === 0) {
-        console.log('No server-side agents found. Use `opencara agent create` to add one.');
-        return;
-    }
-    // Fetch registry for command templates
-    let registry;
-    try {
-        registry = await client.get('/api/registry');
-    }
-    catch {
-        registry = DEFAULT_REGISTRY;
-    }
-    const toolCommands = new Map(registry.tools.map((t) => [t.name, t.commandTemplate]));
-    const existing = config.agents ?? [];
-    let imported = 0;
-    for (const agent of res.agents) {
-        const isDuplicate = existing.some((e) => e.model === agent.model && e.tool === agent.tool);
-        if (isDuplicate)
-            continue;
-        let command = toolCommands.get(agent.tool);
-        if (command) {
-            command = command.replaceAll('${MODEL}', agent.model);
-        }
-        else {
-            console.warn(`Warning: no command template for ${agent.model}/${agent.tool} — set command manually in config`);
-        }
-        existing.push({ model: agent.model, tool: agent.tool, command });
-        imported++;
-    }
-    config.agents = existing;
-    saveConfig(config);
-    console.log(`Imported ${imported} agent(s) to local config.`);
-    if (imported > 0) {
-        console.log('Edit ~/.opencara/config.yml to adjust commands for your system.');
-    }
-});
-agentCommand
-    .command('list')
-    .description('List registered agents')
-    .action(async () => {
-    const config = loadConfig();
-    const apiKey = requireApiKey(config);
-    const client = new ApiClient(config.platformUrl, apiKey);
-    let res;
-    try {
-        res = await client.get('/api/agents');
-    }
-    catch (err) {
-        console.error('Failed to list agents:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-    // Fetch trust tier labels for each agent
-    const trustLabels = new Map();
-    for (const agent of res.agents) {
-        try {
-            const stats = await client.get(`/api/stats/${agent.id}`);
-            trustLabels.set(agent.id, stats.agent.trustTier.label);
-        }
-        catch {
-            // Leave as '--' if stats unavailable
-        }
-    }
-    formatTable(res.agents, trustLabels);
-});
-/** Register or reuse an anonymous agent, returning credentials and command template */
-async function resolveAnonymousAgent(config, model, tool) {
-    // Check for stored anonymous agent with matching model+tool
-    const existing = config.anonymousAgents.find((a) => a.model === model && a.tool === tool);
-    if (existing) {
-        console.log(`Reusing stored anonymous agent ${existing.agentId} (${model} / ${tool})`);
-        const command = resolveCommandTemplate(DEFAULT_REGISTRY.tools
-            .find((t) => t.name === tool)
-            ?.commandTemplate.replaceAll('${MODEL}', model) ?? null);
-        return { entry: existing, command };
-    }
-    // Register new anonymous agent
-    console.log('Registering anonymous agent...');
-    const client = new ApiClient(config.platformUrl);
-    const body = { model, tool };
-    const res = await client.post('/api/agents/anonymous', body);
-    const entry = {
-        agentId: res.agentId,
-        apiKey: res.apiKey,
-        model,
-        tool,
-    };
-    // Store in config
-    config.anonymousAgents.push(entry);
-    saveConfig(config);
-    console.log(`Agent registered: ${res.agentId} (${model} / ${tool})`);
-    console.log('Credentials saved to ~/.opencara/config.yml');
-    const command = resolveCommandTemplate(DEFAULT_REGISTRY.tools
-        .find((t) => t.name === tool)
-        ?.commandTemplate.replaceAll('${MODEL}', model) ?? null);
-    return { entry, command };
-}
-export { resolveAnonymousAgent };
-agentCommand
-    .command('start [agentIdOrModel]')
-    .description('Connect agent to platform via WebSocket')
-    .option('--all', 'Start all agents from local config concurrently')
-    .option('-a, --anonymous', 'Start an anonymous agent (no login required)')
-    .option('--model <model>', 'AI model name (used with --anonymous)')
-    .option('--tool <tool>', 'Review tool name (used with --anonymous)')
-    .option('--verbose', 'Enable detailed WebSocket diagnostic logging')
-    .option('--stability-threshold <ms>', `Connection stability threshold in ms (${STABILITY_THRESHOLD_MIN_MS}–${STABILITY_THRESHOLD_MAX_MS}, default: ${CONNECTION_STABILITY_THRESHOLD_MS})`)
-    .action(async (agentIdOrModel, opts) => {
-    let stabilityThresholdMs;
-    if (opts.stabilityThreshold !== undefined) {
-        const val = Number(opts.stabilityThreshold);
-        if (!Number.isInteger(val) ||
-            val < STABILITY_THRESHOLD_MIN_MS ||
-            val > STABILITY_THRESHOLD_MAX_MS) {
-            console.error(`Invalid --stability-threshold: must be an integer between ${STABILITY_THRESHOLD_MIN_MS} and ${STABILITY_THRESHOLD_MAX_MS}`);
-            process.exit(1);
-        }
-        stabilityThresholdMs = val;
-    }
-    const config = loadConfig();
-    // === Path C: Anonymous mode ===
-    if (opts.anonymous) {
-        if (!opts.model || !opts.tool) {
-            console.error('Both --model and --tool are required with --anonymous.');
-            process.exit(1);
-        }
-        let resolved;
-        try {
-            resolved = await resolveAnonymousAgent(config, opts.model, opts.tool);
-        }
-        catch (err) {
-            console.error('Failed to register anonymous agent:', err instanceof Error ? err.message : err);
-            process.exit(1);
-        }
-        const { entry, command } = resolved;
-        let reviewDeps;
-        if (validateCommandBinary(command)) {
-            reviewDeps = { commandTemplate: command, maxDiffSizeKb: config.maxDiffSizeKb };
-        }
-        else {
-            console.warn(`Warning: binary "${command.split(' ')[0]}" not found. Reviews will be rejected.`);
-        }
-        const consumptionDeps = {
-            agentId: entry.agentId,
-            limits: config.limits,
-            session: createSessionTracker(),
-        };
-        console.log(`Starting anonymous agent ${entry.agentId}...`);
-        startAgent(entry.agentId, config.platformUrl, entry.apiKey, reviewDeps, consumptionDeps, {
-            verbose: opts.verbose,
-            stabilityThresholdMs,
-            repoConfig: entry.repoConfig,
-        });
-        return;
-    }
-    // === Path B: Local-config mode (agents section exists) ===
-    if (config.agents !== null) {
-        // Validate and filter agents by binary availability
-        const validAgents = [];
-        for (const local of config.agents) {
-            let cmd;
-            try {
-                cmd = resolveLocalAgentCommand(local, config.agentCommand);
-            }
-            catch (err) {
-                console.warn(`Skipping ${local.model}/${local.tool}: ${err instanceof Error ? err.message : 'no command template available'}`);
-                continue;
-            }
-            if (!validateCommandBinary(cmd)) {
-                console.warn(`Skipping ${local.model}/${local.tool}: binary "${cmd.split(' ')[0]}" not found`);
-                continue;
-            }
-            validAgents.push({ local, command: cmd });
-        }
-        if (validAgents.length === 0 && config.anonymousAgents.length === 0) {
-            console.error('No valid agents in config. Check that tool binaries are installed.');
-            process.exit(1);
-        }
-        // Determine which agents to start
-        let agentsToStart;
-        const anonAgentsToStart = [];
-        if (opts.all) {
-            agentsToStart = validAgents;
-            // Also include anonymous agents when --all is used
-            anonAgentsToStart.push(...config.anonymousAgents);
-        }
-        else if (agentIdOrModel) {
-            const match = validAgents.find((a) => a.local.model === agentIdOrModel);
-            if (!match) {
-                console.error(`No agent with model "${agentIdOrModel}" found in local config.`);
-                console.error('Available agents:');
-                for (const a of validAgents) {
-                    console.error(`  ${a.local.model}  (${a.local.tool})`);
-                }
-                process.exit(1);
-            }
-            agentsToStart = [match];
-        }
-        else if (validAgents.length === 1) {
-            agentsToStart = [validAgents[0]];
-            console.log(`Using agent ${validAgents[0].local.model} (${validAgents[0].local.tool})`);
-        }
-        else if (validAgents.length === 0) {
-            console.error('No valid authenticated agents in config. Use --anonymous or --all.');
-            process.exit(1);
-        }
-        else {
-            console.error('Multiple agents in config. Specify a model name or use --all:');
-            for (const a of validAgents) {
-                console.error(`  ${a.local.model}  (${a.local.tool})`);
-            }
-            process.exit(1);
-        }
-        // Increase listener limit when starting multiple agents
-        const totalAgents = agentsToStart.length + anonAgentsToStart.length;
-        if (totalAgents > 1) {
-            process.setMaxListeners(process.getMaxListeners() + totalAgents * 2);
-        }
-        // Start each authenticated agent (requires login)
-        let startedCount = 0;
-        let apiKey;
-        let client;
-        let serverAgents;
-        if (agentsToStart.length > 0) {
-            apiKey = requireApiKey(config);
-            client = new ApiClient(config.platformUrl, apiKey);
-            try {
-                const res = await client.get('/api/agents');
-                serverAgents = res.agents;
-            }
-            catch (err) {
-                console.error('Failed to fetch agents:', err instanceof Error ? err.message : err);
-                process.exit(1);
-            }
-        }
-        for (const selected of agentsToStart) {
-            let agentId;
-            try {
-                const sync = await syncAgentToServer(client, serverAgents, selected.local);
-                agentId = sync.agentId;
-                if (sync.created) {
-                    console.log(`Registered new agent ${agentId} on platform`);
-                    // Update snapshot to prevent duplicate registrations
-                    serverAgents.push({
-                        id: agentId,
-                        model: selected.local.model,
-                        tool: selected.local.tool,
-                        isAnonymous: false,
-                        status: 'offline',
-                        repoConfig: null,
-                        createdAt: new Date().toISOString(),
-                    });
-                }
-            }
-            catch (err) {
-                console.error(`Failed to sync agent ${selected.local.model} to server:`, err instanceof Error ? err.message : err);
-                continue;
-            }
-            const reviewDeps = {
-                commandTemplate: selected.command,
-                maxDiffSizeKb: config.maxDiffSizeKb,
-            };
-            const consumptionDeps = {
-                agentId,
-                limits: resolveAgentLimits(selected.local.limits, config.limits),
-                session: createSessionTracker(),
-            };
-            console.log(`Starting agent ${selected.local.model} (${agentId})...`);
-            startAgent(agentId, config.platformUrl, apiKey, reviewDeps, consumptionDeps, {
-                verbose: opts.verbose,
-                stabilityThresholdMs,
-                repoConfig: selected.local.repos,
-            });
-            startedCount++;
-        }
-        // Start anonymous agents (for --all)
-        for (const anon of anonAgentsToStart) {
-            let command;
-            try {
-                command = resolveCommandTemplate(DEFAULT_REGISTRY.tools
-                    .find((t) => t.name === anon.tool)
-                    ?.commandTemplate.replaceAll('${MODEL}', anon.model) ?? null);
-            }
-            catch {
-                console.warn(`Skipping anonymous agent ${anon.agentId}: no command template for tool "${anon.tool}"`);
-                continue;
-            }
-            let reviewDeps;
-            if (validateCommandBinary(command)) {
-                reviewDeps = { commandTemplate: command, maxDiffSizeKb: config.maxDiffSizeKb };
-            }
-            else {
-                console.warn(`Warning: binary "${command.split(' ')[0]}" not found for anonymous agent ${anon.agentId}. Reviews will be rejected.`);
-            }
-            const consumptionDeps = {
-                agentId: anon.agentId,
-                limits: config.limits,
-                session: createSessionTracker(),
-            };
-            console.log(`Starting anonymous agent ${anon.model} (${anon.agentId})...`);
-            startAgent(anon.agentId, config.platformUrl, anon.apiKey, reviewDeps, consumptionDeps, {
-                verbose: opts.verbose,
-                stabilityThresholdMs,
-                repoConfig: anon.repoConfig,
-            });
-            startedCount++;
-        }
-        if (startedCount === 0) {
-            console.error('No agents could be started.');
-            process.exit(1);
-        }
-        return;
-    }
-    // === Path A: Old server-side behavior (no agents section) ===
-    const apiKey = requireApiKey(config);
-    const client = new ApiClient(config.platformUrl, apiKey);
-    console.log('Hint: No agents in local config. Run `opencara agent init` to import, or `opencara agent create` to add agents.');
-    let agentId = agentIdOrModel;
-    if (!agentId) {
-        let res;
-        try {
-            res = await client.get('/api/agents');
-        }
-        catch (err) {
-            console.error('Failed to list agents:', err instanceof Error ? err.message : err);
-            process.exit(1);
-        }
-        if (res.agents.length === 0) {
-            console.error('No agents registered. Run `opencara agent create` first.');
-            process.exit(1);
-        }
-        if (res.agents.length === 1) {
-            agentId = res.agents[0].id;
-            console.log(`Using agent ${agentId}`);
-        }
-        else {
-            console.error('Multiple agents found. Please specify an agent ID:');
-            for (const a of res.agents) {
-                console.error(`  ${a.id}  ${a.model} / ${a.tool}`);
-            }
-            process.exit(1);
-        }
-    }
-    let reviewDeps;
-    try {
-        const commandTemplate = resolveCommandTemplate(config.agentCommand);
-        reviewDeps = {
-            commandTemplate,
-            maxDiffSizeKb: config.maxDiffSizeKb,
-        };
-    }
-    catch (err) {
-        console.warn(`Warning: ${err instanceof Error ? err.message : 'Could not determine agent command.'}` +
-            ' Reviews will be rejected.');
-    }
-    const consumptionDeps = {
-        agentId,
-        limits: config.limits,
-        session: createSessionTracker(),
-    };
-    console.log(`Starting agent ${agentId}...`);
-    startAgent(agentId, config.platformUrl, apiKey, reviewDeps, consumptionDeps, {
-        verbose: opts.verbose,
-        stabilityThresholdMs,
-    });
-});
-//# sourceMappingURL=agent.js.map