eve 0.6.0-beta.9 → 0.7.2

package/dist/src/setup/boxes/add-channels.d.ts

@@ -1,33 +1,117 @@
-import { runAddToAgent, type AddToAgentState } from "#setup/scaffold/steps/index.js";
+import { deriveSlackConnectorSlug, ensureChannel, type ChannelKind } from "#setup/scaffold/index.js";
+import { detectPackageManager } from "#setup/package-manager.js";
+import { runPackageManagerInstall } from "#setup/primitives/pm/run.js";
+import { runVercel } from "#setup/primitives/run-vercel.js";
+import { detectDeployment, type ProjectResolution } from "../project-resolution.js";
+import { type Asker } from "../ask.js";
 import type { Prompter } from "../prompter.js";
+import { provisionSlackbot, reconcileSlackUid } from "../slackbot.js";
 import { type SetupState } from "../state.js";
 import type { SetupBox } from "../step.js";
-/** Injected for tests; defaults to the real channel-setup engine. */
+/** Injected for tests; defaults to the real scaffold, Connect, and Vercel effects. */
 export interface AddChannelsDeps {
-    runAddToAgent: typeof runAddToAgent;
+    ensureChannel: typeof ensureChannel;
+    deriveSlackConnectorSlug: typeof deriveSlackConnectorSlug;
+    provisionSlackbot: typeof provisionSlackbot;
+    reconcileSlackUid: typeof reconcileSlackUid;
+    detectPackageManager: typeof detectPackageManager;
+    runPackageManagerInstall: typeof runPackageManagerInstall;
+    runVercel: typeof runVercel;
+    detectDeployment: typeof detectDeployment;
 }
 export interface AddChannelsOptions {
-    /** Adapted and handed to the channel engine, which owns the slackbot prompt. */
+    /** Resolves the slackbot question; the composed stack decides how. */
+    asker: Asker;
+    /**
+     * Logs through `prompter.log` in `perform`, and owns the interactive
+     * `vercel link` fallback. The slackbot question itself now travels the asker,
+     * not this prompter.
+     */
     prompter: Prompter;
-    evePackageVersion: string;
-    /** Skip the "Create slackbot?" prompt inside the engine. */
+    /**
+     * Headless mode: gates the interactive `vercel link` fallback inside `perform`
+     * and refuses Slack up front. Fixed at composition time (the same place the
+     * asker base is chosen), since `gather` cannot read the mode off the asker.
+     */
+    headless?: boolean;
+    /**
+     * The `eve` dependency version for the scaffolded web `package.json`. When
+     * omitted (the `eve channels add` composition), `ensureChannel` receives no
+     * `webPackageVersions` at all, so every version comes from its build-stamped
+     * defaults.
+     */
+    evePackageVersion?: string;
+    /** Skip the "Create slackbot?" prompt and use this answer. */
     presetCreateSlackbot?: boolean;
+    /** Overwrite existing channel files (`eve channels add --force`). */
+    force?: boolean;
+    /**
+     * Override for the web scaffold's Vercel services config. Defaults to
+     * `hasVercelProject(state)`; `eve channels add` pins it to true so an
+     * unlinked directory still gets the config, matching the dissolved engine.
+     */
+    configureVercelServices?: boolean;
+    /**
+     * Opt-in fallback when Slack is chosen interactively but `state.project` is
+     * unresolved: run the interactive bare `vercel link` before provisioning the
+     * slackbot. Only the `eve channels add` composition sets this; onboarding
+     * resolves the project up front via the link box and keeps the hard gate.
+     */
+    ensureLinkedProject?: "interactive-vercel-link";
+    /**
+     * What a failed slackbot provision (create or attach) does to the run. The
+     * default, "abort", fails the whole box — right for `eve channels add slack`,
+     * where Slack is the point. Onboarding passes "warn-and-continue": the agent
+     * still scaffolds, deploys, and chats without Slack (recorded as nothing, so
+     * a later `eve channels add slack` starts clean).
+     */
+    slackbotFailure?: "abort" | "warn-and-continue";
     deps?: AddChannelsDeps;
 }
 /**
- * Which gather face produced the input. The engine needs the headless flag
- * inside `perform` (it gates Slack and interactive `vercel` commands), so the
- * faces record it instead of taking a factory option.
+ * What the user (or the preset) decided before `perform` runs effects.
+ * `createSlackbot` is only consulted when Slack is in the channel selection.
  */
 export interface AddChannelsInput {
     headless: boolean;
+    createSlackbot: boolean | undefined;
+}
+/** Slackbot facts resolved by a successful Connect provision. */
+export interface AddChannelsSlackbotFacts {
+    connectorUid: string;
+    workspaceUrl?: string;
+    workspaceName?: string;
+}
+/**
+ * What `perform` actually did. `channelsAdded` lists the channels recorded this
+ * run (web before slack); a skipped Web scaffold (Next.js detected) records
+ * nothing, deliberately. `slackbot` is present only after a fresh, fully
+ * attached provision; every failure mode either throws or (under
+ * `slackbotFailure: "warn-and-continue"`) skips Slack entirely, so a failed
+ * Slack setup records nothing (atomicity).
+ */
+export interface AddChannelsPayload {
+    channelsAdded: ChannelKind[];
+    webScaffolded: boolean;
+    slackScaffolded: boolean;
+    /**
+     * Whether the post-scaffold dependency install succeeded. False both when no
+     * channels were recorded (nothing ran) and when the install failed; only a
+     * success lets `apply` mark the deploy-time install as already done.
+     */
+    dependenciesInstalled: boolean;
+    project: ProjectResolution;
+    slackbot?: AddChannelsSlackbotFacts;
 }
 /**
- * THE CHANNEL SCAFFOLD BOX. Wraps the scaffold engine's `runAddToAgent`, which
- * owns its own interleaved prompting (the slackbot question), so this box is a
- * documented exception to "gather prompts, perform executes": the gather faces
- * return a trivial input and `perform` hands the real prompter to the engine.
- * The channels themselves were chosen up front by the select-channels box and
- * ride in as `state.channelSelection`, so the engine's picker never re-opens.
+ * THE CHANNEL SCAFFOLD BOX. Scaffolds the channels chosen up front by the
+ * select-channels box (`state.channelSelection`): writes the Web Chat files,
+ * provisions the Slackbot through Vercel Connect, writes the Slack channel
+ * definition, reconciles a Connect-assigned connector UID, and installs the
+ * dependencies the scaffold added to `package.json` so a running `eve dev`
+ * can load the new channel modules right away. The only prompt
+ * (the slackbot question) travels the asker in `gather`; `perform` is promptless
+ * and reads `state.project` directly, resolved earlier by the link box or the
+ * in-project seed.
  */
-export declare function addChannels(options: AddChannelsOptions): SetupBox<SetupState, AddChannelsInput, AddToAgentState>;
+export declare function addChannels(options: AddChannelsOptions): SetupBox<SetupState, AddChannelsInput, AddChannelsPayload>;

package/dist/src/setup/boxes/add-channels.js

@@ -1 +1,2 @@
-import{toChannelSetupPrompter}from"../channel-setup-prompter.js";import{hasVercelProject,requireProjectPath}from"../state.js";import{assignAddToAgentState,isProjectResolved,runAddToAgent}from"#setup/scaffold/steps/index.js";const SLACK_REQUIRES_VERCEL=`Slack requires a Vercel project. Re-run and choose to deploy to Vercel to add Slack.`;function addChannels(a){let o=a.deps??{runAddToAgent};return{id:`add-channels`,async gatherInteractive(){return{kind:`done`,input:{headless:!1}}},async gatherHeadless(){return{headless:!0}},async perform({state:r,input:i}){let s=requireProjectPath(r),c=!hasVercelProject(r),l=r.project;return o.runAddToAgent({prompter:toChannelSetupPrompter(a.prompter),projectPath:s,projectName:r.agentName,state:r,presetChannels:r.channelSelection,presetCreateSlackbot:a.presetCreateSlackbot,headless:i.headless,webPackageVersions:{evePackageVersion:a.evePackageVersion},configureVercelServices:!c,disabledChannelReasons:c?{slack:SLACK_REQUIRES_VERCEL}:void 0,validateSelectedChannels:async e=>{if(c&&e.includes(`slack`))throw Error(SLACK_REQUIRES_VERCEL)},async linkProjectForSlackbot(){if(c)throw Error(SLACK_REQUIRES_VERCEL);if(!isProjectResolved(l))throw Error(`Expected a linked Vercel project for Slack, but none was resolved.`);return l}})},apply(e,t){let n={...e};return assignAddToAgentState(n,t),n}}}export{addChannels};
+import{SkippedSignal,confirm}from"../ask.js";import{detectDeployment,isProjectResolved,mergeProjectResolution,projectResolutionFromDeployment}from"../project-resolution.js";import{provisionSlackbot,reconcileSlackUid}from"../slackbot.js";import{hasVercelProject,requireProjectPath}from"../state.js";import{deriveSlackConnectorSlug,ensureChannel}from"#setup/scaffold/index.js";import{detectPackageManager}from"#setup/package-manager.js";import{HumanActionRequiredError}from"#setup/human-action.js";import{createPromptCommandOutput}from"#setup/cli/index.js";import{runPackageManagerInstall}from"#setup/primitives/pm/run.js";import{runVercel}from"#setup/primitives/run-vercel.js";const SLACKBOT_NOT_ATTACHED_ERROR=`Slackbot provisioning did not attach this project. Slack channel was not added.`;function warnOverwrittenFiles(e,t){for(let n of t??[])e.warning(`Overwrote ${n}`)}function warnCompetingNextConfigFiles(e,t){for(let n of t??[])e.warning(`Found competing Next.js config at ${n}; merge any needed settings into next.config.ts and remove it before starting the preview, or Next.js may ignore the generated Eve rewrite.`)}function addChannels(l){let u=l.deps??{ensureChannel,deriveSlackConnectorSlug,provisionSlackbot,reconcileSlackUid,detectPackageManager,runPackageManagerInstall,runVercel,detectDeployment};async function scaffoldSlackChannel(e,t,n,r,i){if(!t.slackScaffolded){e.message(`Scaffolding Slack channel files...`);let t=await u.ensureChannel({projectRoot:n,kind:`slack`,slackConnectorSlug:r,force:l.force});warnOverwrittenFiles(e,t.filesOverwritten),t.action===`created`||t.action===`overwritten`?e.success(`Scaffolded channel: slack`):e.info(`Channel "slack" already exists. Skipping file creation.`),i.slackScaffolded=!0}i.channelsAdded.push(`slack`)}async function linkProjectForSlackbot(e,t,n,o){if(o)throw new HumanActionRequiredError({kind:`vercel-link`,command:`vercel link`,reason:`Slackbot creation needs this directory linked to a Vercel project.`});if(e.message(`Linking this directory to a Vercel project...`),!await u.runVercel([`link`],{cwd:t}))throw Error(`Vercel project linking failed. Slackbot creation did not start.`);let s=mergeProjectResolution(n,projectResolutionFromDeployment(await u.detectDeployment(t)));if(!isProjectResolved(s))throw Error(`Vercel project linking failed. Slackbot creation did not start.`);return s}async function performAddChannels(e,t){let n=l.prompter.log,i=requireProjectPath(e),a=e.channelSelection,o={channelsAdded:[],webScaffolded:e.webScaffolded,slackScaffolded:e.slackScaffolded,dependenciesInstalled:!1,project:e.project},s=await u.detectPackageManager(i);if(a.includes(`web`))if(e.webScaffolded)o.channelsAdded.push(`web`);else{n.message(`Scaffolding Web Chat channel files...`);let t={projectRoot:i,kind:`web`,packageManager:s.kind,force:l.force,configureVercelServices:l.configureVercelServices??hasVercelProject(e)};l.evePackageVersion!==void 0&&(t.webPackageVersions={evePackageVersion:l.evePackageVersion});let r=await u.ensureChannel(t);warnOverwrittenFiles(n,r.filesOverwritten),warnCompetingNextConfigFiles(n,`competingNextConfigFiles`in r?r.competingNextConfigFiles:void 0),r.action===`created`||r.action===`overwritten`?(n.success(`Scaffolded channel: web`),o.webScaffolded=!0,o.channelsAdded.push(`web`)):n.info(`Next.js project detected. Skipping Web Chat scaffolding.`)}if(a.includes(`slack`)){if(l.ensureLinkedProject===void 0){if(!hasVercelProject(e))throw Error(`Slack requires a Vercel project. Re-run and choose to deploy to Vercel to add Slack.`);if(!isProjectResolved(e.project))throw Error(`Expected a linked Vercel project for Slack, but none was resolved.`)}let a=await u.deriveSlackConnectorSlug(i,e.agentName),s=`slack/${a}`;if(e.slackbotCreated){if(!e.slackbotAttached)throw Error(SLACKBOT_NOT_ATTACHED_ERROR);if(e.deploymentPending){await scaffoldSlackChannel(n,e,i,a,o);let t=e.slackConnectorUid;if(t===void 0)throw Error(`Slack connector UID was not resolved. Slack deployment did not start.`);if(!await u.reconcileSlackUid(n,i,{kind:`attached`,created:!0,attached:!0,connectorUid:t},s))throw Error(`Slack connector UID update is required before deployment.`)}}else if(t.createSlackbot!==!0)n.info(`Slack channel was not added because Slackbot setup was skipped.`);else{isProjectResolved(o.project)||(o.project=await linkProjectForSlackbot(n,i,o.project,t.headless));let c=await u.provisionSlackbot(n,i,a);if(c.kind!==`attached`){let e=c.created?SLACKBOT_NOT_ATTACHED_ERROR:`Slackbot creation failed.`;if(l.slackbotFailure!==`warn-and-continue`)throw Error(e);let t=c.created?"Continuing without Slack — finish event delivery with the `vercel connect attach` command above.":"Continuing without Slack — add it later with `eve channels add slack`.";n.warning(`${e} ${t}`)}else if(o.slackbot={connectorUid:c.connectorUid,workspaceUrl:c.workspaceUrl,workspaceName:c.workspaceName},await scaffoldSlackChannel(n,e,i,a,o),!await u.reconcileSlackUid(n,i,c,s))throw Error(`Slack connector UID update is required before deployment.`)}}return o.channelsAdded.length>0&&(n.message(`Installing channel dependencies (${s.kind} install)...`),await u.runPackageManagerInstall(s.kind,i,{onOutput:createPromptCommandOutput(n)})?o.dependenciesInstalled=!0:n.warning(`Dependency installation failed. The new channels stay unloadable until \`${s.kind} install\` or a deploy succeeds.`)),o}return{id:`add-channels`,async gather({state:n}){let r=l.headless??!1;if(r&&n.channelSelection.includes(`slack`))throw Error("Slack setup is interactive. Run `eve channels add slack` from an interactive terminal.");if(!n.channelSelection.includes(`slack`)||l.presetCreateSlackbot!==void 0||n.slackbotCreated)return{headless:r,createSlackbot:l.presetCreateSlackbot};try{return{headless:r,createSlackbot:await l.asker.ask(confirm({key:`create-slackbot`,message:`Do you want to create your slackbot?`}))}}catch(t){if(t instanceof SkippedSignal)return{headless:r,createSlackbot:!1};throw t}},async perform({state:e,input:t}){try{return await performAddChannels(e,t)}catch(e){let t=e instanceof Error?e.message:String(e),n=t.split(`
+`)[0]?.trim()??t;throw l.prompter.log.error(n),e}},apply(e,t){let n=[...e.channels];for(let e of t.channelsAdded)n.includes(e)||n.push(e);let r={...e,channels:n,webScaffolded:t.webScaffolded,slackScaffolded:t.slackScaffolded,deploymentPending:e.deploymentPending||t.channelsAdded.length>0,deploymentDependenciesInstalled:t.channelsAdded.length>0?t.dependenciesInstalled:e.deploymentDependenciesInstalled,project:mergeProjectResolution(e.project,t.project)};return t.slackbot===void 0?r:{...r,slackbotCreated:!0,slackbotAttached:!0,slackConnectorUid:t.slackbot.connectorUid,slackWorkspaceUrl:t.slackbot.workspaceUrl,slackWorkspaceName:t.slackbot.workspaceName}}}}export{addChannels};

package/dist/src/setup/boxes/add-connections.d.ts

@@ -1,34 +1,24 @@
-import { runAddConnection, type ProjectResolution } from "#setup/scaffold/steps/index.js";
+import { ensureConnection } from "#setup/scaffold/index.js";
+import { setupConnectionConnector } from "../connection-connector.js";
+import { type ProjectResolution } from "../project-resolution.js";
 import type { Prompter } from "../prompter.js";
 import { type SetupState } from "../state.js";
 import type { SetupBox } from "../step.js";
-/** Injected for tests; defaults to the real connection engine. */
+/** Injected for tests; defaults to the real scaffold and Connect effects. */
 export interface AddConnectionsDeps {
-    runAddConnection: typeof runAddConnection;
+    ensureConnection: typeof ensureConnection;
+    setupConnectionConnector: typeof setupConnectionConnector;
 }
 export interface AddConnectionsOptions {
-    /** Adapted and handed to the connection engine, which owns the picker. */
+    /** Carries the follow-up log lines and `perform`'s progress output. The box never prompts. */
     prompter: Prompter;
-    /** Skip the picker and scaffold exactly these catalog slugs. */
-    presetConnections?: string[];
     deps?: AddConnectionsDeps;
 }
 /**
- * Which gather face produced the input. `skip` records the face's decision that
- * there is nothing to do (headless with no presets, or an interactive run where
- * no catalog entry is usable without a project), since `shouldRun` is sync and
- * cannot tell the faces apart.
+ * THE CONNECTIONS BOX: executes the {@link ConnectionPlan}s the
+ * select-connections box recorded during the interview. Prompts for nothing —
+ * every decision (slug, protocol, entry, provisioning mode) was resolved at
+ * selection time — and only runs effects: the file scaffold, the follow-up log
+ * lines, and the Connect connector provisioning against the linked project.
  */
-export interface AddConnectionsInput {
-    headless: boolean;
-    skip: boolean;
-}
-/**
- * THE CONNECTIONS BOX. Offers the connection catalog (plus a custom MCP /
- * OpenAPI escape hatch) and scaffolds the selected `agent/connections/*.ts`.
- * Shares the same flow as `eve connections add`: the engine `runAddConnection`
- * owns the picker and custom sub-prompts, so this box is a documented exception
- * to "gather prompts, perform executes" like the add-channels box. Skipped in
- * headless mode unless explicit `presetConnections` were requested.
- */
-export declare function addConnections(options: AddConnectionsOptions): SetupBox<SetupState, AddConnectionsInput, ProjectResolution>;
+export declare function addConnections(options: AddConnectionsOptions): SetupBox<SetupState, null, ProjectResolution>;

package/dist/src/setup/boxes/add-connections.js

@@ -1 +1 @@
-import{hasVercelProject,requireProjectPath}from"../state.js";import{projectIdFromResolution}from"../vercel-project.js";import{CONNECTION_CATALOG}from"#setup/scaffold/index.js";import{isProjectResolved,mergeProjectResolution,runAddConnection}from"#setup/scaffold/steps/index.js";const CONNECT_BACKED_SLUGS=CONNECTION_CATALOG.filter(e=>e.auth.kind===`connect`).map(e=>e.slug),CONNECT_REQUIRES_VERCEL=`Authenticates through Vercel Connect, which needs a Vercel project. Re-run and choose to deploy to Vercel.`,NO_AVAILABLE_CONNECTIONS_TITLE=`All connections require a Vercel project. Skipping.`;function toConnectionPrompter(e){let t=e.log;return{intro:(t,n)=>e.intro(t,n),outro:t=>e.outro(t),multiselect:t=>e.select({multiple:!0,message:t.message,required:t.required,options:t.options.map(e=>({value:e.value,label:e.label,hint:e.hint,disabled:e.disabled}))}),select:t=>e.select({message:t.message,initialValue:t.initialValue,options:t.options.map(e=>({value:e.value,label:e.label,hint:e.hint,disabled:e.disabled}))}),text:t=>e.text({message:t.message,placeholder:t.placeholder,defaultValue:t.initialValue,validate:t.validate}),log:{message:e=>t.message(e),info:e=>t.info(e),success:e=>t.success(e),warning:e=>t.warning(e),error:e=>t.error(e),commandOutput:e=>t.commandOutput(e),spinner:e=>t.spinner?.(e)??{stop(){}},settle:()=>t.settle?.()}}}function hasAvailableCatalogConnection(e){return CONNECTION_CATALOG.some(t=>!(e&&t.auth.kind===`connect`))}function logSkippedConnectionsStep(e){if(e.log.section!==void 0){e.log.section(NO_AVAILABLE_CONNECTIONS_TITLE,[]);return}e.log.info(NO_AVAILABLE_CONNECTIONS_TITLE)}function addConnections(r){let o=r.deps??{runAddConnection};return{id:`add-connections`,async gatherInteractive({state:t}){if((r.presetConnections?.length??0)===0){let n=!hasVercelProject(t);if(n&&!hasAvailableCatalogConnection(n))return logSkippedConnectionsStep(r.prompter),{kind:`done`,input:{headless:!1,skip:!0}}}return{kind:`done`,input:{headless:!1,skip:!1}}},async gatherHeadless(){return{headless:!0,skip:(r.presetConnections?.length??0)===0}},async perform({state:i,input:a}){if(a.skip)return{kind:`unresolved`};let s=requireProjectPath(i),c=!hasVercelProject(i),l=i.project;if(c&&r.presetConnections!==void 0){let e=r.presetConnections.filter(e=>CONNECT_BACKED_SLUGS.includes(e));if(e.length>0)throw Error(`${e.join(`, `)} ${CONNECT_REQUIRES_VERCEL}`)}return await o.runAddConnection({prompter:toConnectionPrompter(r.prompter),projectRoot:s,presetSlugs:r.presetConnections,interactive:!a.headless,disabledConnectionReasons:c?Object.fromEntries(CONNECT_BACKED_SLUGS.map(e=>[e,CONNECT_REQUIRES_VERCEL])):void 0,linkProject:async()=>{if(c)throw Error(CONNECT_REQUIRES_VERCEL);if(!isProjectResolved(l))throw Error(`Expected a linked Vercel project for Connect, but none was resolved.`);return projectIdFromResolution(l)}}),l},apply(e,t){return{...e,project:mergeProjectResolution(e.project,t)}}}}export{addConnections};
+import{isProjectResolved,mergeProjectResolution}from"../project-resolution.js";import{hasVercelProject,requireProjectPath}from"../state.js";import{setupConnectionConnector}from"../connection-connector.js";import{projectIdFromResolution}from"../vercel-project.js";import{CONNECT_REQUIRES_VERCEL}from"./select-connections.js";import{ensureConnection}from"#setup/scaffold/index.js";function logFollowUp(e,t){if(t.action===`skipped`){e.warning(`Skipped ${t.slug} (already exists; pass --force to overwrite).`);return}e.success(`Added agent/connections/${t.slug}.ts`),t.envKeysAdded.length>0?e.info(`Set ${t.envKeysAdded.join(`, `)} in .env.local`):t.envKeysRequired.length>0&&e.info(`Set ${t.envKeysRequired.join(`, `)} in your environment`)}function addConnections(a){let o=a.deps??{ensureConnection,setupConnectionConnector};return{id:`add-connections`,shouldRun(e){return e.connectionSelection.length>0},async gather(){return null},async perform({state:t}){let r=a.prompter.log,i=requireProjectPath(t),s=!hasVercelProject(t),c=t.project;for(let n of t.connectionSelection){let t=await o.ensureConnection({projectRoot:i,slug:n.slug,protocol:n.protocol,entry:n.entry});if(logFollowUp(r,t),t.action!==`skipped`)switch(n.provision.kind){case`connect`:await o.setupConnectionConnector({log:r,projectRoot:i,slug:t.slug,service:n.provision.service,connectionFilePath:t.filePath,linkProject:async()=>{if(s)throw Error(CONNECT_REQUIRES_VERCEL);if(!isProjectResolved(c))throw Error(`Expected a linked Vercel project for Connect, but none was resolved.`);return projectIdFromResolution(c)}});break;case`command-hint`:r.info(`Run \`vercel connect create ${n.provision.service} --name ${t.slug}\`, then set the connector UID in agent/connections/${t.slug}.ts.`);break;case`connect-manual`:r.warning(`Could not determine a Connect service for ${t.slug}. Create the connector manually and set its UID in agent/connections/${t.slug}.ts.`);break;case`none`:break}}return c},apply(e,n){return{...e,project:mergeProjectResolution(e.project,n)}}}}export{addConnections};

package/dist/src/setup/boxes/apply-ai-gateway-credential.d.ts

@@ -20,8 +20,8 @@ export interface ApplyAiGatewayCredentialOptions {
  * after the project link is settled. It carries nothing about the project
  * decision: whether a project is linked is read from `state.project` (set by
  * the link box), and the credential choice is read from `state.aiGateway`
- * (set by the resolve-provisioning box). Neither gather face prompts; `perform`
- * owns all the work: `byok` writes a pasted AI Gateway key, `inherit` pulls the
+ * (set by the resolve-provisioning box). The gather prompts for nothing;
+ * `perform` owns all the work: `byok` writes a pasted AI Gateway key, `inherit` pulls the
  * linked project's OIDC gateway, and `byop` leaves provider credentials to the
  * scaffolded provider block.
  */

package/dist/src/setup/boxes/apply-ai-gateway-credential.js

@@ -1 +1 @@
-import{appendEnv}from"../append-env.js";import{requireProjectPath}from"../state.js";import{runVercelEnvPull}from"../run-vercel-link.js";import{detectAiGatewayResolution}from"./detect-ai-gateway.js";import{join}from"node:path";import{isProjectResolved}from"#setup/scaffold/steps/index.js";import{createPromptCommandOutput}from"#setup/scaffold/cli/index.js";const AI_GATEWAY_ENV_KEY=`AI_GATEWAY_API_KEY`,ENV_FILE_NAME=`.env.local`;function applyAiGatewayCredential(a){let o=a.deps??{appendEnv,runVercelEnvPull,detectAiGatewayResolution};async function writeAiGatewayApiKey(e,t){let n=join(e,ENV_FILE_NAME);await o.appendEnv(n,{[AI_GATEWAY_ENV_KEY]:t.trim()},{force:!0}),a.prompter.log.success(`Wrote ${AI_GATEWAY_ENV_KEY} to ${n}`)}return{id:`apply-ai-gateway-credential`,shouldRun(e){let{aiGateway:t,project:n}=e;return t.kind===`byok`||t.kind===`inherit`&&isProjectResolved(n)},async gatherInteractive(){return{kind:`done`,input:null}},async gatherHeadless(){return null},async perform({state:e}){let{prompter:n}=a,r=requireProjectPath(e),i=e.aiGateway,s=isProjectResolved(e.project);if(i.kind===`byop`)return{kind:`unresolved`};if(i.kind===`byok`)return await writeAiGatewayApiKey(r,i.apiGatewayKey),{kind:`api-key`,envFile:ENV_FILE_NAME};if(!s)return n.log.warning(`No Vercel project linked and no API key provided. The agent will not reach a model until you set ${AI_GATEWAY_ENV_KEY} in ${ENV_FILE_NAME} or link a project.`),{kind:`unresolved`};n.log.message(`Pulling Vercel environment variables into .env.local...`);let c=createPromptCommandOutput(n.log);return await o.runVercelEnvPull(r,c)?n.log.success(`Connected the agent to the Vercel AI Gateway.`):n.log.warning(`Linked the project, but pulling environment variables did not complete.`),o.detectAiGatewayResolution(r)},apply(e,t){return{...e,aiGatewayCredentials:t}}}}export{applyAiGatewayCredential};
+import{appendEnv}from"../append-env.js";import{isProjectResolved}from"../project-resolution.js";import{requireProjectPath}from"../state.js";import{withNetworkSpinner}from"../vercel-project.js";import{runVercelEnvPull}from"../run-vercel-link.js";import{detectAiGatewayResolution}from"./detect-ai-gateway.js";import{join}from"node:path";import{createPromptCommandOutput}from"#setup/cli/index.js";const AI_GATEWAY_ENV_KEY=`AI_GATEWAY_API_KEY`,ENV_FILE_NAME=`.env.local`;function applyAiGatewayCredential(s){let c=s.deps??{appendEnv,runVercelEnvPull,detectAiGatewayResolution};async function writeAiGatewayApiKey(e,t){let n=join(e,ENV_FILE_NAME);await c.appendEnv(n,{[AI_GATEWAY_ENV_KEY]:t.trim()},{force:!0}),s.prompter.log.success(`Wrote ${AI_GATEWAY_ENV_KEY} to ${n}`)}return{id:`apply-ai-gateway-credential`,shouldRun(e){let{aiGateway:n,project:r}=e;return n.kind===`byok`||n.kind===`inherit`&&isProjectResolved(r)},async gather(){return null},async perform({state:e}){let{prompter:i}=s,a=requireProjectPath(e),o=e.aiGateway,l=isProjectResolved(e.project);if(o.kind===`byop`)return{kind:`unresolved`};if(o.kind===`byok`)return await writeAiGatewayApiKey(a,o.apiGatewayKey),{kind:`api-key`,envFile:ENV_FILE_NAME};if(!l)return i.log.warning(`No Vercel project linked and no API key provided. The agent will not reach a model until you set ${AI_GATEWAY_ENV_KEY} in ${ENV_FILE_NAME} or link a project.`),{kind:`unresolved`};let u=createPromptCommandOutput(i.log);return await withNetworkSpinner(i,`Pulling Vercel environment variables into .env.local...`,()=>c.runVercelEnvPull(a,u))?i.log.success(`Connected the agent to the Vercel AI Gateway.`):i.log.warning(`Linked the project, but pulling environment variables did not complete.`),c.detectAiGatewayResolution(a)},apply(e,t){return{...e,aiGatewayCredentials:t}}}}export{applyAiGatewayCredential};

package/dist/src/setup/boxes/deploy-project.d.ts

@@ -1,30 +1,62 @@
-import { deployProject as runDeployProject, type AddToAgentState } from "#setup/scaffold/steps/index.js";
-import type { Prompter } from "../prompter.js";
+import { type ChannelSetupLog } from "#setup/cli/index.js";
+import { detectPackageManager } from "#setup/package-manager.js";
+import { runPackageManagerInstall } from "#setup/primitives/pm/run.js";
+import { runVercel } from "#setup/primitives/run-vercel.js";
+import { detectDeployment, type ProjectResolution } from "../project-resolution.js";
 import { type SetupState } from "../state.js";
 import type { SetupBox } from "../step.js";
-/** Injected for tests; defaults to the real eve-scaffold deploy engine. */
+/** Injected for tests; defaults to the real subprocess primitives. */
 export interface DeployProjectDeps {
-    deployProject: typeof runDeployProject;
+    runVercel: typeof runVercel;
+    detectPackageManager: typeof detectPackageManager;
+    runPackageManagerInstall: typeof runPackageManagerInstall;
+    detectDeployment: typeof detectDeployment;
 }
 export interface DeployProjectOptions {
-    /** Adapted and handed to the deploy engine for its progress output. */
-    prompter: Prompter;
+    /** Deploy progress and command output stream through this log (rail styling preserved). */
+    prompter: {
+        log: ChannelSetupLog;
+    };
     /** Skip the post-channel Vercel deployment entirely (`--no-deploy`). */
     skip?: boolean;
+    /**
+     * Run even without a planned or detected project, linking interactively from
+     * inside `perform` (the `eve channels add` composition; onboarding always has
+     * a plan or skips deploy with the channels).
+     */
+    ensureLinkedProject?: "interactive-vercel-link";
+    /**
+     * Headless mode: gates interactive `vercel` commands inside `perform`. The box
+     * asks no questions, so the dispatch decision the gather faces used to encode
+     * comes from the composition site (the same place that picks the asker base),
+     * not from a prompt.
+     */
+    headless?: boolean;
     deps?: DeployProjectDeps;
 }
 /**
- * Which gather face produced the input. The engine needs the headless flag
- * inside `perform` (it gates interactive `vercel` commands), so the faces
- * record it instead of taking a factory option.
+ * What `perform` consumes. The headless flag gates interactive `vercel`
+ * commands inside `perform`; it is fixed at composition time (the box prompts
+ * for nothing) and passed straight through {@link DeployProjectOptions.headless}.
  */
 export interface DeployProjectInput {
     headless: boolean;
 }
+/** The deploy facts `apply` records: the (re)deployed project and the cleared flags. */
+export interface DeployProjectPayload {
+    project: ProjectResolution;
+    deploymentPending: boolean;
+    deploymentDependenciesInstalled: boolean;
+}
 /**
- * THE DEPLOY BOX. Runs the scaffold engine's deploy once channel setup has
- * marked deployment work pending. The project was linked up front by the
- * link box; `linkProjectForDeployment` reuses that resolution so the deploy
- * never triggers a second interactive `vercel link` (the #1020 deadlock).
+ * THE DEPLOY BOX. Owns the post-channel `vercel deploy --prod` once channel
+ * setup has marked deployment work pending: dependency install (once per
+ * state), the production deploy, the env pull, and the deployment probe.
+ *
+ * The project was linked up front by the link box, so `perform` reuses
+ * `state.project` and never triggers a second interactive `vercel link` (the
+ * #1020 deadlock). When no resolution exists (no link box ran, e.g. the
+ * `eve channels add` composition), it falls back to the interactive bare
+ * `vercel link`, or throws {@link HumanActionRequiredError} headlessly.
  */
-export declare function deployProject(options: DeployProjectOptions): SetupBox<SetupState, DeployProjectInput, AddToAgentState>;
+export declare function deployProject(options: DeployProjectOptions): SetupBox<SetupState, DeployProjectInput, DeployProjectPayload>;

package/dist/src/setup/boxes/deploy-project.js

@@ -1 +1 @@
-import{toChannelSetupPrompter}from"../channel-setup-prompter.js";import{hasVercelProject,requireProjectPath}from"../state.js";import{assignAddToAgentState,deployProject as deployProject$1}from"#setup/scaffold/steps/index.js";function deployProject(a){let o=a.deps??{deployProject:deployProject$1};return{id:`deploy-project`,shouldRun(e){return!a.skip&&hasVercelProject(e)&&e.deploymentPending},async gatherInteractive(){return{kind:`done`,input:{headless:!1}}},async gatherHeadless(){return{headless:!0}},async perform({state:t,input:r}){let i=requireProjectPath(t),s=t.project;return o.deployProject({projectPath:i,prompter:toChannelSetupPrompter(a.prompter),state:t,headless:r.headless,linkProjectForDeployment:async()=>s})},apply(e,t){let n={...e};return assignAddToAgentState(n,t),n}}}export{deployProject};
+import{detectDeployment,isProjectResolved,mergeProjectResolution,projectResolutionFromDeployResult,projectResolutionFromDeployment}from"../project-resolution.js";import{hasVercelProject,requireProjectPath}from"../state.js";import{detectPackageManager}from"#setup/package-manager.js";import{HumanActionRequiredError}from"#setup/human-action.js";import{createPromptCommandOutput}from"#setup/cli/index.js";import{runPackageManagerInstall}from"#setup/primitives/pm/run.js";import{runVercel}from"#setup/primitives/run-vercel.js";const VERCEL_DEPLOY_ENV={VERCEL_USE_EXPERIMENTAL_FRAMEWORKS:`1`};function deployProject(o){let s=o.deps??{runVercel,detectPackageManager,runPackageManagerInstall,detectDeployment};return{id:`deploy-project`,shouldRun(e){return o.skip||!e.deploymentPending?!1:hasVercelProject(e)||o.ensureLinkedProject===`interactive-vercel-link`},async gather(){return{headless:o.headless??!1}},async perform({state:e,input:n}){let r=requireProjectPath(e),{log:i}=o.prompter,a=createPromptCommandOutput(i),c=e.project;if(!isProjectResolved(c)){if(n.headless)throw new HumanActionRequiredError({kind:`vercel-link`,command:`vercel link`,reason:`Deployment needs this directory linked to a Vercel project.`});if(i.message(`Linking this directory to a Vercel project before deployment...`),!await s.runVercel([`link`],{cwd:r})||(c=mergeProjectResolution(c,projectResolutionFromDeployment(await s.detectDeployment(r))),!isProjectResolved(c)))throw Error(`Vercel project linking failed. Deployment did not start.`)}if(!e.deploymentDependenciesInstalled){let e=await s.detectPackageManager(r);if(i.message(`Installing project dependencies before deployment (${e.kind} install)...`),!await s.runPackageManagerInstall(e.kind,r,{onOutput:a}))throw Error(`Dependency installation failed. Deployment did not start.`)}i.message(`Deploying the agent to Vercel production...`);let l=n.headless?[`deploy`,`--prod`,`--yes`,`--non-interactive`]:[`deploy`,`--prod`,`--yes`];if(!await s.runVercel(l,{cwd:r,extraEnv:VERCEL_DEPLOY_ENV,nonInteractive:n.headless,onOutput:a}))throw i.error("`vercel deploy --prod` failed. The deploy output above shows the cause; fix it, then run `vercel deploy --prod` to retry."),Error(`Deployment failed after channel setup.`);i.message(`Pulling Vercel environment variables into .env.local...`),await s.runVercel([`env`,`pull`,`--yes`],{cwd:r,nonInteractive:n.headless,onOutput:a})||i.warning(`Deployment succeeded, but pulling Vercel environment variables did not complete.`);let u=await s.detectDeployment(r),d=u.state===`deployed`?u.productionUrl:void 0;return d===void 0?i.warning(`Deployment succeeded, but Eve could not verify its production URL.`):i.info(`Production URL: ${d}`),{project:projectResolutionFromDeployResult(c,{deployed:!0,productionUrl:d}),deploymentPending:!1,deploymentDependenciesInstalled:!0}},apply(e,t){return{...e,project:t.project,deploymentPending:t.deploymentPending,deploymentDependenciesInstalled:t.deploymentDependenciesInstalled}}}}export{deployProject};

package/dist/src/setup/boxes/detect-ai-gateway.d.ts

@@ -1,10 +1,17 @@
-import { type ResolvedAiGatewayCredentials, type SetupState } from "../state.js";
+import { type AiGatewayEnvFile, type ResolvedAiGatewayCredentials, type SetupState } from "../state.js";
 import type { SetupBox } from "../step.js";
+/**
+ * Returns the first env file (`.env.local`, then `.env`) defining a non-empty
+ * value for `key`, or `undefined` when neither does. Exported for flows that
+ * verify credentials landed after a `vercel env pull` (the `eve link` flow
+ * checks both `VERCEL_OIDC_TOKEN` and `AI_GATEWAY_API_KEY`).
+ */
+export declare function findEnvFileWithKey(projectRoot: string, key: string): Promise<AiGatewayEnvFile | undefined>;
 export declare function detectAiGatewayResolution(projectRoot: string): Promise<ResolvedAiGatewayCredentials>;
 /**
  * THE AI GATEWAY DETECTION BOX: reads the scaffolded project's `.env.local` and
  * `.env` for an existing `AI_GATEWAY_API_KEY` so the credential step can skip
- * work already done. Pure detection: it prompts for nothing on either face, so
- * the gather faces produce an empty input.
+ * work already done. Pure detection: it prompts for nothing, so the single
+ * gather produces an empty input in every mode.
  */
 export declare function detectAiGateway(): SetupBox<SetupState, null, ResolvedAiGatewayCredentials>;

package/dist/src/setup/boxes/detect-ai-gateway.js

@@ -1,2 +1,2 @@
 import{requireProjectPath}from"../state.js";import{join}from"node:path";import{readFile}from"node:fs/promises";const ENV_FILE_CANDIDATES=[`.env.local`,`.env`];function readEnvValue(e,t){let n=e.trim();if(n.length===0||n.startsWith(`#`)||!n.startsWith(`${t}=`))return;let r=n.slice(t.length+1);if(r.length===0)return;let i=r.length>=2&&r.startsWith(`"`)&&r.endsWith(`"`)?r.slice(1,-1):r;return i.length===0?void 0:i}async function hasApiKeyInFile(e,t){let r;try{r=await readFile(e,`utf8`)}catch{return!1}for(let e of r.split(`
-`))if(readEnvValue(e,t)!==void 0)return!0;return!1}async function detectApiKey(e){for(let n of ENV_FILE_CANDIDATES)if(await hasApiKeyInFile(join(e,n),`AI_GATEWAY_API_KEY`))return n}async function detectAiGatewayResolution(e){let t=await detectApiKey(e);return t===void 0?{kind:`unresolved`}:{kind:`api-key`,envFile:t}}function detectAiGateway(){return{id:`detect-ai-gateway`,shouldRun(e){return e.projectPath.kind===`resolved`},async gatherInteractive(){return{kind:`done`,input:null}},async gatherHeadless(){return null},async perform({state:t}){return detectAiGatewayResolution(requireProjectPath(t))},apply(e,t){return{...e,aiGatewayCredentials:t}}}}export{detectAiGateway,detectAiGatewayResolution};
+`))if(readEnvValue(e,t)!==void 0)return!0;return!1}async function findEnvFileWithKey(e,n){for(let i of ENV_FILE_CANDIDATES)if(await hasApiKeyInFile(join(e,i),n))return i}async function detectAiGatewayResolution(e){let t=await findEnvFileWithKey(e,`AI_GATEWAY_API_KEY`);return t===void 0?{kind:`unresolved`}:{kind:`api-key`,envFile:t}}function detectAiGateway(){return{id:`detect-ai-gateway`,shouldRun(e){return e.projectPath.kind===`resolved`},async gather(){return null},async perform({state:t}){return detectAiGatewayResolution(requireProjectPath(t))},apply(e,t){return{...e,aiGatewayCredentials:t}}}}export{detectAiGateway,detectAiGatewayResolution,findEnvFileWithKey};

package/dist/src/setup/boxes/link-project.d.ts

@@ -1,8 +1,8 @@
-import { type ProjectResolution } from "#setup/scaffold/steps/index.js";
+import { detectProjectResolution, type ProjectResolution } from "../project-resolution.js";
 import type { Prompter } from "../prompter.js";
 import { type SetupState } from "../state.js";
 import type { SetupBox } from "../step.js";
-import { detectProjectResolution, linkProject, resolveProjectByNameOrId, unresolvedProject } from "../vercel-project.js";
+import { linkProject, resolveProjectByNameOrId, unresolvedProject } from "../vercel-project.js";
 /** Injected for tests; defaults to the real Vercel project helpers. */
 export interface LinkProjectDeps {
     linkProject: typeof linkProject;
@@ -18,7 +18,7 @@ export interface LinkProjectOptions {
 /**
  * THE PROJECT BOX. Executes the resolved Vercel project plan after scaffolding,
  * once the project directory exists (so `vercel link` can write `.vercel/`).
- * Neither gather face prompts: every decision was made up front by the
+ * The gather prompts for nothing: every decision was made up front by the
  * resolve-provisioning box, so `perform` owns all the work.
  *
  * The plan is authoritative. The box always re-links to the planned project so

package/dist/src/setup/boxes/link-project.js

@@ -1 +1 @@
-import{requireProjectPath}from"../state.js";import{detectProjectResolution,linkProject,resolveProjectByNameOrId,unresolvedProject}from"../vercel-project.js";import{mergeProjectResolution}from"#setup/scaffold/steps/index.js";import{createPromptCommandOutput}from"#setup/scaffold/cli/index.js";function linkVercelProject(o){let s=o.deps??{linkProject,detectProjectResolution,resolveProjectByNameOrId,unresolvedProject};return{id:`link-project`,shouldRun(e){return e.vercelProject.kind!==`none`},async gatherInteractive(){return{kind:`done`,input:null}},async gatherHeadless(){return null},async perform({state:t}){let n=t.vercelProject;if(n.kind===`none`)return s.unresolvedProject();let r=requireProjectPath(t),i=createPromptCommandOutput(o.prompter.log);if(!await s.linkProject(o.prompter,r,n,i))throw Error("Vercel project provisioning did not complete. Run `vercel link` manually, or re-run and choose not to deploy to Vercel.");let a=await s.detectProjectResolution(r);if(a.kind===`unresolved`)throw Error(`Linked the directory, but could not resolve the Vercel project from .vercel/project.json.`);let c=await s.resolveProjectByNameOrId(r,n.team,n.project);if(c===null||a.projectId!==c.id)throw Error(`Linked project identity did not match the planned Vercel project "${n.project}".`);return a},apply(e,t){return{...e,project:mergeProjectResolution(e.project,t)}}}}export{linkVercelProject};
+import{detectProjectResolution,mergeProjectResolution}from"../project-resolution.js";import{requireProjectPath}from"../state.js";import{linkProject,resolveProjectByNameOrId,unresolvedProject}from"../vercel-project.js";import{createPromptCommandOutput}from"#setup/cli/index.js";function linkVercelProject(o){let s=o.deps??{linkProject,detectProjectResolution,resolveProjectByNameOrId,unresolvedProject};return{id:`link-project`,shouldRun(e){return e.vercelProject.kind!==`none`},async gather(){return null},async perform({state:e}){let t=e.vercelProject;if(t.kind===`none`)return s.unresolvedProject();let r=requireProjectPath(e),i=createPromptCommandOutput(o.prompter.log);if(!await s.linkProject(o.prompter,r,t,i))throw Error("Vercel project provisioning did not complete. Run `vercel link` manually, or re-run and choose not to deploy to Vercel.");let a=await s.detectProjectResolution(r);if(a.kind===`unresolved`)throw Error(`Linked the directory, but could not resolve the Vercel project from .vercel/project.json.`);let c=await s.resolveProjectByNameOrId(r,t.team,t.project);if(c===null||a.projectId!==c.id)throw Error(`Linked project identity did not match the planned Vercel project "${t.project}".`);return a},apply(e,n){return{...e,project:mergeProjectResolution(e.project,n)}}}}export{linkVercelProject};

package/dist/src/setup/boxes/one-shot-next-steps.d.ts

@@ -0,0 +1,18 @@
+import { detectPackageManager } from "../package-manager.js";
+import type { Prompter } from "../prompter.js";
+import { type SetupState } from "../state.js";
+import type { SetupBox } from "../step.js";
+export interface OneShotNextStepsOptions {
+    /** Reports the next-steps note. The box never prompts. */
+    prompter: Prompter;
+    /** Test seam for the package manager that owns generated commands. */
+    detectPackageManager?: typeof detectPackageManager;
+}
+/**
+ * THE ONE-SHOT EPILOGUE BOX: a one-shot run skips every post-scaffold box, so
+ * it ends here with exactly the commands that take the scaffold to a running
+ * agent. No project or team was resolved, so `vercel link` is the credential
+ * step: a logged-in CLI plus the link lets the runtime mint an AI Gateway
+ * token, and pasting a key into `.env.local` is the manual alternative.
+ */
+export declare function oneShotNextSteps(options: OneShotNextStepsOptions): SetupBox<SetupState, null, null>;

package/dist/src/setup/boxes/one-shot-next-steps.js

@@ -0,0 +1,2 @@
+import{__toESM}from"../../_virtual/_rolldown/runtime.js";import{require_picocolors}from"../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js";import{requireProjectPath}from"../state.js";import{detectPackageManager}from"../package-manager.js";import{relative}from"node:path";var import_picocolors=__toESM(require_picocolors(),1);function cdTarget(e){let t=relative(process.cwd(),e);return t.length===0||t.startsWith(`..`)?e:t}function step(e,t){return`  ${import_picocolors.default.bold(e)}${t===void 0?``:` ${import_picocolors.default.dim(`# ${t}`)}`}`}function oneShotNextSteps(e){return{id:`one-shot-next-steps`,shouldRun(e){return e.setupMode===`one-shot`},async gather(){return null},async perform({state:t}){let n=requireProjectPath(t),r=await(e.detectPackageManager??detectPackageManager)(n),i=[`Your agent is scaffolded but not deployed or connected yet.`,...t.projectPath.inPlace?[]:[step(`cd ${cdTarget(n)}`)],step(`${r.kind} install`),step(`vercel link`,`or set AI_GATEWAY_API_KEY in .env.local manually`),step(`eve dev`)];return e.prompter.note(i.join(`
+`),`Next steps`,{tone:`success`}),null},apply(e){return e}}}export{oneShotNextSteps};

package/dist/src/setup/boxes/preflight.d.ts

@@ -2,9 +2,8 @@ import { fetchGatewayModelIds } from "../gateway-models.js";
 import type { SetupState } from "../state.js";
 import type { SetupBox } from "../step.js";
 /**
- * What the headless face decided to validate. `model: null` means nothing to
- * validate: interactive runs pick from the gateway-backed catalog, and
- * self-managed provider wiring never routes through the Gateway.
+ * What the gather decided to validate. `model: null` means nothing to
+ * validate: interactive runs pick from the gateway-backed catalog already.
  */
 export interface PreflightInput {
     /** Model id to validate against the AI Gateway catalog, or null to skip. */
@@ -17,13 +16,22 @@ export interface PreflightDeps {
 export interface PreflightOptions {
     /** Directory to run `vercel` from: the project's parent (it does not exist yet). */
     cwd: string;
+    /**
+     * Headless mode: only a headless `--model` needs catalog validation, so the
+     * gather derives a model to check from state. Interactive runs pick from the
+     * gateway-backed catalog and validate nothing. The box prompts for nothing,
+     * so this dispatch comes from the composition site, not from a question.
+     */
+    headless?: boolean;
     deps?: PreflightDeps;
 }
 /**
  * THE PREFLIGHT BOX: fails fast on an unknown `--model` BEFORE any filesystem
  * scaffolding, so a bad flag never leaves a half-provisioned project on disk.
- * Only a headless `--model` needs the gateway round-trip when the resolved
- * wiring uses Gateway, so the interactive face gathers a no-op input. Team
- * validation lives in the resolve-provisioning box.
+ * Only a headless `--model` needs the gateway round-trip, so the interactive
+ * gather yields a no-op input. The scaffold bakes a gateway-format model id
+ * on every wiring (the `byok` block routes through the Gateway too), so the
+ * check applies regardless of how credentials are wired. Team validation
+ * lives in the resolve-provisioning box.
  */
 export declare function preflight(options: PreflightOptions): SetupBox<SetupState, PreflightInput, null>;

package/dist/src/setup/boxes/preflight.js

@@ -1 +1 @@
-import{fetchGatewayModelIds}from"../gateway-models.js";function preflight(t){let n=t.deps??{fetchGatewayModelIds};return{id:`preflight`,async gatherInteractive(){return{kind:`done`,input:{model:null}}},async gatherHeadless({state:e}){return{model:e.modelWiring===`gateway`?e.modelId:null}},async perform({input:e}){return e.model!==null&&await validateModel(n,e.model,t.cwd),null},apply(e){return e}}}async function validateModel(e,t,n){let r=await e.fetchGatewayModelIds(n);if(!(r===null||r.has(t)))throw Error(`Model "${t}" is not in the AI Gateway catalog. Pass a model id from https://ai-gateway.vercel.sh/v1/models (e.g. anthropic/claude-sonnet-4.6).`)}export{preflight};
+import{fetchGatewayModelIds}from"../gateway-models.js";function preflight(t){let n=t.deps??{fetchGatewayModelIds};return{id:`preflight`,async gather({state:e}){return t.headless?{model:e.modelId.length>0?e.modelId:null}:{model:null}},async perform({input:e}){return e.model!==null&&await validateModel(n,e.model,t.cwd),null},apply(e){return e}}}async function validateModel(e,t,n){let r=await e.fetchGatewayModelIds(n);if(!(r===null||r.has(t)))throw Error(`Model "${t}" is not in the AI Gateway catalog. Pass a model id from https://ai-gateway.vercel.sh/v1/models (e.g. anthropic/claude-sonnet-4.6).`)}export{preflight};

package/dist/src/setup/boxes/resolve-provisioning.d.ts

@@ -1,10 +1,16 @@
+import { type Asker } from "../ask.js";
+import { pathExists } from "../path-exists.js";
+import { detectProjectResolution, type ProjectResolution } from "../project-resolution.js";
 import type { Prompter } from "../prompter.js";
 import type { ProvisioningMode, ResolvedAiGateway, ResolvedVercelProject, SetupState, WiringMode } from "../state.js";
 import type { SetupBox } from "../step.js";
-import { assertNewProjectNameAvailable, pickNewProjectName, pickProject, pickTeam, requireAuth, resolveTeam, validateTeam } from "../vercel-project.js";
-/** Injected for tests; defaults to the real Vercel project helpers. */
+import { assertNewProjectNameAvailable, isVercelAuthenticated, pickNewProjectName, pickProject, pickTeam, requireAuth, resolveTeam, validateTeam } from "../vercel-project.js";
+/** Injected for tests; defaults to the real Vercel project and fs helpers. */
 export interface ResolveProvisioningDeps {
     requireAuth: typeof requireAuth;
+    isVercelAuthenticated: typeof isVercelAuthenticated;
+    detectProjectResolution: typeof detectProjectResolution;
+    pathExists: typeof pathExists;
     validateTeam: typeof validateTeam;
     resolveTeam: typeof resolveTeam;
     pickTeam: typeof pickTeam;
@@ -13,12 +19,26 @@ export interface ResolveProvisioningDeps {
     assertNewProjectNameAvailable: typeof assertNewProjectNameAvailable;
 }
 export interface ResolveProvisioningOptions {
-    /** Drives the interactive prompts, and progress/spinner output headlessly. */
+    /** Resolves the provisioning-tree questions; the composed stack decides how. */
+    asker: Asker;
+    /**
+     * Still drives the Vercel reads that validate a decision (team/project
+     * pickers, auth, name availability) and carries the spinner/progress log. The
+     * deploy-tree questions themselves now travel the asker.
+     */
     prompter: Prompter;
     /** Parent directory the project folder is created inside. Defaults to cwd. */
     targetDirectory?: string;
     /** Headless flags vs interactive prompts. The args are read only when headless. */
     mode: ProvisioningMode;
+    /**
+     * Whether a detected on-disk link short-circuits the interview. Defaults to
+     * true — an in-place setup adopts the link it finds. False skips adoption so
+     * the team/project pickers always run: the re-link path's whole point is
+     * choosing a different project, so re-adopting the current link would be a
+     * dead end.
+     */
+    adoptExistingLink?: boolean;
     deps?: ResolveProvisioningDeps;
 }
 /** Both provisioning plans plus the model wiring they imply. Input and payload. */
@@ -26,12 +46,20 @@ export interface ResolvedProvisioning {
     vercelProject: ResolvedVercelProject;
     aiGateway: ResolvedAiGateway;
     modelWiring: WiringMode;
+    /**
+     * The detected on-disk link when the target directory is already linked to
+     * a Vercel project. Adopted instead of planning a project: the link is the
+     * source of truth, so the project plan stays `none` (nothing to create or
+     * link) and this resolution seeds `state.project`, exactly as in-project
+     * setup models the same fact.
+     */
+    project?: ProjectResolution;
 }
 /**
- * THE PROVISIONING BOX (Q3): resolves the Vercel project plan and gateway
- * credential plan after the target box has produced the shared agent name, but
- * before any filesystem writes or `vercel link` side effects. Gather owns every
- * decision (and the Vercel reads validating it); `perform` passes the plan
- * through untouched so `apply` can record it.
+ * THE PROVISIONING BOX: the last interview decision — where the agent runs —
+ * made after the agent itself is described (name, model, channels,
+ * connections) and before any filesystem writes or `vercel link` side
+ * effects. Gather owns every decision (and the Vercel reads validating it);
+ * `perform` passes the plan through untouched so `apply` can record it.
  */
 export declare function resolveProvisioning(options: ResolveProvisioningOptions): SetupBox<SetupState, ResolvedProvisioning, ResolvedProvisioning>;

package/dist/src/setup/boxes/resolve-provisioning.js

@@ -1 +1 @@
-import{assertNewProjectNameAvailable,pickNewProjectName,pickProject,pickTeam,requireAuth,resolveTeam,validateTeam}from"../vercel-project.js";import{resolve}from"node:path";function resolveProvisioning(o){let s=o.deps??{requireAuth,validateTeam,resolveTeam,pickTeam,pickProject,pickNewProjectName,assertNewProjectNameAvailable},parent=()=>resolve(o.targetDirectory??process.cwd());async function plansFromFlags(e,t,n){if(t.skipVercel)return n.apiKey===void 0?{vercelProject:{kind:`none`},aiGateway:{kind:`byop`},modelWiring:`self`}:{vercelProject:{kind:`none`},aiGateway:{kind:`byok`,apiGatewayKey:n.apiKey},modelWiring:`gateway`};if(t.team===void 0||t.team.length===0)throw Error(`Headless Vercel provisioning requires --team <slug> or --scope <slug> so the current CLI scope is not applied silently.`);await s.requireAuth(parent()),await s.validateTeam(o.prompter,parent(),t.team);let r=await s.resolveTeam(parent(),t.team),i=n.apiKey===void 0?{kind:`inherit`}:{kind:`byok`,apiGatewayKey:n.apiKey},a=t.project===void 0?{kind:`new`,project:e,team:r}:{kind:`existing`,project:t.project,team:r};return a.kind===`new`&&await s.assertNewProjectNameAvailable(parent(),r,a.project),{vercelProject:a,aiGateway:i,modelWiring:`gateway`}}async function promptPlans(e){let t=o.prompter;if(await t.select({message:`Deploy this agent to Vercel?`,options:[{value:!0,label:`Yes`,description:`Fastest path to production`},{value:!1,label:`No`,description:`Set up locally and wire yourself`}],initialValue:!0})){await s.requireAuth(parent(),t);let n=await s.pickTeam(t,parent(),void 0);if(await t.select({message:`Vercel project`,options:[{value:`new`,label:`Create a new project named "${e}"`},{value:`link`,label:`Link an existing project`}],initialValue:`new`})===`new`)return{vercelProject:{kind:`new`,project:await s.pickNewProjectName(t,parent(),n,e),team:n},aiGateway:{kind:`inherit`},modelWiring:`gateway`};let r=await s.pickProject(t,parent(),n);return{vercelProject:{kind:r.exists?`existing`:`new`,project:r.project,team:n},aiGateway:{kind:`inherit`},modelWiring:`gateway`}}return await t.select({message:`How do you want to wire the model provider credentials?`,options:[{value:`api-key`,label:`Use my own AI Gateway API key`,description:`AI_GATEWAY_API_KEY`},{value:`local`,label:`Use my own provider API key`,description:`e.g., OPENAI_API_KEY`}],initialValue:`api-key`})===`api-key`?{vercelProject:{kind:`none`},aiGateway:{kind:`byok`,apiGatewayKey:await t.password({message:`Enter your AI_GATEWAY_API_KEY`,validate:e=>e.trim().length===0?`API key cannot be empty.`:void 0})},modelWiring:`gateway`}:{vercelProject:{kind:`none`},aiGateway:{kind:`byop`},modelWiring:`self`}}return{id:`resolve-provisioning`,async gatherInteractive({state:e}){return{kind:`done`,input:await promptPlans(e.agentName)}},async gatherHeadless({state:e}){if(!o.mode.headless)throw Error(`resolve-provisioning ran headless without headless provisioning flags; compose the box with mode.headless = true.`);return plansFromFlags(e.agentName,o.mode.project,o.mode.aiGateway)},async perform({input:e}){return e},apply(e,t){return{...e,vercelProject:t.vercelProject,aiGateway:t.aiGateway,modelWiring:t.modelWiring}}}}export{resolveProvisioning};
+import{select,text}from"../ask.js";import{detectProjectResolution,isProjectResolved,mergeProjectResolution}from"../project-resolution.js";import{assertNewProjectNameAvailable,isVercelAuthenticated,pickNewProjectName,pickProject,pickTeam,requireAuth,resolveTeam,validateTeam,withNetworkSpinner}from"../vercel-project.js";import{pathExists}from"../path-exists.js";import{join,resolve}from"node:path";import{byokProviderEnvVar}from"#setup/scaffold/index.js";import{whimsyFor}from"#setup/cli/index.js";function vercelDemands(e){return{slack:e.channelSelection.includes(`slack`),connectSlugs:e.connectionSelection.filter(e=>e.entry.auth?.kind===`connect`).map(e=>e.slug)}}function connectClause(e){let t=e.length===1?`authenticates`:`authenticate`;return`${e.join(`, `)} ${t} through Vercel Connect`}function vercelRequirements(e){let t=[];return e.slack&&t.push(`Slack needs a public URL`),e.connectSlugs.length>0&&t.push(connectClause(e.connectSlugs)),t}function resolveProvisioning(c){let l=c.deps??{requireAuth,isVercelAuthenticated,detectProjectResolution,pathExists,validateTeam,resolveTeam,pickTeam,pickProject,pickNewProjectName,assertNewProjectNameAvailable},parent=()=>resolve(c.targetDirectory??process.cwd());async function detectAdoptableLink(e){if(e.projectPath.kind!==`resolved`)return;let t=e.projectPath.path;if(await l.pathExists(join(t,`.vercel`,`project.json`)))return withNetworkSpinner(c.prompter,whimsyFor(`project-detect`),async()=>{let e=await l.detectProjectResolution(t);if(isProjectResolved(e)&&await l.isVercelAuthenticated(t))return e})}async function plansFromFlags(e,t,n){if(t.skipVercel)return n.apiKey===void 0?{vercelProject:{kind:`none`},aiGateway:{kind:`byop`},modelWiring:`self`}:{vercelProject:{kind:`none`},aiGateway:{kind:`byok`,apiGatewayKey:n.apiKey},modelWiring:`gateway`};if(t.team===void 0||t.team.length===0)throw Error(`Headless Vercel provisioning requires --team <slug> or --scope <slug> so the current CLI scope is not applied silently.`);await l.requireAuth(parent()),await l.validateTeam(c.prompter,parent(),t.team);let r=await l.resolveTeam(parent(),t.team),i=n.apiKey===void 0?{kind:`inherit`}:{kind:`byok`,apiGatewayKey:n.apiKey},a=t.project===void 0?{kind:`new`,project:e,team:r}:{kind:`existing`,project:t.project,team:r};return a.kind===`new`&&await l.assertNewProjectNameAvailable(parent(),r,a.project),{vercelProject:a,aiGateway:i,modelWiring:`gateway`}}async function promptPlans(n){let r=c.prompter,i=n.agentName,a=c.adoptExistingLink===!1?void 0:await detectAdoptableLink(n);if(a!==void 0)return r.log.info(`This directory is already linked to a Vercel project, so your agent will run there — the AI Gateway authenticates through your Vercel login.`),{vercelProject:{kind:`none`},aiGateway:{kind:`inherit`},modelWiring:`gateway`,project:a};let o=vercelRequirements(vercelDemands(n)),s=!0;if(o.length>0?r.log.info(`${o.join(` and `)}, so your agent will run on Vercel.`):s=await c.asker.ask(select({key:`deploy`,message:`Where should your agent run?`,options:[{id:`vercel`,value:!0,label:`On Vercel`,hint:`AI Gateway, Durable Workflow, Sandbox, and more`},{id:`local`,value:!1,label:`Locally for now`,hint:`run with eve dev, deploy any time later`}],recommended:!0,required:!0})),s){await l.requireAuth(parent(),r);let t=await l.pickTeam(r,parent(),void 0);if(await c.asker.ask(select({key:`vercel-project`,message:`Vercel project`,options:[{id:`new`,value:`new`,label:`Create a new project`,hint:`Named '${i}'`},{id:`link`,value:`link`,label:`Link an existing project`}],recommended:`new`,required:!0}))===`new`)return{vercelProject:{kind:`new`,project:await l.pickNewProjectName(r,parent(),t,i),team:t},aiGateway:{kind:`inherit`},modelWiring:`gateway`};let n=await l.pickProject(r,parent(),t);return{vercelProject:{kind:n.exists?`existing`:`new`,project:n.project,team:t},aiGateway:{kind:`inherit`},modelWiring:`gateway`}}return await c.asker.ask(select({key:`credential`,message:`How should your agent reach the model?`,options:[{id:`api-key`,value:`api-key`,label:`Use my own AI Gateway API key`,hint:`AI_GATEWAY_API_KEY`},{id:`local`,value:`local`,label:`Use my own provider API key`,hint:byokProviderEnvVar(n.modelId)}],recommended:`api-key`,required:!0}))===`api-key`?{vercelProject:{kind:`none`},aiGateway:{kind:`byok`,apiGatewayKey:await c.asker.ask(text({key:`gateway-api-key`,message:`Enter your AI_GATEWAY_API_KEY`,sensitive:!0,validate:e=>e.trim().length===0?`API key cannot be empty.`:null,required:!0}))},modelWiring:`gateway`}:{vercelProject:{kind:`none`},aiGateway:{kind:`byop`},modelWiring:`self`}}return{id:`resolve-provisioning`,async gather({state:e}){if(c.mode.headless){let t=await plansFromFlags(e.agentName,c.mode.project,c.mode.aiGateway);if(t.vercelProject.kind===`none`){let t=vercelDemands(e);if(t.slack)throw Error(`Slack requires a Vercel project. Remove --skip-vercel to add Slack.`);if(t.connectSlugs.length>0)throw Error(`${connectClause(t.connectSlugs)}, which needs a Vercel project. Remove --skip-vercel to add ${t.connectSlugs.length===1?`it`:`them`}.`)}return t}return promptPlans(e)},async perform({input:e}){return e},apply(e,t){return{...e,vercelProject:t.vercelProject,aiGateway:t.aiGateway,modelWiring:t.modelWiring,project:t.project===void 0?e.project:mergeProjectResolution(e.project,t.project)}}}}export{resolveProvisioning};