specrails-desktop 2.44.2 → 2.46.0

package/server/dist/agent-runtime-bridge.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_HOST_ENV_KEYS = void 0;
+exports.runtimeChangeName = runtimeChangeName;
+exports.runAgentRuntimeInvocation = runAgentRuntimeInvocation;
+const agent_runtime_repositories_1 = require("./agent-runtime-repositories");
+const node_util_1 = require("node:util");
+const providers_1 = require("./providers");
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_readline_1 = require("node:readline");
+const agent_runtime_loader_1 = require("./agent-runtime-loader");
+const agent_runtime_settings_1 = require("./agent-runtime-settings");
+const core_node_runtime_1 = require("./core-node-runtime");
+const win_spawn_1 = require("./util/win-spawn");
+function runtimeChangeName(runId) {
+    return 'runtime-' + (0, node_crypto_1.createHash)('sha256').update(runId).digest('hex').slice(0, 20);
+}
+exports.RUNTIME_HOST_ENV_KEYS = [
+    'SPECRAILS_REPO_DIR', 'SPECRAILS_GIT_AUTO', 'SPECRAILS_REPO_MAP_PATH',
+    'SPECRAILS_EXECUTION_CONTEXT', 'SPECRAILS_EXECUTION_MANIFEST', 'SPECRAILS_REPOSITORIES',
+    'SPECRAILS_WORKSPACE_DIR', 'SPECRAILS_TICKETS_PATH', 'SPECRAILS_STATE_DIR',
+    'SPECRAILS_BACKLOG_CONFIG_PATH', 'SPECRAILS_PROFILES_DIR',
+    'SPECRAILS_PROFILE_PATH',
+];
+function saveHostContext(options) {
+    const file = (0, node_path_1.join)((0, node_path_1.dirname)(options.contextPath), 'desktop-runtime-host.json');
+    const serialized = JSON.stringify({ schemaVersion: 1, cwd: (0, node_fs_1.realpathSync)(options.cwd), env: Object.fromEntries(exports.RUNTIME_HOST_ENV_KEYS.filter(key => options.env[key] !== undefined).map(key => [key, options.env[key]])) }, null, 2) + '\n';
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(file), { recursive: true, mode: 0o700 });
+    try {
+        (0, node_fs_1.writeFileSync)(file, serialized, { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        if ((0, node_fs_1.readFileSync)(file, 'utf8') !== serialized)
+            throw new Error('Desktop runtime scope changed; resume using its frozen host context');
+    }
+}
+/** Core owns the complete agent workflow in one managed process. The existing
+ * rail's cancellation and worktree ownership remain in Desktop. */
+async function runAgentRuntimeInvocation(options) {
+    const cli = (0, agent_runtime_loader_1.findCoreAgentRuntimeCli)();
+    if (!cli)
+        throw new Error('Programmatic agent runtime is enabled but its Core CLI is unavailable. Build or bundle the compatible Core runtime.');
+    if (!options.resume && (!options.configPath || !options.change))
+        throw new Error('New programmatic runs require configuration and a change name');
+    const admittedContext = JSON.parse((0, node_fs_1.readFileSync)(options.contextPath, 'utf8'));
+    if (typeof admittedContext.runId !== 'string')
+        throw new Error('Core context is missing its run identity');
+    if (!options.resume)
+        saveHostContext(options);
+    const args = [cli, options.resume ? 'resume' : 'run', '--context', options.contextPath];
+    if (!options.resume) {
+        if (!Array.isArray(admittedContext.repositories) || !admittedContext.repositories.length || admittedContext.repositories.some(repo => !repo || typeof repo.id !== 'string' || !repo.id))
+            throw new Error('Core context is missing its repository scope');
+        const config = (0, agent_runtime_settings_1.loadRuntimeConfigFile)(options.configPath, options.defaultProvider);
+        config.rolePrompts = { ...(await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).rolePromptDefaults(), ...(0, agent_runtime_settings_1.loadRuntimeRolePrompts)() };
+        if (options.defaultProvider) {
+            const provider = config.providers.find(entry => entry.id === options.defaultProvider);
+            if (!provider)
+                throw new Error(`Selected runtime provider is not configured: ${options.defaultProvider}`);
+            for (const role of Object.values(config.agents)) {
+                if (role.provider !== provider.id) {
+                    role.provider = provider.id;
+                    role.model = options.selectedModel ?? (provider.kind === 'cli' ? (0, providers_1.getAdapter)(provider.cli).defaultModel() : undefined);
+                    if (!role.model)
+                        throw new Error(`Selected runtime provider requires a model: ${provider.id}`);
+                }
+                if (!role.model && provider.kind === 'cli')
+                    role.model = (0, providers_1.getAdapter)(provider.cli).defaultModel();
+            }
+            if (options.selectedModel)
+                config.agents.developer.model = options.selectedModel;
+        }
+        const selected = new Set(admittedContext.repositories.map(repo => repo.id));
+        // Project settings cover every repository; a ticket may select only a subset.
+        // Freeze that subset for admission without changing the project settings.
+        config.verification = config.verification.filter(command => selected.has(command.repositoryId));
+        const scopedPath = (0, node_path_1.join)((0, node_path_1.dirname)(options.contextPath), 'desktop-runtime-config.json');
+        const serialized = JSON.stringify(config, null, 2) + '\n';
+        try {
+            (0, node_fs_1.writeFileSync)(scopedPath, serialized, { flag: 'wx', mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            if ((0, node_fs_1.readFileSync)(scopedPath, 'utf8') !== serialized)
+                throw new Error('Desktop runtime configuration changed; start a new run');
+        }
+        args.push('--config', scopedPath, '--change', options.change);
+    }
+    const frozenPath = (0, node_path_1.join)((0, node_path_1.dirname)(options.contextPath), 'desktop-runtime-config.json');
+    if ((0, node_fs_1.existsSync)(frozenPath)) {
+        const frozen = JSON.parse((0, node_fs_1.readFileSync)(frozenPath, 'utf8'));
+        for (const [role, assignment] of Object.entries(frozen.agents)) {
+            try {
+                options.onLine?.(`[runtime] ${role}: ${assignment.provider}/${assignment.model ?? 'provider default'}\n`);
+            }
+            catch { /* Log observers cannot prevent execution. */ }
+        }
+    }
+    for (const [flag, values] of [['approve', options.approve], ['recover', options.recover], ['invalidate', options.invalidate]]) {
+        if (values?.length)
+            args.push('--' + flag, values.join(','));
+    }
+    if (options.answer !== undefined) {
+        if (!options.resume)
+            throw new Error('Answers apply to runtime resume');
+        args.push('--answer', options.answer);
+    }
+    const started = Date.now();
+    return new Promise((resolve) => {
+        let result;
+        let stderr = '', summary = '', invalidProtocol = false, timedOut = false;
+        let timer;
+        const child = (0, node_child_process_1.spawn)((0, core_node_runtime_1.resolveCoreNodeRuntime)(), args, {
+            cwd: options.cwd, env: (0, win_spawn_1.windowsSpawnEnv)(options.env), shell: false, windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Always leave a terminal result, including synchronous observer failures.
+        let observerError;
+        try {
+            options.onSpawn?.(child);
+        }
+        catch (error) {
+            observerError = error instanceof Error ? error.message : String(error);
+            if (child.pid)
+                (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL');
+        }
+        const observe = (callback) => { try {
+            callback?.();
+        }
+        catch { /* Logging cannot replay a workflow. */ } };
+        const lines = (0, node_readline_1.createInterface)({ input: child.stdout });
+        lines.on('line', line => {
+            if (line.length > 2_000_000) {
+                invalidProtocol = true;
+                if (child.pid)
+                    (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL');
+                return;
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                invalidProtocol = true;
+                return;
+            }
+            if (!event || typeof event !== 'object') {
+                invalidProtocol = true;
+                return;
+            }
+            if (event.type === 'agent-event' && event.event && typeof event.event === 'object' && event.event.kind === 'tool-start' && (admittedContext.repositories?.length ?? 0) > 1) {
+                const repositories = (0, agent_runtime_repositories_1.toolRepositories)(event.event, admittedContext.repositories, admittedContext.artifactRoot ?? options.cwd);
+                if (repositories.length)
+                    event.repositories = repositories.map(repo => ({ id: repo.id, name: repo.name || repo.id }));
+            }
+            observe(() => options.onRawLine?.(event.repositories ? JSON.stringify(event) : line));
+            if (event.type === 'runtime-result') {
+                if (result)
+                    invalidProtocol = true;
+                result = event;
+            }
+            else if (event.type === 'workflow-event') {
+                const payload = event.event;
+                if (payload?.type)
+                    observe(() => options.onLine?.(`[runtime] ${payload.type}${payload.stepId ? ': ' + payload.stepId : ''}${payload.message ? ' — ' + payload.message : ''}\n`));
+            }
+            else if (event.type === 'agent-event') {
+                const payload = event.event;
+                const role = typeof event.role === 'string' ? event.role : 'agent';
+                if (payload?.kind === 'text' && typeof payload.text === 'string') {
+                    summary = (summary + payload.text).slice(-32_000);
+                    observe(() => options.onLine?.(payload.text + '\n'));
+                }
+                else if (payload?.kind === 'tool-start' && typeof payload.tool === 'string') {
+                    // Live tool activity keeps a long developer turn from looking hung.
+                    const repositories = event.repositories;
+                    const scope = repositories?.length ? ` [${repositories.map(repo => repo.name).join(' + ')}]` : '';
+                    observe(() => options.onLine?.(`[${role}]${scope} ${payload.tool}${payload.detail ? ' ' + payload.detail : ''}\n`));
+                }
+            }
+            else if (event.type === 'verification-output' && typeof event.text === 'string') {
+                observe(() => options.onLine?.((0, node_util_1.stripVTControlCharacters)(String(event.text))));
+            }
+            else if (event.type === 'span') {
+                // Trace spans are telemetry; the raw line is already recorded for diagnostics.
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr = (stderr + chunk.toString('utf8')).slice(-32_000);
+            observe(() => options.onLine?.(chunk.toString('utf8'), 'stderr'));
+        });
+        child.on('error', error => { stderr = error.message; });
+        if (options.timeoutMs && options.timeoutMs > 0) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                if (child.pid)
+                    (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL');
+            }, options.timeoutMs);
+            timer.unref?.();
+        }
+        child.on('close', code => {
+            if (timer)
+                clearTimeout(timer);
+            lines.close();
+            const usage = result?.invocationUsage;
+            const known = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+            const cost = known(usage?.costUsd), tokensIn = known(usage?.inputTokens), tokensOut = known(usage?.outputTokens);
+            if (result?.status === 'succeeded' && result.runId !== admittedContext.runId)
+                invalidProtocol = true;
+            const failed = code !== 0 || result?.status !== 'succeeded' || invalidProtocol || timedOut || Boolean(observerError);
+            const errorText = observerError ?? (timedOut ? 'Programmatic workflow timed out; inspect its checkpoint before recovery'
+                : invalidProtocol ? 'Core returned an invalid runtime event stream'
+                    : result?.error ?? (result?.status === 'paused' ? (typeof result.pendingQuestion?.question === 'string' && result.pendingQuestion.question.trim()
+                        ? `Workflow awaits an answer in Agent Runtime settings: ${result.pendingQuestion.question.trim().slice(0, 500)}`
+                        : 'Workflow awaits approval in Agent Runtime settings')
+                        : failed ? stderr || 'Core exited without a successful programmatic workflow result' : undefined));
+            resolve({
+                text: summary || (failed ? errorText ?? '' : 'Programmatic implementation verified and archived.'),
+                provider: 'agent-runtime', model: 'per-role', failed, errorText,
+                cost, tokensIn, tokensOut, tokens: tokensIn === undefined || tokensOut === undefined ? undefined : tokensIn + tokensOut,
+                estimated: cost === undefined, durationMs: Date.now() - started,
+            });
+        });
+    });
+}

package/server/dist/agent-runtime-controls-router.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeContinuationActive = isRuntimeContinuationActive;
+exports.activeRuntimeContinuationIds = activeRuntimeContinuationIds;
+exports.cancelRuntimeContinuation = cancelRuntimeContinuation;
+exports.shutdownAgentRuntimeControls = shutdownAgentRuntimeControls;
+exports.registerAgentRuntimeControlRoutes = registerAgentRuntimeControlRoutes;
+const agent_runtime_paths_1 = require("./agent-runtime-paths");
+const agent_runtime_controls_1 = require("./agent-runtime-controls");
+const controllers = new WeakMap();
+function isRuntimeContinuationActive(context, runId) { return controllers.get(context)?.isActive(runId) ?? false; }
+function activeRuntimeContinuationIds(context) { return controllers.get(context)?.activeRunIds() ?? []; }
+function cancelRuntimeContinuation(context, runId) {
+    const controller = controllers.get(context);
+    if (!controller?.isActive(runId))
+        return false;
+    controller.cancel(runId);
+    return true;
+}
+function shutdownAgentRuntimeControls(context) { controllers.get(context)?.shutdown(); }
+function registerAgentRuntimeControlRoutes({ router, ctx }) {
+    function controls(request) {
+        const context = ctx(request);
+        let controller = controllers.get(context);
+        if (!controller) {
+            controller = new agent_runtime_controls_1.AgentRuntimeControls(context);
+            controllers.set(context, controller);
+        }
+        return controller;
+    }
+    router.get('/:projectId/agent-runtime/runs', async (req, res) => {
+        try {
+            if (req.query.railIndex !== undefined) {
+                const railIndex = Number(req.query.railIndex);
+                if (!Number.isSafeInteger(railIndex) || railIndex < 0) {
+                    res.status(400).json({ error: 'invalid_rail_index' });
+                    return;
+                }
+                const context = ctx(req);
+                const latest = context.db.prepare('SELECT id FROM loop_runs WHERE rail_index = ? ORDER BY started_at DESC, rowid DESC LIMIT 1').get(railIndex);
+                res.json({ runs: latest && (0, agent_runtime_paths_1.hasAgentRuntimeRequest)(context.project, latest.id) ? [await controls(req).summary(latest.id)] : [] });
+                return;
+            }
+            res.json({ runs: await controls(req).list() });
+        }
+        catch {
+            res.status(500).json({ error: 'runtime_status_failed', message: 'Could not read runtime executions' });
+        }
+    });
+    router.get('/:projectId/agent-runtime/runs/:runId', async (req, res) => {
+        try {
+            const context = ctx(req), runId = String(req.params.runId);
+            res.json({ runs: (0, agent_runtime_paths_1.hasAgentRuntimeRequest)(context.project, runId) ? [await controls(req).summary(runId)] : [] });
+        }
+        catch {
+            res.status(500).json({ error: 'runtime_status_failed' });
+        }
+    });
+    router.post('/:projectId/agent-runtime/runs/:runId/resume', async (req, res) => {
+        try {
+            await controls(req).resume(String(req.params.runId), (0, agent_runtime_controls_1.validateRuntimeResumeInput)(req.body));
+            res.status(202).json({ accepted: true });
+        }
+        catch (error) {
+            res.status(error instanceof agent_runtime_controls_1.RuntimeControlError ? error.statusCode : 500).json({ error: error instanceof agent_runtime_controls_1.RuntimeControlError ? error.code : 'runtime_resume_failed', message: error instanceof agent_runtime_controls_1.RuntimeControlError ? error.message : 'Could not resume runtime execution' });
+        }
+    });
+    router.post('/:projectId/agent-runtime/runs/:runId/settle', async (req, res) => {
+        try {
+            await controls(req).settle(String(req.params.runId));
+            res.json({ settled: true });
+        }
+        catch (error) {
+            res.status(error instanceof agent_runtime_controls_1.RuntimeControlError ? error.statusCode : 500).json({ message: error instanceof agent_runtime_controls_1.RuntimeControlError ? error.message : 'Could not prepare delivery' });
+        }
+    });
+    router.post('/:projectId/agent-runtime/runs/:runId/cancel', (req, res) => {
+        try {
+            controls(req).cancel(String(req.params.runId));
+            res.status(202).json({ accepted: true });
+        }
+        catch (error) {
+            res.status(error instanceof agent_runtime_controls_1.RuntimeControlError ? error.statusCode : 500).json({ error: error instanceof agent_runtime_controls_1.RuntimeControlError ? error.code : 'runtime_cancel_failed', message: error instanceof agent_runtime_controls_1.RuntimeControlError ? error.message : 'Could not cancel runtime execution' });
+        }
+    });
+}