rivet-design 0.23.1 → 0.25.0

package/dist/agent-variants/workItemInput.js

@@ -15,6 +15,7 @@ const isVariantWorkItem = (item) => (0, exports.isVariantWorkItemKind)(item.kind
 exports.isVariantWorkItem = isVariantWorkItem;
 const recordOf = () => v3_1.z.custom((value) => typeof value === 'object' && value !== null && !Array.isArray(value));
 const variantWorkItemInputFields = v3_1.z.object({
+    workerSelection: recordOf().optional(),
     projectContext: recordOf(),
     briefId: v3_1.z.string().optional(),
     briefLabel: v3_1.z.string().optional(),

package/dist/agent-variants/workerRuntime.d.ts

@@ -3,6 +3,7 @@ import { type RunnerVendor } from '../cli/runnerSelection';
 import type { WorkerEffortLevel } from '../hosts/workerDefaults';
 import type { WorkerFidelity } from './contracts';
 import type { WorkItemInitiator, WorkerSelection } from '../types/change-request-types';
+export declare const CURSOR_NATIVE_WORKER_REQUIRED = "Detached Cursor workers cannot apply edits without bypassing approvals. Start this request from a native Cursor host.";
 export type ExecutorWorkerTier = {
     vendor: 'claude';
     model: string;
@@ -58,9 +59,11 @@ export type WorkerRuntimeDecision = {
     callerModel?: string;
 } | {
     mode: 'host';
+    reason: 'initiating_host' | 'runtime_unavailable';
     diagnostics: PreflightDiagnostic[];
 };
-export type ProbeFailureCategory = 'spawn_error' | 'timeout' | 'aborted' | 'login_required' | 'exit_nonzero' | 'worker_failure';
+export type ProbeFailureCategory = 'spawn_error' | 'timeout' | 'aborted' | 'login_required' | 'permission_denied' | 'exit_nonzero' | 'worker_failure';
+export declare const isWorkerPermissionFailure: (message: string | undefined) => boolean;
 export type PreflightSpawn = (args: {
     command: string;
     args: string[];
@@ -87,6 +90,10 @@ export type WorkerRuntimeResolverOptions = {
         track: (event: string, properties?: Record<string, unknown>) => void;
     };
 };
+export declare const assertNativeWorkerSelection: (args: {
+    initiator?: WorkItemInitiator;
+    selection?: WorkerSelection;
+}) => void;
 export declare class WorkerRuntimeResolver {
     private readonly options;
     private readonly health;

package/dist/agent-variants/workerRuntime.js

@@ -3,16 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.describeWorkerRuntimeDecision = exports.WorkerRuntimeResolver = exports.adapterForVendor = exports.makeCursorAdapter = exports.parseCursorWorkerResult = exports.makeCodexAdapter = exports.makeClaudeAdapter = exports.parseCodexWorkerResult = exports.parseClaudeWorkerResult = exports.PREFLIGHT_TIERS = exports.EXECUTOR_FIDELITY_TIERS = void 0;
+exports.describeWorkerRuntimeDecision = exports.WorkerRuntimeResolver = exports.assertNativeWorkerSelection = exports.isWorkerPermissionFailure = exports.adapterForVendor = exports.makeCursorAdapter = exports.parseCursorWorkerResult = exports.makeCodexAdapter = exports.makeClaudeAdapter = exports.parseCodexWorkerResult = exports.parseClaudeWorkerResult = exports.PREFLIGHT_TIERS = exports.EXECUTOR_FIDELITY_TIERS = exports.CURSOR_NATIVE_WORKER_REQUIRED = void 0;
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 const logger_1 = require("../utils/logger");
-const hostAgentEnv_1 = require("../utils/hostAgentEnv");
+const subprocessEnvironment_1 = require("../utils/subprocessEnvironment");
 const runnerSelection_1 = require("../cli/runnerSelection");
 const callerRunnerPaths_1 = require("../cli/callerRunnerPaths");
 const workerDefaults_1 = require("../hosts/workerDefaults");
 const errorMessage_1 = require("../utils/errorMessage");
+const errors_1 = require("./errors");
 const log = (0, logger_1.createLogger)('WorkerRuntime');
+exports.CURSOR_NATIVE_WORKER_REQUIRED = 'Detached Cursor workers cannot apply edits without bypassing approvals. Start this request from a native Cursor host.';
 exports.EXECUTOR_FIDELITY_TIERS = {
     claude: {
         low: { vendor: 'claude', ...workerDefaults_1.FIDELITY_WORKER_TIERS.low },
@@ -50,6 +52,8 @@ const parseClaudeWorkerResult = (stdout) => {
         const parsed = JSON.parse(trimmed.slice(start));
         const sum = (...values) => values.reduce((total, value) => total + (typeof value === 'number' ? value : 0), 0);
         const usage = parsed.usage;
+        const isPermissionDenied = Array.isArray(parsed.permission_denials) &&
+            parsed.permission_denials.length > 0;
         const errorParts = [
             parsed.subtype,
             parsed.result,
@@ -58,9 +62,12 @@ const parseClaudeWorkerResult = (stdout) => {
         ]
             .filter((value) => typeof value === 'string')
             .join(': ');
+        const resultText = isPermissionDenied
+            ? 'Permission denied for worker tool calls; partial output may exist'
+            : errorParts;
         return {
-            ...(typeof parsed.is_error === 'boolean'
-                ? { isFailed: parsed.is_error }
+            ...(isPermissionDenied || typeof parsed.is_error === 'boolean'
+                ? { isFailed: isPermissionDenied || parsed.is_error === true }
                 : {}),
             ...(parsed.error !== undefined ? { error: parsed.error } : {}),
             ...(usage || typeof parsed.total_cost_usd === 'number'
@@ -78,7 +85,7 @@ const parseClaudeWorkerResult = (stdout) => {
                     },
                 }
                 : {}),
-            ...(errorParts.length > 0 ? { resultText: errorParts } : {}),
+            ...(resultText.length > 0 ? { resultText } : {}),
             ...(typeof parsed.api_error_status === 'number'
                 ? { apiErrorStatus: parsed.api_error_status }
                 : {}),
@@ -146,15 +153,12 @@ const makeClaudeAdapter = (binary = 'claude') => ({
             claudeTier.model,
             '--effort',
             claudeTier.effort,
-            '--dangerously-skip-permissions',
-            '--allowed-tools',
-            'Read,Write,Edit,Bash,Glob,Grep',
             '--exclude-dynamic-system-prompt-sections',
         ];
     },
     parseResult: exports.parseClaudeWorkerResult,
     supportsModelFallback: true,
-    spawnEnv: () => (0, hostAgentEnv_1.sanitizeHostAgentEnv)(process.env),
+    spawnEnv: () => (0, subprocessEnvironment_1.subprocessEnvironment)('claude'),
 });
 exports.makeClaudeAdapter = makeClaudeAdapter;
 const makeCodexAdapter = (binary = runnerSelection_1.RUNNER_VENDOR_BINARIES.codex) => ({
@@ -167,7 +171,6 @@ const makeCodexAdapter = (binary = runnerSelection_1.RUNNER_VENDOR_BINARIES.code
             'exec',
             '--json',
             '--skip-git-repo-check',
-            '--dangerously-bypass-approvals-and-sandbox',
             ...(codexTier.model ? ['--model', codexTier.model] : []),
             '-c',
             `model_reasoning_effort=${codexTier.reasoningEffort}`,
@@ -176,7 +179,7 @@ const makeCodexAdapter = (binary = runnerSelection_1.RUNNER_VENDOR_BINARIES.code
     },
     parseResult: exports.parseCodexWorkerResult,
     supportsModelFallback: false,
-    spawnEnv: () => process.env,
+    spawnEnv: () => (0, subprocessEnvironment_1.subprocessEnvironment)('codex'),
 });
 exports.makeCodexAdapter = makeCodexAdapter;
 const parseCursorWorkerResult = (stdout) => {
@@ -228,12 +231,11 @@ const makeCursorAdapter = (binary = runnerSelection_1.RUNNER_VENDOR_BINARIES.cur
             '--output-format',
             'json',
             ...(cursorTier.model ? ['-m', cursorTier.model] : []),
-            '--force',
         ];
     },
     parseResult: exports.parseCursorWorkerResult,
     supportsModelFallback: false,
-    spawnEnv: () => process.env,
+    spawnEnv: () => (0, subprocessEnvironment_1.subprocessEnvironment)('cursor'),
 });
 exports.makeCursorAdapter = makeCursorAdapter;
 const adapterForVendor = (vendor, binaryOverride) => {
@@ -247,15 +249,6 @@ const adapterForVendor = (vendor, binaryOverride) => {
     }
 };
 exports.adapterForVendor = adapterForVendor;
-const CALLER_MODEL_VENDORS = new Set([
-    'claude',
-    'codex',
-]);
-const callerModelFor = (initiator, vendor) => initiator?.kind === 'agent' &&
-    initiator.agent === vendor &&
-    CALLER_MODEL_VENDORS.has(vendor)
-    ? initiator.model
-    : undefined;
 const PREFLIGHT_PROMPT = 'Reply with the single word: ok. Do not use any tools.';
 const DEFAULT_PREFLIGHT_TIMEOUT_MS = 30_000;
 const asExecutableVendor = (value) => {
@@ -276,6 +269,8 @@ const sanitizeProbeText = (text) => text
     .replace(/\s+/g, ' ')
     .trim();
 const LOGIN_MARKERS = /sign[ -]?in|not logged in|not signed in|unauthenticated|not authenticated|authentication required|invalid api key|please run \/login|401/i;
+const isWorkerPermissionFailure = (message) => /permission(s)?\s+(denied|required)|approval(s)?\s+(denied|required|unavailable|disabled)|sandbox\s+(denied|violation|restriction)|operation not permitted|EACCES|EPERM/i.test(message ?? '');
+exports.isWorkerPermissionFailure = isWorkerPermissionFailure;
 const VENDOR_LOGIN_HINTS = {
     claude: 'not logged in — run /login inside `claude`',
     codex: 'not logged in — run `codex login`',
@@ -305,6 +300,15 @@ const killProcessTree = (pid) => {
         catch { }
     }
 };
+const assertNativeWorkerSelection = (args) => {
+    if (args.initiator?.kind !== 'agent')
+        return;
+    const provider = args.selection?.provider;
+    if (provider && provider !== args.initiator.agent) {
+        throw new errors_1.AgentVariantsError('RUNTIME_VALIDATION_FAILED', `Native ${args.initiator.agent} workers cannot select provider ${provider}. Start this request from ${provider} to retain its permissions and approvals.`);
+    }
+};
+exports.assertNativeWorkerSelection = assertNativeWorkerSelection;
 class WorkerRuntimeResolver {
     options;
     health = new Map();
@@ -325,9 +329,21 @@ class WorkerRuntimeResolver {
         log.warn(`worker runtime ${vendor} marked unhealthy: ${reason}`);
     }
     async resolve(args) {
-        const { candidates, source, strict } = this.candidatesFor(args?.initiator, args?.selection);
+        if (args?.initiator?.kind === 'agent') {
+            (0, exports.assertNativeWorkerSelection)(args);
+            return { mode: 'host', reason: 'initiating_host', diagnostics: [] };
+        }
+        const { candidates, source, strict } = this.candidatesFor(args?.selection);
         const diagnostics = [];
         for (const candidate of candidates) {
+            if (candidate.vendor === 'cursor') {
+                diagnostics.push({
+                    vendor: candidate.vendor,
+                    binary: candidate.binary,
+                    reason: exports.CURSOR_NATIVE_WORKER_REQUIRED,
+                });
+                break;
+            }
             const envModel = (this.options.env ?? process.env).RIVET_EXECUTOR_MODEL;
             const modelPinApplies = Boolean(!envModel &&
                 args?.selection?.model &&
@@ -336,13 +352,11 @@ class WorkerRuntimeResolver {
                     : candidate === candidates[0]));
             const outcome = await this.preflight(candidate, args?.signal, modelPinApplies ? args?.selection : undefined);
             if (outcome.healthy) {
-                const callerModel = callerModelFor(args?.initiator, candidate.vendor);
                 return {
                     mode: 'executor',
                     adapter: candidate,
                     source: strict && candidate !== candidates[0] ? 'fallback' : source,
                     ...(modelPinApplies ? { modelOverride: args?.selection?.model } : {}),
-                    ...(callerModel ? { callerModel } : {}),
                 };
             }
             diagnostics.push({
@@ -350,12 +364,14 @@ class WorkerRuntimeResolver {
                 binary: candidate.binary,
                 reason: outcome.reason,
             });
+            if (outcome.category === 'permission_denied')
+                break;
             if (strict && !(this.options.crossVendorFallback?.() ?? false))
                 break;
         }
-        return { mode: 'host', diagnostics };
+        return { mode: 'host', reason: 'runtime_unavailable', diagnostics };
     }
-    candidatesFor(initiator, selection) {
+    candidatesFor(selection) {
         const env = this.options.env ?? process.env;
         const legacyCommand = env.RIVET_EXECUTOR_COMMAND;
         if (legacyCommand) {
@@ -389,16 +405,6 @@ class WorkerRuntimeResolver {
                 strict: true,
             };
         }
-        const initiatorVendor = initiator?.kind === 'agent'
-            ? asExecutableVendor(initiator.agent)
-            : undefined;
-        if (initiatorVendor) {
-            return {
-                candidates: this.withFallbackCandidates(initiatorVendor),
-                source: 'initiator',
-                strict: true,
-            };
-        }
         return {
             candidates: runnerSelection_1.EXECUTABLE_RUNNER_VENDORS.filter((vendor) => this.knownRunnerPaths()[vendor] !== undefined).map((vendor) => this.adapterFor(vendor)),
             source: 'probe',
@@ -494,7 +500,10 @@ class WorkerRuntimeResolver {
         log.warn(`worker runtime preflight: ${adapter.vendor} model '${primaryModel}' ` +
             `unavailable — probing fallback model '${fallbackModel}'`);
         const fallbackOutcome = await this.runProbe(adapter, { ...tier, model: fallbackModel }, signal);
-        return fallbackOutcome.healthy ? fallbackOutcome : outcome;
+        return fallbackOutcome.healthy ||
+            fallbackOutcome.category === 'permission_denied'
+            ? fallbackOutcome
+            : outcome;
     }
     runProbe(adapter, tier, signal) {
         const timeoutMs = this.options.probeTimeoutMs ??
@@ -572,14 +581,22 @@ class WorkerRuntimeResolver {
                 });
             });
             child.on('close', (code) => {
-                if (code === 0) {
+                const { resultText, apiErrorStatus, isFailed } = adapter.parseResult(stdoutTail);
+                if (code === 0 && !isFailed) {
                     settle({ healthy: true });
                     return;
                 }
-                const { resultText, apiErrorStatus } = adapter.parseResult(stdoutTail);
                 const stderrDetail = sanitizeProbeText(stderrTail);
                 const stdoutDetail = sanitizeProbeText(stdoutTail);
                 const detail = stderrDetail || (resultText ? '' : stdoutDetail);
+                if ((0, exports.isWorkerPermissionFailure)(`${stderrDetail}\n${resultText ?? ''}\n${stdoutDetail}`)) {
+                    settle({
+                        healthy: false,
+                        category: 'permission_denied',
+                        reason: `Permission denied: ${detail.slice(-400)} ${resultText?.slice(-500) ?? ''}`,
+                    });
+                    return;
+                }
                 const loginRequired = LOGIN_MARKERS.test(`${stderrDetail}\n${resultText ?? ''}\n${stdoutDetail}`);
                 settle(loginRequired
                     ? {
@@ -606,6 +623,8 @@ const describeWorkerRuntimeDecision = (decision) => {
     if (decision.mode === 'executor') {
         return decision.adapter.vendor;
     }
+    if (decision.reason === 'initiating_host')
+        return 'initiating host (native permissions and approvals)';
     const reasons = decision.diagnostics
         .map((d) => `${d.vendor}: ${d.reason}`)
         .join('; ');

package/dist/cli/browser.d.ts

@@ -9,8 +9,10 @@ export type BrowserOpenResult = {
     action: 'launch_failed';
     reason: 'launcher_error';
 };
-export declare const requestBrowserOpen: ({ editorUrl, isBrowserDisabled, io, launch, }: {
-    editorUrl: string;
+export type BrowserUrlField = 'editorUrl' | 'authUrl';
+export declare const requestBrowserOpen: ({ url, urlField, isBrowserDisabled, io, launch, }: {
+    url: string;
+    urlField: BrowserUrlField;
     isBrowserDisabled: boolean;
     io: CliIO;
     launch?: (url: string) => Promise<unknown>;

package/dist/cli/browser.js

@@ -34,19 +34,21 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestBrowserOpen = void 0;
-const requestBrowserOpen = async ({ editorUrl, isBrowserDisabled, io, launch, }) => {
+const requestBrowserOpen = async ({ url, urlField, isBrowserDisabled, io, launch, }) => {
+    const publicUrl = new URL(url);
+    publicUrl.hash = '';
     if (isBrowserDisabled) {
-        io.writeProgress(`Browser launch skipped (--no-browser). Editor: ${editorUrl}`);
+        io.writeProgress(`Browser launch skipped (--no-browser). Open the ${urlField} from the command result to authorize ${publicUrl}.`);
         return { action: 'skipped', reason: 'no_browser_flag' };
     }
     try {
         const open = launch ?? (await Promise.resolve().then(() => __importStar(require('open')))).default;
-        await open(editorUrl);
-        io.writeProgress(`Requested browser launch for ${editorUrl}`);
+        await open(url);
+        io.writeProgress(`Requested browser launch for ${publicUrl}`);
         return { action: 'launch_requested', reason: 'interactive_open' };
     }
     catch {
-        io.writeProgress(`Browser launch failed. Open ${editorUrl} in your browser.`);
+        io.writeProgress(`Browser launch failed. Open the ${urlField} from the command result to authorize ${publicUrl}.`);
         return { action: 'launch_failed', reason: 'launcher_error' };
     }
 };

package/dist/cli/browserSignIn.d.ts

@@ -0,0 +1,15 @@
+import { AuthService } from '../services/AuthService';
+import { type CliCommandResult } from './envelope';
+import type { CliIO } from './io';
+type BrowserSignInOptions = {
+    command: string;
+    io: CliIO;
+    isBrowserDisabled: boolean;
+    env: NodeJS.ProcessEnv;
+    editor?: string;
+    authService?: AuthService;
+    launch?: (url: string) => Promise<unknown>;
+};
+export declare const signInThroughBrowser: ({ command, io, isBrowserDisabled, env, editor, authService, launch, }: BrowserSignInOptions) => Promise<CliCommandResult | null>;
+export {};
+//# sourceMappingURL=browserSignIn.d.ts.map

package/dist/cli/browserSignIn.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signInThroughBrowser = void 0;
+const AuthService_1 = require("../services/AuthService");
+const browser_1 = require("./browser");
+const envelope_1 = require("./envelope");
+const SIGN_IN_WAIT_ENV = 'RIVET_SIGN_IN_WAIT_MS';
+const DEFAULT_SIGN_IN_WAIT_MS = 45_000;
+const SIGN_IN_POLL_INTERVAL_MS = 2_000;
+const signInWaitMs = (env) => {
+    const parsed = Number.parseInt(env[SIGN_IN_WAIT_ENV] ?? '', 10);
+    return Number.isFinite(parsed) && parsed >= 0
+        ? parsed
+        : DEFAULT_SIGN_IN_WAIT_MS;
+};
+const signInRequired = ({ command, io, authUrl, browser, }) => {
+    const message = browser?.action === 'launch_requested'
+        ? `Rivet sign-in is open in the browser. Finish signing in there, then run \`rivet open\` again. If the browser did not open, use this link: ${authUrl}`
+        : `Sign in to Rivet in the browser with this link, then run \`rivet open\` again: ${authUrl}`;
+    io.writeProgress(message);
+    return (0, envelope_1.errorResult)(command, 'AUTH_REQUIRED', message, browser ? { browser } : undefined, (0, envelope_1.loginRecovery)(authUrl));
+};
+const signInThroughBrowser = async ({ command, io, isBrowserDisabled, env, editor, authService = new AuthService_1.AuthService(), launch, }) => {
+    const waitAttempts = isBrowserDisabled
+        ? 0
+        : Math.floor(signInWaitMs(env) / SIGN_IN_POLL_INTERVAL_MS);
+    const isSignedIn = async (attempts) => (await authService.resumePendingLogin(attempts))?.success === true;
+    if (await isSignedIn(waitAttempts + 1))
+        return null;
+    const pending = authService.peekPendingLogin();
+    if (pending?.authUrl) {
+        return signInRequired({ command, io, authUrl: pending.authUrl });
+    }
+    const begun = await authService.beginGoogleLogin({
+        source: 'cli',
+        editor,
+        noBrowser: true,
+    });
+    if (!begun.started) {
+        return (0, envelope_1.errorResult)(command, 'AUTH_REQUIRED', `Authentication required. Rivet could not start browser sign-in: ${begun.error} Have the user run \`rivet login\` to sign in.`);
+    }
+    const browser = await (0, browser_1.requestBrowserOpen)({
+        url: begun.authUrl,
+        urlField: 'authUrl',
+        isBrowserDisabled,
+        io,
+        launch,
+    });
+    if (browser.action === 'launch_requested' && (await isSignedIn(waitAttempts)))
+        return null;
+    return signInRequired({ command, io, authUrl: begun.authUrl, browser });
+};
+exports.signInThroughBrowser = signInThroughBrowser;
+//# sourceMappingURL=browserSignIn.js.map

package/dist/cli/client.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callerSessionOf = exports.editorUrlFor = exports.requestServer = exports.attachToServer = exports.inspectServer = exports.invalidateAttachCache = exports.enableAttachCache = exports.isServerHealthy = void 0;
+const telemetryPolicy_1 = require("../config/telemetryPolicy");
+const editorSession_1 = require("./editorSession");
+const editorAccess_1 = require("../utils/editorAccess");
 const telemetry_1 = require("../config/telemetry");
 const serverHandshake_1 = require("./serverHandshake");
 const queueAccess_1 = require("../utils/queueAccess");
@@ -16,10 +19,14 @@ const isServerHealthy = async (rivetPort, env = process.env) => {
         if (!response.ok)
             return false;
         const health = zod_1.z
-            .object({ pluginName: zod_1.z.string().optional() })
+            .object({
+            pluginName: zod_1.z.string().optional(),
+            telemetryMode: zod_1.z.unknown().optional(),
+        })
             .safeParse(await response.json().catch(() => null));
         if (health.success) {
             (0, pluginContext_1.assertPluginContext)(health.data.pluginName, env);
+            (0, telemetryPolicy_1.assertTelemetryMode)(health.data.telemetryMode, env);
         }
         else if ((0, pluginContext_1.getPluginName)(env)) {
             return false;
@@ -27,7 +34,8 @@ const isServerHealthy = async (rivetPort, env = process.env) => {
         return true;
     }
     catch (error) {
-        if (error instanceof pluginContext_1.PluginContextMismatchError)
+        if (error instanceof pluginContext_1.PluginContextMismatchError ||
+            error instanceof telemetryPolicy_1.TelemetryPolicyMismatchError)
             throw error;
         return false;
     }
@@ -59,12 +67,14 @@ const inspectServer = async (projectPath, env = process.env) => {
         return { status: 'unavailable', reason: 'process_not_running' };
     }
     (0, pluginContext_1.assertPluginContext)(handshake.pluginName, env);
+    (0, telemetryPolicy_1.assertTelemetryMode)(handshake.telemetryMode, env);
     if (cached &&
         cached.handshake.pid === handshake.pid &&
         cached.handshake.startedAt === handshake.startedAt &&
         cached.handshake.rivetPort === handshake.rivetPort &&
         cached.handshake.rivetVersion === handshake.rivetVersion &&
         cached.handshake.pluginName === handshake.pluginName &&
+        cached.handshake.telemetryMode === handshake.telemetryMode &&
         cached.handshake.queueAccessToken === handshake.queueAccessToken) {
         return { status: 'attached', server: cached };
     }
@@ -99,7 +109,18 @@ const requestServer = async (attached, path, options = {}) => {
     if (options.expectedAccountId) {
         headers['X-Rivet-Account-Id'] = options.expectedAccountId;
     }
+    if ((0, editorAccess_1.isEditorApiPath)(path, options.method)) {
+        const token = (0, editorSession_1.readEditorAccessToken)({
+            pid: attached.handshake.pid,
+            port: attached.handshake.rivetPort,
+            projectPath: attached.handshake.projectPath,
+            startedAt: attached.handshake.startedAt,
+        });
+        if (token)
+            headers[editorAccess_1.EDITOR_ACCESS_TOKEN_HEADER] = token;
+    }
     const response = await fetch(`${attached.baseUrl}${path}`, {
+        redirect: 'error',
         method: options.method ?? 'GET',
         headers,
         ...(options.body === undefined
@@ -111,7 +132,17 @@ const requestServer = async (attached, path, options = {}) => {
     return { status: response.status, body };
 };
 exports.requestServer = requestServer;
-const editorUrlFor = (attached) => `http://localhost:${attached.handshake.rivetPort}/rivet`;
+const editorUrlFor = (attached) => {
+    const token = (0, editorSession_1.readEditorAccessToken)({
+        pid: attached.handshake.pid,
+        port: attached.handshake.rivetPort,
+        projectPath: attached.handshake.projectPath,
+        startedAt: attached.handshake.startedAt,
+    });
+    if (!token)
+        throw new Error('Restart this project editor to authorize browser access.');
+    return (0, editorAccess_1.createEditorUrl)({ port: attached.handshake.rivetPort, token });
+};
 exports.editorUrlFor = editorUrlFor;
 const callerSessionOf = (handoff) => handoff?.session ?? undefined;
 exports.callerSessionOf = callerSessionOf;

package/dist/cli/commands/context.js

@@ -1,12 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleContext = void 0;
-const path_1 = __importDefault(require("path"));
-const crypto_1 = require("crypto");
-const GuidanceVerifierRunner_1 = require("../../services/GuidanceVerifierRunner");
+const contextVerification_1 = require("./contextVerification");
 const HubClient_1 = require("../../library/HubClient");
 const guidance_1 = require("../../types/guidance");
 const ProjectLibrary_1 = require("../../services/ProjectLibrary");
@@ -53,35 +48,15 @@ const handleContext = async (args, options = {}) => {
         });
         assertAccount();
         if (request.verificationTarget !== undefined) {
-            const controller = new AbortController();
-            const cancel = () => controller.abort();
-            if (!options.signal) {
-                process.once('SIGINT', cancel);
-                process.once('SIGTERM', cancel);
-            }
-            try {
-                const report = await (0, GuidanceVerifierRunner_1.runGuidanceVerifier)({
-                    packet: result,
-                    projectPath,
-                    target: request.verificationTarget,
-                    runsDirectory: path_1.default.join((0, ProjectLibrary_1.currentLibraryRoot)(), 'verifier-runs', (0, crypto_1.createHash)('sha256').update(accountId).digest('hex')),
-                    signal: options.signal
-                        ? AbortSignal.any([controller.signal, options.signal])
-                        : controller.signal,
-                });
-                assertAccount();
-                if (report.execution === 'completed' && report.status === 'pass')
-                    return (0, envelope_1.okResult)(command, report);
-                return (0, envelope_1.errorResult)(command, 'OPERATION_FAILED', report.execution === 'error'
-                    ? `Verifier execution failed: ${report.reason}`
-                    : `Verifier completed with ${report.status} checks`, report);
-            }
-            finally {
-                if (!options.signal) {
-                    process.removeListener('SIGINT', cancel);
-                    process.removeListener('SIGTERM', cancel);
-                }
-            }
+            return (0, contextVerification_1.executeContextVerification)({
+                command,
+                packet: result,
+                target: request.verificationTarget,
+                projectPath,
+                accountId,
+                signal: options.signal,
+                outputDirectory: request.outputDirectory,
+            });
         }
         return (0, envelope_1.okResult)(command, result);
     }

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

@@ -7,6 +7,7 @@ interface ContextRequest {
     projectPath: string;
     isProjectRequest: boolean;
     verificationTarget?: Record<string, unknown>;
+    outputDirectory?: string;
 }
 export declare const contextRequest: (args: string[]) => Promise<ContextRequest | CliCommandResult>;
 export {};

package/dist/cli/commands/contextRequest.js

@@ -32,7 +32,10 @@ const ACTION_FLAGS = {
         'remove-verifier': { takesValue: false },
     },
     verifier: {},
-    verify: { input: { takesValue: true } },
+    verify: {
+        input: { takesValue: true },
+        'output-directory': { takesValue: true },
+    },
     list: {},
     show: {},
     enable: {},
@@ -116,6 +119,10 @@ const contextRequest = async (args) => {
             case 'show':
                 break;
             case 'verify': {
+                const outputDirectory = (0, flags_1.stringFlag)(flags, 'output-directory');
+                request.outputDirectory = outputDirectory
+                    ? path_1.default.resolve(outputDirectory)
+                    : path_1.default.join(context.projectPath, '.rivet', 'verifier-runs');
                 const inputFile = (0, flags_1.stringFlag)(flags, 'input');
                 if (inputFile === undefined)
                     throw new zod_1.z.ZodError([

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

@@ -0,0 +1,12 @@
+import type { GuidanceVerification } from '../../types/guidance-verifier';
+import { type CliCommandResult } from '../envelope';
+export declare const executeContextVerification: ({ command, packet, target, projectPath, accountId, signal, outputDirectory, }: {
+    command: string;
+    packet: GuidanceVerification;
+    target: Record<string, unknown>;
+    projectPath: string;
+    accountId: string;
+    signal?: AbortSignal;
+    outputDirectory?: string;
+}) => Promise<CliCommandResult>;
+//# sourceMappingURL=contextVerification.d.ts.map

package/dist/cli/commands/contextVerification.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeContextVerification = void 0;
+const path_1 = __importDefault(require("path"));
+const GuidanceVerifierRunner_1 = require("../../services/GuidanceVerifierRunner");
+const ConfigManager_1 = require("../../services/ConfigManager");
+const envelope_1 = require("../envelope");
+const executeContextVerification = async ({ command, packet, target, projectPath, accountId, signal, outputDirectory, }) => {
+    const options = { signal };
+    const assertAccount = () => {
+        if ((0, ConfigManager_1.getConfigManager)().getUserId() !== accountId)
+            throw new Error('Rivet account changed during verification.');
+    };
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    if (!options.signal) {
+        process.once('SIGINT', cancel);
+        process.once('SIGTERM', cancel);
+    }
+    try {
+        const report = await (0, GuidanceVerifierRunner_1.runGuidanceVerifier)({
+            packet,
+            projectPath,
+            target: target,
+            runsDirectory: outputDirectory ?? path_1.default.join(projectPath, '.rivet', 'verifier-runs'),
+            signal: options.signal
+                ? AbortSignal.any([controller.signal, options.signal])
+                : controller.signal,
+        });
+        assertAccount();
+        if (report.execution === 'completed' && report.status === 'pass')
+            return (0, envelope_1.okResult)(command, report);
+        return (0, envelope_1.errorResult)(command, 'OPERATION_FAILED', report.execution === 'error'
+            ? `Verifier execution failed: ${report.reason}`
+            : `Verifier completed with ${report.status} checks`, report);
+    }
+    finally {
+        if (!options.signal) {
+            process.removeListener('SIGINT', cancel);
+            process.removeListener('SIGTERM', cancel);
+        }
+    }
+};
+exports.executeContextVerification = executeContextVerification;
+//# sourceMappingURL=contextVerification.js.map