eve 0.7.4 → 0.8.0

package/dist/src/setup/slackbot.d.ts

@@ -1,66 +1,79 @@
-import { type ChannelSetupLog } from "#setup/cli/index.js";
-import { captureVercel, runVercel, runVercelCaptureStdout } from "#setup/primitives/run-vercel.js";
+import { type ChannelSetupAwaitChoice, type ChannelSetupLog } from "#setup/cli/index.js";
+import { runVercelCaptureStdout } from "#setup/primitives/run-vercel.js";
+import { readProjectId, type SlackConnectLifecycleDeps } from "./slack-connect-lifecycle.js";
+export { parseCreatedSlackConnector, parseInstallation, pickSlackConnector, type SlackConnectorRef, } from "./slack-connect.js";
 /** Injected for tests; defaults to the real Vercel CLI subprocess primitives. */
-export interface SlackbotProvisionDeps {
-    captureVercel: typeof captureVercel;
-    runVercel: typeof runVercel;
+export interface SlackbotProvisionDeps extends SlackConnectLifecycleDeps {
     runVercelCaptureStdout: typeof runVercelCaptureStdout;
+    /** Test seam for the linked-project lookup. */
+    readProjectId?: typeof readProjectId;
+    /** Test seam for the installation poll's pacing; defaults to a real sleep. */
+    delay?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    /** Monotonic-enough clock for enforcing the installation deadline. */
+    now?: () => number;
 }
-/** Outcome of the Connect create-and-attach sequence for a Slackbot. */
+/**
+ * Outcome of the Connect create-and-attach sequence for a Slackbot. The
+ * discriminant is the complete lifecycle state: `attached` means a connector
+ * exists, this project is registered as the trigger destination, and the app
+ * is installed into a Slack workspace.
+ * `not-installed` means the workspace-install deadline elapsed and any connector
+ * created by this attempt was removed. `cleanup-failed` means it may remain and
+ * callers must stop rather than create another connector. Attachment setup
+ * reports detach and attach failures separately because attach must not run
+ * while an old trigger destination may still exist.
+ */
 export type ProvisionSlackbotResult = {
-    kind: "create-failed";
-    created: false;
-    attached: false;
+    state: "connector-lookup-failed";
+} | {
+    state: "create-failed";
+} | {
+    state: "cancelled";
+} | {
+    state: "existing-not-installed";
+    connectorUid: string;
+} | {
+    state: "cleanup-failed";
+    connectorUids: readonly string[];
+} | {
+    state: "detach-failed";
+    connectorUid: string;
 } | {
-    kind: "connector-unresolved";
-    created: true;
-    attached: false;
+    state: "attach-failed";
+    connectorUid: string;
+} | {
+    state: "not-installed";
 } | {
-    kind: "attach-failed";
-    created: true;
-    attached: false;
+    state: "installation-check-failed";
     connectorUid: string;
 } | {
-    kind: "attached";
-    created: true;
-    attached: true;
+    state: "attached";
     connectorUid: string;
-    workspaceUrl?: string;
+    /** Deep link that opens a DM compose with the bot ("chat with your agent"). */
+    chatUrl?: string;
     workspaceName?: string;
 };
-/** Identifiers returned by Vercel Connect for a Slack connector. */
-export interface SlackConnectorRef {
-    uid: string;
-    id: string;
-}
-/**
- * Reads the connector identifiers from `vercel connect create … -F json`
- * stdout, the authoritative source for the just-created connector's UID.
- * Returns `undefined` when stdout is empty or not the expected JSON.
- */
-export declare function parseCreatedSlackConnector(stdout: string): SlackConnectorRef | undefined;
-/**
- * Finds the expected connector, or the newest Slack connector already attached to this project.
- */
-export declare function pickSlackConnector(listJson: unknown, projectId: string | undefined, expectedUid: string | undefined): SlackConnectorRef | undefined;
-/** Extracts Slack workspace information from a Connect installations response. */
-export declare function parseInstallation(body: unknown): {
-    workspaceUrl: string;
-    workspaceName?: string;
-} | undefined;
 /**
  * Creates a Slack Connect client, replaces its default trigger destination with the Eve route,
- * and resolves workspace details when Connect reports them. Promptless: progress streams
- * through the rail-styled `log`, and the result union carries every failure mode for the
- * caller to act on.
- *
- * Known quirk, preserved deliberately: a `connector-unresolved` result reports
- * `created: true`, but callers discard that fact (nothing is recorded), so a rerun
- * creates a second connector instead of adopting the unresolved one.
+ * and waits for the app's Slack workspace installation. Promptless: progress streams
+ * through the rail-styled `log`, and the result union carries every completed provisioning
+ * outcome for the caller to act on. `attached` is only returned once an installation exists. An
+ * attempt that times out is abandoned: its connector is removed and the result
+ * is `not-installed`, so callers never treat an unfinished browser OAuth as a
+ * working Slack connection — and no orphaned connector is left behind.
  */
+export interface ProvisionSlackbotOptions {
+    /**
+     * Cancels the caller's whole operation. The promise rejects after attempting
+     * cleanup; only the explicit interactive Cancel action returns `cancelled`.
+     */
+    signal?: AbortSignal;
+    /** Concurrent retry/cancel controls supplied by an interactive prompter. */
+    awaitChoice?: ChannelSetupAwaitChoice;
+}
 export declare function provisionSlackbot(log: ChannelSetupLog, projectRoot: string, 
 /** Connector short-name passed to `vercel connect create slack --name`. */
-slug: string, deps?: SlackbotProvisionDeps): Promise<ProvisionSlackbotResult>;
+slug: string, deps?: SlackbotProvisionDeps, options?: ProvisionSlackbotOptions): Promise<ProvisionSlackbotResult>;
 /**
  * Patches a connector UID chosen by Connect before the caller deploys the channel definition.
  */

package/dist/src/setup/slackbot.js

@@ -1 +1 @@
-import{join}from"node:path";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#setup/scaffold/index.js";import{readFile}from"node:fs/promises";import{createPromptCommandOutput}from"#setup/cli/index.js";import{captureVercel,runVercel,runVercelCaptureStdout}from"#setup/primitives/run-vercel.js";import{updateSlackChannelConnectorUid}from"#setup/scaffold/update/update-slack-channel.js";const defaultDeps={captureVercel,runVercel,runVercelCaptureStdout},LOOKUP_TIMEOUT_MS=6e4,ATTACH_TIMEOUT_MS=2*6e4;function parseCreatedSlackConnector(e){let t=e.trim();if(!t)return;let n;try{n=JSON.parse(t)}catch{return}if(typeof n!=`object`||!n)return;let{uid:r,id:i}=n;if(!(typeof r!=`string`||typeof i!=`string`))return{uid:r,id:i}}async function readProjectId(t){try{let r=await readFile(join(t,`.vercel`,`project.json`),`utf8`),i=JSON.parse(r);return typeof i.projectId==`string`?i.projectId:void 0}catch{return}}function pickSlackConnector(e,t,n){if(typeof e!=`object`||!e)return;let r=e,i=r.connectors??r.clients;if(!Array.isArray(i))return;let a;for(let e of i){if(e.type!==`slack`||typeof e.uid!=`string`||typeof e.id!=`string`)continue;let r={uid:e.uid,id:e.id};if(n!==void 0&&r.uid===n)return r;let i=typeof e.createdAt==`number`?e.createdAt:0;t!==void 0&&Array.isArray(e.projects)&&e.projects.some(e=>typeof e==`object`&&!!e&&e.id===t)&&(!a||i>a.createdAt)&&(a={ref:r,createdAt:i})}return a?.ref}function parseInstallation(e){if(typeof e!=`object`||!e)return;let t=e.installations;if(!Array.isArray(t)||t.length===0)return;let n=t[0];if(typeof n.tenantUrl==`string`)return{workspaceUrl:n.tenantUrl,workspaceName:typeof n.tenantName==`string`?n.tenantName:void 0}}async function findSlackConnector(e,t,n,r,i){let a=await e.captureVercel([`connect`,`list`,`-F`,`json`,`--all-projects`],{cwd:t,onOutput:i,timeoutMs:LOOKUP_TIMEOUT_MS});if(a.ok)try{return pickSlackConnector(JSON.parse(a.stdout),n,r)}catch{return}}async function fetchInstallationInfo(e,t,n,r){let i=await e.captureVercel([`api`,`/v1/connex/clients/${n}/installations`],{cwd:t,onOutput:r,timeoutMs:LOOKUP_TIMEOUT_MS});if(i.ok)try{return parseInstallation(JSON.parse(i.stdout))}catch{return}}async function withPhase(e,t,n){let r=e.spinner?.(t);r||e.message(t);try{return await n()}finally{r?.stop()}}async function provisionSlackbot(e,n,i,a=defaultDeps){let o=createPromptCommandOutput(e),s=await readProjectId(n),c=`slack/${i}`,l=await withPhase(e,`Creating a Slackbot through Vercel Connect...`,()=>a.runVercelCaptureStdout([`connect`,`create`,`slack`,`--triggers`,`--name`,i,`-F`,`json`],{cwd:n,onOutput:o,timeoutMs:6e5}));if(!l.ok)return{kind:`create-failed`,created:!1,attached:!1};e.success(`Slackbot created via Vercel Connect.`);let u=parseCreatedSlackConnector(l.stdout);if(u||=await withPhase(e,`Locating the Slack connector...`,()=>findSlackConnector(a,n,s,c,o)),!u)return e.warning("Could not locate the Slack connector. Run `vercel connect list --all-projects` to find its UID."),{kind:`connector-unresolved`,created:!0,attached:!1};let d=u;if(e.info(`Slack connector: ${d.uid}`),!await withPhase(e,`Configuring Slack event delivery for this agent...`,async()=>(await a.runVercel([`connect`,`detach`,d.uid,`--yes`],{cwd:n,onOutput:o,timeoutMs:ATTACH_TIMEOUT_MS}),a.runVercel([`connect`,`attach`,d.uid,`--triggers`,`--trigger-path`,SLACK_CHANNEL_DEFAULT_ROUTE,`--yes`],{cwd:n,onOutput:o,timeoutMs:ATTACH_TIMEOUT_MS}))))return e.warning(`Could not register this project as a trigger destination. Run \`vercel connect attach ${d.uid} --triggers --trigger-path ${SLACK_CHANNEL_DEFAULT_ROUTE} --yes\` to enable event delivery.`),{kind:`attach-failed`,created:!0,attached:!1,connectorUid:d.uid};let f=await withPhase(e,`Reading Slack workspace details...`,()=>fetchInstallationInfo(a,n,d.id,o));return f?{kind:`attached`,created:!0,attached:!0,connectorUid:d.uid,workspaceUrl:f.workspaceUrl,workspaceName:f.workspaceName}:{kind:`attached`,created:!0,attached:!0,connectorUid:d.uid}}async function reconcileSlackUid(t,n,r,i){if(r.kind!==`attached`||r.connectorUid===i)return!0;t.info(`Connect assigned UID ${r.connectorUid} (expected ${i}). Updating agent/channels/slack.ts before deployment...`);let{patched:a}=await updateSlackChannelConnectorUid(join(n,`agent/channels/slack.ts`),r.connectorUid);return a?!0:(t.warning(`Could not patch agent/channels/slack.ts automatically. Update \`connectSlackCredentials("...")\` to \`"${r.connectorUid}"\` and run \`vercel deploy --prod\`.`),!1)}export{parseCreatedSlackConnector,parseInstallation,pickSlackConnector,provisionSlackbot,reconcileSlackUid};
+import{parseCreatedSlackConnector,parseInstallation,pickSlackConnector}from"./slack-connect.js";import{CONNECT_LOOKUP_TIMEOUT_MS,attachSlackConnector,cleanupCreatedAttempt,fetchInstallationInfo,findSlackConnector,listSlackConnectors,readProjectId}from"./slack-connect-lifecycle.js";import{join}from"node:path";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#setup/scaffold/index.js";import{setTimeout}from"node:timers/promises";import{createPromptCommandOutput,withPhase}from"#setup/cli/index.js";import{captureVercel,runVercel,runVercelCaptureStdout}from"#setup/primitives/run-vercel.js";import{performance}from"node:perf_hooks";import{updateSlackChannelConnectorUid}from"#setup/scaffold/update/update-slack-channel.js";const defaultDeps={captureVercel,runVercel,runVercelCaptureStdout},realDelay=(e,t)=>setTimeout(e,void 0,{signal:t}),monotonicNow=()=>performance.now();async function pollInstallation(e,t,n,i,a){let s=e.delay??realDelay,c=e.now??monotonicNow,l=c()+3e5;for(;;){a?.throwIfAborted();let u=l-c();if(u<=0)return{state:`timed-out`};let d=await fetchInstallationInfo(e,t,n,i,Math.min(CONNECT_LOOKUP_TIMEOUT_MS,u),a);if(a?.throwIfAborted(),d.state!==`pending`)return d;let f=l-c();if(f<=0)return{state:`timed-out`};await s(Math.min(3e3,f),a)}}function isAbortFromSignal(e,t){return t?.aborted===!0&&(e===t.reason||e instanceof Error&&e.name===`AbortError`)}function cleanupFailureResult(e){return{state:`cleanup-failed`,connectorUids:e.connectorUids}}async function runAttempt(t){let{log:n,deps:r,projectRoot:a,onOutput:o,signal:s,phase:c}=t,l;if(t.source.state===`existing`)l=t.source.ref;else{let i=await c(`Creating a Slackbot through Vercel Connect...`,()=>r.runVercelCaptureStdout([`connect`,`create`,`slack`,`--triggers`,`--name`,t.slug,`-F`,`json`],{cwd:a,nonInteractive:!0,onOutput:o,timeoutMs:6e5,signal:s})),u=parseCreatedSlackConnector(i.stdout);if(u&&t.onCreated(u),!i.ok)return s?.throwIfAborted(),{state:`create-failed`};if(s?.throwIfAborted(),!u)return n.warning(`Vercel did not return an exact Slack connector UID for this request, so Eve cannot attach or remove it safely.`),{state:`unresolved`};l=u}let u=await c(`Configuring Slack event delivery for this agent...`,()=>attachSlackConnector(r,a,l,o,s));if(s?.throwIfAborted(),u.state!==`attached`)return{state:u.state,ref:l};let d=await c(`Waiting for the Slack workspace connection...`,()=>pollInstallation(r,a,l.id,o,s));return d.state===`installed`?{state:`installed`,ref:l,info:d.info}:d.state===`timed-out`?{state:`timed-out`,ref:l}:{state:`failed`,ref:l,message:d.message}}async function raceAttemptAgainstChoice(e){let t=new AbortController,n=e.outerSignal?AbortSignal.any([e.outerSignal,t.signal]):t.signal,r=e.run(n);try{let i=await Promise.race([r.then(e=>({via:`work`,outcome:e})),e.prompt.choice.then(e=>({via:`choice`,choice:e}))]);if(i.via===`work`)return i;t.abort();let a;try{a=await r}catch(e){if(!isAbortFromSignal(e,n))throw e}return{via:`choice`,choice:i.choice,settled:a}}catch(e){t.abort();try{await r}catch{}throw e}finally{e.prompt.close()}}async function provisionSlackbot(e,t,n,r=defaultDeps,i={}){i.signal?.throwIfAborted();let o=createPromptCommandOutput(e),u={log:e,deps:r,projectRoot:t,onOutput:o},f=await(r.readProjectId??readProjectId)(t),p=`slack/${n}`,m=await withPhase(e,`Checking for an existing Slackbot...`,()=>findSlackConnector(r,t,f,p,o,i.signal));if(i.signal?.throwIfAborted(),m.state===`failed`)return e.warning(`Could not inspect existing Slack connectors, so Eve did not create another one. ${m.message}`),{state:`connector-lookup-failed`};if(f===void 0&&m.connectorUids.size>0)return e.warning("Could not verify which Slack connectors belong to this Vercel project, so Eve did not create another one. Restore `.vercel/project.json`, then try again."),{state:`connector-lookup-failed`};let finishOutcome=async(t,n,r)=>{let i=n.state===`new`;switch(t.state){case`create-failed`:if(i){let e=await r();if(e.state===`failed`)return cleanupFailureResult(e)}return{state:`create-failed`};case`unresolved`:if(i){let e=await r();if(e.state===`failed`)return cleanupFailureResult(e)}return{state:`create-failed`};case`detach-failed`:return e.warning(`Could not remove the connector's existing trigger destination. Run \`vercel connect detach ${t.ref.uid} --yes\`, then \`vercel connect attach ${t.ref.uid} --triggers --trigger-path ${SLACK_CHANNEL_DEFAULT_ROUTE} --yes\`.`),{state:`detach-failed`,connectorUid:t.ref.uid};case`attach-failed`:return e.warning(`Could not register this project as a trigger destination. Run \`vercel connect attach ${t.ref.uid} --triggers --trigger-path ${SLACK_CHANNEL_DEFAULT_ROUTE} --yes\` to enable event delivery.`),{state:`attach-failed`,connectorUid:t.ref.uid};case`installed`:return{state:`attached`,connectorUid:t.ref.uid,chatUrl:t.info.workspaceUrl,workspaceName:t.info.workspaceName};case`failed`:return e.warning(`Could not verify the Slack workspace installation. ${t.message}`),{state:`installation-check-failed`,connectorUid:t.ref.uid};case`timed-out`:if(e.warning(`The Slackbot did not connect to a Slack workspace in time.`),i){let e=await r();if(e.state===`failed`)return cleanupFailureResult(e)}return{state:`not-installed`}}},cleanupNewAttempt=async(e,t)=>cleanupCreatedAttempt(u,{expectedUid:p,baselineConnectorUids:e.baselineConnectorUids,createdRef:t});function attemptInput(i,a){return{log:e,deps:r,projectRoot:t,slug:n,source:i,onOutput:o,onCreated:a}}async function runExistingConnector(t){let cleanupCurrentAttempt=async()=>({state:`clean`}),notInstalled=()=>(e.warning(`The existing Slack connector \`${t.ref.uid}\` has no Slack workspace installation. Eve did not remove it because this run did not create it. If its original browser request is still open, complete it; otherwise run \`vercel connect remove ${t.ref.uid} --disconnect-all --yes\` before trying again.`),{state:`existing-not-installed`,connectorUid:t.ref.uid}),finishExistingOutcome=async e=>e.state===`timed-out`?notInstalled():finishOutcome(e,t,cleanupCurrentAttempt);if(i.awaitChoice!==void 0){let e=await raceAttemptAgainstChoice({prompt:i.awaitChoice({status:`Waiting for the existing Slack workspace connection...`,context:`Complete the original setup in the browser`,actions:[{value:`cancel`,label:`Stop waiting`}]}),outerSignal:i.signal,run:e=>runAttempt({...attemptInput(t,()=>{}),signal:e,phase:(e,t)=>t()})});return e.via===`work`?finishExistingOutcome(e.outcome):e.settled?.state===`installed`?finishExistingOutcome(e.settled):notInstalled()}return finishExistingOutcome(await runAttempt({...attemptInput(t,()=>{}),signal:i.signal,phase:(t,n)=>withPhase(e,t,n)}))}async function runUncontrolledAttempt(t){let n,cleanupCurrentAttempt=()=>cleanupNewAttempt(t,n),r=runAttempt({...attemptInput(t,e=>{n=e}),signal:i.signal,phase:(t,n)=>withPhase(e,t,n)});try{return await finishOutcome(await r,t,cleanupCurrentAttempt)}catch(e){throw i.signal?.aborted===!0&&await cleanupCurrentAttempt(),e}}async function runInteractiveAttempt(n,a){let s,cleanupCurrentAttempt=()=>cleanupNewAttempt(n,s),l=a({status:`Creating a Slackbot through Vercel Connect...`,context:`Waiting for you to complete setup in the browser`,actions:[{value:`retry`,label:`Did your browser not open? Try again`},{value:`cancel`,label:`Cancel`}]}),u;try{u=await raceAttemptAgainstChoice({prompt:l,outerSignal:i.signal,run:e=>runAttempt({...attemptInput(n,e=>{s=e}),signal:e,phase:(e,t)=>t()})})}catch(e){throw await cleanupCurrentAttempt(),e}if(u.via===`work`)return{state:`finished`,result:await finishOutcome(u.outcome,n,cleanupCurrentAttempt)};if(u.settled?.state===`installed`)return{state:`finished`,result:await finishOutcome(u.settled,n,cleanupCurrentAttempt)};let d=await cleanupCurrentAttempt();if(d.state===`failed`)return{state:`finished`,result:cleanupFailureResult(d)};if(u.choice===`retry`){let n=await withPhase(e,`Checking existing Slack connectors...`,()=>listSlackConnectors(r,t,o,i.signal));return i.signal?.throwIfAborted(),n.state===`failed`?(e.warning(`Could not inspect existing Slack connectors, so Eve did not create another one. ${n.message}`),{state:`finished`,result:{state:`connector-lookup-failed`}}):{state:`retry`,source:{state:`new`,baselineConnectorUids:new Set(n.connectors.map(e=>e.uid))}}}return{state:`finished`,result:{state:`cancelled`}}}if(m.state===`found`)return runExistingConnector({state:`existing`,ref:m.connector});let h={state:`new`,baselineConnectorUids:m.connectorUids};if(i.awaitChoice===void 0)return runUncontrolledAttempt(h);for(;;){let e=await runInteractiveAttempt(h,i.awaitChoice);if(e.state===`finished`)return e.result;h=e.source}}async function reconcileSlackUid(e,t,n,r){if(n.state!==`attached`||n.connectorUid===r)return!0;let{patched:i}=await updateSlackChannelConnectorUid(join(t,`agent/channels/slack.ts`),n.connectorUid);return i?!0:(e.warning(`Could not patch agent/channels/slack.ts automatically. Update \`connectSlackCredentials("...")\` to \`"${n.connectorUid}"\` and run \`vercel deploy --prod\`.`),!1)}export{parseCreatedSlackConnector,parseInstallation,pickSlackConnector,provisionSlackbot,reconcileSlackUid};

package/dist/src/setup/state.d.ts

@@ -164,7 +164,8 @@ export interface SetupState {
     slackbotCreated: boolean;
     slackbotAttached: boolean;
     slackConnectorUid: string | undefined;
-    slackWorkspaceUrl: string | undefined;
+    /** Deep link that opens a DM compose with the bot ("chat with your agent"). */
+    slackChatUrl: string | undefined;
     slackWorkspaceName: string | undefined;
 }
 export declare function createDefaultSetupState(): SetupState;

package/dist/src/setup/state.js

@@ -1 +1 @@
-import{isProjectResolved}from"./project-resolution.js";import{CURRENT_DIRECTORY_PROJECT_NAME}from"#setup/scaffold/index.js";function createDefaultSetupState(){return{channels:[],webScaffolded:!1,slackScaffolded:!1,deploymentDependenciesInstalled:!1,project:{kind:`unresolved`},deploymentPending:!1,slackbotCreated:!1,slackbotAttached:!1,slackConnectorUid:void 0,slackWorkspaceUrl:void 0,slackWorkspaceName:void 0,agentName:``,setupMode:`complete`,modelId:``,modelWiring:`gateway`,channelSelection:[],connectionSelection:[],vercelProject:{kind:`none`},aiGateway:{kind:`inherit`},projectPath:{kind:`unresolved`,inPlace:!1},aiGatewayCredentials:{kind:`unresolved`},chat:null}}function hasVercelProject(t){return t.vercelProject.kind!==`none`||isProjectResolved(t.project)}function requireProjectPath(e){if(e.projectPath.kind===`resolved`)return e.projectPath.path;throw Error(`Project path has not been resolved.`)}function snapshotSetupState(e){return Object.freeze({...e,aiGatewayCredentials:Object.freeze({...e.aiGatewayCredentials}),aiGateway:Object.freeze({...e.aiGateway}),channelSelection:Object.freeze([...e.channelSelection]),connectionSelection:Object.freeze([...e.connectionSelection]),channels:Object.freeze([...e.channels]),project:Object.freeze({...e.project}),projectPath:Object.freeze({...e.projectPath}),vercelProject:Object.freeze({...e.vercelProject})})}export{CURRENT_DIRECTORY_PROJECT_NAME,createDefaultSetupState,hasVercelProject,requireProjectPath,snapshotSetupState};
+import{isProjectResolved}from"./project-resolution.js";import{CURRENT_DIRECTORY_PROJECT_NAME}from"#setup/scaffold/index.js";function createDefaultSetupState(){return{channels:[],webScaffolded:!1,slackScaffolded:!1,deploymentDependenciesInstalled:!1,project:{kind:`unresolved`},deploymentPending:!1,slackbotCreated:!1,slackbotAttached:!1,slackConnectorUid:void 0,slackChatUrl:void 0,slackWorkspaceName:void 0,agentName:``,setupMode:`complete`,modelId:``,modelWiring:`gateway`,channelSelection:[],connectionSelection:[],vercelProject:{kind:`none`},aiGateway:{kind:`inherit`},projectPath:{kind:`unresolved`,inPlace:!1},aiGatewayCredentials:{kind:`unresolved`},chat:null}}function hasVercelProject(t){return t.vercelProject.kind!==`none`||isProjectResolved(t.project)}function requireProjectPath(e){if(e.projectPath.kind===`resolved`)return e.projectPath.path;throw Error(`Project path has not been resolved.`)}function snapshotSetupState(e){return Object.freeze({...e,aiGatewayCredentials:Object.freeze({...e.aiGatewayCredentials}),aiGateway:Object.freeze({...e.aiGateway}),channelSelection:Object.freeze([...e.channelSelection]),connectionSelection:Object.freeze([...e.connectionSelection]),channels:Object.freeze([...e.channels]),project:Object.freeze({...e.project}),projectPath:Object.freeze({...e.projectPath}),vercelProject:Object.freeze({...e.vercelProject})})}export{CURRENT_DIRECTORY_PROJECT_NAME,createDefaultSetupState,hasVercelProject,requireProjectPath,snapshotSetupState};

package/dist/src/setup/step.d.ts

@@ -32,6 +32,8 @@ export interface SetupBox<State, Input, Payload> {
     gather(ctx: {
         state: Readonly<State>;
         initial?: Input;
+        /** Parent flow cancellation, when this box runs under an interruptible UI. */
+        signal?: AbortSignal;
     }): Promise<Input>;
     /** The only side-effecting step. Must be idempotent: detect current files,
      *  link state, and connectors before mutating, so a rerun converges. */
@@ -39,6 +41,8 @@ export interface SetupBox<State, Input, Payload> {
         state: Readonly<State>;
         input: Input;
         sink: OutputSink;
+        /** Parent flow cancellation, when this box runs under an interruptible UI. */
+        signal?: AbortSignal;
     }): Promise<Payload>;
     /** The only in-memory state transition. Pure: no I/O. */
     apply(state: State, payload: Payload): State;

package/dist/src/setup/validate-gateway-key.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Outcome of round-tripping an `AI_GATEWAY_API_KEY` against the Vercel AI
+ * Gateway.
+ *
+ * - `valid`: the gateway accepted the key.
+ * - `invalid`: the gateway rejected the key (authentication failure).
+ * - `inconclusive`: the check itself failed (offline, timeout). The caller can
+ *   save the key anyway rather than block on a flaky network. Only an explicit
+ *   rejection counts as a wrong key.
+ */
+export type GatewayKeyValidation = {
+    kind: "valid";
+} | {
+    kind: "invalid";
+    message: string;
+} | {
+    kind: "inconclusive";
+    message: string;
+};
+/**
+ * Confirms an `AI_GATEWAY_API_KEY` authenticates before Eve saves it, by making
+ * one account-scoped request to the gateway (`getCredits`). That endpoint
+ * rejects a bad key with a 401; the model catalog (`getAvailableModels`) is
+ * public and would accept any key, so it cannot validate.
+ *
+ * Aborts with the caller's `signal` (so the dev TUI's Esc/Ctrl-C interrupt
+ * cancels it like any other loading state); a user-initiated abort is rethrown,
+ * while a timeout or network failure resolves to `inconclusive`.
+ */
+export declare function validateGatewayApiKey(apiKey: string, signal?: AbortSignal): Promise<GatewayKeyValidation>;

package/dist/src/setup/validate-gateway-key.js

@@ -0,0 +1 @@
+import{toErrorMessage}from"#shared/errors.js";import{createGateway}from"ai";function isGatewayAuthRejection(e){if(typeof e!=`object`||!e)return!1;let t=e;return t.type===`authentication_error`||t.name===`GatewayAuthenticationError`||t.statusCode===401}async function validateGatewayApiKey(n,r){let i=AbortSignal.timeout(1e4),a=r===void 0?i:AbortSignal.any([r,i]);try{return await createGateway({apiKey:n,fetch:(e,t)=>globalThis.fetch(e,{...t,signal:a})}).getCredits(),{kind:`valid`}}catch(t){if(r?.aborted===!0)throw t;return isGatewayAuthRejection(t)?{kind:`invalid`,message:`The AI Gateway rejected this key.`}:{kind:`inconclusive`,message:toErrorMessage(t)}}}export{validateGatewayApiKey};

package/dist/src/setup/vercel-project.d.ts

@@ -20,6 +20,13 @@ declare const VercelProjectReferenceSchema: z.ZodObject<{
     name: z.ZodString;
 }, z.core.$strip>;
 type VercelProjectReference = z.infer<typeof VercelProjectReferenceSchema>;
+export interface VercelProjectOperationOptions {
+    signal?: AbortSignal;
+}
+export interface PickProjectOptions extends VercelProjectOperationOptions {
+    /** Whether an empty project list may fall back to entering a name to create. */
+    allowCreateWhenEmpty?: boolean;
+}
 export declare function unresolvedProject(): ProjectResolution;
 /**
  * Runs a network reach behind a section-like spinner so the user sees the CLI
@@ -30,12 +37,12 @@ export declare function withNetworkSpinner<T>(prompter: Prompter, message: strin
 /** Resolves the linked project id from a resolution, if any. */
 export declare function projectIdFromResolution(project: ProjectResolution): string | undefined;
 /** Lists the Vercel scopes available to the current CLI user. */
-export declare function listTeams(projectRoot: string): Promise<VercelTeamListEntry[]>;
+export declare function listTeams(projectRoot: string, options?: VercelProjectOperationOptions): Promise<VercelTeamListEntry[]>;
 /** Lists Vercel projects available under an explicit team or personal scope. */
-export declare function listProjects(projectRoot: string, team: string): Promise<VercelProjectListEntry[]>;
+export declare function listProjects(projectRoot: string, team: string, options?: VercelProjectOperationOptions): Promise<VercelProjectListEntry[]>;
 /** Resolves one project by exact name or id through the Vercel API. */
-export declare function resolveProjectByNameOrId(projectRoot: string, team: string, projectNameOrId: string): Promise<VercelProjectReference | null>;
-export declare function assertNewProjectNameAvailable(projectRoot: string, team: string, projectName: string): Promise<void>;
+export declare function resolveProjectByNameOrId(projectRoot: string, team: string, projectNameOrId: string, options?: VercelProjectOperationOptions): Promise<VercelProjectReference | null>;
+export declare function assertNewProjectNameAvailable(projectRoot: string, team: string, projectName: string, options?: VercelProjectOperationOptions): Promise<void>;
 /**
  * Throws the login action. When the underlying `vercel whoami` failure is
  * known, its diagnostic is folded into the reason: without it the agent only
@@ -48,18 +55,18 @@ export declare function requireVercelLogin(failure?: VercelCaptureFailure): neve
  * non-zero when not logged in; any other failure (a missing CLI, a transient
  * API error) is surfaced verbatim rather than mislabeled as a login problem.
  */
-export declare function requireAuth(projectRoot: string, prompter?: Prompter): Promise<void>;
+export declare function requireAuth(projectRoot: string, prompter?: Prompter, options?: VercelProjectOperationOptions): Promise<void>;
 /**
  * Non-throwing auth probe: whether the Vercel CLI has a logged-in user. Used
  * where authentication changes a decision (e.g. adopting an existing link)
  * rather than being a precondition to enforce.
  */
-export declare function isVercelAuthenticated(projectRoot: string): Promise<boolean>;
+export declare function isVercelAuthenticated(projectRoot: string, options?: VercelProjectOperationOptions): Promise<boolean>;
 /**
  * Resolves a passed team slug, or the current scope when unset, to a concrete
  * slug so every provisioning command can pass an explicit `--scope`.
  */
-export declare function resolveTeam(projectRoot: string, team: string | undefined): Promise<string>;
+export declare function resolveTeam(projectRoot: string, team: string | undefined, options?: VercelProjectOperationOptions): Promise<string>;
 /**
  * Validates a passed team slug against the account's teams, failing fast.
  *
@@ -71,13 +78,13 @@ export declare function resolveTeam(projectRoot: string, team: string | undefine
  * `prompter` is accepted so callers can pass it uniformly across the team
  * resolution helpers; it is unused now that an invalid slug throws.
  */
-export declare function validateTeam(prompter: Prompter, projectRoot: string, team: string | undefined): Promise<void>;
+export declare function validateTeam(prompter: Prompter, projectRoot: string, team: string | undefined, options?: VercelProjectOperationOptions): Promise<void>;
 /**
  * Picks the Vercel team (scope). A passed slug is validated and resolved; with
  * zero or one team the current scope is used without prompting; otherwise the
  * user filters and chooses from the list with a single-selection picker.
  */
-export declare function pickTeam(prompter: Prompter, projectRoot: string, presetTeam: string | undefined): Promise<string>;
+export declare function pickTeam(prompter: Prompter, projectRoot: string, presetTeam: string | undefined, options?: VercelProjectOperationOptions): Promise<string>;
 /**
  * A picked Vercel project. `exists` distinguishes a project the user selected
  * from the existing list (link it) from a name they typed because none exist
@@ -90,13 +97,13 @@ export interface ArgsPickedProject {
     exists: boolean;
 }
 /** Picks an existing project under a team, or a name to create when none exist. */
-export declare function pickProject(prompter: Prompter, projectRoot: string, team: string): Promise<ArgsPickedProject>;
+export declare function pickProject(prompter: Prompter, projectRoot: string, team: string, options?: PickProjectOptions): Promise<ArgsPickedProject>;
 /** Returns a project name for a new Vercel project, prompting when the default exists. */
-export declare function pickNewProjectName(prompter: Prompter, projectRoot: string, team: string, defaultProjectName: string): Promise<string>;
+export declare function pickNewProjectName(prompter: Prompter, projectRoot: string, team: string, defaultProjectName: string, options?: VercelProjectOperationOptions): Promise<string>;
 /**
  * Ensures the concrete project exists (creating it for a `new` plan) and links
  * this directory to it. Pure executor: it acts on a fully-resolved spec and
  * never prompts for a team or project. Returns whether the link succeeded.
  */
-export declare function linkProject(prompter: Prompter, projectRoot: string, spec: ResolvedVercelProjectSpec, onOutput: ReturnType<typeof createPromptCommandOutput>): Promise<boolean>;
+export declare function linkProject(prompter: Prompter, projectRoot: string, spec: ResolvedVercelProjectSpec, onOutput: ReturnType<typeof createPromptCommandOutput>, options?: VercelProjectOperationOptions): Promise<boolean>;
 export {};

package/dist/src/setup/vercel-project.js

@@ -1 +1 @@
-import{boolean,object,record,string,unknown}from"../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/schemas.js";import"../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js";import{captureVercel,runVercel}from"#setup/primitives/index.js";import{HumanActionRequiredError}from"#setup/human-action.js";import{whimsyFor}from"#setup/cli/index.js";const JsonObjectSchema=record(string(),unknown()),VercelTeamListEntrySchema=object({name:string(),slug:string(),current:boolean()}),VercelProjectListEntrySchema=object({name:string(),id:string()}),VercelProjectReferenceSchema=object({id:string(),name:string()}),VercelApiErrorSchema=object({error:object({code:string().optional(),message:string().optional()}).optional()});function unresolvedProject(){return{kind:`unresolved`}}async function withNetworkSpinner(e,t,n){let r=e.log.spinner?.(t);try{return await n()}finally{r?.stop()}}function projectIdFromResolution(e){return e.kind===`unresolved`?void 0:e.projectId}function parseJson(e,t){try{return JSON.parse(e)}catch{throw Error(`Could not parse ${t} JSON from Vercel CLI output.`)}}function parseVercelJsonList(e,t,n){let r=parseJson(e,t),i=JsonObjectSchema.safeParse(r);if(!i.success)throw Error(`Could not read ${t} from Vercel CLI JSON output.`);let a=i.data[t];if(!Array.isArray(a))throw Error(`Vercel CLI JSON output did not include ${t}.`);let o=[];for(let e of a){let t=n.safeParse(e);t.success&&o.push(t.data)}return o}function parseTeamList(e){return e===void 0?[]:parseVercelJsonList(e,`teams`,VercelTeamListEntrySchema)}async function listTeams(e){let t=await captureVercel([`teams`,`ls`,`--format`,`json`],{cwd:e});if(!t.ok)throw Error(`Could not list Vercel teams. ${t.failure.message}`);return parseTeamList(t.stdout)}function parseProjectList(e){return e===void 0?[]:parseVercelJsonList(e,`projects`,VercelProjectListEntrySchema)}async function listProjects(e,t){let n=await captureVercel([`project`,`ls`,`--format`,`json`,`--scope`,t],{cwd:e});if(!n.ok)throw Error(`Could not list Vercel projects in ${t}. ${n.failure.message}`);return parseProjectList(n.stdout)}function isNotFoundApiFailure(e){if(e.code===404)return!0;let t=VercelApiErrorSchema.safeParse(safeParseJson(e.stdout)),n=t.success?t.data.error:void 0,r=`${n?.code??``} ${n?.message??``} ${e.stderr}`.toLowerCase();return r.includes(`not_found`)||r.includes(`not found`)||r.includes(`404`)}function isConflictApiFailure(e){let t=VercelApiErrorSchema.safeParse(safeParseJson(e.stdout)),n=t.success?t.data.error:void 0,r=`${n?.code??``} ${n?.message??``} ${e.stdout} ${e.stderr}`.toLowerCase();return r.includes(`409`)||r.includes(`conflict`)||r.includes(`already exists`)}function safeParseJson(e){try{return JSON.parse(e)}catch{return}}function parseProjectReference(e,t){let n=VercelProjectReferenceSchema.safeParse(parseJson(e,t));if(!n.success)throw Error(`Could not read Vercel project identity from ${t}.`);return n.data}async function resolveProjectByNameOrId(e,t,n){let r=await captureVercel([`api`,`/v9/projects/${encodeURIComponent(n)}`,`--scope`,t,`--raw`],{cwd:e});if(r.ok)return parseProjectReference(r.stdout,`project ${n}`);if(isNotFoundApiFailure(r.failure))return null;throw Error(`Could not resolve project "${n}" in ${t}. ${r.failure.message}`)}async function createProject(e,t,n,r){let i=await captureVercel([`api`,`/v10/projects`,`--scope`,t,`--method`,`POST`,`--raw-field`,`name=${n}`,`--raw`],{cwd:e,onOutput:r});if(i.ok)return parseProjectReference(i.stdout,`created project ${n}`);throw isConflictApiFailure(i.failure)?Error(projectNameCollisionMessage(n,t)):Error(`Could not create Vercel project "${n}" in ${t}. ${i.failure.message}`)}function projectNameCollisionMessage(e,t){return`Vercel project "${e}" already exists in ${t}. Pass --project ${e} to link it, or choose a different project name.`}async function assertNewProjectNameAvailable(e,t,n){if(await resolveProjectByNameOrId(e,t,n)!==null)throw Error(projectNameCollisionMessage(n,t))}function requireVercelLogin(e){let t=`Provisioning a Vercel project requires you to be logged in to Vercel.`,n=e?.stderr.trim();throw new HumanActionRequiredError({kind:`vercel-login`,command:`vercel login`,reason:e?`${t} The Vercel CLI check did not succeed: ${e.message}${n?` ${n}`:``}`:t})}async function requireAuth(e,t){let check=async()=>{let t=await captureVercel([`whoami`],{cwd:e});t.ok||requireVercelLogin(t.failure)};if(t===void 0){await check();return}await withNetworkSpinner(t,whimsyFor(`auth`),check)}async function isVercelAuthenticated(e){return(await captureVercel([`whoami`],{cwd:e})).ok}async function whoamiScope(e){let t=await captureVercel([`whoami`],{cwd:e});return t.ok||requireVercelLogin(t.failure),t.stdout.trim()}async function resolveTeam(e,t){return t===void 0?(await listTeams(e)).find(e=>e.current)?.slug??await whoamiScope(e):t}async function validateTeam(e,t,n){if(n===void 0)return;let r=await listTeams(t);if(r.length>0&&!r.some(e=>e.slug===n))throw Error(`Team "${n}" was not found in \`vercel teams ls\`. Pass a valid team slug or omit --team.`)}async function pickTeam(e,t,n){if(n!==void 0)return await validateTeam(e,t,n),resolveTeam(t,n);let r=await withNetworkSpinner(e,whimsyFor(`teams`),()=>listTeams(t));return r.length<=1?r.find(e=>e.current)?.slug??await whoamiScope(t):e.select({message:`Select your team`,search:!0,placeholder:`type to filter teams`,options:r.map(e=>({value:e.slug,label:e.current?`${e.name} (current)`:e.name})),initialValue:r.find(e=>e.current)?.slug})}async function pickProject(e,t,n){let r=await withNetworkSpinner(e,whimsyFor(`projects`,n),()=>listProjects(t,n));return r.length===0?{project:await e.text({message:`No projects found in ${n}. Enter a project name to create`,validate:e=>e.trim().length===0?`Project name cannot be empty.`:void 0}),exists:!1}:{project:await e.select({message:`Project to link`,search:!0,placeholder:`type to filter projects`,options:r.map(e=>({value:e.name,label:e.name}))}),exists:!0}}async function pickNewProjectName(e,t,n,r){let i=await withNetworkSpinner(e,whimsyFor(`project-name`,n),()=>resolveProjectByNameOrId(t,n,r.trim())),a=r.trim();for(;i!==null;)e.note(`Vercel project "${a}" already exists in ${n}. Choose a different project name.`,`Project name unavailable`),a=(await e.text({message:`New Vercel project name`,defaultValue:`${a}-2`,validate:e=>{if(e.trim().length===0)return`Project name cannot be empty.`}})).trim(),i=await resolveProjectByNameOrId(t,n,a);return a}async function linkProject(e,t,n,r){let i=[`--scope`,n.team],a;if(n.kind===`new`)a=await withNetworkSpinner(e,`Creating Vercel project "${n.project}" in ${n.team}...`,async()=>(await assertNewProjectNameAvailable(t,n.team,n.project),createProject(t,n.team,n.project,r)));else{let e=await resolveProjectByNameOrId(t,n.team,n.project);if(e===null)throw Error(`Vercel project "${n.project}" was not found in ${n.team}.`);a=e}return withNetworkSpinner(e,`Linking this directory to Vercel project "${a.name}"...`,()=>runVercel([`link`,`--project`,a.id,...i,`--yes`],{cwd:t,onOutput:r}))}export{assertNewProjectNameAvailable,isVercelAuthenticated,linkProject,listProjects,listTeams,pickNewProjectName,pickProject,pickTeam,projectIdFromResolution,requireAuth,requireVercelLogin,resolveProjectByNameOrId,resolveTeam,unresolvedProject,validateTeam,withNetworkSpinner};
+import{__toESM}from"../_virtual/_rolldown/runtime.js";import{require_picocolors}from"../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js";import{boolean,object,record,string,unknown}from"../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/schemas.js";import"../node_modules/.pnpm/zod@4.4.3/node_modules/zod/index.js";import{captureVercel,runVercel}from"#setup/primitives/index.js";import{HumanActionRequiredError}from"#setup/human-action.js";import{whimsyFor}from"#setup/cli/index.js";var import_picocolors=__toESM(require_picocolors(),1);const JsonObjectSchema=record(string(),unknown()),VercelTeamListEntrySchema=object({name:string(),slug:string(),current:boolean()}),VercelProjectListEntrySchema=object({name:string(),id:string()}),VercelProjectReferenceSchema=object({id:string(),name:string()}),VercelApiErrorSchema=object({error:object({code:string().optional(),message:string().optional()}).optional()});function unresolvedProject(){return{kind:`unresolved`}}async function withNetworkSpinner(e,t,n){let r=e.log.spinner?.(t);try{return await n()}finally{r?.stop()}}function projectIdFromResolution(e){return e.kind===`unresolved`?void 0:e.projectId}function parseJson(e,t){try{return JSON.parse(e)}catch{throw Error(`Could not parse ${t} JSON from Vercel CLI output.`)}}function parseVercelJsonList(e,t,n){let r=parseJson(e,t),i=JsonObjectSchema.safeParse(r);if(!i.success)throw Error(`Could not read ${t} from Vercel CLI JSON output.`);let a=i.data[t];if(!Array.isArray(a))throw Error(`Vercel CLI JSON output did not include ${t}.`);let o=[];for(let e of a){let t=n.safeParse(e);t.success&&o.push(t.data)}return o}function parseTeamList(e){return e===void 0?[]:parseVercelJsonList(e,`teams`,VercelTeamListEntrySchema)}async function listTeams(e,t={}){let n=await captureVercel([`teams`,`ls`,`--format`,`json`],{cwd:e,signal:t.signal});if(!n.ok)throw Error(`Could not list Vercel teams. ${n.failure.message}`);return parseTeamList(n.stdout)}function parseProjectList(e){return e===void 0?[]:parseVercelJsonList(e,`projects`,VercelProjectListEntrySchema)}async function listProjects(e,t,n={}){let r=await captureVercel([`project`,`ls`,`--format`,`json`,`--scope`,t],{cwd:e,signal:n.signal});if(!r.ok)throw Error(`Could not list Vercel projects in ${t}. ${r.failure.message}`);return parseProjectList(r.stdout)}function isNotFoundApiFailure(e){if(e.code===404)return!0;let t=VercelApiErrorSchema.safeParse(safeParseJson(e.stdout)),n=t.success?t.data.error:void 0,r=`${n?.code??``} ${n?.message??``} ${e.stderr}`.toLowerCase();return r.includes(`not_found`)||r.includes(`not found`)||r.includes(`404`)}function isConflictApiFailure(e){let t=VercelApiErrorSchema.safeParse(safeParseJson(e.stdout)),n=t.success?t.data.error:void 0,r=`${n?.code??``} ${n?.message??``} ${e.stdout} ${e.stderr}`.toLowerCase();return r.includes(`409`)||r.includes(`conflict`)||r.includes(`already exists`)}function safeParseJson(e){try{return JSON.parse(e)}catch{return}}function parseProjectReference(e,t){let n=VercelProjectReferenceSchema.safeParse(parseJson(e,t));if(!n.success)throw Error(`Could not read Vercel project identity from ${t}.`);return n.data}async function resolveProjectByNameOrId(e,t,n,r={}){let i=await captureVercel([`api`,`/v9/projects/${encodeURIComponent(n)}`,`--scope`,t,`--raw`],{cwd:e,signal:r.signal});if(i.ok)return parseProjectReference(i.stdout,`project ${n}`);if(isNotFoundApiFailure(i.failure))return null;throw Error(`Could not resolve project "${n}" in ${t}. ${i.failure.message}`)}async function createProject(e,t,n,r,i){let a=await captureVercel([`api`,`/v10/projects`,`--scope`,t,`--method`,`POST`,`--raw-field`,`name=${n}`,`--raw`],{cwd:e,onOutput:r,signal:i.signal});if(a.ok)return parseProjectReference(a.stdout,`created project ${n}`);throw isConflictApiFailure(a.failure)?Error(projectNameCollisionMessage(n,t)):Error(`Could not create Vercel project "${n}" in ${t}. ${a.failure.message}`)}function projectNameCollisionMessage(e,t){return`Vercel project "${e}" already exists in ${t}. Pass --project ${e} to link it, or choose a different project name.`}async function assertNewProjectNameAvailable(e,t,n,r={}){if(await resolveProjectByNameOrId(e,t,n,r)!==null)throw Error(projectNameCollisionMessage(n,t))}function requireVercelLogin(e){let t=`Provisioning a Vercel project requires you to be logged in to Vercel.`,n=e?.stderr.trim();throw new HumanActionRequiredError({kind:`vercel-login`,command:`vercel login`,reason:e?`${t} The Vercel CLI check did not succeed: ${e.message}${n?` ${n}`:``}`:t})}async function requireAuth(e,t,n={}){let check=async()=>{let t=await captureVercel([`whoami`],{cwd:e,signal:n.signal});n.signal?.throwIfAborted(),t.ok||requireVercelLogin(t.failure)};if(t===void 0){await check();return}await withNetworkSpinner(t,whimsyFor(`auth`),check)}async function isVercelAuthenticated(e,t={}){let n=await captureVercel([`whoami`],{cwd:e,signal:t.signal});return t.signal?.throwIfAborted(),n.ok}async function whoamiScope(e,t){let n=await captureVercel([`whoami`],{cwd:e,signal:t.signal});return t.signal?.throwIfAborted(),n.ok||requireVercelLogin(n.failure),n.stdout.trim()}async function resolveTeam(e,t,n={}){return t===void 0?(await listTeams(e,n)).find(e=>e.current)?.slug??await whoamiScope(e,n):t}async function validateTeam(e,t,n,r={}){if(n===void 0)return;let i=await listTeams(t,r);if(i.length>0&&!i.some(e=>e.slug===n))throw Error(`Team "${n}" was not found in \`vercel teams ls\`. Pass a valid team slug or omit --team.`)}async function pickTeam(e,t,n,r={}){if(n!==void 0)return await validateTeam(e,t,n,r),resolveTeam(t,n,r);let i=await withNetworkSpinner(e,whimsyFor(`teams`),()=>listTeams(t,r));return i.length<=1?i.find(e=>e.current)?.slug??await whoamiScope(t,r):e.select({message:`Select your team`,search:!0,placeholder:`type to search teams`,options:i.map(e=>({value:e.slug,label:e.current?`${e.name} (current)`:e.name})),initialValue:i.find(e=>e.current)?.slug})}async function pickProject(e,t,n,r={}){let i=await withNetworkSpinner(e,whimsyFor(`projects`,n),()=>listProjects(t,n,r));if(i.length===0){if(r.allowCreateWhenEmpty===!1)throw Error(`No existing Vercel projects found in ${n}. Create one in Vercel, then try again.`);return{project:await e.text({message:`No projects found in ${n}. Enter a project name to create`,validate:e=>e.trim().length===0?`Project name cannot be empty.`:void 0}),exists:!1}}return{project:await e.select({message:`Project to link`,search:!0,placeholder:`type to filter projects`,options:i.map(e=>({value:e.name,label:e.name}))}),exists:!0}}async function pickNewProjectName(e,t,n,r,i={}){let a=await withNetworkSpinner(e,whimsyFor(`project-name`,n),()=>resolveProjectByNameOrId(t,n,r.trim(),i)),o=r.trim();for(;a!==null;)o=(await e.text({message:`New project name`,defaultValue:`${o}-2`,notices:[{tone:`warning`,text:`${import_picocolors.default.yellow(`Project named`)} '${import_picocolors.default.blue(o)}' ${import_picocolors.default.yellow(`already exists in`)} '${import_picocolors.default.blue(n)}'`}],validate:e=>{if(e.trim().length===0)return`Project name cannot be empty.`}})).trim(),a=await resolveProjectByNameOrId(t,n,o,i);return o}async function linkProject(e,t,n,r,i={}){let a=[`--scope`,n.team],o;if(n.kind===`new`)o=await withNetworkSpinner(e,`Creating Vercel project "${n.project}" in ${n.team}...`,async()=>(await assertNewProjectNameAvailable(t,n.team,n.project,i),createProject(t,n.team,n.project,r,i)));else{let e=await resolveProjectByNameOrId(t,n.team,n.project,i);if(e===null)throw Error(`Vercel project "${n.project}" was not found in ${n.team}.`);o=e}return withNetworkSpinner(e,`Linking this directory to Vercel project "${o.name}"...`,()=>runVercel([`link`,`--project`,o.id,...a,`--yes`],{cwd:t,onOutput:r,signal:i.signal}))}export{assertNewProjectNameAvailable,isVercelAuthenticated,linkProject,listProjects,listTeams,pickNewProjectName,pickProject,pickTeam,projectIdFromResolution,requireAuth,requireVercelLogin,resolveProjectByNameOrId,resolveTeam,unresolvedProject,validateTeam,withNetworkSpinner};

package/dist/src/shared/agent-definition.d.ts

@@ -9,6 +9,32 @@ import type { ModuleSourceRef } from "#shared/source-ref.js";
 export interface AgentModelOptionsDefinition {
     readonly providerOptions?: Record<string, JsonObject>;
 }
+/**
+ * How an agent's model is reached at runtime, decided at compile time from the
+ * authored model value.
+ *
+ * - `gateway`: routed through the Vercel AI Gateway. This covers a bare model
+ *   id string (resolved via the AI SDK global default provider), a
+ *   `gateway(...)` instance, and a gateway id whose provider key is forwarded
+ *   to the gateway via `providerOptions.gateway.byok`. `target` is the upstream
+ *   provider slug carried in the model id (e.g. `"anthropic"`), best-effort.
+ *   `byok` is set to that provider slug when a `providerOptions.gateway.byok`
+ *   block is present.
+ * - `external`: a direct provider instance (e.g. `anthropic(...)`) that bypasses
+ *   the gateway and talks to the provider's own endpoint. `provider` is the AI
+ *   SDK provider name (e.g. `"anthropic"`).
+ *
+ * This is a routing fact, not a model-existence check; it does not assert the
+ * model id names a real model.
+ */
+export type ModelRouting = {
+    kind: "gateway";
+    target: string;
+    byok?: string;
+} | {
+    kind: "external";
+    provider: string;
+};
 export type InternalAgentModelDefinition = {
     id: string;
     contextWindowTokens?: number;

package/dist/src/shared/model-endpoint-status.d.ts

@@ -0,0 +1,27 @@
+/**
+ * How the agent reaches its model and whether it's ready: the build-time
+ * {@link ModelRouting} composed with runtime credential presence. A client (the
+ * dev TUI status bar, or any other consumer of `/eve/v1/info`) shows and gates
+ * on three states:
+ *
+ * - `external`: a direct provider endpoint, not the gateway. Eve makes no
+ *   connectedness claim, since the provider key lives in the agent's own code
+ *   rather than the gateway's credentials, and model selection is disabled
+ *   because Eve cannot rewrite the authored source.
+ * - `gateway` + `connected: true`: routed through the Vercel AI Gateway with a
+ *   resolvable credential (`api-key` from `AI_GATEWAY_API_KEY`, else `oidc`).
+ * - `gateway` + `connected: false`: routed through the gateway with neither a
+ *   gateway API key nor an OIDC token. This is the "no provider connected" state
+ *   that gates the "provider required" setup prompt.
+ */
+export type ModelEndpointStatus = {
+    kind: "external";
+    provider: string;
+} | {
+    kind: "gateway";
+    connected: true;
+    credential: "api-key" | "oidc";
+} | {
+    kind: "gateway";
+    connected: false;
+};

package/dist/src/shared/model-endpoint-status.js

@@ -0,0 +1 @@
+export{};

package/dist/src/shared/sandbox-backend.d.ts

@@ -88,6 +88,10 @@ export interface SandboxBackendCreateInput {
 export interface SandboxBackendPrewarmInput<BO = Record<string, never>> {
     readonly templateKey: string;
     readonly bootstrap?: (input: SandboxBootstrapContext<BO>) => void | Promise<void>;
+    /**
+     * Optional progress logger for backend-specific prewarm phases.
+     */
+    readonly log?: (message: string) => void;
     readonly runtimeContext: SandboxBackendRuntimeContext;
     readonly seedFiles: ReadonlyArray<SandboxSeedFile>;
 }
@@ -110,8 +114,10 @@ export interface SandboxBackendPrewarmResult {
  *
  * A `SandboxBackend` is a value an author attaches to a
  * {@link SandboxDefinition} to choose which underlying runtime hosts the
- * sandbox. Eve ships two built-in backends (`vercelBackend()` and
- * `localBackend()`), but the interface is public so authors can write
+ * sandbox. Eve ships built-in backends (`dockerBackend()`,
+ * `justBashBackend()`, `microsandboxBackend()`,
+ * `vercelSandboxBackend()`, and the availability-aware
+ * `defaultBackend()`), but the interface is public so authors can write
  * their own.
  *
  * A backend implements the full two-phase lifecycle:

package/dist/src/shared/sandbox-definition.d.ts

@@ -69,13 +69,14 @@ interface SandboxDefinitionBase<BO = Record<string, never>, SO = Record<string,
      *
      * ```ts
      * defineSandbox({
-     *   backend: () => vercelBackend({ env: { TOKEN: process.env.TOKEN ?? "" } }),
+     *   backend: () => vercelSandboxBackend({ env: { TOKEN: process.env.TOKEN ?? "" } }),
      * });
      * ```
      *
      * When this field is omitted, Eve substitutes `defaultBackend()` at
-     * runtime, which delegates to `vercelBackend()` on hosted Vercel
-     * (where `process.env.VERCEL` is set) and to `localBackend()`
+     * runtime, which picks the best available backend: `vercelSandboxBackend()`
+     * on hosted Vercel (where `process.env.VERCEL` is set), then Docker,
+     * microsandbox, or just-bash
      * everywhere else. Set `backend` explicitly to pin the sandbox to a
      * specific backend regardless of environment.
      */

package/dist/src/shared/sandbox-network-policy.d.ts

@@ -17,7 +17,9 @@ import type { NetworkPolicy } from "#compiled/@vercel/sandbox/index.js";
  * });
  * ```
  *
- * The local backend rejects `setNetworkPolicy`: just-bash cannot update its
- * network policy at run time and runs no binaries to govern.
+ * The Docker backend honors only the coarse `"allow-all"` and
+ * `"deny-all"` policies; the just-bash backend rejects `setNetworkPolicy`
+ * entirely (its network policy is fixed at sandbox creation and it runs
+ * no binaries to govern).
  */
 export type SandboxNetworkPolicy = NetworkPolicy;

package/dist/src/shared/sandbox-session.d.ts

@@ -107,8 +107,9 @@ export interface SandboxSession extends Pick<AiSdkSandbox, "run" | "spawn" | "re
      *
      * When the policy is known at session start, prefer configuring it up
      * front in the sandbox backend factory or `onSession`'s `use()`. The
-     * local backend rejects this call: just-bash cannot update its network
-     * policy at run time and runs no binaries to govern.
+     * Docker backend honors only `"allow-all"` and `"deny-all"`;
+     * the just-bash backend rejects this call entirely (its network policy
+     * is fixed at sandbox creation and it runs no binaries to govern).
      */
     setNetworkPolicy(policy: SandboxNetworkPolicy): Promise<void>;
     /**

package/dist/src/svelte/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-DoR8C4i6.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-Dlut2Qzt.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/svelte/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-DoR8C4i6.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-Dlut2Qzt.js";
 
 export { useEveAgent };

package/dist/src/vue/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-DErQj5hs.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-BSXZSn-R.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/vue/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-DErQj5hs.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-BSXZSn-R.js";
 
 export { useEveAgent };

package/{dist/docs/public → docs}/getting-started.mdx

@@ -26,7 +26,17 @@ You also need a model credential. Set the provider or gateway key your model str
 
 The quick start uses `eve init` for a guided scaffold. The target can also be an existing project directory (`eve init .`): the project must have a `package.json`, the `agent/` files must not exist yet, and the missing `eve`, `ai`, and `zod` dependencies are added without touching anything else the project owns. Either way the final handoff runs the `eve dev` binary through the project's package manager, never the project's own `dev` script.
 
-To wire Eve into an existing app yourself instead, add only the dependency and author the two files the runtime needs:
+To wire Eve into an existing app yourself instead, make sure the app declares a compatible Node runtime in `package.json`:
+
+```json
+{
+  "engines": {
+    "node": ">=24"
+  }
+}
+```
+
+Then add only the dependency and author the two files the runtime needs:
 
 ```bash
 npm install eve@latest
@@ -157,8 +167,8 @@ See [Sessions, runs & streaming](./concepts/sessions-runs-and-streaming) for the
 
 If a coding agent (Claude Code, Cursor, and the like) is doing the setup, hand it this prompt:
 
-<CopyPrompt text="Set up an Eve agent for the user. Eve is a filesystem-first TypeScript framework for durable agents, published as the npm package eve. Read its docs: once eve is installed they are bundled in the package at node_modules/eve/dist/docs/public; before eve is installed, read the published Introduction and Getting Started pages. If the project has no Eve app, scaffold one with `npx eve@latest init <name>`; add `--channel-web-nextjs` only when the user wants Web Chat. The init command installs dependencies, initializes Git, and starts the dev server, so run it in a controllable process and stop it before editing. To add Eve to an existing app, run `npm install eve@latest`. Make sure agent/agent.ts and agent/instructions.md exist, then add a first typed tool at agent/tools/get_weather.ts using defineTool from eve/tools with a Zod inputSchema and an inline execute. Start the dev server again, then exercise the HTTP API: create a session with POST /eve/v1/session, attach to GET /eve/v1/session/:id/stream, and send a follow-up with the returned continuationToken. Verify with the project's typecheck, adapt model and provider choices to the project, and do not commit unless the user asks.">
-  Set up an Eve agent: read the Eve docs (bundled at node_modules/eve/dist/docs/public once eve is
+<CopyPrompt text="Set up an Eve agent for the user. Eve is a filesystem-first TypeScript framework for durable agents, published as the npm package eve. Read its docs: once eve is installed they are bundled in the package at node_modules/eve/docs; before eve is installed, read the published Introduction and Getting Started pages. If the project has no Eve app, scaffold one with `npx eve@latest init <name>`; add `--channel-web-nextjs` only when the user wants Web Chat. The init command installs dependencies, initializes Git, and starts the dev server, so run it in a controllable process and stop it before editing. To add Eve to an existing app, run `npm install eve@latest`. Make sure agent/agent.ts and agent/instructions.md exist, then add a first typed tool at agent/tools/get_weather.ts using defineTool from eve/tools with a Zod inputSchema and an inline execute. Start the dev server again, then exercise the HTTP API: create a session with POST /eve/v1/session, attach to GET /eve/v1/session/:id/stream, and send a follow-up with the returned continuationToken. Verify with the project's typecheck, adapt model and provider choices to the project, and do not commit unless the user asks.">
+  Set up an Eve agent: read the Eve docs (bundled at node_modules/eve/docs once eve is
   installed), scaffold with `npx eve@latest init <name>` (or `npm install eve@latest` in an existing app), add
   a typed tool at agent/tools/get_weather.ts, run it with `npm run dev`, then create a session, stream
   it, and send a follow-up.
@@ -166,7 +176,7 @@ If a coding agent (Claude Code, Cursor, and the like) is doing the setup, hand i
 
 Once `eve` is a dependency, the full docs are bundled in the package, so the agent can read them locally without fetching anything:
 
-- Docs: `node_modules/eve/dist/docs/public/`
+- Docs: `node_modules/eve/docs/`
 
 `eve init <name>` creates the base agent; `eve init .` adds one to an existing project. Add `--channel-web-nextjs` for Web Chat, or run
 `eve channels add slack` later from an interactive terminal.

package/{dist/docs/public → docs}/guides/deployment.md

@@ -29,10 +29,10 @@ Route-auth secrets never get serialized into the compiled discovery or module-ma
 On Vercel, the [sandbox](../sandbox) runs on hosted [Vercel Sandbox](https://vercel.com/docs/sandbox) infrastructure. Attach the backend on the sandbox definition:
 
 ```ts title="agent/sandbox/sandbox.ts"
-import { defineSandbox, vercelBackend } from "eve/sandbox";
+import { defineSandbox, vercelSandboxBackend } from "eve/sandbox";
 
 export default defineSandbox({
-  backend: vercelBackend(),
+  backend: vercelSandboxBackend(),
 });
 ```
 
@@ -110,7 +110,7 @@ Agent Runs is separate from the OpenTelemetry exporters configured in [`instrume
 
 - [ ] `eve build` succeeds and writes `.vercel/output`.
 - [ ] Provider keys and route-auth secrets are set in Vercel env vars.
-- [ ] The sandbox backend matches the environment (`vercelBackend()` or `defaultBackend()`).
+- [ ] The sandbox backend matches the environment (`vercelSandboxBackend()` or `defaultBackend()`).
 - [ ] Build-time prewarm reused or built templates without failing.
 - [ ] `placeholderAuth()` is replaced with your real policy.