rivet-design 0.26.1 → 0.26.2

package/dist/cli/commands/contextRequest.js

@@ -133,7 +133,7 @@ const contextRequest = async (args) => {
                         },
                     ]);
                 request.verificationTarget = zod_1.z
-                    .record(zod_1.z.unknown())
+                    .record(zod_1.z.string(), zod_1.z.unknown())
                     .parse(JSON.parse(await (0, guidanceReferences_1.readGuidanceText)(path_1.default.resolve(inputFile))));
                 request.endpoint += '/verifier';
                 break;

package/dist/cli/commands/guidanceReferences.d.ts

@@ -1,11 +1,11 @@
 export declare const readGuidanceText: (file: string) => Promise<string>;
 export declare const guidanceReferences: (manifestPath: string) => Promise<({
-    path: string;
     kind: "directory";
+    path: string;
     intent: string;
 } | {
-    url: string;
     kind: "url" | "repository";
+    url: string;
     intent: string;
     revision?: string | undefined;
     files?: {

package/dist/cli/commands/guidanceVerifierPackage.d.ts

@@ -1,9 +1,9 @@
 export declare const guidanceVerifierPackage: (manifestPath: string) => Promise<{
+    runtime: "node";
+    entrypoint: string;
     files: {
         name: string;
         content: string;
     }[];
-    runtime: "node";
-    entrypoint: string;
 }>;
 //# sourceMappingURL=guidanceVerifierPackage.d.ts.map

package/dist/cli/editorSession.d.ts

@@ -5,19 +5,7 @@ declare const EditorSessionSchema: z.ZodObject<{
     projectPath: z.ZodString;
     startedAt: z.ZodString;
     token: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    port: number;
-    token: string;
-    pid: number;
-    projectPath: string;
-    startedAt: string;
-}, {
-    port: number;
-    token: string;
-    pid: number;
-    projectPath: string;
-    startedAt: string;
-}>;
+}, z.core.$strip>;
 type EditorOwner = Omit<z.infer<typeof EditorSessionSchema>, 'token'>;
 export declare const createEditorAccessToken: () => string;
 export declare const writeEditorSession: (session: z.infer<typeof EditorSessionSchema>) => void;

package/dist/cli/runtimeInterruption.d.ts

@@ -5,23 +5,9 @@ declare const interruptionSchema: z.ZodObject<{
     serverVersion: z.ZodNullable<z.ZodString>;
     clientVersion: z.ZodString;
     createdAt: z.ZodString;
-    workIds: z.ZodArray<z.ZodString, "many">;
+    workIds: z.ZodArray<z.ZodString>;
     message: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    message: string;
-    clientVersion: string;
-    createdAt: string;
-    receiptPath: string;
-    serverVersion: string | null;
-    workIds: string[];
-}, {
-    message: string;
-    clientVersion: string;
-    createdAt: string;
-    receiptPath: string;
-    serverVersion: string | null;
-    workIds: string[];
-}>;
+}, z.core.$strip>;
 export type RuntimeInterruption = z.infer<typeof interruptionSchema>;
 export declare const recordRuntimeInterruption: ({ attached, snapshot, }: {
     attached: AttachedServer;

package/dist/config/pluginMetrics.js

@@ -205,7 +205,6 @@ const PRODUCT_EVENTS = new Set([
     'visual_editor_reference_connection_failed',
     'agent_variants.request_started',
     'agent_variants.request_accepted',
-    'agent_variants.request_rejected',
     'agent_variants.refinement_requested',
     'agent_variants.refinement_completed',
     'agent_variants.refinement_failed',

package/dist/hosts/workerDefaults.d.ts

@@ -5,22 +5,12 @@ type WorkerAgentDefinition = {
     filename: string;
     content: string;
 };
-export type WorkerHostId = 'claude' | 'codex' | 'cursor' | 'unknown';
 export type WorkerEffortLevel = 'low' | 'medium' | 'high';
 export declare const FIDELITY_WORKER_TIERS: Record<WorkerFidelity, {
     model: string;
     effort: WorkerEffortLevel;
 }>;
 export declare const DEFAULT_WORKER_FIDELITY: WorkerFidelity;
-export type HostWorkerProfile = {
-    id: WorkerHostId;
-    binding: 'agent_definition' | 'none';
-    agentType?: string;
-    defaults?: {
-        model: string;
-        effort: WorkerEffortLevel;
-    };
-};
 export declare const RIVET_WORKER_AGENT_TYPE = "rivet-worker";
 export declare const RIVET_WORKER_AGENT_TYPES: Record<WorkerFidelity, string>;
 export declare const RIVET_WORKER_DEFAULTS: {
@@ -31,7 +21,6 @@ export declare const RIVET_WORKER_REFERENCE_CREATE_DEFAULTS: {
     model: string;
     effort: WorkerEffortLevel;
 };
-export declare const workerProfileFor: (callerAgent?: string, fidelity?: WorkerFidelity) => HostWorkerProfile;
 export declare const RIVET_WORKER_AGENT_VERSION = 3;
 export declare const RIVET_WORKER_AGENT_DEFINITIONS: Record<WorkerFidelity, WorkerAgentDefinition>;
 export declare const RIVET_WORKER_AGENT_FILENAME: string;

package/dist/hosts/workerDefaults.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RIVET_WORKER_AGENT_FILENAME = exports.RIVET_WORKER_AGENT_DEFINITIONS = exports.RIVET_WORKER_AGENT_VERSION = exports.workerProfileFor = exports.RIVET_WORKER_REFERENCE_CREATE_DEFAULTS = exports.RIVET_WORKER_DEFAULTS = exports.RIVET_WORKER_AGENT_TYPES = exports.RIVET_WORKER_AGENT_TYPE = exports.DEFAULT_WORKER_FIDELITY = exports.FIDELITY_WORKER_TIERS = void 0;
-const pluginContext_1 = require("./pluginContext");
+exports.RIVET_WORKER_AGENT_FILENAME = exports.RIVET_WORKER_AGENT_DEFINITIONS = exports.RIVET_WORKER_AGENT_VERSION = exports.RIVET_WORKER_REFERENCE_CREATE_DEFAULTS = exports.RIVET_WORKER_DEFAULTS = exports.RIVET_WORKER_AGENT_TYPES = exports.RIVET_WORKER_AGENT_TYPE = exports.DEFAULT_WORKER_FIDELITY = exports.FIDELITY_WORKER_TIERS = void 0;
 exports.FIDELITY_WORKER_TIERS = {
     low: { model: 'claude-opus-4-8', effort: 'low' },
     medium: { model: 'claude-opus-4-8', effort: 'medium' },
@@ -16,34 +15,6 @@ exports.RIVET_WORKER_AGENT_TYPES = {
 };
 exports.RIVET_WORKER_DEFAULTS = exports.FIDELITY_WORKER_TIERS[exports.DEFAULT_WORKER_FIDELITY];
 exports.RIVET_WORKER_REFERENCE_CREATE_DEFAULTS = exports.FIDELITY_WORKER_TIERS[exports.DEFAULT_WORKER_FIDELITY];
-const HOST_WORKER_PROFILES = {
-    claude: {
-        id: 'claude',
-        binding: 'agent_definition',
-        agentType: exports.RIVET_WORKER_AGENT_TYPE,
-        defaults: exports.RIVET_WORKER_DEFAULTS,
-    },
-    codex: { id: 'codex', binding: 'none' },
-    cursor: { id: 'cursor', binding: 'none' },
-    unknown: { id: 'unknown', binding: 'none' },
-};
-const workerProfileFor = (callerAgent, fidelity = exports.DEFAULT_WORKER_FIDELITY) => {
-    const key = (callerAgent ?? '').trim().toLowerCase();
-    if (key === 'claude') {
-        const pluginName = (0, pluginContext_1.getPluginName)();
-        const agentType = exports.RIVET_WORKER_AGENT_TYPES[fidelity];
-        return {
-            ...HOST_WORKER_PROFILES.claude,
-            agentType: pluginName ? `${pluginName}:${agentType}` : agentType,
-            defaults: exports.FIDELITY_WORKER_TIERS[fidelity],
-        };
-    }
-    if (key === 'codex' || key === 'cursor') {
-        return HOST_WORKER_PROFILES[key];
-    }
-    return HOST_WORKER_PROFILES.unknown;
-};
-exports.workerProfileFor = workerProfileFor;
 exports.RIVET_WORKER_AGENT_VERSION = 3;
 const workerAgentContentFor = (fidelity) => {
     const agentType = exports.RIVET_WORKER_AGENT_TYPES[fidelity];

package/dist/index-core.d.ts

@@ -1,4 +1,3 @@
 export { ProjectDetectionService } from './services/ProjectDetectionService';
 export { createLogger, setLogLevel, redirectLogsToStderr, } from './utils/logger';
-export type { ChangeRecord, } from './types/change-types';
 //# sourceMappingURL=index-core.d.ts.map

package/dist/index.js

@@ -861,7 +861,7 @@ const handleInstall = async (installArgs) => {
     (0, exports.rememberInstallRef)(installArgs, selection.targetIds.join(','));
     if (installRef)
         await reportInstallRefActivations();
-    const bootstrap = (0, globalBootstrap_1.bootstrapGlobalInstall)(installArgs);
+    const bootstrap = await (0, globalBootstrap_1.bootstrapGlobalInstall)(installArgs);
     if (bootstrap.action === 'reexeced') {
         process.exit(bootstrap.exitCode);
     }

package/dist/install/automaticCliUpdate.d.ts

@@ -34,6 +34,7 @@ export type AutomaticCliUpdateOptions = {
     currentVersion: string;
     env?: NodeJS.ProcessEnv;
     homeDirectory?: string;
+    installTimeoutMs?: number;
     lockWaitTimeoutMs?: number;
     now?: () => number;
     packageRoot: string;

package/dist/install/automaticCliUpdate.js

@@ -9,10 +9,11 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const serverVersion_1 = require("../cli/serverVersion");
+const npmCommand_1 = require("./npmCommand");
+const OperatingSystemServices_1 = require("../services/OperatingSystemServices");
 const errnoCode_1 = require("../utils/errnoCode");
 const writeFileAtomic_1 = require("../utils/writeFileAtomic");
 const pluginContext_1 = require("../hosts/pluginContext");
-const packageManagerProcess_1 = require("../services/packageManagerProcess");
 const subprocessEnvironment_1 = require("../utils/subprocessEnvironment");
 const AUTOMATIC_UPDATE_STATE_SCHEMA_VERSION = 1;
 const AUTOMATIC_UPDATE_STATE_FILENAME = 'automatic-cli-update.json';
@@ -102,8 +103,7 @@ const persistUpdateState = (statePath, state) => {
     try {
         writeUpdateState(statePath, state);
     }
-    catch {
-    }
+    catch { }
 };
 const normalizedPath = (filePath) => {
     try {
@@ -122,10 +122,11 @@ const isExcludedExecution = (options) => {
         pathSegments.includes('_npx') ||
         (pathSegments.includes('.rivet') && pathSegments.includes('channels')));
 };
-const resolveGlobalPackageRoot = (env) => {
-    const result = (0, packageManagerProcess_1.spawnProcessSync)({ packageManager: 'npm', args: ['root', '-g'] }, {
+const resolveGlobalPackageRoot = async (env) => {
+    const result = await (0, npmCommand_1.runNpm)({
+        args: ['root', '-g'],
         env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager', env),
-        timeout: NPM_ROOT_TIMEOUT_MS,
+        timeoutMs: NPM_ROOT_TIMEOUT_MS,
     });
     if (result.error || result.status !== 0 || !result.stdout.trim()) {
         return { failure: 'global_root_unavailable' };
@@ -221,6 +222,11 @@ const isProcessRunning = (pid) => {
         return (0, errnoCode_1.errnoCode)(error) !== 'ESRCH';
     }
 };
+const readLockOwners = (lockPath) => fs_1.default
+    .readFileSync(lockPath, 'utf8')
+    .split('\n')
+    .map((line) => Number.parseInt(line, 10))
+    .filter((owner) => !Number.isNaN(owner));
 const acquireUpdateLock = (lockPath) => {
     fs_1.default.mkdirSync(path_1.default.dirname(lockPath), { recursive: true });
     const tryAcquire = () => {
@@ -246,10 +252,10 @@ const acquireUpdateLock = (lockPath) => {
     let isAcquired = tryAcquire();
     if (!isAcquired) {
         try {
-            const owner = Number.parseInt(fs_1.default.readFileSync(lockPath, 'utf8'), 10);
-            if (!Number.isNaN(owner) && isProcessRunning(owner))
+            const owners = readLockOwners(lockPath);
+            if (owners.some(isProcessRunning))
                 return null;
-            if (Number.isNaN(owner)) {
+            if (owners.length === 0) {
                 const lockAge = Date.now() - fs_1.default.statSync(lockPath).mtimeMs;
                 if (lockAge < LOCK_INITIALIZATION_GRACE_MS)
                     return null;
@@ -263,21 +269,24 @@ const acquireUpdateLock = (lockPath) => {
     }
     if (!isAcquired)
         return null;
-    return () => fs_1.default.rmSync(lockPath, { force: true });
+    return {
+        addOwner: (processId) => fs_1.default.appendFileSync(lockPath, `\n${processId}`, 'utf8'),
+        release: () => fs_1.default.rmSync(lockPath, { force: true }),
+    };
 };
 const waitForUpdateLock = async (lockPath, timeoutMs) => {
     const deadline = Date.now() + timeoutMs;
-    let releaseLock = acquireUpdateLock(lockPath);
-    while (releaseLock === null) {
+    let lock = acquireUpdateLock(lockPath);
+    while (lock === null) {
         const remainingMs = deadline - Date.now();
         if (remainingMs <= 0)
             return null;
         await new Promise((resolve) => {
             setTimeout(resolve, Math.min(LOCK_POLL_INTERVAL_MS, remainingMs));
         });
-        releaseLock = acquireUpdateLock(lockPath);
+        lock = acquireUpdateLock(lockPath);
     }
-    return releaseLock;
+    return lock;
 };
 const shouldUseCachedState = (options) => {
     if (options.isForced || !options.state)
@@ -306,7 +315,7 @@ const checkAndInstallCliUpdate = async (options) => {
     const isKnownGlobalPackage = state !== null &&
         normalizedPath(state.packageRoot) === normalizedPath(options.packageRoot);
     if (!isKnownGlobalPackage) {
-        const globalPackage = resolveGlobalPackageRoot(env);
+        const globalPackage = await resolveGlobalPackageRoot(env);
         if (!globalPackage.packageRoot) {
             return failedResult({
                 currentVersion: options.currentVersion,
@@ -375,8 +384,8 @@ const checkAndInstallCliUpdate = async (options) => {
         return { action: 'continue', checkedVersion: latest.version };
     }
     const lockPath = `${statePath}.lock`;
-    const releaseLock = await waitForUpdateLock(lockPath, options.lockWaitTimeoutMs ?? LOCK_WAIT_TIMEOUT_MS);
-    if (releaseLock === null) {
+    const lock = await waitForUpdateLock(lockPath, options.lockWaitTimeoutMs ?? LOCK_WAIT_TIMEOUT_MS);
+    if (lock === null) {
         return activeUpdateResult({
             currentVersion: options.currentVersion,
             durationMs: now() - startedAt,
@@ -403,12 +412,13 @@ const checkAndInstallCliUpdate = async (options) => {
             };
         }
         const packageSpec = env.RIVET_AUTO_UPDATE_PACKAGE_SPEC ?? RIVET_LATEST_PACKAGE_SPEC;
-        const install = (0, packageManagerProcess_1.spawnProcessSync)({
-            packageManager: 'npm',
+        const install = await (0, npmCommand_1.runNpm)({
             args: ['install', '-g', packageSpec, '--no-audit', '--no-fund'],
-        }, {
             env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager', env),
-            timeout: NPM_INSTALL_TIMEOUT_MS,
+            onStarted: lock.addOwner,
+            timeoutMs: OperatingSystemServices_1.selectedOperatingSystemServices.operatingSystemFamily === 'windows'
+                ? undefined
+                : (options.installTimeoutMs ?? NPM_INSTALL_TIMEOUT_MS),
         });
         if (install.error || install.status !== 0) {
             const failure = failedResult({
@@ -457,7 +467,7 @@ const checkAndInstallCliUpdate = async (options) => {
         };
     }
     finally {
-        releaseLock();
+        lock.release();
     }
 };
 exports.checkAndInstallCliUpdate = checkAndInstallCliUpdate;

package/dist/install/channelCli.d.ts

@@ -1,2 +1,2 @@
-export declare const runChannelCli: (args: string[]) => number;
+export declare const runChannelCli: (args: string[]) => Promise<number>;
 //# sourceMappingURL=channelCli.d.ts.map

package/dist/install/channelCli.js

@@ -9,8 +9,8 @@ const os_1 = __importDefault(require("os"));
 const subprocessEnvironment_1 = require("../utils/subprocessEnvironment");
 const path_1 = __importDefault(require("path"));
 const channelManager_1 = require("./channelManager");
+const npmCommand_1 = require("./npmCommand");
 const errorMessage_1 = require("../utils/errorMessage");
-const packageManagerProcess_1 = require("../services/packageManagerProcess");
 const CHANNEL_USAGE = `Rivet channel QA
 
 Usage:
@@ -22,8 +22,11 @@ Usage:
 
 Hosts: claude, claude-desktop, cursor, codex, all
 `;
-const resolveGlobalPrefix = () => {
-    const result = (0, packageManagerProcess_1.spawnProcessSync)({ packageManager: 'npm', args: ['prefix', '--global'] }, { env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager') });
+const resolveGlobalPrefix = async () => {
+    const result = await (0, npmCommand_1.runNpm)({
+        args: ['prefix', '--global'],
+        env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager'),
+    });
     if (result.error || result.status !== 0 || !result.stdout.trim()) {
         throw new Error('Could not resolve the global npm prefix');
     }
@@ -37,11 +40,11 @@ const printStatus = (channels) => {
     console.log(`Local: ${status.local.isAvailable ? (status.local.version ?? 'unknown version') : 'not built'} (${status.local.revision ?? 'unknown revision'})`);
     console.log(`Production: ${status.production.isAvailable ? (status.production.version ?? 'unknown version') : 'not installed'}`);
 };
-const runChannelCli = (args) => {
+const runChannelCli = async (args) => {
     try {
         const repoRoot = path_1.default.resolve(__dirname, '..', '..');
         const channels = new channelManager_1.RivetChannels({
-            globalPrefix: resolveGlobalPrefix(),
+            globalPrefix: await resolveGlobalPrefix(),
             homeDirectory: os_1.default.homedir(),
             repoRoot,
         });
@@ -92,6 +95,8 @@ const runChannelCli = (args) => {
 };
 exports.runChannelCli = runChannelCli;
 if (require.main === module) {
-    process.exitCode = (0, exports.runChannelCli)(process.argv.slice(2));
+    void (0, exports.runChannelCli)(process.argv.slice(2)).then((exitCode) => {
+        process.exitCode = exitCode;
+    });
 }
 //# sourceMappingURL=channelCli.js.map

package/dist/install/channelManager.d.ts

@@ -1,8 +1,11 @@
 import { z } from 'zod';
 import { type ProcessCommand } from '../services/packageManagerProcess';
-declare const RivetChannelSchema: z.ZodEnum<["local", "production"]>;
+declare const RivetChannelSchema: z.ZodEnum<{
+    production: "production";
+    local: "local";
+}>;
 export type RivetChannel = z.infer<typeof RivetChannelSchema>;
-export type ChannelCommandOptions = {
+type ChannelCommandOptions = {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
 };

package/dist/install/globalBootstrap.d.ts

@@ -1,10 +1,11 @@
 import { type ProcessCommand } from '../services/packageManagerProcess';
 export type BootstrapExec = (command: ProcessCommand, options: {
+    env: NodeJS.ProcessEnv;
     stdio: 'inherit' | 'pipe';
-}) => {
+}) => Promise<{
     status: number | null;
     stdout?: string;
-};
+}>;
 export type BootstrapResult = {
     action: 'not_needed';
 } | {
@@ -17,7 +18,8 @@ export type BootstrapResult = {
 export declare const bootstrapGlobalInstall: (installArgs: string[], options?: {
     exec?: BootstrapExec;
     binPath?: string;
+    env?: NodeJS.ProcessEnv;
     version?: string;
-}) => BootstrapResult;
+}) => Promise<BootstrapResult>;
 export declare const bootstrapFailureAdvisory: (reason: string) => string;
 //# sourceMappingURL=globalBootstrap.d.ts.map

package/dist/install/globalBootstrap.js

@@ -8,36 +8,48 @@ const fs_1 = __importDefault(require("fs"));
 const subprocessEnvironment_1 = require("../utils/subprocessEnvironment");
 const path_1 = __importDefault(require("path"));
 const mcpRegistration_1 = require("./mcpRegistration");
+const npmCommand_1 = require("./npmCommand");
 const telemetry_1 = require("../config/telemetry");
 const errorMessage_1 = require("../utils/errorMessage");
 const packageManagerProcess_1 = require("../services/packageManagerProcess");
-const defaultExec = (command, options) => {
+const defaultExec = async (command, { env, stdio }) => {
+    if ('packageManager' in command && command.packageManager === 'npm') {
+        const result = await (0, npmCommand_1.runNpm)({
+            args: command.args,
+            env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager', env),
+            stdio,
+        });
+        if (result.error)
+            throw result.error;
+        return { status: result.status, stdout: result.stdout };
+    }
     const result = (0, packageManagerProcess_1.spawnProcessSync)(command, {
-        ...options,
-        env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager' in command ? 'packageManager' : 'rivetRuntime'),
+        stdio,
+        env: (0, subprocessEnvironment_1.subprocessEnvironment)('packageManager' in command ? 'packageManager' : 'rivetRuntime', env),
     });
     if (result.error)
         throw result.error;
     return { status: result.status, stdout: result.stdout ?? undefined };
 };
-const bootstrapGlobalInstall = (installArgs, options) => {
+const bootstrapGlobalInstall = async (installArgs, options) => {
     const exec = options?.exec ?? defaultExec;
+    const env = options?.env ?? process.env;
     if (!(0, mcpRegistration_1.isEphemeralNpxInstall)(options?.binPath)) {
         return { action: 'not_needed' };
     }
-    const spec = process.env.RIVET_GLOBAL_INSTALL_SPEC ??
+    const spec = env.RIVET_GLOBAL_INSTALL_SPEC ??
         `rivet-design@${options?.version ?? telemetry_1.RIVET_VERSION}`;
     console.log(`Rivet is running from npx's temporary cache — installing ${spec} globally first so ` +
         'MCP registrations and `rivet` commands keep working...\n');
     try {
-        const installResult = exec({ packageManager: 'npm', args: ['install', '-g', spec] }, { stdio: 'inherit' });
+        const installResult = await exec({ packageManager: 'npm', args: ['install', '-g', spec] }, { env, stdio: 'inherit' });
         if (installResult.status !== 0) {
             return {
                 action: 'failed',
                 reason: `npm install -g exited ${installResult.status}`,
             };
         }
-        const rootResult = exec({ packageManager: 'npm', args: ['root', '-g'] }, { stdio: 'pipe' });
+        const rootResult = await exec({ packageManager: 'npm', args: ['root', '-g'] }, { env, stdio: 'pipe' });
         const globalRoot = String(rootResult.stdout ?? '').trim();
         const globalBin = path_1.default.join(globalRoot, 'rivet-design', 'bin', 'rivet.js');
         if (!globalRoot || !fs_1.default.existsSync(globalBin)) {
@@ -46,10 +58,10 @@ const bootstrapGlobalInstall = (installArgs, options) => {
                 reason: `global install not found at ${globalBin || 'npm root -g'}`,
             };
         }
-        const rerun = exec({
+        const rerun = await exec({
             executable: process.execPath,
             args: [globalBin, 'install', ...installArgs],
-        }, { stdio: 'inherit' });
+        }, { env, stdio: 'inherit' });
         return { action: 'reexeced', exitCode: rerun.status ?? 0 };
     }
     catch (error) {

package/dist/install/npmCommand.d.ts

@@ -0,0 +1,15 @@
+export type NpmCommandResult = {
+    error?: Error;
+    isTimedOut: boolean;
+    status: number | null;
+    stderr: string;
+    stdout: string;
+};
+export declare const runNpm: ({ args, env, onStarted, stdio, timeoutMs, }: {
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    onStarted?: (processId: number) => void;
+    stdio?: "inherit" | "pipe";
+    timeoutMs?: number;
+}) => Promise<NpmCommandResult>;
+//# sourceMappingURL=npmCommand.d.ts.map

package/dist/install/npmCommand.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNpm = void 0;
+const OperatingSystemServices_1 = require("../services/OperatingSystemServices");
+const packageManagerProcess_1 = require("../services/packageManagerProcess");
+const runNpm = ({ args, env, onStarted, stdio = 'pipe', timeoutMs, }) => new Promise((resolve) => {
+    const { operatingSystemFamily, projectProcesses } = OperatingSystemServices_1.selectedOperatingSystemServices;
+    const isProcessGroupLeader = timeoutMs !== undefined && operatingSystemFamily === 'posix';
+    let stdout = '';
+    let stderr = '';
+    let isTimedOut = false;
+    let spawnError;
+    const child = (0, packageManagerProcess_1.spawnProcess)({ packageManager: 'npm', args }, {
+        detached: isProcessGroupLeader,
+        env,
+        stdio: stdio === 'inherit' ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+    });
+    if (child.pid !== undefined)
+        onStarted?.(child.pid);
+    child.stdout?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr?.setEncoding('utf8');
+    child.stderr?.on('data', (chunk) => {
+        stderr += chunk;
+    });
+    child.on('error', (error) => {
+        spawnError = error;
+        stderr += error.message;
+    });
+    const stopProcessTree = async () => {
+        if (isProcessGroupLeader && child.pid !== undefined) {
+            process.kill(-child.pid, 'SIGTERM');
+            return;
+        }
+        await projectProcesses.terminate(child, { isForceful: false, env });
+    };
+    const timeout = timeoutMs === undefined
+        ? undefined
+        : setTimeout(() => {
+            isTimedOut = true;
+            stopProcessTree().catch((error) => {
+                stderr += String(error);
+            });
+        }, timeoutMs);
+    child.once('close', (status) => {
+        clearTimeout(timeout);
+        resolve({
+            error: spawnError,
+            isTimedOut,
+            status: isTimedOut ? null : status,
+            stderr,
+            stdout,
+        });
+    });
+});
+exports.runNpm = runNpm;
+//# sourceMappingURL=npmCommand.js.map

package/dist/routes/agentVariants.js

@@ -21,6 +21,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const path_1 = __importDefault(require("path"));
 const express_1 = require("express");
 const v3_1 = require("zod/v3");
+const api_responses_1 = require("../types/api-responses");
 const logger_1 = require("../utils/logger");
 const agent_variants_1 = require("../agent-variants");
 const changeBatchClassification_1 = require("../mcp/changeBatchClassification");
@@ -154,22 +155,10 @@ const renameRunBody = v3_1.z.object({
     label: renameLabelSchema,
     projectPath: v3_1.z.string().optional(),
 });
-const uiStateKeySchema = v3_1.z.string().min(1).max(500);
-const uiStateSchema = v3_1.z.object({
-    pinned: v3_1.z.array(uiStateKeySchema).max(1000),
-    order: v3_1.z.object({
-        groups: v3_1.z.array(uiStateKeySchema).max(1000),
-        rows: v3_1.z.record(v3_1.z.array(uiStateKeySchema).max(1000)),
-    }),
-});
 const EMPTY_UI_STATE = {
     pinned: [],
     order: { groups: [], rows: {} },
 };
-const uiStatePutBody = v3_1.z.object({
-    uiState: uiStateSchema,
-    projectPath: v3_1.z.string().optional(),
-});
 const HISTORY_STATUSES = new Set([
     'completed',
     'committed',
@@ -1218,7 +1207,7 @@ const createAgentVariantsRouter = (orchestrator, bridge, telemetry, variantHisto
                 }
                 catch { }
             }
-            const parsed = uiStateSchema.safeParse(stored);
+            const parsed = api_responses_1.VariantsUiStateSchema.safeParse(stored);
             res.json({
                 projectPath,
                 uiState: parsed.success ? parsed.data : EMPTY_UI_STATE,
@@ -1231,7 +1220,7 @@ const createAgentVariantsRouter = (orchestrator, bridge, telemetry, variantHisto
     router.put('/variants/ui-state', async (req, res) => {
         if (rejectNonLocalRequest(req, res))
             return;
-        const parsed = uiStatePutBody.safeParse(req.body);
+        const parsed = api_responses_1.VariantsUiStateUpdateSchema.safeParse(req.body);
         if (!parsed.success) {
             res.status(400).json({
                 errorCode: 'SCHEMA_VALIDATION_FAILED',

package/dist/routes/library/browserAccess.js

@@ -28,7 +28,9 @@ const createBrowserAccessRouter = ({ token, sessions, telemetry, }) => {
             profile = await (0, AuthService_1.validateAccessToken)(sessions.config.getProxyUrl(), parsed.data.token);
         }
         catch {
-            return res.status(502).json({ error: 'Could not verify Google sign-in' });
+            return res.status(502).json({
+                error: 'Could not verify Google sign-in',
+            });
         }
         if (!profile)
             return res.sendStatus(401);
@@ -68,7 +70,9 @@ const createBrowserAccessRouter = ({ token, sessions, telemetry, }) => {
     });
     const handleError = (error, _req, res, _next) => {
         if (error instanceof BrowserAuthorizationRecords_1.AuthorizationChanged)
-            return res.status(409).json({ error: error.message });
+            return res
+                .status(409)
+                .json({ error: error.message });
         res.status(503).json({
             error: 'Browser authorization is unavailable. Please retry or sign in again.',
         });

package/dist/routes/library/guidance.js

@@ -59,7 +59,9 @@ const createGuidanceRoutes = (profiles, telemetry) => {
             .json({ guidance, ...(guidanceWarning ? { guidanceWarning } : {}) });
     });
     router.post('/guidance/resolutions', async (req, res) => {
-        const { accountId, ...input } = zod_1.z.record(zod_1.z.unknown()).parse(req.body);
+        const { accountId, ...input } = zod_1.z
+            .record(zod_1.z.string(), zod_1.z.unknown())
+            .parse(req.body);
         const selection = guidance_1.GuidanceSelectionSchema.parse(input);
         const headerAccountId = callerAccount(req);
         const bodyAccountId = zod_1.z.string().min(1).optional().parse(accountId);