specrails-desktop 2.16.0 → 2.18.0

package/server/dist/mcp/tools/jobs.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobsTools = jobsTools;
+const zod_1 = require("zod");
+const types_1 = require("./types");
+/**
+ * Jobs domain facade. Maps every in-scope jobs/queue action to its REST
+ * endpoint on the loopback API (server/project-router-jobs.ts, plus the
+ * diagnostic export in server/project-router-settings.ts).
+ *
+ * Rail-specific operations (launch/stop/set_* on /rails) live in a separate
+ * rails tool; this facade covers the project-level job queue and individual
+ * job lifecycle. Note: `spawn` here is the rail-bypass `/spawn` endpoint that
+ * enqueues an arbitrary slash-command job (incurs token cost, async 202).
+ */
+function jobsTools() {
+    return [
+        {
+            name: 'specrails_jobs',
+            title: 'Jobs & Queue',
+            description: 'Manage a project\'s AI-pipeline job queue and individual jobs. ' +
+                'Actions: list, get, queue, spawn (ai-spawn — enqueues an arbitrary slash-command job, returns {jobId,position}, async), ' +
+                'cancel (destructive — cancels a running/queued job or deletes a terminal one), ' +
+                'purge (destructive — bulk-delete persisted job rows in a date range), ' +
+                'pause / resume (queue), reorder (queued-job order), priority (change a queued job\'s priority), ' +
+                'compare (two jobs side-by-side), export (up to 10k rows as JSON/CSV), ' +
+                'diagnostic (binary ZIP — returns a note, not the bytes), run_state (project run state), ' +
+                'activity (recent activity feed), stats, metrics, default_spec_model, ' +
+                'interactive_turn (ai-spawn — send one more prompt to a running interactive ultracode job), ' +
+                'finalize (finalize a running interactive job).',
+            hintTier: 'read',
+            tier: (a) => {
+                const action = a.action;
+                if (['cancel', 'purge'].includes(action))
+                    return 'destructive';
+                if (['spawn', 'interactive_turn'].includes(action))
+                    return 'ai-spawn';
+                if (['pause', 'resume', 'reorder', 'priority', 'finalize'].includes(action))
+                    return 'write';
+                return 'read';
+            },
+            inputSchema: {
+                action: zod_1.z
+                    .enum([
+                    'list',
+                    'get',
+                    'queue',
+                    'spawn',
+                    'cancel',
+                    'purge',
+                    'pause',
+                    'resume',
+                    'reorder',
+                    'priority',
+                    'compare',
+                    'export',
+                    'diagnostic',
+                    'run_state',
+                    'activity',
+                    'stats',
+                    'metrics',
+                    'default_spec_model',
+                    'interactive_turn',
+                    'finalize',
+                ])
+                    .describe('Operation to perform'),
+                projectId: zod_1.z.string().optional().describe('Project id (defaults to the active project)'),
+                // ── job identity ──
+                jobId: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('Job id (for get / cancel / priority / diagnostic / interactive_turn / finalize)'),
+                // ── list / export pagination + filters ──
+                limit: zod_1.z.number().optional().describe('Page size for list (1-200, default 50) / activity (1-100, default 50)'),
+                offset: zod_1.z.number().optional().describe('Page offset for list'),
+                status: zod_1.z.string().optional().describe('Filter by job status (list)'),
+                from: zod_1.z.string().optional().describe('ISO date lower bound (list / export / purge)'),
+                to: zod_1.z.string().optional().describe('ISO date upper bound (list / export / purge)'),
+                before: zod_1.z.string().optional().describe('Activity cursor: return rows before this timestamp'),
+                // ── spawn (rail-bypass enqueue) ──
+                command: zod_1.z.string().optional().describe('Slash-command to enqueue (spawn), e.g. "/specrails:implement #5 --yes"'),
+                priority: zod_1.z
+                    .enum(['low', 'normal', 'high', 'critical'])
+                    .optional()
+                    .describe('Priority for spawn / priority action'),
+                dependsOnJobId: zod_1.z.string().optional().describe('Make the spawned job depend on this job id'),
+                pipelineId: zod_1.z.string().optional().describe('Group the spawned job into this pipeline'),
+                profileName: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('Agent profile for spawn (omit = default resolution; pass empty/null upstream forces legacy)'),
+                aiEngine: zod_1.z.string().optional().describe('Per-job provider override for spawn (must be installed on the project)'),
+                // ── reorder ──
+                jobIds: zod_1.z
+                    .array(zod_1.z.string())
+                    .optional()
+                    .describe('reorder: exact set of currently-queued job ids in the desired order; compare: exactly 2 job ids'),
+                // ── interactive_turn ──
+                text: zod_1.z.string().optional().describe('Prompt text for interactive_turn'),
+                // ── export ──
+                format: zod_1.z.enum(['json', 'csv']).optional().describe('Export format (default json)'),
+                // ── default_spec_model ──
+                provider: zod_1.z.string().optional().describe('Provider to resolve the default spec model for (default_spec_model)'),
+            },
+            async handler(ctx, args) {
+                const base = (0, types_1.projectPath)(ctx, args.projectId);
+                const action = args.action;
+                switch (action) {
+                    case 'list': {
+                        const qs = new URLSearchParams();
+                        if (args.limit !== undefined)
+                            qs.set('limit', String(args.limit));
+                        if (args.offset !== undefined)
+                            qs.set('offset', String(args.offset));
+                        if (args.status)
+                            qs.set('status', args.status);
+                        if (args.from)
+                            qs.set('from', args.from);
+                        if (args.to)
+                            qs.set('to', args.to);
+                        const q = qs.toString();
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/jobs${q ? `?${q}` : ''}`);
+                    }
+                    case 'get': {
+                        const id = args.jobId;
+                        if (!id)
+                            throw new Error('get requires a "jobId".');
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/jobs/${encodeURIComponent(id)}`);
+                    }
+                    case 'queue':
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/queue`);
+                    case 'spawn': {
+                        const command = args.command;
+                        if (!command || !command.trim())
+                            throw new Error('spawn requires a "command".');
+                        const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/spawn`, {
+                            command,
+                            priority: args.priority,
+                            dependsOnJobId: args.dependsOnJobId,
+                            pipelineId: args.pipelineId,
+                            profileName: args.profileName,
+                            aiEngine: args.aiEngine,
+                        });
+                        return {
+                            ...r,
+                            hint: 'Spawned an AI CLI job (incurs token cost). Use specrails_watch with the returned jobId to await completion.',
+                        };
+                    }
+                    case 'cancel': {
+                        const id = args.jobId;
+                        if (!id)
+                            throw new Error('cancel requires a "jobId".');
+                        return (0, types_1.apiCall)(ctx, 'DELETE', `${base}/jobs/${encodeURIComponent(id)}`);
+                    }
+                    case 'purge':
+                        return (0, types_1.apiCall)(ctx, 'DELETE', `${base}/jobs`, {
+                            from: args.from,
+                            to: args.to,
+                        });
+                    case 'pause':
+                        return (0, types_1.apiCall)(ctx, 'POST', `${base}/queue/pause`);
+                    case 'resume':
+                        return (0, types_1.apiCall)(ctx, 'POST', `${base}/queue/resume`);
+                    case 'reorder': {
+                        const jobIds = args.jobIds;
+                        if (!Array.isArray(jobIds))
+                            throw new Error('reorder requires "jobIds" (array of queued job ids).');
+                        return (0, types_1.apiCall)(ctx, 'PUT', `${base}/queue/reorder`, { jobIds });
+                    }
+                    case 'priority': {
+                        const id = args.jobId;
+                        if (!id)
+                            throw new Error('priority requires a "jobId".');
+                        const priority = args.priority;
+                        if (!priority)
+                            throw new Error('priority requires a "priority" (low|normal|high|critical).');
+                        return (0, types_1.apiCall)(ctx, 'PATCH', `${base}/jobs/${encodeURIComponent(id)}/priority`, { priority });
+                    }
+                    case 'compare': {
+                        const jobIds = args.jobIds;
+                        if (!Array.isArray(jobIds) || jobIds.length !== 2) {
+                            throw new Error('compare requires exactly 2 ids in "jobIds".');
+                        }
+                        const qs = new URLSearchParams({ jobIds: jobIds.join(',') });
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/jobs/compare?${qs.toString()}`);
+                    }
+                    case 'export': {
+                        const qs = new URLSearchParams();
+                        qs.set('format', args.format ?? 'json');
+                        if (args.from)
+                            qs.set('from', args.from);
+                        if (args.to)
+                            qs.set('to', args.to);
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/jobs/export?${qs.toString()}`);
+                    }
+                    case 'diagnostic': {
+                        const id = args.jobId;
+                        if (!id)
+                            throw new Error('diagnostic requires a "jobId".');
+                        // The diagnostic endpoint streams an application/zip (job-metadata.json,
+                        // telemetry.ndjson, logs.txt, summary.md, profile + plugin snapshot).
+                        // We do NOT inline binary bytes through the MCP text channel — return a
+                        // pointer the caller can fetch over the loopback REST API directly.
+                        return {
+                            note: 'Binary export (application/zip) — not inlined.',
+                            jobId: id,
+                            path: `${base}/jobs/${encodeURIComponent(id)}/diagnostic`,
+                            hint: 'Requires a telemetry blob to exist for the job (else 404). Fetch the ZIP via the REST endpoint at the given path.',
+                        };
+                    }
+                    case 'run_state':
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/state`);
+                    case 'activity': {
+                        const qs = new URLSearchParams();
+                        if (args.limit !== undefined)
+                            qs.set('limit', String(args.limit));
+                        if (args.before)
+                            qs.set('before', args.before);
+                        const q = qs.toString();
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/activity${q ? `?${q}` : ''}`);
+                    }
+                    case 'stats':
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/stats`);
+                    case 'metrics':
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/metrics`);
+                    case 'default_spec_model': {
+                        const qs = new URLSearchParams();
+                        if (args.provider)
+                            qs.set('provider', args.provider);
+                        const q = qs.toString();
+                        return (0, types_1.apiCall)(ctx, 'GET', `${base}/default-spec-model${q ? `?${q}` : ''}`);
+                    }
+                    case 'interactive_turn': {
+                        const id = args.jobId;
+                        if (!id)
+                            throw new Error('interactive_turn requires a "jobId".');
+                        const text = args.text;
+                        if (!text || !text.trim())
+                            throw new Error('interactive_turn requires "text".');
+                        const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/jobs/${encodeURIComponent(id)}/messages`, { text });
+                        return {
+                            ...r,
+                            hint: 'Queued an additional interactive turn (incurs token cost). Use specrails_watch with the jobId to follow the job.',
+                        };
+                    }
+                    case 'finalize': {
+                        const id = args.jobId;
+                        if (!id)
+                            throw new Error('finalize requires a "jobId".');
+                        return (0, types_1.apiCall)(ctx, 'POST', `${base}/jobs/${encodeURIComponent(id)}/finalize`);
+                    }
+                    default:
+                        throw new Error(`Unknown action "${action}".`);
+                }
+            },
+        },
+    ];
+}

package/server/dist/mcp/tools/loops.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopsTools = loopsTools;
+const zod_1 = require("zod");
+const types_1 = require("./types");
+/**
+ * Loops — the GLOBAL (cross-project) visual loop-builder library. Routes live at
+ * `/api/loops*` and `/api/loop-templates` (NOT under `/projects` — no projectId).
+ * Gated server-side by SPECRAILS_LOOPS_SECTION (every route 404s when off).
+ *
+ * A single domain-facade tool with an `action` enum and a dynamic tier:
+ *   - read:        list, get, templates, factory, commands, constants_list, preview
+ *   - write:       constant_create, constant_update, import, create, from_template,
+ *                  fork, update, publish, unpublish, duplicate
+ *   - destructive: constant_delete, delete
+ */
+function loopsTools() {
+    return [
+        {
+            name: 'specrails_loops',
+            title: 'Loops',
+            description: 'Manage the global (cross-project) loop library and its templates/factory/constants. ' +
+                'Loops are visual builder graphs reused across projects; this is an APP-LEVEL domain (no projectId). ' +
+                'Actions: ' +
+                'list (all saved loops), ' +
+                'get (one loop by id), ' +
+                'templates (built-in template catalog with graphs), ' +
+                'factory (built-in locked factory loops), ' +
+                'commands (magic-command catalog for the builder palette), ' +
+                'constants_list (global cross-loop constants), ' +
+                'constant_create (write), constant_update (write), constant_delete (destructive), ' +
+                'preview (dry-run resolve tokens of a graph — no spawn), ' +
+                'import (import loops from an export envelope), ' +
+                'create (new Draft loop), ' +
+                'from_template (instantiate from a template), ' +
+                'fork (fork a factory loop into an editable Draft), ' +
+                'update (name/description/graph — reverts to Draft, 409 while running), ' +
+                'publish (graph-validated), unpublish (409 while running), ' +
+                'duplicate (copy a loop), ' +
+                'delete (destructive — 409 while running).',
+            hintTier: 'read',
+            tier: (a) => {
+                const action = a.action;
+                if (action === 'delete' || action === 'constant_delete')
+                    return 'destructive';
+                if ([
+                    'constant_create',
+                    'constant_update',
+                    'import',
+                    'create',
+                    'from_template',
+                    'fork',
+                    'update',
+                    'publish',
+                    'unpublish',
+                    'duplicate',
+                ].includes(action)) {
+                    return 'write';
+                }
+                return 'read';
+            },
+            inputSchema: {
+                action: zod_1.z
+                    .enum([
+                    'list',
+                    'get',
+                    'templates',
+                    'factory',
+                    'commands',
+                    'constants_list',
+                    'constant_create',
+                    'constant_update',
+                    'constant_delete',
+                    'preview',
+                    'import',
+                    'create',
+                    'from_template',
+                    'fork',
+                    'update',
+                    'publish',
+                    'unpublish',
+                    'duplicate',
+                    'delete',
+                ])
+                    .describe('Operation to perform'),
+                loopId: zod_1.z.string().optional().describe('Loop id (for get / update / publish / unpublish / duplicate / delete)'),
+                constantId: zod_1.z.string().optional().describe('Constant id (for constant_update / constant_delete)'),
+                templateId: zod_1.z.string().optional().describe('Template id (for from_template)'),
+                factoryId: zod_1.z.string().optional().describe('Factory loop id (for fork)'),
+                name: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('Loop or constant name (required for create / constant_create; optional override for from_template / fork / duplicate / update)'),
+                description: zod_1.z.string().optional().describe('Loop description (for create / update)'),
+                graph: zod_1.z
+                    .record(zod_1.z.unknown())
+                    .optional()
+                    .describe('Loop graph object { nodes, edges, ... } (for create / update; required for preview)'),
+                value: zod_1.z.string().optional().describe('Constant value (for constant_create / constant_update)'),
+                provider: zod_1.z.string().optional().describe('Provider for token resolution in preview (default "claude")'),
+                loops: zod_1.z.array(zod_1.z.unknown()).optional().describe('Array of loop export envelopes (for import)'),
+            },
+            async handler(ctx, args) {
+                const action = args.action;
+                const loopId = args.loopId;
+                const constantId = args.constantId;
+                switch (action) {
+                    // ── Reads ──────────────────────────────────────────────────────────
+                    case 'list':
+                        return (0, types_1.apiCall)(ctx, 'GET', '/loops');
+                    case 'get': {
+                        if (!loopId)
+                            throw new Error('get requires a "loopId".');
+                        return (0, types_1.apiCall)(ctx, 'GET', `/loops/${encodeURIComponent(loopId)}`);
+                    }
+                    case 'templates':
+                        return (0, types_1.apiCall)(ctx, 'GET', '/loop-templates');
+                    case 'factory':
+                        return (0, types_1.apiCall)(ctx, 'GET', '/loops/factory');
+                    case 'commands':
+                        return (0, types_1.apiCall)(ctx, 'GET', '/loops/commands');
+                    case 'constants_list':
+                        return (0, types_1.apiCall)(ctx, 'GET', '/loops/constants');
+                    case 'preview': {
+                        const graph = args.graph;
+                        if (!graph)
+                            throw new Error('preview requires a "graph".');
+                        return (0, types_1.apiCall)(ctx, 'POST', '/loops/preview', {
+                            graph,
+                            ...(args.provider !== undefined ? { provider: args.provider } : {}),
+                        });
+                    }
+                    // ── Constants (write / destructive) ─────────────────────────────────
+                    case 'constant_create': {
+                        const name = args.name;
+                        if (!name)
+                            throw new Error('constant_create requires a "name".');
+                        return (0, types_1.apiCall)(ctx, 'POST', '/loops/constants', {
+                            name,
+                            value: args.value ?? '',
+                        });
+                    }
+                    case 'constant_update': {
+                        if (!constantId)
+                            throw new Error('constant_update requires a "constantId".');
+                        return (0, types_1.apiCall)(ctx, 'PUT', `/loops/constants/${encodeURIComponent(constantId)}`, {
+                            value: args.value ?? '',
+                        });
+                    }
+                    case 'constant_delete': {
+                        if (!constantId)
+                            throw new Error('constant_delete requires a "constantId".');
+                        return (0, types_1.apiCall)(ctx, 'DELETE', `/loops/constants/${encodeURIComponent(constantId)}`);
+                    }
+                    // ── Loops (write) ───────────────────────────────────────────────────
+                    case 'import': {
+                        const loops = args.loops;
+                        if (!Array.isArray(loops))
+                            throw new Error('import requires a "loops" array.');
+                        return (0, types_1.apiCall)(ctx, 'POST', '/loops/import', { loops });
+                    }
+                    case 'create': {
+                        const name = args.name;
+                        if (!name)
+                            throw new Error('create requires a "name".');
+                        return (0, types_1.apiCall)(ctx, 'POST', '/loops', {
+                            name,
+                            ...(args.description !== undefined ? { description: args.description } : {}),
+                            ...(args.graph !== undefined ? { graph: args.graph } : {}),
+                        });
+                    }
+                    case 'from_template': {
+                        const templateId = args.templateId;
+                        if (!templateId)
+                            throw new Error('from_template requires a "templateId".');
+                        return (0, types_1.apiCall)(ctx, 'POST', `/loops/from-template/${encodeURIComponent(templateId)}`, {
+                            ...(args.name !== undefined ? { name: args.name } : {}),
+                        });
+                    }
+                    case 'fork': {
+                        const factoryId = args.factoryId;
+                        if (!factoryId)
+                            throw new Error('fork requires a "factoryId".');
+                        return (0, types_1.apiCall)(ctx, 'POST', `/loops/factory/${encodeURIComponent(factoryId)}/fork`, {
+                            ...(args.name !== undefined ? { name: args.name } : {}),
+                        });
+                    }
+                    case 'update': {
+                        if (!loopId)
+                            throw new Error('update requires a "loopId".');
+                        const body = {};
+                        if (args.name !== undefined)
+                            body.name = args.name;
+                        if (args.description !== undefined)
+                            body.description = args.description;
+                        if (args.graph !== undefined)
+                            body.graph = args.graph;
+                        return (0, types_1.apiCall)(ctx, 'PUT', `/loops/${encodeURIComponent(loopId)}`, body);
+                    }
+                    case 'publish': {
+                        if (!loopId)
+                            throw new Error('publish requires a "loopId".');
+                        return (0, types_1.apiCall)(ctx, 'POST', `/loops/${encodeURIComponent(loopId)}/publish`);
+                    }
+                    case 'unpublish': {
+                        if (!loopId)
+                            throw new Error('unpublish requires a "loopId".');
+                        return (0, types_1.apiCall)(ctx, 'POST', `/loops/${encodeURIComponent(loopId)}/unpublish`);
+                    }
+                    case 'duplicate': {
+                        if (!loopId)
+                            throw new Error('duplicate requires a "loopId".');
+                        return (0, types_1.apiCall)(ctx, 'POST', `/loops/${encodeURIComponent(loopId)}/duplicate`, {
+                            ...(args.name !== undefined ? { name: args.name } : {}),
+                        });
+                    }
+                    // ── Destructive ─────────────────────────────────────────────────────
+                    case 'delete': {
+                        if (!loopId)
+                            throw new Error('delete requires a "loopId".');
+                        return (0, types_1.apiCall)(ctx, 'DELETE', `/loops/${encodeURIComponent(loopId)}`);
+                    }
+                    default:
+                        throw new Error(`Unknown action "${action}".`);
+                }
+            },
+        },
+    ];
+}

package/server/dist/mcp/tools/meta.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metaTools = metaTools;
+const zod_1 = require("zod");
+const guide_1 = require("../guide");
+const types_1 = require("./types");
+/**
+ * Meta tools that teach the platform and aid discovery.
+ * `getSpecs` returns the full catalog (passed lazily to avoid a cycle).
+ */
+function metaTools(getSpecs) {
+    return [
+        {
+            name: 'specrails_guide',
+            title: 'Platform guide',
+            description: 'Returns a self-contained guide to Specrails: concepts, workflow, invariants, and how to use these tools. Read this first.',
+            tier: 'read',
+            inputSchema: {},
+            handler: () => guide_1.SPECRAILS_GUIDE,
+        },
+        {
+            name: 'specrails_search',
+            title: 'Search tools',
+            description: 'Find the right Specrails tool/action for an intent. Returns matching tools with their descriptions.',
+            tier: 'read',
+            inputSchema: {
+                query: zod_1.z.string().describe('Natural-language intent, e.g. "launch the pipeline for a ticket"'),
+            },
+            handler: (_ctx, args) => {
+                const q = String(args.query ?? '').toLowerCase().trim();
+                const terms = q.split(/\s+/).filter(Boolean);
+                const scored = getSpecs()
+                    .filter((s) => s.name !== 'specrails_search')
+                    .map((s) => {
+                    const hay = `${s.name} ${s.title} ${s.description}`.toLowerCase();
+                    const score = terms.reduce((acc, t) => acc + (hay.includes(t) ? 1 : 0), 0);
+                    return { name: s.name, title: s.title, description: s.description, score };
+                })
+                    .filter((r) => r.score > 0)
+                    .sort((a, b) => b.score - a.score)
+                    .slice(0, 8);
+                return scored.length ? scored : { hint: 'No direct match. Call specrails_guide for an overview, or list all tools.' };
+            },
+        },
+        {
+            name: 'specrails_describe',
+            title: 'Describe a tool',
+            description: 'Return the full description and input schema summary for a named Specrails tool.',
+            tier: 'read',
+            inputSchema: {
+                name: zod_1.z.string().describe('Tool name, e.g. "specrails_rails"'),
+            },
+            handler: (_ctx, args) => {
+                const name = String(args.name ?? '');
+                const spec = getSpecs().find((s) => s.name === name);
+                if (!spec)
+                    throw new Error(`Unknown tool "${name}". Use specrails_search to find one.`);
+                return {
+                    name: spec.name,
+                    title: spec.title,
+                    description: spec.description,
+                    inputFields: Object.keys(spec.inputSchema),
+                };
+            },
+        },
+        {
+            name: 'specrails_select_project',
+            title: 'Select active project',
+            description: 'Set the active project so subsequent per-project tools may omit projectId. Pass an id or a path. Pass null to clear.',
+            tier: 'read',
+            inputSchema: {
+                projectId: zod_1.z.string().nullable().optional().describe('Project id to make active, or null to clear'),
+                path: zod_1.z.string().optional().describe('Resolve+select a project by filesystem path instead of id'),
+            },
+            handler: (ctx, args) => {
+                if (args.path) {
+                    const pc = ctx.registry.getContextByPath(String(args.path));
+                    if (!pc)
+                        throw new Error(`No project registered at path "${args.path}".`);
+                    (0, types_1.setActiveProject)(pc.project.id);
+                    return { active: pc.project.id, name: pc.project.name };
+                }
+                if (args.projectId === null) {
+                    (0, types_1.setActiveProject)(null);
+                    return { active: null };
+                }
+                const id = args.projectId;
+                if (!id)
+                    throw new Error('Provide a projectId, a path, or null.');
+                const pc = (0, types_1.requireProject)(ctx, id);
+                (0, types_1.setActiveProject)(pc.project.id);
+                return { active: pc.project.id, name: pc.project.name };
+            },
+        },
+    ];
+}