eve 0.75.1 → 0.76.0

package/dist/src/setup/slack-connect-lifecycle.d.ts

@@ -1,21 +1,13 @@
-import { type ConnectTriggerAttachmentResult } from "#setup/connect-provisioning.js";
 import { createPromptCommandOutput, type ChannelSetupLog } from "#setup/cli/index.js";
 import { captureVercel, runVercel } from "#setup/primitives/run-vercel.js";
-import { type RawSlackConnector, type SlackConnectorDetails, type SlackConnectorRef, type SlackWorkspaceConnection } from "./slack-connect.js";
+import { type SlackConnectorDetails, type SlackConnectorRef, type SlackWorkspaceConnection } from "./slack-connect.js";
+import type { SlackConnectorCandidate, SlackRoutingPlan } from "./slack-setup-plan.js";
 export declare const CONNECT_LOOKUP_TIMEOUT_MS = 60000;
-/** Connect subprocess operations needed to inventory and remove Slack connectors. */
+/** Connect subprocess operations needed to inspect and remove Slack connectors. */
 export interface SlackConnectLifecycleDeps {
     captureVercel: typeof captureVercel;
     runVercel: typeof runVercel;
 }
-type SlackConnectorInventory = {
-    state: "ok";
-    body: unknown;
-    connectors: readonly RawSlackConnector[];
-} | {
-    state: "failed";
-    message: string;
-};
 export type SlackConnectorCleanupResult = {
     state: "clean";
 } | {
@@ -23,43 +15,96 @@ export type SlackConnectorCleanupResult = {
     connectorUids: readonly string[];
 };
 type CommandOutput = ReturnType<typeof createPromptCommandOutput>;
+type LookupFailure = {
+    state: "failed";
+    message: string;
+};
 /** Shared dependencies and output routing for one connector cleanup operation. */
 interface SlackConnectorCleanupContext {
     log: ChannelSetupLog;
     deps: SlackConnectLifecycleDeps;
     projectRoot: string;
+    orgId: string | undefined;
     onOutput: CommandOutput;
 }
-/** Reads and validates the account-level Slack connector inventory. */
-export declare function listSlackConnectors(deps: SlackConnectLifecycleDeps, projectRoot: string, onOutput: CommandOutput, signal?: AbortSignal): Promise<SlackConnectorInventory>;
-export type SlackConnectorLookup = {
-    state: "found";
-    connectors: readonly SlackConnectorRef[];
-    preferred?: SlackConnectorRef;
-    connectorUids: ReadonlySet<string>;
-} | {
-    state: "not-found";
-    connectorUids: ReadonlySet<string>;
-} | {
-    state: "failed";
-    message: string;
-};
-/** Lists Slack connectors attached to the linked project and identifies the expected UID. */
-export declare function findSlackConnector(deps: SlackConnectLifecycleDeps, projectRoot: string, projectId: string | undefined, expectedUid: string | undefined, onOutput: CommandOutput, signal?: AbortSignal): Promise<SlackConnectorLookup>;
+export type SlackConnectorInspection = {
+    state: "ok";
+    /** Connectors attached to this project or found by UID, with details. */
+    candidates: readonly SlackConnectorCandidate[];
+} | LookupFailure;
+/**
+ * Read-only snapshot of the Slack connectors that matter to the linked
+ * project: those attached to it, plus `namedUids` looked up directly. Each
+ * carries its attachment, workspace installation, and trigger destination.
+ * Any unreadable connector fails the whole snapshot so setup never guesses.
+ */
+export declare function inspectSlackConnectors(input: {
+    deps: SlackConnectLifecycleDeps;
+    projectRoot: string;
+    projectId: string;
+    orgId: string | undefined;
+    /**
+     * UIDs to look up even when this project isn't attached: the channel
+     * file's connector and `slack/<slug>`, the names a connector made for this
+     * agent would carry. No other unattached connector is ever reused.
+     */
+    namedUids: ReadonlySet<string>;
+    onOutput: CommandOutput;
+    signal?: AbortSignal;
+}): Promise<SlackConnectorInspection>;
+/** Rechecks the chosen connector before changing its project access or destinations. */
+export declare function refreshSlackCandidate(input: {
+    deps: SlackConnectLifecycleDeps;
+    projectRoot: string;
+    candidate: SlackConnectorCandidate;
+    projectId: string;
+    orgId: string | undefined;
+    onOutput: CommandOutput;
+    signal?: AbortSignal;
+}): Promise<{
+    state: "ok";
+    candidate: SlackConnectorCandidate;
+} | LookupFailure>;
 /**
- * Outcome of pointing a connector's trigger destination at this project's eve
- * route. Detach and attach are reported separately because attach must not run
- * while an old trigger destination may still exist. A `detach-failed` connector
- * is left in a known-stale state the caller surfaces with manual recovery steps.
+ * Picks the `--name` for a new connector: `slug`, then `slug-2`, `slug-3`,
+ * and so on. Connect derives the UID `slack/<name>` from it, and a UID a
+ * team connector already uses fails the create, so each name is checked by
+ * looking its UID up directly.
  */
-type SlackConnectorAttachmentResult = ConnectTriggerAttachmentResult;
+export declare function findFreeSlackConnectorName(input: {
+    deps: Pick<SlackConnectLifecycleDeps, "captureVercel">;
+    projectRoot: string;
+    orgId: string | undefined;
+    slug: string;
+    onOutput: CommandOutput;
+    signal?: AbortSignal;
+}): Promise<{
+    state: "ok";
+    name: string;
+} | LookupFailure>;
+/** Result of making a connector deliver this project's events to eve's Slack route. */
+export type SlackRoutingResult = {
+    state: "configured";
+} | {
+    state: "attach-failed";
+    message?: string;
+};
 /**
- * Replaces the connector's default trigger destination with the eve route:
- * detach the existing destination first, then attach this project. Either
- * subprocess failing short-circuits so a half-configured connector is reported
- * rather than silently left pointing at the wrong place.
+ * Applies the planned routing mutation. Never detaches: attach only adds
+ * token access, and the trigger-destinations replacement keeps the project's
+ * token access and every other project's entries intact.
  */
-export declare function attachSlackConnector(deps: SlackConnectLifecycleDeps, projectRoot: string, ref: SlackConnectorRef, onOutput: CommandOutput, signal?: AbortSignal): Promise<SlackConnectorAttachmentResult>;
+export declare function applySlackRouting(input: {
+    deps: SlackConnectLifecycleDeps;
+    projectRoot: string;
+    ref: SlackConnectorRef;
+    plan: Extract<SlackRoutingPlan, {
+        kind: "apply";
+    }>;
+    orgId: string | undefined;
+    onOutput: CommandOutput;
+    signal?: AbortSignal;
+}): Promise<SlackRoutingResult>;
 type SlackWorkspaceLookup = {
     state: "connected";
     workspace: SlackWorkspaceConnection;
@@ -97,16 +142,19 @@ export declare function fetchSlackWorkspace(input: {
     signal?: AbortSignal;
 }): Promise<SlackWorkspaceLookup>;
 /**
- * Removes the exact connector returned by `connect create`. When no UID was
- * returned, ownership cannot be proven: a concurrent or eventually-consistent
- * connector looks the same as this attempt's. So cleanup fails closed. It
- * removes nothing and instead surfaces the connectors that look like this
- * attempt's, matching `expectedUid` and absent from the pre-create snapshot, so
- * the caller can stop rather than risk removing a bystander's connector.
+ * Removes the exact connector returned by `connect create`. A run the CLI
+ * rejected before its browser flow cannot have created a connector, so there
+ * is nothing to remove. Otherwise, when no UID was returned, ownership cannot be
+ * proven: the browser page may still create one, and a concurrent or
+ * eventually-consistent connector looks the same as this attempt's. So
+ * cleanup fails closed. It removes nothing and instead surfaces
+ * `expectedUid`, which was free before this attempt, if it now exists, so the
+ * caller can stop rather than risk removing a bystander's connector.
  */
 export declare function cleanupCreatedAttempt(context: SlackConnectorCleanupContext, input: {
     expectedUid: string;
-    baselineConnectorUids: ReadonlySet<string>;
     createdRef: SlackConnectorRef | undefined;
+    /** The CLI reported its own error before printing the browser URL. */
+    rejected: boolean;
 }): Promise<SlackConnectorCleanupResult>;
 export {};

package/dist/src/setup/slack-connect-lifecycle.js

@@ -1 +1 @@
-import{parseSlackConnectorDetails,parseSlackConnectors}from"./slack-connect.js";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#setup/scaffold/index.js";import"#setup/primitives/run-vercel.js";import"#setup/cli/index.js";import{CONNECT_MUTATION_TIMEOUT_MS,replaceConnectTrigger}from"#setup/connect-provisioning.js";const CONNECT_LOOKUP_TIMEOUT_MS=6e4;async function listSlackConnectors(e,t,n,r){let i=await e.captureVercel([`connect`,`list`,`-F`,`json`,`--all-projects`],{cwd:t,onOutput:n,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS,signal:r});if(!i.ok)return{state:`failed`,message:i.failure.message};try{let e=JSON.parse(i.stdout);if(typeof e!=`object`||!e)return{state:`failed`,message:`Vercel returned a malformed connector list.`};let t=e;return Array.isArray(t.connectors??t.clients)?{state:`ok`,body:e,connectors:parseSlackConnectors(e)}:{state:`failed`,message:`Vercel returned a malformed connector list.`}}catch{return{state:`failed`,message:`Vercel returned invalid JSON for the connector list.`}}}async function findSlackConnector(e,t,n,r,i,a){let o=await listSlackConnectors(e,t,i,a);if(o.state===`failed`)return o;let s=new Set(o.connectors.map(e=>e.uid));if(n===void 0)return{state:`not-found`,connectorUids:s};let c=o.connectors.filter(e=>e.id!==void 0&&e.projectIds.includes(n)).sort((e,t)=>t.createdAt-e.createdAt).map(({uid:e,id:t})=>({uid:e,id:t}));if(c.length===0)return{state:`not-found`,connectorUids:s};let l=c.find(e=>e.uid===r);return l===void 0?{state:`found`,connectors:c,connectorUids:s}:{state:`found`,connectors:c,preferred:l,connectorUids:s}}async function attachSlackConnector(e,t,n,r,i){return replaceConnectTrigger({connectorUid:n.uid,projectRoot:t,triggerPath:SLACK_CHANNEL_DEFAULT_ROUTE,onOutput:r,signal:i,deps:e})}async function fetchSlackConnectorDetails(e){let t=e.orgId===void 0?``:`?teamId=${encodeURIComponent(e.orgId)}`,n=[`api`,`/v1/connect/connectors/${encodeURIComponent(e.connectorId)}${t}`];e.orgId!==void 0&&n.push(`--scope`,e.orgId);let r=await e.deps.captureVercel(n,{cwd:e.projectRoot,onOutput:e.onOutput,timeoutMs:e.timeoutMs,signal:e.signal});if(!r.ok)return{state:`failed`,message:r.failure.message};try{let t=JSON.parse(r.stdout),n=parseSlackConnectorDetails(t);return n?.ref.id===e.connectorId?{state:`found`,details:n}:{state:`failed`,message:`Vercel returned an invalid Slack connector.`}}catch{return{state:`failed`,message:`Vercel returned invalid JSON for the Slack connector.`}}}async function fetchSlackWorkspace(e){let t=await fetchSlackConnectorDetails(e);return t.state===`failed`?t:t.details.workspace===void 0?{state:`pending`}:{state:`connected`,workspace:t.details.workspace}}async function cleanupConnectorUid(e,t){let{log:n,deps:r,projectRoot:i,onOutput:a}=e;return await r.runVercel([`connect`,`remove`,t,`--disconnect-all`,`--yes`],{cwd:i,onOutput:a,timeoutMs:CONNECT_MUTATION_TIMEOUT_MS})?!0:(n.warning(`Could not remove the abandoned Slack connector. Run \`vercel connect remove ${t} --disconnect-all --yes\` to clean it up.`),!1)}async function cleanupConnectorUids(e,t){let n=[];for(let r of new Set(t))await cleanupConnectorUid(e,r)||n.push(r);return n.length===0?{state:`clean`}:{state:`failed`,connectorUids:n}}async function cleanupCreatedAttempt(e,t){if(t.createdRef)return cleanupConnectorUids(e,[t.createdRef.uid]);e.log.warning(`eve couldn't confirm the Slack request in your browser was cancelled. Wait for it to expire before retrying.`);let n=await listSlackConnectors(e.deps,e.projectRoot,e.onOutput);return n.state===`failed`?{state:`failed`,connectorUids:[]}:{state:`failed`,connectorUids:n.connectors.map(e=>e.uid).filter(e=>(e===t.expectedUid||e.startsWith(`${t.expectedUid}-`))&&!t.baselineConnectorUids.has(e))}}export{CONNECT_LOOKUP_TIMEOUT_MS,attachSlackConnector,cleanupCreatedAttempt,fetchSlackConnectorDetails,fetchSlackWorkspace,findSlackConnector,listSlackConnectors};
+import{parseConnectorProjects,parseSlackConnectorDetails,parseSlackConnectorPage}from"./slack-connect.js";import"#setup/primitives/run-vercel.js";import{isNotFoundApiFailure,normalizeVercelApiResult}from"#setup/vercel-api-failure.js";import{mapWithConcurrency}from"#shared/map-with-concurrency.js";import"#setup/cli/index.js";import{CONNECT_MUTATION_TIMEOUT_MS}from"#setup/connect-provisioning.js";const CONNECT_LOOKUP_TIMEOUT_MS=6e4;function connectApiArgs(e,t,n={},r=[]){let i=new URLSearchParams(n);t!==void 0&&i.set(`teamId`,t);let a=i.toString(),o=[`api`,a===``?e:`${e}?${a}`,...r];return t!==void 0&&o.push(`--scope`,t),o}function connectorPath(e){return`/v1/connect/connectors/${encodeURIComponent(e)}`}async function listProjectSlackConnectors(e){let t=[],n=new Set,r;for(let i=0;i<50;i+=1){let i={projectId:e.projectId,type:`slack`,include:`projects`,limit:`100`};r!==void 0&&(i.cursor=r);let a=await e.deps.captureVercel(connectApiArgs(`/v1/connect/connectors`,e.orgId,i),{cwd:e.projectRoot,onOutput:e.onOutput,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS,signal:e.signal});if(!a.ok)return{state:`failed`,message:a.failure.message};let o;try{o=parseSlackConnectorPage(JSON.parse(a.stdout))}catch{return{state:`failed`,message:`Vercel returned invalid JSON for the connector list.`}}if(o===void 0)return{state:`failed`,message:`Vercel returned a malformed connector list.`};if(t.push(...o.connectors),o.next===void 0)return{state:`ok`,connectors:t};if(n.has(o.next))return{state:`failed`,message:`The connector list repeated cursor ${o.next}.`};n.add(o.next),r=o.next}return{state:`failed`,message:`The connector list has more than 50 pages.`}}async function fetchConnectorProjects(e){let t=await e.deps.captureVercel(connectApiArgs(`${connectorPath(e.connectorId)}/projects`,e.orgId),{cwd:e.projectRoot,onOutput:e.onOutput,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS,signal:e.signal});if(!t.ok)return{state:`failed`,message:t.failure.message};try{let e=parseConnectorProjects(JSON.parse(t.stdout));return e===void 0?{state:`failed`,message:`Vercel returned a malformed connector project list.`}:{state:`ok`,projects:e}}catch{return{state:`failed`,message:`Vercel returned invalid JSON for the connector project list.`}}}function otherProjectsOf(e,t,n){let r=e.filter(e=>e.id!==n);for(let e of t)e.projectId!==n&&(r.some(t=>t.id===e.projectId)||r.push({id:e.projectId}));return r}function toCandidate(e){let{details:t,projectId:n}=e,r=t.triggerDestinations,i={...t.ref,attached:e.attached,triggerDestinations:r,otherProjects:otherProjectsOf(e.projects,r,n),createdAt:e.createdAt};return t.workspace!==void 0&&(i.workspace=t.workspace),i}async function inspectSlackConnectors(e){let{deps:t,projectRoot:n,projectId:r,orgId:i,onOutput:a,signal:o}=e,s=await listProjectSlackConnectors(e);if(s.state===`failed`)return s;let c=new Set(s.connectors.map(e=>e.uid)),l=[...e.namedUids].filter(e=>!c.has(e)),u={deps:t,projectRoot:n,orgId:i,onOutput:a,signal:o},inspectListed=async e=>{let t=await fetchSlackConnectorDetails({...u,connectorId:e.id,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS});return t.state===`failed`?`${e.uid}: ${t.message}`:toCandidate({details:t.details,attached:!0,projects:e.projects,projectId:r,createdAt:e.createdAt})},inspectNamed=async e=>{let t=await lookupSlackConnector({...u,key:e,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS});if(t.state===`absent`)return;if(t.state===`failed`)return`${e}: ${t.message}`;let n=await fetchConnectorProjects({...u,connectorId:t.details.ref.id});return n.state===`failed`?`${e}: ${n.message}`:toCandidate({details:t.details,attached:n.projects.some(e=>e.id===r),projects:n.projects,projectId:r,createdAt:0})},d=await mapWithConcurrency([...s.connectors.map(e=>()=>inspectListed(e)),...l.map(e=>()=>inspectNamed(e))],4,e=>e()),f=d.find(e=>typeof e==`string`);return f===void 0?{state:`ok`,candidates:d.filter(e=>typeof e==`object`)}:{state:`failed`,message:f}}async function refreshSlackCandidate(e){let{deps:t,projectRoot:n,candidate:r,projectId:i,orgId:a,onOutput:o,signal:s}=e,c=await fetchSlackConnectorDetails({deps:t,projectRoot:n,connectorId:r.id,orgId:a,onOutput:o,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS,signal:s});if(c.state===`failed`)return c;if(c.details.ref.uid!==r.uid)return{state:`failed`,message:`The connector ${r.uid} changed since inspection.`};let l=await fetchConnectorProjects({deps:t,projectRoot:n,connectorId:r.id,orgId:a,onOutput:o,signal:s});return l.state===`failed`?l:{state:`ok`,candidate:toCandidate({details:c.details,attached:l.projects.some(e=>e.id===i),projects:l.projects,projectId:i,createdAt:r.createdAt})}}async function findFreeSlackConnectorName(e){for(let t=1;t<=20;t+=1){let n=t===1?e.slug:`${e.slug}-${t}`,r=`slack/${n}`,i=await lookupSlackConnector({...e,key:r,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS});if(i.state===`failed`)return i;if(i.state===`absent`)return{state:`ok`,name:n}}return{state:`failed`,message:`Slack connectors \`slack/${e.slug}\` through \`slack/${e.slug}-20\` already exist. Remove unused ones with \`vercel connect remove <uid> --disconnect-all --yes\`, then try again.`}}async function applySlackRouting(e){let{deps:t,projectRoot:n,ref:r,plan:i,orgId:a,onOutput:o,signal:s}=e;if(i.attach){let e=[`connect`,`attach`,r.uid,`--yes`];if(a!==void 0&&e.push(`--scope`,a),!await t.runVercel(e,{cwd:n,onOutput:o,nonInteractive:!0,timeoutMs:CONNECT_MUTATION_TIMEOUT_MS,signal:s}))return{state:`attach-failed`}}if(i.destinations===void 0)return{state:`configured`};let c=connectApiArgs(`${connectorPath(r.id)}/trigger-destinations`,a,{},[`--method`,`PATCH`,`--input`,`-`]),l=normalizeVercelApiResult(await t.captureVercel(c,{cwd:n,onOutput:o,stdin:JSON.stringify({destinations:i.destinations}),timeoutMs:CONNECT_MUTATION_TIMEOUT_MS,signal:s}));return l.ok?{state:`configured`}:{state:`attach-failed`,message:l.failure.message}}async function lookupSlackConnector(e){let t=await e.deps.captureVercel(connectApiArgs(connectorPath(e.key),e.orgId),{cwd:e.projectRoot,onOutput:e.onOutput,timeoutMs:e.timeoutMs,signal:e.signal});if(!t.ok)return{state:isNotFoundApiFailure(t.failure)?`absent`:`failed`,message:t.failure.message};try{let n=JSON.parse(t.stdout),r=parseSlackConnectorDetails(n);return r?.ref.id===e.key||r?.ref.uid===e.key?{state:`found`,details:r}:{state:`failed`,message:`Vercel returned an invalid Slack connector.`}}catch{return{state:`failed`,message:`Vercel returned invalid JSON for the Slack connector.`}}}async function fetchSlackConnectorDetails(e){let t=await lookupSlackConnector({...e,key:e.connectorId});return t.state===`absent`?{state:`failed`,message:t.message}:t}async function fetchSlackWorkspace(e){let t=await fetchSlackConnectorDetails(e);return t.state===`failed`?t:t.details.workspace===void 0?{state:`pending`}:{state:`connected`,workspace:t.details.workspace}}async function cleanupConnectorUid(e,t){let{log:n,deps:r,projectRoot:i,onOutput:a}=e;return await r.runVercel([`connect`,`remove`,t,`--disconnect-all`,`--yes`],{cwd:i,onOutput:a,timeoutMs:CONNECT_MUTATION_TIMEOUT_MS})?!0:(n.warning(`Could not remove the abandoned Slack connector. Run \`vercel connect remove ${t} --disconnect-all --yes\` to clean it up.`),!1)}async function cleanupConnectorUids(e,t){let n=[];for(let r of new Set(t))await cleanupConnectorUid(e,r)||n.push(r);return n.length===0?{state:`clean`}:{state:`failed`,connectorUids:n}}async function cleanupCreatedAttempt(e,t){return t.createdRef?cleanupConnectorUids(e,[t.createdRef.uid]):t.rejected?{state:`clean`}:(e.log.warning(`eve couldn't confirm the Slack request in your browser was cancelled. Wait for it to expire before retrying.`),{state:`failed`,connectorUids:(await lookupSlackConnector({...e,key:t.expectedUid,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS})).state===`found`?[t.expectedUid]:[]})}export{CONNECT_LOOKUP_TIMEOUT_MS,applySlackRouting,cleanupCreatedAttempt,fetchSlackConnectorDetails,fetchSlackWorkspace,findFreeSlackConnectorName,inspectSlackConnectors,refreshSlackCandidate};

package/dist/src/setup/slack-connect.d.ts

@@ -6,12 +6,6 @@
  * focused on flow and these stay trivially testable.
  */
 import { z } from "#compiled/zod/index.js";
-export interface VercelConnectListResponse {
-    /** `vercel connect list -F json` (current CLI). */
-    connectors?: unknown;
-    /** Older CLI builds emitted the same array under `clients`. */
-    clients?: unknown;
-}
 declare const SlackConnectorRefSchema: z.ZodObject<{
     uid: z.ZodString;
     id: z.ZodString;
@@ -23,10 +17,21 @@ export interface SlackWorkspaceConnection {
     workspaceUrl: string;
     workspaceName?: string;
 }
+/**
+ * One place Vercel Connect forwards Slack events. A destination without
+ * `branch` or `customEnvironmentId` targets the project's default deployment.
+ */
+export interface SlackTriggerDestination {
+    projectId: string;
+    path?: string;
+    branch?: string;
+    customEnvironmentId?: string;
+}
 /** Parsed Slack connector state returned by Vercel's connector detail API. */
 export interface SlackConnectorDetails {
     ref: SlackConnectorRef;
     workspace?: SlackWorkspaceConnection;
+    triggerDestinations: readonly SlackTriggerDestination[];
 }
 /**
  * Parses the exact connector response. Vercel reports a completed Slack
@@ -48,13 +53,27 @@ export declare function parseCreatedSlackConnector(stdout: string): SlackConnect
  * See https://docs.slack.dev/interactivity/deep-linking/.
  */
 export declare function slackMessageDeepLink(url: string): string;
-/** A Slack connector plus the project ids it is attached to. */
+/** A project attached to a connector. */
+export interface SlackConnectorProject {
+    id: string;
+    name?: string;
+}
+/** A Slack connector plus the projects it is attached to. */
 export interface RawSlackConnector {
     uid: string;
-    id?: string;
-    projectIds: readonly string[];
+    id: string;
+    /** Attached projects, possibly truncated to the first few. */
+    projects: readonly SlackConnectorProject[];
     createdAt: number;
 }
-/** Parses Slack connectors (uid + attached project ids) from a connect-list response. */
-export declare function parseSlackConnectors(listJson: unknown): RawSlackConnector[];
+/** One page of `GET /v1/connect/connectors?include=projects`. */
+export interface SlackConnectorPage {
+    connectors: RawSlackConnector[];
+    /** Cursor for the next page, absent on the last one. */
+    next?: string;
+}
+/** Parses one connector list page, keeping only Slack connectors. */
+export declare function parseSlackConnectorPage(body: unknown): SlackConnectorPage | undefined;
+/** Parses one page of `GET /v1/connect/connectors/<id>/projects`. */
+export declare function parseConnectorProjects(body: unknown): SlackConnectorProject[] | undefined;
 export {};

package/dist/src/setup/slack-connect.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";const NonEmptyStringSchema=z.string().min(1),SlackConnectorDetailsSchema=z.object({uid:NonEmptyStringSchema,id:NonEmptyStringSchema}).extend({data:z.object({appId:NonEmptyStringSchema.nullish(),slackTeam:z.object({id:NonEmptyStringSchema,name:NonEmptyStringSchema.nullish()}).nullish()}).nullish()});function parseSlackConnectorDetails(e){let t=SlackConnectorDetailsSchema.safeParse(e);if(!t.success)return;let{id:n,uid:r,data:i}=t.data,a={id:n,uid:r};if(i?.appId==null||i.slackTeam==null)return{ref:a};let o=new URL(`https://slack.com/app_redirect`);return o.searchParams.set(`app`,i.appId),o.searchParams.set(`team`,i.slackTeam.id),{ref:a,workspace:i.slackTeam.name==null?{workspaceUrl:o.href}:{workspaceUrl:o.href,workspaceName:i.slackTeam.name}}}function parseCreatedSlackConnector(e){let t=e.trim();if(!t)return;let n;try{n=JSON.parse(t)}catch{return}return parseSlackConnectorDetails(n)?.ref}function slackMessageDeepLink(e){let t=URL.parse(e);return t===null||!t.pathname.endsWith(`/app_redirect`)||!t.searchParams.has(`app`)||!t.searchParams.has(`team`)?e:(t.searchParams.set(`tab`,`messages`),t.href)}function parseSlackConnectors(e){if(typeof e!=`object`||!e)return[];let t=e,n=t.connectors??t.clients;if(!Array.isArray(n))return[];let r=[];for(let e of n){if(e.type!==`slack`||typeof e.uid!=`string`)continue;let t=Array.isArray(e.projects)?e.projects.map(e=>typeof e==`object`&&e?e.id:void 0).filter(e=>typeof e==`string`):[],n={uid:e.uid,projectIds:t,createdAt:typeof e.createdAt==`number`?e.createdAt:0};typeof e.id==`string`&&(n.id=e.id),r.push(n)}return r}export{parseCreatedSlackConnector,parseSlackConnectorDetails,parseSlackConnectors,slackMessageDeepLink};
+import{z}from"#compiled/zod/index.js";const NonEmptyStringSchema=z.string().min(1),SlackConnectorRefSchema=z.object({uid:NonEmptyStringSchema,id:NonEmptyStringSchema}),SlackTriggerDestinationSchema=z.object({projectId:NonEmptyStringSchema,path:NonEmptyStringSchema.nullish(),branch:NonEmptyStringSchema.nullish(),customEnvironmentId:NonEmptyStringSchema.nullish()}),SlackConnectorDetailsSchema=SlackConnectorRefSchema.extend({triggerDestinations:z.array(SlackTriggerDestinationSchema).nullish(),data:z.object({appId:NonEmptyStringSchema.nullish(),slackTeam:z.object({id:NonEmptyStringSchema,name:NonEmptyStringSchema.nullish()}).nullish()}).nullish()});function toTriggerDestination(e){let t={projectId:e.projectId};return e.path!=null&&(t.path=e.path),e.branch!=null&&(t.branch=e.branch),e.customEnvironmentId!=null&&(t.customEnvironmentId=e.customEnvironmentId),t}function parseSlackConnectorDetails(e){let t=SlackConnectorDetailsSchema.safeParse(e);if(!t.success)return;let{id:n,uid:r,data:i}=t.data,a={id:n,uid:r},o=(t.data.triggerDestinations??[]).map(toTriggerDestination);if(i?.appId==null||i.slackTeam==null)return{ref:a,triggerDestinations:o};let s=new URL(`https://slack.com/app_redirect`);return s.searchParams.set(`app`,i.appId),s.searchParams.set(`team`,i.slackTeam.id),{ref:a,workspace:i.slackTeam.name==null?{workspaceUrl:s.href}:{workspaceUrl:s.href,workspaceName:i.slackTeam.name},triggerDestinations:o}}function parseCreatedSlackConnector(e){let t=e.trim();if(!t)return;let n;try{n=JSON.parse(t)}catch{return}return parseSlackConnectorDetails(n)?.ref}function slackMessageDeepLink(e){let t=URL.parse(e);return t===null||!t.pathname.endsWith(`/app_redirect`)||!t.searchParams.has(`app`)||!t.searchParams.has(`team`)?e:(t.searchParams.set(`tab`,`messages`),t.href)}const ProjectLinkSchema=z.object({projectId:NonEmptyStringSchema,project:z.object({id:NonEmptyStringSchema,name:z.string().nullish()}).nullish()}),PaginationSchema=z.object({next:z.string().nullish()}).nullish(),ConnectorPageSchema=z.object({clients:z.array(z.object({id:NonEmptyStringSchema,uid:NonEmptyStringSchema,type:z.string(),createdAt:z.number().nullish(),includes:z.object({projects:z.object({items:z.array(ProjectLinkSchema)}).nullish()}).nullish()})),pagination:PaginationSchema}),ConnectorProjectsSchema=z.object({projects:z.array(ProjectLinkSchema)});function toProject(e){let t=e.project?.id??e.projectId,n=e.project?.name;return n==null?{id:t}:{id:t,name:n}}function parseSlackConnectorPage(e){let t=ConnectorPageSchema.safeParse(e);if(!t.success)return;let n=t.data.clients.filter(e=>e.type===`slack`).map(e=>({uid:e.uid,id:e.id,projects:(e.includes?.projects?.items??[]).map(toProject),createdAt:e.createdAt??0})),r=t.data.pagination?.next;return r==null?{connectors:n}:{connectors:n,next:r}}function parseConnectorProjects(e){let t=ConnectorProjectsSchema.safeParse(e);return t.success?t.data.projects.map(toProject):void 0}export{parseConnectorProjects,parseCreatedSlackConnector,parseSlackConnectorDetails,parseSlackConnectorPage,slackMessageDeepLink};

package/dist/src/setup/slack-setup-plan.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Pure decisions for resumable Slack setup: which mutation (if any) finishes
+ * event delivery and which connector setup suggests.
+ */
+import type { SlackConnectorProject, SlackConnectorRef, SlackTriggerDestination, SlackWorkspaceConnection } from "./slack-connect.js";
+/** Connect rejects a fourth trigger destination on one connector. */
+export declare const MAX_SLACK_TRIGGER_DESTINATIONS = 3;
+/** A connector other projects use, which setup never attaches to this one. */
+export interface SlackConnectorInUse {
+    uid: string;
+    otherProjects: readonly SlackConnectorProject[];
+}
+/** One team Slack connector as setup sees it before changing anything. */
+export interface SlackConnectorCandidate extends SlackConnectorRef {
+    /** Whether the linked project has token access to this connector. */
+    attached: boolean;
+    /** Present once the Slack app is installed into a workspace. */
+    workspace?: SlackWorkspaceConnection;
+    triggerDestinations: readonly SlackTriggerDestination[];
+    /**
+     * Other projects that use this connector, by attachment or by trigger
+     * destination. Setup never changes their attachments or destinations.
+     */
+    otherProjects: readonly SlackConnectorProject[];
+    createdAt: number;
+}
+/**
+ * Whether setup may reuse a connector: it already belongs to this project, or
+ * no other project uses it (for example, one created by hand for this agent).
+ * One Slack app forwards every event to every destination, so attaching a
+ * second agent would make both respond.
+ */
+export declare function isReusableSlackConnector(candidate: SlackConnectorCandidate): boolean;
+/**
+ * What finishes event delivery for one connector. `attach` gives the project
+ * token access; `destinations`, when present, is the full destination set to
+ * write, changing only this project's default-deployment entry. Each half is
+ * idempotent, so a run that stops between them resumes on the next one.
+ */
+export type SlackRoutingPlan = {
+    kind: "apply";
+    attach: boolean;
+    destinations?: readonly SlackTriggerDestination[];
+} | {
+    kind: "limit-reached";
+    destinations: readonly SlackTriggerDestination[];
+};
+/**
+ * Plans the routing mutation. An attached project is never re-attached,
+ * because `connect attach` without `--environment` resets its environment
+ * scoping.
+ */
+export declare function planSlackRouting(input: {
+    attached: boolean;
+    destinations: readonly SlackTriggerDestination[];
+    projectId: string;
+    route: string;
+}): SlackRoutingPlan;
+/**
+ * Orders candidates for the connector question and picks the suggestion:
+ * the channel file's UID, then `slack/<slug>`, then the newest connector
+ * already attached to this project. `undefined` suggests a new connector.
+ */
+export declare function orderSlackConnectorCandidates(candidates: readonly SlackConnectorCandidate[], input: {
+    channelConnectorUid?: string | undefined;
+    expectedUid: string;
+}): {
+    candidates: SlackConnectorCandidate[];
+    preferred?: SlackConnectorCandidate;
+};
+/** Human-readable destination list for the trigger-limit report. */
+export declare function describeSlackDestinations(destinations: readonly SlackTriggerDestination[], projectNames: ReadonlyMap<string, string>): string[];

package/dist/src/setup/slack-setup-plan.js

@@ -0,0 +1 @@
+const MAX_SLACK_TRIGGER_DESTINATIONS=3;function isReusableSlackConnector(e){return e.attached||e.otherProjects.length===0}function isDefaultDeployment(e){return e.branch===void 0&&e.customEnvironmentId===void 0}function isProjectDefault(e,t){return e.projectId===t&&isDefaultDeployment(e)}function planSlackRouting(e){let{attached:t,destinations:n,projectId:r,route:i}=e,a=!t,o=n.filter(e=>isProjectDefault(e,r));if(o.length===1&&o[0]?.path===i)return{kind:`apply`,attach:a};let s=[...n.filter(e=>!isProjectDefault(e,r)),{projectId:r,path:i}];return s.length>3?{kind:`limit-reached`,destinations:n}:{kind:`apply`,attach:a,destinations:s}}function orderSlackConnectorCandidates(e,t){let n=[...e].sort((e,t)=>t.createdAt-e.createdAt),r=n.find(e=>e.uid===t.channelConnectorUid)??n.find(e=>e.uid===t.expectedUid)??n.find(e=>e.attached),i=n.filter(e=>e!==r).sort((e,t)=>Number(t.attached)-Number(e.attached)),a=r===void 0?i:[r,...i];return r===void 0?{candidates:a}:{candidates:a,preferred:r}}function describeSlackDestinations(e,t){return e.map(e=>`${t.get(e.projectId)??e.projectId} (${e.customEnvironmentId===void 0?e.branch===void 0?`production`:`branch ${e.branch}`:`custom environment ${e.customEnvironmentId}`}) ${e.path??`<default path>`}`)}export{MAX_SLACK_TRIGGER_DESTINATIONS,describeSlackDestinations,isReusableSlackConnector,orderSlackConnectorCandidates,planSlackRouting};

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

@@ -1,8 +1,10 @@
 import { readProjectLink } from "#setup/project-resolution.js";
 import { type ChannelSetupAwaitChoice, type ChannelSetupLog } from "#setup/cli/index.js";
-import type { SlackConnectorRef } from "./slack-connect.js";
+import type { SlackConnectorProject, SlackTriggerDestination } from "./slack-connect.js";
 import { type SlackConnectorCreateDeps } from "./slack-connect-create.js";
-import { type SlackConnectLifecycleDeps, type SlackConnectorLookup } from "./slack-connect-lifecycle.js";
+import { type SlackConnectLifecycleDeps } from "./slack-connect-lifecycle.js";
+import { type SlackConnectorInUse, type SlackConnectorCandidate } from "./slack-setup-plan.js";
+export type { SlackConnectorCandidate } from "./slack-setup-plan.js";
 /** Injected for tests; defaults to the real Vercel CLI subprocess primitives. */
 interface SlackbotProvisionDeps extends SlackConnectLifecycleDeps, SlackConnectorCreateDeps {
     /** Test seam for the linked Vercel project and team lookup. */
@@ -12,21 +14,32 @@ interface SlackbotProvisionDeps extends SlackConnectLifecycleDeps, SlackConnecto
     /** Monotonic-enough clock for enforcing the workspace lookup deadline. */
     now?: () => number;
 }
+/** A Slack connector that delivers this project's events to eve's Slack route. */
+interface SlackbotConnection {
+    connectorUid: string;
+    /** Deep link that opens a DM compose with the bot ("chat with your agent"). */
+    chatUrl?: string;
+    workspaceName?: string;
+}
 /**
- * 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.
+ * Outcome of Slackbot provisioning. `attached` means a connector exists, this
+ * project receives its events at eve's Slack route, and the app is installed
+ * into a Slack workspace. `already-configured` is the same state reached
+ * without changing anything. `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. `trigger-limit-reached` changed nothing because
+ * the connector already has the maximum number of trigger destinations.
+ * `connector-in-use` changed nothing because another project now uses the
+ * chosen connector.
  */
 export type ProvisionSlackbotResult = {
     state: "connector-lookup-failed";
-} | {
+}
+/** `detail` is the Vercel CLI's own error line, when it printed one. */
+ | {
     state: "create-failed";
+    detail?: string;
 } | {
     state: "cancelled";
 } | {
@@ -36,50 +49,77 @@ export type ProvisionSlackbotResult = {
     state: "cleanup-failed";
     connectorUids: readonly string[];
 } | {
-    state: "detach-failed";
+    state: "attach-failed";
     connectorUid: string;
 } | {
-    state: "attach-failed";
+    state: "connector-in-use";
     connectorUid: string;
+    projects: readonly SlackConnectorProject[];
+} | {
+    state: "trigger-limit-reached";
+    connectorUid: string;
+    destinations: readonly SlackTriggerDestination[];
 } | {
     state: "not-installed";
 } | {
     state: "installation-check-failed";
     connectorUid: string;
-} | {
+} | ({
     state: "attached";
-    connectorUid: string;
-    /** Deep link that opens a DM compose with the bot ("chat with your agent"). */
-    chatUrl?: string;
-    workspaceName?: string;
-};
+} & SlackbotConnection) | ({
+    state: "already-configured";
+} & SlackbotConnection);
+/** Explains why setup won't attach a connector another project uses. */
+export declare function connectorInUseMessage(candidate: SlackConnectorInUse): string;
+/** A reusable connector from {@link inspectSlackbotConnectors}, or a request to create one. */
+export type SlackConnectorSelection = SlackConnectorCandidate | "create";
+/**
+ * Read-only snapshot of the Slack connectors setup may reuse for the linked
+ * project. Setup takes it once, asks its questions from it, and hands it to
+ * {@link provisionSlackbot}.
+ */
+export interface SlackbotConnectorInspection {
+    projectId: string;
+    orgId: string | undefined;
+    /** Preferred short-name for `connect create slack --name`; suffixed when taken. */
+    slug: string;
+    /**
+     * Reusable connectors in question order: the suggestion first, then
+     * attached, then the rest. Connectors other projects use are excluded.
+     */
+    candidates: readonly SlackConnectorCandidate[];
+    preferred?: SlackConnectorCandidate;
+    /** Connectors other projects use, which setup never attaches to this one. */
+    inUse: readonly SlackConnectorInUse[];
+}
 /**
- * Creates or reuses a Slack connector and points its event destination at eve.
- * A successful `connect create` is the completion boundary for a new browser
- * flow. Existing connectors are verified through their team-scoped detail
- * payload before attachment.
+ * Inspects the connectors attached to the linked project, plus
+ * `slack/<slug>` and the channel file's UID looked up by name. Throws when
+ * the project isn't linked or any connector can't be read, so setup never
+ * creates a connector on a guess.
  */
-export type SlackConnectorSelection = SlackConnectorRef | "create";
-/** Read-only connector inventory used to resolve the create/reuse decision before provisioning. */
-export declare function inspectSlackbotConnectors(log: ChannelSetupLog, projectRoot: string, slug: string, signal?: AbortSignal, deps?: SlackbotProvisionDeps): Promise<Extract<SlackConnectorLookup, {
-    state: "found" | "not-found";
-}>>;
+export declare function inspectSlackbotConnectors(log: ChannelSetupLog, projectRoot: string, slug: string, options?: {
+    signal?: AbortSignal;
+    channelConnectorUid?: string | undefined;
+}, deps?: SlackbotProvisionDeps): Promise<SlackbotConnectorInspection>;
 interface ProvisionSlackbotOptions {
     /**
      * Cancels the caller's whole operation. The promise rejects after attempting
      * cleanup; only the explicit interactive Cancel action returns `cancelled`.
      */
     signal?: AbortSignal;
-    /** Chooses a project-attached connector or requests a new one. */
-    selectConnector?: (connectors: readonly SlackConnectorRef[], preferred: SlackConnectorRef | undefined) => Promise<SlackConnectorSelection>;
     /** 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, options?: ProvisionSlackbotOptions): Promise<ProvisionSlackbotResult>;
+/**
+ * Reuses the selected connector or creates a new one, then points its event
+ * destination at eve, running only the steps the connector still needs.
+ * Re-running it after a partial failure resumes where the previous run
+ * stopped; it never detaches a project. A successful `connect create` is the
+ * completion boundary for a new browser flow.
+ */
+export declare function provisionSlackbot(log: ChannelSetupLog, projectRoot: string, inspection: SlackbotConnectorInspection, selection: SlackConnectorSelection, deps?: SlackbotProvisionDeps, options?: ProvisionSlackbotOptions): Promise<ProvisionSlackbotResult>;
 /**
  * Patches a connector UID chosen by Connect before the caller deploys the channel definition.
  */
 export declare function reconcileSlackUid(log: ChannelSetupLog, projectRoot: string, slackbot: ProvisionSlackbotResult, expectedUid: string): Promise<boolean>;
-export {};

package/dist/src/setup/slackbot.js

@@ -1 +1,2 @@
-import{CONNECT_LOOKUP_TIMEOUT_MS,attachSlackConnector,cleanupCreatedAttempt,fetchSlackWorkspace,findSlackConnector,listSlackConnectors}from"./slack-connect-lifecycle.js";import{createSlackConnector}from"./slack-connect-create.js";import{join}from"node:path";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#setup/scaffold/index.js";import{readProjectLink}from"#setup/project-resolution.js";import{performance}from"node:perf_hooks";import{captureVercel,runVercel,runVercelCaptureStdout}from"#setup/primitives/run-vercel.js";import{setTimeout}from"node:timers/promises";import{createPromptCommandOutput,withPhase}from"#setup/cli/index.js";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 pollSlackWorkspace(e,t,n,r,i,a){let o=e.delay??realDelay,s=e.now??monotonicNow,c=s()+3e5;for(;;){a?.throwIfAborted();let l=c-s();if(l<=0)return{state:`timed-out`};let u=await fetchSlackWorkspace({deps:e,projectRoot:t,connectorId:n,orgId:r,onOutput:i,timeoutMs:Math.min(CONNECT_LOOKUP_TIMEOUT_MS,l),signal:a});if(a?.throwIfAborted(),u.state!==`pending`)return u;let d=c-s();if(d<=0)return{state:`timed-out`};await o(Math.min(3e3,d),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(e){let{log:t,deps:n,projectRoot:r,orgId:i,onOutput:a,signal:o,phase:s}=e,c,l;if(e.source.state===`existing`)c=e.source.ref;else{let u=await createSlackConnector({deps:n,projectRoot:r,orgId:i,slug:e.slug,onOutput:a,signal:o,phase:s,onCreated:e.onCreated,waitForWorkspace:async(e,t)=>{let o=await pollSlackWorkspace(n,r,e.id,i,a,t);return o.state===`connected`?o.workspace:void 0}});if(u.state===`failed`)return{state:`create-failed`};if(u.state===`unresolved`)return t.warning(`Vercel did not return an exact Slack connector UID for this request, so eve cannot attach or remove it safely.`),{state:`unresolved`};c=u.ref,u.via===`workspace`&&(l=u.workspace)}if(e.source.state===`existing`&&l===void 0){let e=await s(`Waiting for the Slack workspace connection...`,()=>pollSlackWorkspace(n,r,c.id,i,a,o));if(e.state===`timed-out`)return{state:`timed-out`,ref:c};if(e.state===`failed`)return{state:`failed`,ref:c,message:e.message};l=e.workspace}let u=await s(`Configuring Slack event delivery for this agent...`,()=>attachSlackConnector(n,r,c,a,o));return o?.throwIfAborted(),u.state===`attached`?l===void 0?{state:`attached`,ref:c}:{state:`attached`,ref:c,workspace:l}:{state:u.state,ref:c}}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 inspectSlackbotConnectors(e,t,n,r,i=defaultDeps){let a=await(i.readProjectLink??readProjectLink)(t),o=await findSlackConnector(i,t,a?.projectId,`slack/${n}`,createPromptCommandOutput(e),r);if(o.state===`failed`)throw Error(o.message);return o}async function provisionSlackbot(e,t,n,r=defaultDeps,i={}){i.signal?.throwIfAborted();let a=createPromptCommandOutput(e),o={log:e,deps:r,projectRoot:t,onOutput:a},s=await(r.readProjectLink??readProjectLink)(t),c=s?.projectId,l=s?.orgId,u=`slack/${n}`,d=await withPhase(e,`Checking for an existing Slackbot...`,()=>findSlackConnector(r,t,c,u,a,i.signal));if(i.signal?.throwIfAborted(),d.state===`failed`)return e.warning(`Could not inspect existing Slack connectors, so eve did not create another one. ${d.message}`),{state:`connector-lookup-failed`};if(c===void 0&&d.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`attached`:return t.workspace===void 0?{state:`attached`,connectorUid:t.ref.uid}:{state:`attached`,connectorUid:t.ref.uid,chatUrl:t.workspace.workspaceUrl,workspaceName:t.workspace.workspaceName};case`failed`:return e.warning(`Could not verify the Slack workspace connection. ${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(o,{expectedUid:u,baselineConnectorUids:e.baselineConnectorUids,createdRef:t});function attemptInput(i,o){return{log:e,deps:r,projectRoot:t,orgId:l,slug:n,source:i,onOutput:a,onCreated:o}}async function runExistingConnector(t){let cleanupCurrentAttempt=async()=>({state:`clean`}),notInstalled=()=>(e.warning(`The existing Slack connector \`${t.ref.uid}\` is not connected to a Slack workspace. 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===`attached`?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,o){let s,cleanupCurrentAttempt=()=>cleanupNewAttempt(n,s),c=o({status:`Waiting for Slack setup to finish...`,context:`Complete setup in the browser, then wait while eve verifies the connection`,actions:[{value:`retry`,label:`Did your browser not open? Try again`},{value:`cancel`,label:`Cancel`}]}),l;try{l=await raceAttemptAgainstChoice({prompt:c,outerSignal:i.signal,run:t=>runAttempt({...attemptInput(n,e=>{s=e}),signal:t,phase:e.spinner===void 0?(e,t)=>t():(t,n)=>withPhase(e,t,n)})})}catch(e){throw await cleanupCurrentAttempt(),e}if(l.via===`work`)return{state:`finished`,result:await finishOutcome(l.outcome,n,cleanupCurrentAttempt)};if(l.settled?.state===`attached`)return{state:`finished`,result:await finishOutcome(l.settled,n,cleanupCurrentAttempt)};let u=await cleanupCurrentAttempt();if(u.state===`failed`)return{state:`finished`,result:cleanupFailureResult(u)};if(l.choice===`retry`){let n=await withPhase(e,`Checking existing Slack connectors...`,()=>listSlackConnectors(r,t,a,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(d.state===`found`){let e=i.selectConnector===void 0?d.preferred??d.connectors[0]:await i.selectConnector(d.connectors,d.preferred);if(i.signal?.throwIfAborted(),e!==`create`)return runExistingConnector({state:`existing`,ref:e})}let f={state:`new`,baselineConnectorUids:d.connectorUids};if(i.awaitChoice===void 0)return runUncontrolledAttempt(f);for(;;){let e=await runInteractiveAttempt(f,i.awaitChoice);if(e.state===`finished`)return e.result;f=e.source}}async function reconcileSlackUid(e,t,n,r){if(n.state!==`attached`||n.connectorUid===r)return!0;let i=join(t,`agent/channels/slack.ts`),{patched:a}=await updateSlackChannelConnectorUid(i,n.connectorUid);return a?!0:(e.warning(`Could not patch agent/channels/slack.ts automatically. Update \`connectSlackCredentials("...")\` to \`"${n.connectorUid}"\` and run \`vercel deploy --prod\`.`),!1)}export{inspectSlackbotConnectors,provisionSlackbot,reconcileSlackUid};
+import{CONNECT_LOOKUP_TIMEOUT_MS,applySlackRouting,cleanupCreatedAttempt,fetchSlackConnectorDetails,fetchSlackWorkspace,findFreeSlackConnectorName,inspectSlackConnectors,refreshSlackCandidate}from"./slack-connect-lifecycle.js";import{createSlackConnector}from"./slack-connect-create.js";import{describeSlackDestinations,isReusableSlackConnector,orderSlackConnectorCandidates,planSlackRouting}from"./slack-setup-plan.js";import{createHash,randomBytes}from"node:crypto";import{join}from"node:path";import{SLACK_CHANNEL_DEFAULT_ROUTE}from"#setup/scaffold/index.js";import{readProjectLink}from"#setup/project-resolution.js";import{performance}from"node:perf_hooks";import{captureVercel,runVercel,runVercelCaptureStdout}from"#setup/primitives/run-vercel.js";import{setTimeout}from"node:timers/promises";import{createPromptCommandOutput,withPhase}from"#setup/cli/index.js";import{openUrl}from"#setup/primitives/open-url.js";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 pollSlackWorkspace(e,t,n,r,i,a){let o=e.delay??realDelay,s=e.now??monotonicNow,c=s()+3e5;for(;;){a?.throwIfAborted();let l=c-s();if(l<=0)return{state:`timed-out`};let u=await fetchSlackWorkspace({deps:e,projectRoot:t,connectorId:n,orgId:r,onOutput:i,timeoutMs:Math.min(CONNECT_LOOKUP_TIMEOUT_MS,l),signal:a});if(a?.throwIfAborted(),u.state!==`pending`)return u;let d=c-s();if(d<=0)return{state:`timed-out`};await o(Math.min(3e3,d),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}}function openSlackInstall(e,t,n){if(n===void 0){e.info(`Run \`vercel connect open ${t.uid}\` to install it in a Slack workspace.`);return}let r=randomBytes(37).toString(`base64url`),i=new URL(`https://vercel.com/api/v1/connect/install/${encodeURIComponent(t.id)}`);i.searchParams.set(`teamId`,n),i.searchParams.set(`request_code`,createHash(`sha256`).update(r).digest(`base64url`)),e.info(`Install \`${t.uid}\` in a Slack workspace: ${i.href}`),openUrl(i.href)}function renamedConnectorMessage(e,t,n){let r=n.find(t=>t.uid===`slack/${e}`);if(r===void 0)return`A Slack connector named \`slack/${e}\` already exists, so eve will name the new one \`slack/${t}\`.`;let i=r.otherProjects.map(e=>e.name??e.id);return`\`slack/${e}\` is already used by ${i.length===1?`another project`:`other projects`} (${i.join(`, `)}), so eve will create \`slack/${t}\` for this project.`}function connectorInUseMessage(e){let t=e.otherProjects.map(e=>e.name??e.id).join(`, `);return`\`${e.uid}\` is used by ${t}. eve does not add a second agent to one Slack app because both would respond to the same events. Create a new Slack app for this agent instead.`}async function runAttempt(e){let{log:t,deps:n,projectRoot:r,projectId:i,orgId:a,onOutput:o,signal:s,phase:c}=e,l,u,d,f,p=[],m=e.source.state===`new`;if(e.source.state===`existing`){let{candidate:h}=e.source;if(l={uid:h.uid,id:h.id},u=h.workspace,u===void 0){openSlackInstall(t,l,a);let e=await c(`Waiting for the Slack workspace install...`,()=>pollSlackWorkspace(n,r,l.id,a,o,s));if(e.state===`timed-out`)return{state:`timed-out`,ref:l};if(e.state===`failed`)return{state:`failed`,ref:l,message:e.message};u=e.workspace,m=!0}let g=await refreshSlackCandidate({deps:n,projectRoot:r,candidate:h,projectId:i,orgId:a,onOutput:o,signal:s});if(s?.throwIfAborted(),g.state===`failed`)return{state:`attach-failed`,ref:l,message:g.message};if(!isReusableSlackConnector(g.candidate))return{state:`in-use`,ref:l,projects:g.candidate.otherProjects};d=g.candidate.attached,f=g.candidate.triggerDestinations,p=g.candidate.otherProjects,u??=g.candidate.workspace}else{let i=await createSlackConnector({deps:n,projectRoot:r,orgId:a,slug:e.source.name,onOutput:o,signal:s,phase:c,onCreated:t=>{e.trace.createdRef=t},waitForWorkspace:async(e,t)=>{let i=await pollSlackWorkspace(n,r,e.id,a,o,t);return i.state===`connected`?i.workspace:void 0}});if(i.state===`failed`)return e.trace.rejected=i.rejected,i.detail===void 0?{state:`create-failed`}:{state:`create-failed`,detail:i.detail};if(i.state===`unresolved`)return t.warning(`Vercel did not return an exact Slack connector UID for this request, so eve cannot attach or remove it safely.`),{state:`unresolved`};l=i.ref,i.via===`workspace`&&(u=i.workspace),d=!0;let p=await fetchSlackConnectorDetails({deps:n,projectRoot:r,connectorId:l.id,orgId:a,onOutput:o,timeoutMs:CONNECT_LOOKUP_TIMEOUT_MS,signal:s});if(s?.throwIfAborted(),p.state===`failed`)return{state:`attach-failed`,ref:l,message:p.message};f=p.details.triggerDestinations,u??=p.details.workspace}let h=planSlackRouting({attached:d,destinations:f,projectId:i,route:SLACK_CHANNEL_DEFAULT_ROUTE});if(h.kind===`limit-reached`){let e=new Map(p.map(e=>[e.id,e.name??e.id]));return e.set(i,`this project`),{state:`limit-reached`,ref:l,destinations:h.destinations,description:describeSlackDestinations(h.destinations,e)}}if(h.attach||h.destinations!==void 0){let e=await c(`Configuring Slack event delivery for this agent...`,()=>applySlackRouting({deps:n,projectRoot:r,ref:l,plan:h,orgId:a,onOutput:o,signal:s}));if(s?.throwIfAborted(),e.state===`attach-failed`)return{state:`attach-failed`,ref:l,message:e.message};m=!0}return u===void 0?{state:`attached`,ref:l,changed:m}:{state:`attached`,ref:l,workspace:u,changed:m}}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 inspectSlackbotConnectors(e,t,n,r={},i=defaultDeps){let a=await(i.readProjectLink??readProjectLink)(t);if(a?.projectId===void 0)throw Error("Slack setup with Vercel Connect needs a linked Vercel project to tell which Slack connectors belong to it, so eve did not create one. Run `vercel link`, then try again.");let{projectId:o,orgId:s}=a,{channelConnectorUid:c}=r,l=`slack/${n}`,u=new Set([l]);c!==void 0&&u.add(c);let d=await withPhase(e,`Checking existing Slack connectors...`,()=>inspectSlackConnectors({deps:i,projectRoot:t,projectId:o,orgId:s,namedUids:u,onOutput:createPromptCommandOutput(e),signal:r.signal}));if(d.state===`failed`)throw Error(`Could not inspect existing Slack connectors, so eve did not create another one. ${d.message}`);return{projectId:o,orgId:s,slug:n,...orderSlackConnectorCandidates(d.candidates.filter(isReusableSlackConnector),{expectedUid:l,channelConnectorUid:c}),inUse:d.candidates.filter(e=>!isReusableSlackConnector(e))}}async function provisionSlackbot(e,t,n,r,i=defaultDeps,a={}){a.signal?.throwIfAborted();let o=createPromptCommandOutput(e),{projectId:s,orgId:c,slug:l}=n,u={log:e,deps:i,projectRoot:t,orgId:c,onOutput:o},findFreeName=async()=>{let n=await findFreeSlackConnectorName({deps:i,projectRoot:t,orgId:c,slug:l,onOutput:o,signal:a.signal});return n.state===`failed`&&e.warning(`Could not pick a name for the new Slack connector. ${n.message}`),n},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 t.detail===void 0?{state:`create-failed`}:{state:`create-failed`,detail:t.detail};case`unresolved`:if(i){let e=await r();if(e.state===`failed`)return cleanupFailureResult(e)}return{state:`create-failed`};case`in-use`:return e.warning(connectorInUseMessage({uid:t.ref.uid,otherProjects:t.projects})),{state:`connector-in-use`,connectorUid:t.ref.uid,projects:t.projects};case`attach-failed`:return e.warning(`Could not register ${SLACK_CHANNEL_DEFAULT_ROUTE} on this project as a trigger destination for \`${t.ref.uid}\`.${t.message===void 0?``:` ${t.message}`} eve kept the connector; re-run \`eve add channel/slack\` to finish event delivery.`),{state:`attach-failed`,connectorUid:t.ref.uid};case`limit-reached`:return e.warning([`\`${t.ref.uid}\` already has ${t.destinations.length} trigger destinations, the most Vercel Connect allows, so eve changed nothing:`,...t.description.map(e=>`  - ${e}`),"Remove one in the Connect dashboard, then re-run `eve add channel/slack`."].join(`
+`)),{state:`trigger-limit-reached`,connectorUid:t.ref.uid,destinations:t.destinations};case`attached`:{let e=t.changed?`attached`:`already-configured`;return t.workspace===void 0?{state:e,connectorUid:t.ref.uid}:{state:e,connectorUid:t.ref.uid,chatUrl:t.workspace.workspaceUrl,workspaceName:t.workspace.workspaceName}}case`failed`:return e.warning(`Could not verify the Slack workspace connection. ${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:`slack/${e.name}`,createdRef:t.createdRef,rejected:t.rejected});function attemptInput(n,r){return{log:e,deps:i,projectRoot:t,projectId:s,orgId:c,source:n,onOutput:o,trace:r}}async function runExistingConnector(t){let cleanupCurrentAttempt=async()=>({state:`clean`}),n=t.candidate.uid,notInstalled=()=>(e.warning(`The Slack connector \`${n}\` is not installed in a Slack workspace yet. Re-run \`eve add channel/slack\` to open its install page again, or choose "Create a new Slack app" instead.`),{state:`existing-not-installed`,connectorUid:n}),finishExistingOutcome=async e=>e.state===`timed-out`?notInstalled():finishOutcome(e,t,cleanupCurrentAttempt);if(a.awaitChoice!==void 0&&t.candidate.workspace===void 0)for(;;){let e=await raceAttemptAgainstChoice({prompt:a.awaitChoice({status:`Waiting for the Slack workspace install...`,context:`Install the Slack app in your browser, then wait while eve verifies it`,actions:[{value:`retry`,label:`Did your browser not open? Try again`},{value:`cancel`,label:`Stop waiting`}]}),outerSignal:a.signal,run:e=>runAttempt({...attemptInput(t,{rejected:!1}),signal:e,phase:(e,t)=>t()})});if(e.via===`work`)return finishExistingOutcome(e.outcome);if(e.settled?.state===`attached`)return finishExistingOutcome(e.settled);if(e.choice!==`retry`)return notInstalled()}return finishExistingOutcome(await runAttempt({...attemptInput(t,{rejected:!1}),signal:a.signal,phase:(t,n)=>withPhase(e,t,n)}))}async function runUncontrolledAttempt(t){let n={rejected:!1},cleanupCurrentAttempt=()=>cleanupNewAttempt(t,n),r=runAttempt({...attemptInput(t,n),signal:a.signal,phase:(t,n)=>withPhase(e,t,n)});try{return await finishOutcome(await r,t,cleanupCurrentAttempt)}catch(e){throw a.signal?.aborted===!0&&await cleanupCurrentAttempt(),e}}async function runInteractiveAttempt(t,n){let r={rejected:!1},cleanupCurrentAttempt=()=>cleanupNewAttempt(t,r),i=n({status:`Waiting for Slack setup to finish...`,context:`Complete setup in the browser, then wait while eve verifies the connection`,actions:[{value:`retry`,label:`Did your browser not open? Try again`},{value:`cancel`,label:`Cancel`}]}),o;try{o=await raceAttemptAgainstChoice({prompt:i,outerSignal:a.signal,run:n=>runAttempt({...attemptInput(t,r),signal:n,phase:e.spinner===void 0?(e,t)=>t():(t,n)=>withPhase(e,t,n)})})}catch(e){throw await cleanupCurrentAttempt(),e}if(o.via===`work`)return{state:`finished`,result:await finishOutcome(o.outcome,t,cleanupCurrentAttempt)};if(o.settled?.state===`attached`)return{state:`finished`,result:await finishOutcome(o.settled,t,cleanupCurrentAttempt)};let s=await cleanupCurrentAttempt();if(s.state===`failed`)return{state:`finished`,result:cleanupFailureResult(s)};if(o.choice===`retry`){let t=await withPhase(e,`Checking existing Slack connectors...`,()=>findFreeName());return a.signal?.throwIfAborted(),t.state===`failed`?{state:`finished`,result:{state:`connector-lookup-failed`}}:{state:`retry`,source:{state:`new`,name:t.name}}}return{state:`finished`,result:{state:`cancelled`}}}if(r!==`create`)return runExistingConnector({state:`existing`,candidate:r});let d=await findFreeName();if(a.signal?.throwIfAborted(),d.state===`failed`)return{state:`connector-lookup-failed`};d.name!==l&&e.info(renamedConnectorMessage(l,d.name,n.inUse));let f={state:`new`,name:d.name};if(a.awaitChoice===void 0)return runUncontrolledAttempt(f);for(;;){let e=await runInteractiveAttempt(f,a.awaitChoice);if(e.state===`finished`)return e.result;f=e.source}}async function reconcileSlackUid(e,t,n,r){if(n.state!==`attached`&&n.state!==`already-configured`||n.connectorUid===r)return!0;let i=join(t,`agent/channels/slack.ts`),{patched:a}=await updateSlackChannelConnectorUid(i,n.connectorUid);return a?!0:(e.warning(`Could not patch agent/channels/slack.ts automatically. Update \`connectSlackCredentials("...")\` to \`"${n.connectorUid}"\` and run \`vercel deploy --prod\`.`),!1)}export{connectorInUseMessage,inspectSlackbotConnectors,provisionSlackbot,reconcileSlackUid};

package/dist/src/shared/action-label.d.ts

@@ -0,0 +1,10 @@
+import type { ActionPresentationByCallId } from "#protocol/message.js";
+import type { RuntimeActionRequest } from "#shared/action-types.js";
+/**
+ * How a call reads to people on every surface: the label its entry's definition
+ * gives it, or the entry's display title. A call made through `eve__tool` or
+ * `eve__skill` arrives as the call to its entry, so it reads like a direct call.
+ */
+export declare function actionLabel(action: RuntimeActionRequest, presentation: ActionPresentationByCallId | undefined): string;
+/** The calls people see: the model waiting on or stopping its own tasks stays out of view. */
+export declare function visibleActions<T extends RuntimeActionRequest>(actions: readonly T[]): T[];

package/dist/src/shared/action-label.js

@@ -0,0 +1 @@
+import{actionRequestName}from"#shared/action-request-name.js";import{displayTitle}from"#shared/display-name.js";import{isTaskControlTool}from"#protocol/task-tools.js";function actionLabel(e,t){return t?.[e.callId]?.label??displayTitle(actionRequestName(e))}function visibleActions(e){return e.filter(e=>!(e.kind===`tool-call`&&isTaskControlTool(e.toolName)))}export{actionLabel,visibleActions};

package/dist/src/shared/action-request-name.d.ts

@@ -1,3 +1,5 @@
 import type { RuntimeActionRequest } from "#shared/action-types.js";
-/** The tool, agent, or `load_skill` a request targets. */
+/** The tool, agent, or skill a request targets. */
 export declare function actionRequestName(action: RuntimeActionRequest): string;
+/** The skill an `eve__skill` input names, if it names one. */
+export declare function skillTarget(input: unknown): string | undefined;