vercel 54.21.1 → 56.0.0

package/dist/chunks/{chunk-QMZO4CEP.js → chunk-KODCUW77.js}

@@ -7,17 +7,20 @@ const __dirname = __dirname_(__filename);
 import {
   AGENT_REASON,
   AGENT_STATUS
-} from "./chunk-QH7WYDEP.js";
+} from "./chunk-IC4YEIGW.js";
 import {
-  getLocalPathConfig
-} from "./chunk-DKE73NGN.js";
+  getLocalPathConfig,
+  isPromptBackError,
+  isPromptCanceledError
+} from "./chunk-C6E2RJS7.js";
 import {
   getScope
-} from "./chunk-HMFUXSD7.js";
+} from "./chunk-VSD5BID5.js";
 import {
   table
 } from "./chunk-QEEGXNFK.js";
 import {
+  Separator,
   VERCEL_DIR_PROJECT,
   VERCEL_DIR_README,
   checkExistsAndConnect,
@@ -32,7 +35,6 @@ import {
   getLinkedProject,
   getProjectByNameOrId,
   getServicesConfigWriteBlocker,
-  getTeams,
   getVercelDirectory,
   humanizePath,
   isDirectory,
@@ -51,12 +53,12 @@ import {
   selectAndParseRemoteUrl,
   selectOrg,
   writeServicesConfig
-} from "./chunk-I4NRKN2Z.js";
+} from "./chunk-THMFJODG.js";
 import {
   buildCommandWithGlobalFlags,
   outputAgentError,
   shouldEmitNonInteractiveCommandError
-} from "./chunk-2QBF3ZL3.js";
+} from "./chunk-CB3I3QIT.js";
 import {
   printError
 } from "./chunk-EHTPDXTS.js";
@@ -357,14 +359,19 @@ function displayServiceErrors(errors) {
 }
 
 // src/util/link/setup-and-link.ts
-var import_chalk6 = __toESM(require_source(), 1);
 var import_fs_extra2 = __toESM(require_lib(), 1);
 var import_fs_detectors2 = __toESM(require_dist(), 1);
 import { join as join2, basename } from "path";
+import { getPlatformEnv } from "@vercel/build-utils";
 
 // src/util/input/input-project.ts
 var import_chalk2 = __toESM(require_source(), 1);
 var import_slugify = __toESM(require_slugify(), 1);
+var SEARCH_ALL_PROJECTS = "search-all-projects";
+var CREATE_NEW_PROJECT = "create-new-project";
+var BACK_TO_PROJECT_SELECTION = Symbol("back-to-project-selection");
+var BACK_TO_TEAM_SELECTION = Symbol("back-to-team-selection");
+var NO_EXISTING_PROJECTS = Symbol("no-existing-projects");
 async function inputProjectDecision(client, defaultDecision) {
   const createChoice = {
     name: "Create new project",
@@ -379,10 +386,119 @@ async function inputProjectDecision(client, defaultDecision) {
     choices: defaultDecision === "existing" ? [existingChoice, createChoice] : [createChoice, existingChoice]
   });
 }
-async function inputProject(client, org, detectedProjectName, autoConfirm = false, skipAutoDetect = false) {
+function randomNameSuffix() {
+  return Math.random().toString(36).slice(2, 6).padEnd(4, "0");
+}
+async function suggestNewProjectName(client, org, slugifiedName, knownTaken) {
+  let taken = knownTaken;
+  if (!taken) {
+    try {
+      const existing = await getProjectByNameOrId(
+        client,
+        slugifiedName,
+        org.id
+      );
+      taken = !(existing instanceof ProjectNotFound);
+    } catch {
+      taken = false;
+    }
+  }
+  return taken ? `${slugifiedName}-${randomNameSuffix()}` : slugifiedName;
+}
+function promptForProjectName(client, org, defaultName, message = "Name?") {
+  return client.input.text({
+    message,
+    default: defaultName,
+    validate: async (val) => {
+      if (!val) {
+        return "Project name cannot be empty";
+      }
+      const project = await getProjectByNameOrId(client, val, org.id);
+      if (!(project instanceof ProjectNotFound)) {
+        return "Project already exists";
+      }
+      return true;
+    }
+  });
+}
+async function promptForProjectNameWithBack(client, org, defaultName) {
+  try {
+    return await client.withPromptBackNavigation(
+      () => promptForProjectName(
+        client,
+        org,
+        defaultName,
+        `Name? ${import_chalk2.default.dim("Press \u2191 to return to project options")}`
+      )
+    );
+  } catch (error) {
+    if (isPromptBackError(error)) {
+      return BACK_TO_PROJECT_SELECTION;
+    }
+    throw error;
+  }
+}
+async function searchExistingProjects(client, org, allowBack) {
+  const firstPage = await client.fetch(`/v9/projects?limit=100`, { accountId: org.id });
+  const projects = firstPage.projects;
+  const hasMoreProjects = firstPage.pagination.next != null;
+  if (projects.length === 0) {
+    output_manager_default.log(
+      `No existing projects found under ${import_chalk2.default.bold(org.slug)}. Creating new project.`
+    );
+    return NO_EXISTING_PROJECTS;
+  }
+  const pageSize = 15;
+  const countHint = projects.length > pageSize ? ` ${import_chalk2.default.dim(
+    `(${hasMoreProjects ? "100+" : projects.length} projects)`
+  )}` : "";
+  return await client.input.search({
+    message: `Which project?${countHint}`,
+    pageSize,
+    source: async (term, { signal }) => {
+      const searchTerm = term?.trim();
+      let matchingProjects = projects;
+      if (searchTerm) {
+        if (hasMoreProjects) {
+          matchingProjects = (await client.fetch(
+            `/v9/projects?search=${encodeURIComponent(searchTerm)}&limit=20`,
+            {
+              accountId: org.id,
+              signal
+            }
+          )).projects;
+        } else {
+          const normalizedSearchTerm = searchTerm.toLowerCase();
+          matchingProjects = projects.filter(
+            (project) => project.name.toLowerCase().includes(normalizedSearchTerm) || project.id === searchTerm
+          );
+        }
+      }
+      const choices = matchingProjects.slice().sort((a, b) => b.updatedAt - a.updatedAt).map((project) => ({
+        name: project.name,
+        value: project
+      }));
+      if (!allowBack) {
+        return choices;
+      }
+      const backChoice = {
+        name: "Back to project options",
+        value: BACK_TO_PROJECT_SELECTION
+      };
+      if (choices.length === 0) {
+        return [backChoice];
+      }
+      if (searchTerm) {
+        return choices;
+      }
+      return [...choices, new Separator(), backChoice];
+    }
+  });
+}
+async function inputProject(client, org, detectedProjectName, autoConfirm = false, skipAutoDetect = false, showProjectSuggestions = false, allowTeamSelectionBack = false, repoMatches = []) {
   const slugifiedName = (0, import_slugify.default)(detectedProjectName);
   let detectedProject = null;
-  if (!skipAutoDetect) {
+  if (!skipAutoDetect && repoMatches.length === 0) {
     output_manager_default.spinner("Searching for existing projects\u2026", 1e3);
     const [project, slugifiedProject] = await Promise.all([
       getProjectByNameOrId(client, detectedProjectName, org.id),
@@ -395,6 +511,9 @@ async function inputProject(client, org, detectedProjectName, autoConfirm = fals
     output_manager_default.stopSpinner();
   }
   if (autoConfirm) {
+    if (repoMatches.length === 1) {
+      return repoMatches[0];
+    }
     return detectedProject || detectedProjectName;
   }
   if (client.nonInteractive) {
@@ -405,8 +524,98 @@ async function inputProject(client, org, detectedProjectName, autoConfirm = fals
     err.code = "HEADLESS";
     throw err;
   }
+  const slugifiedNameKnownFree = !skipAutoDetect && repoMatches.length === 0 && !detectedProject;
+  let memoizedDefaultName;
+  async function defaultNewProjectName() {
+    if (memoizedDefaultName === void 0) {
+      memoizedDefaultName = slugifiedNameKnownFree ? slugifiedName : await suggestNewProjectName(
+        client,
+        org,
+        slugifiedName,
+        detectedProject?.name === slugifiedName
+      );
+    }
+    return memoizedDefaultName;
+  }
   let shouldLinkProject;
-  if (!detectedProject) {
+  if (showProjectSuggestions && !skipAutoDetect) {
+    for (; ; ) {
+      const choices = [];
+      if (repoMatches.length > 0) {
+        choices.push(
+          ...repoMatches.map((match) => ({
+            name: `${match.project.name} ${import_chalk2.default.gray("(linked by git)")}`,
+            value: match
+          })),
+          new Separator()
+        );
+      } else if (detectedProject) {
+        choices.push(
+          {
+            name: `${detectedProject.name} ${import_chalk2.default.gray("(folder name)")}`,
+            value: detectedProject
+          },
+          new Separator()
+        );
+      }
+      choices.push(
+        {
+          name: "Search all projects",
+          value: SEARCH_ALL_PROJECTS,
+          description: "Browse or search every project in this team"
+        },
+        {
+          name: "Create a new project",
+          value: CREATE_NEW_PROJECT,
+          description: `Create it under ${org.slug}`
+        }
+      );
+      if (allowTeamSelectionBack) {
+        choices.push({
+          name: "Choose a different team",
+          value: BACK_TO_TEAM_SELECTION,
+          description: "Return to team selection"
+        });
+      }
+      const selected = await client.input.select({
+        message: "Which project?",
+        choices
+      });
+      if (selected === BACK_TO_TEAM_SELECTION) {
+        return BACK_TO_TEAM_SELECTION;
+      }
+      if (selected === CREATE_NEW_PROJECT) {
+        const projectName = await promptForProjectNameWithBack(
+          client,
+          org,
+          await defaultNewProjectName()
+        );
+        if (projectName === BACK_TO_PROJECT_SELECTION) {
+          continue;
+        }
+        return projectName;
+      }
+      if (selected !== SEARCH_ALL_PROJECTS) {
+        return selected;
+      }
+      const existingProject = await searchExistingProjects(client, org, true);
+      if (existingProject === BACK_TO_PROJECT_SELECTION) {
+        continue;
+      }
+      if (existingProject === NO_EXISTING_PROJECTS) {
+        const projectName = await promptForProjectNameWithBack(
+          client,
+          org,
+          slugifiedName
+        );
+        if (projectName === BACK_TO_PROJECT_SELECTION) {
+          continue;
+        }
+        return projectName;
+      }
+      return existingProject;
+    }
+  } else if (!detectedProject) {
     const decision = await inputProjectDecision(
       client,
       skipAutoDetect ? "existing" : "create"
@@ -423,56 +632,12 @@ async function inputProject(client, org, detectedProjectName, autoConfirm = fals
     shouldLinkProject = decision === "existing";
   }
   if (shouldLinkProject) {
-    const firstPage = await client.fetch(`/v9/projects?limit=100`, { accountId: org.id });
-    const projects = firstPage.projects;
-    const hasMoreProjects = firstPage.pagination.next !== null;
-    if (projects.length === 0) {
-      output_manager_default.log(
-        `No existing projects found under ${import_chalk2.default.bold(org.slug)}. Creating new project.`
-      );
-    } else if (hasMoreProjects) {
-      let toLink;
-      await client.input.text({
-        message: "Existing project name?",
-        validate: async (val) => {
-          if (!val) {
-            return "Project name cannot be empty";
-          }
-          const project = await getProjectByNameOrId(client, val, org.id);
-          if (project instanceof ProjectNotFound) {
-            return "Project not found";
-          }
-          toLink = project;
-          return true;
-        }
-      });
-      return toLink;
-    } else {
-      const choices = projects.sort((a, b) => b.updatedAt - a.updatedAt).map((project) => ({
-        name: project.name,
-        value: project
-      }));
-      const toLink = await client.input.select({
-        message: "Which project?",
-        choices
-      });
-      return toLink;
+    const existingProject = await searchExistingProjects(client, org, false);
+    if (existingProject !== NO_EXISTING_PROJECTS && existingProject !== BACK_TO_PROJECT_SELECTION) {
+      return existingProject;
     }
   }
-  return await client.input.text({
-    message: `Name?`,
-    default: !detectedProject ? slugifiedName : void 0,
-    validate: async (val) => {
-      if (!val) {
-        return "Project name cannot be empty";
-      }
-      const project = await getProjectByNameOrId(client, val, org.id);
-      if (!(project instanceof ProjectNotFound)) {
-        return "Project already exists";
-      }
-      return true;
-    }
-  });
+  return await promptForProjectName(client, org, await defaultNewProjectName());
 }
 
 // src/util/input/input-root-directory.ts
@@ -800,77 +965,6 @@ async function promptForInferredServicesSetup({
 // src/util/projects/search-project-across-teams.ts
 var import_slugify2 = __toESM(require_slugify(), 1);
 import { relative as relative2 } from "path";
-async function searchProjectAcrossTeams(client, projectName, cwd, {
-  autoConfirm = false,
-  nonInteractive = false,
-  teams,
-  skipLimited,
-  gitProjectName
-} = {}) {
-  const teamsToSearch = teams ?? await getTeams(client);
-  const shouldSkipLimited = skipLimited ?? true;
-  const accessibleTeams = [];
-  const skippedTeams = [];
-  const skippedSlugs = [];
-  for (const t of teamsToSearch) {
-    if (shouldSkipLimited && t.limited) {
-      skippedTeams.push(t);
-      skippedSlugs.push(t.slug);
-    } else {
-      accessibleTeams.push(t);
-    }
-  }
-  if (skippedSlugs.length > 0) {
-    output_manager_default.debug(
-      `Skipping limited teams during cross-team project search: ${skippedSlugs.join(", ")}`
-    );
-  }
-  const searchedTeamSlugs = accessibleTeams.map((team) => team.slug);
-  const orgs = accessibleTeams.map((t) => ({
-    type: "team",
-    id: t.id,
-    slug: t.slug
-  }));
-  const repoMatchesPromise = searchProjectsByRepoRoot({
-    client,
-    cwd,
-    gitProjectName,
-    orgs,
-    autoConfirm,
-    nonInteractive
-  });
-  const slugifiedName = (0, import_slugify2.default)(projectName);
-  const searchNames = [projectName];
-  if (slugifiedName !== projectName) {
-    searchNames.push(slugifiedName);
-  }
-  const folderNameSearchPromises = orgs.flatMap(
-    (org) => searchNames.map(
-      (name) => getProjectByNameOrId(client, name, org.id).then(
-        (result) => result instanceof ProjectNotFound ? null : { project: result, org, reason: "folder-name" }
-      ).catch(() => null)
-    )
-  );
-  const [repoMatches, folderNameMatches] = await Promise.all([
-    repoMatchesPromise,
-    Promise.all(folderNameSearchPromises)
-  ]);
-  const results = [...repoMatches, ...folderNameMatches];
-  const seen = /* @__PURE__ */ new Set();
-  const matches = [];
-  for (const r of results) {
-    if (r && r.project.id && !seen.has(r.project.id)) {
-      seen.add(r.project.id);
-      matches.push(r);
-    }
-  }
-  return {
-    matches,
-    searchedTeamSlugs,
-    skippedLimitedTeamSlugs: skippedSlugs,
-    skippedLimitedTeams: skippedTeams
-  };
-}
 async function searchProjectsByRepoRoot({
   client,
   cwd,
@@ -889,9 +983,10 @@ async function searchProjectsByRepoRoot({
       yes: autoConfirm || nonInteractive
     });
   } catch (error) {
-    output_manager_default.debug(
-      `Failed to resolve Git remote for cross-team search: ${error}`
-    );
+    if (isPromptCanceledError(error)) {
+      throw error;
+    }
+    output_manager_default.debug(`Failed to resolve Git remote for project search: ${error}`);
     return [];
   }
   if (!remote) {
@@ -934,6 +1029,9 @@ async function searchProjectsByRepoRoot({
           };
         }).filter(Boolean);
       } catch (error) {
+        if (isPromptCanceledError(error)) {
+          throw error;
+        }
         output_manager_default.debug(
           `Failed to search Git-linked projects under ${org.slug}: ${error}`
         );
@@ -945,42 +1043,30 @@ async function searchProjectsByRepoRoot({
 }
 
 // src/util/link/setup-and-link.ts
-function formatMatchReason(match) {
-  if (match.reason === "repo-root") {
-    return import_chalk6.default.gray("(linked by git)");
-  }
-  return import_chalk6.default.gray("(folder name)");
-}
-function formatCrossTeamMatch(match) {
-  return `${import_chalk6.default.bold(match.org.slug)}/${match.project.name} ${formatMatchReason(
-    match
-  )}`;
-}
-function formatMatchSource(match) {
-  return match.reason === "repo-root" ? "Git repository" : "Folder name";
+function isCrossTeamMatch(value) {
+  return typeof value === "object" && value !== null && "project" in value && "org" in value && "reason" in value;
 }
-var CHECKBOX_INSTRUCTIONS = [
-  "\n  ",
-  import_chalk6.default.dim("("),
-  import_chalk6.default.cyan("<space>"),
-  import_chalk6.default.dim(" select, "),
-  import_chalk6.default.cyan("<enter>"),
-  import_chalk6.default.dim(" confirm, "),
-  import_chalk6.default.cyan("<a>"),
-  import_chalk6.default.dim(" toggle all, "),
-  import_chalk6.default.cyan("<i>"),
-  import_chalk6.default.dim(" invert)")
-].join("");
-function printCrossTeamSearchScope({
-  searchedTeamSlugs
-}) {
-  if (searchedTeamSlugs.length > 0) {
-    output_manager_default.print(
-      `  ${import_chalk6.default.dim(
-        `Searched ${searchedTeamSlugs.length} ${searchedTeamSlugs.length === 1 ? "team" : "teams"}`
-      )}
-`
+async function selectOrgForLink(client, autoConfirm, searchable = false, meta) {
+  try {
+    return await selectOrg(
+      client,
+      "Which team?",
+      autoConfirm,
+      searchable,
+      meta
     );
+  } catch (err) {
+    if (isAPIError(err)) {
+      if (err.code === "NOT_AUTHORIZED") {
+        output_manager_default.prettyError(err);
+        return { status: "error", exitCode: 1, reason: "NOT_AUTHORIZED" };
+      }
+      if (err.code === "TEAM_DELETED") {
+        output_manager_default.prettyError(err);
+        return { status: "error", exitCode: 1, reason: "TEAM_DELETED" };
+      }
+    }
+    throw err;
   }
 }
 function isErrnoException(err) {
@@ -1082,150 +1168,16 @@ async function linkCrossTeamMatch({
   );
   return { status: "linked", org: match.org, project: match.project };
 }
-async function promptForLimitedTeams(client, teams) {
-  if (teams.length === 0) {
-    return [];
-  }
-  return await client.input.checkbox({
-    message: "Select teams that require SSO",
-    instructions: CHECKBOX_INSTRUCTIONS,
-    choices: teams.map((team) => ({
-      name: team.name ? `${team.name} (${team.slug})` : team.slug,
-      value: team
-    }))
-  });
-}
-async function searchSelectedLimitedTeams({
-  client,
-  path: path2,
-  projectName,
-  gitProjectName,
-  teams
-}) {
-  const selectedTeams = await promptForLimitedTeams(client, teams);
-  if (selectedTeams.length === 0) {
-    return [];
-  }
-  output_manager_default.spinner("Searching selected teams that require SSO\u2026", 1e3);
-  try {
-    const result = await searchProjectAcrossTeams(client, projectName, path2, {
-      teams: selectedTeams,
-      skipLimited: false,
-      gitProjectName
-    });
-    printCrossTeamSearchScope({
-      searchedTeamSlugs: result.searchedTeamSlugs
-    });
-    return result.matches;
-  } catch (err) {
-    output_manager_default.debug(`Selected team search requiring SSO failed: ${err}`);
-    return [];
-  } finally {
-    output_manager_default.stopSpinner();
-  }
-}
-async function linkCrossTeamMatches({
-  client,
-  path: path2,
-  matches,
-  successEmoji,
-  autoConfirm,
-  nonInteractive,
-  pullEnv
-}) {
-  if (matches.length === 0) {
-    return null;
-  }
-  if (matches.length === 1) {
-    const match = matches[0];
-    if (autoConfirm || nonInteractive) {
-      return await linkCrossTeamMatch({
-        client,
-        path: path2,
-        match,
-        successEmoji,
-        autoConfirm,
-        pullEnv
-      });
-    }
-    output_manager_default.print("\n");
-    output_manager_default.print(`  ${import_chalk6.default.bold("Found existing project")}
-`);
-    if (match.reason === "repo-root") {
-      printAlignedLabel("Project", `${match.org.slug}/${match.project.name}`);
-      printAlignedLabel("Source", formatMatchSource(match));
-    } else {
-      printAlignedLabel("Project", `${match.org.slug}/${match.project.name}`);
-    }
-    const confirmed = await client.input.confirm(
-      match.reason === "repo-root" ? "Link repository to project?" : "Link directory to project?",
-      true
-    );
-    if (confirmed) {
-      return await linkCrossTeamMatch({
-        client,
-        path: path2,
-        match,
-        successEmoji,
-        autoConfirm,
-        pullEnv
-      });
-    }
-    return null;
-  }
-  const currentTeamMatch = matches.find(
-    (match) => match.org.id === client.config.currentTeam
-  );
-  if (autoConfirm && currentTeamMatch) {
-    return await linkCrossTeamMatch({
-      client,
-      path: path2,
-      match: currentTeamMatch,
-      successEmoji,
-      autoConfirm,
-      pullEnv
-    });
-  }
-  if (nonInteractive) {
-    return null;
-  }
-  const choices = matches.map((match) => ({
-    name: formatCrossTeamMatch(match),
-    value: match
-  }));
-  choices.push({
-    name: "Not one of these projects",
-    value: null
-  });
-  output_manager_default.print("\n");
-  printAlignedLabel("Projects", `${matches.length} matches across teams`);
-  const selected = await client.input.select({
-    message: "Which project?",
-    choices,
-    default: currentTeamMatch ?? void 0
-  });
-  if (!selected) {
-    return null;
-  }
-  return await linkCrossTeamMatch({
-    client,
-    path: path2,
-    match: selected,
-    successEmoji,
-    autoConfirm,
-    pullEnv
-  });
-}
 async function setupAndLink(client, path2, {
   autoConfirm = false,
   forceDelete = false,
   link,
+  selectedOrg,
   successEmoji = "link",
   projectName,
   nonInteractive = false,
   pullEnv = true,
-  v0,
-  searchAcrossTeams = false
+  v0
 }) {
   const { config } = client;
   const gitProjectName = projectName;
@@ -1240,130 +1192,122 @@ async function setupAndLink(client, path2, {
   const isTTY = client.stdin.isTTY;
   let rootDirectory = null;
   let newProjectName;
-  let org;
+  let org = selectedOrg;
   if (!forceDelete && link.status === "linked") {
     return link;
   }
+  if (getPlatformEnv("ORG_ID") && getPlatformEnv("PROJECT_ID")) {
+    const envLink = await getLinkedProject(client, path2);
+    if (envLink.status === "error") {
+      return envLink;
+    }
+    if (envLink.status === "linked") {
+      config.currentTeam = envLink.org.type === "team" ? envLink.org.id : void 0;
+      output_manager_default.print("\n");
+      printAlignedLabel("Directory", humanizePath(path2));
+      printAlignedLabel("Source", "VERCEL_ORG_ID and VERCEL_PROJECT_ID");
+      output_manager_default.print("\n");
+      printAlignedLabel(
+        "Linked",
+        `${envLink.org.slug}/${envLink.project.name}`,
+        { gutter: "\u2713" }
+      );
+      return envLink;
+    }
+  }
+  if (!isTTY && !autoConfirm && !nonInteractive) {
+    return { status: "error", exitCode: 1, reason: "HEADLESS" };
+  }
+  if (!org && (nonInteractive || !isTTY)) {
+    const resolved = await selectOrgForLink(client, autoConfirm);
+    if ("status" in resolved) {
+      return resolved;
+    }
+    org = resolved;
+  }
   if (forceDelete) {
     const vercelDir = getVercelDirectory(path2);
     (0, import_fs_extra2.remove)(join2(vercelDir, VERCEL_DIR_README));
     (0, import_fs_extra2.remove)(join2(vercelDir, VERCEL_DIR_PROJECT));
   }
-  if (!isTTY && !autoConfirm && !nonInteractive) {
-    return { status: "error", exitCode: 1, reason: "HEADLESS" };
-  }
   output_manager_default.print("\n");
   printAlignedLabel("Directory", humanizePath(path2));
   output_manager_default.print("\n");
-  let skipAutoDetect = false;
-  if (searchAcrossTeams) {
-    let crossTeamMatches = [];
-    let searchedTeamSlugs = [];
-    let skippedLimitedTeams = [];
-    output_manager_default.spinner("Searching for existing projects\u2026", 1e3);
-    try {
-      const searchResult = await searchProjectAcrossTeams(
+  const interactive = isTTY && !nonInteractive;
+  const searchableTeamPicker = interactive;
+  const showProjectSuggestions = interactive && !gitProjectName;
+  let projectOrNewProjectName;
+  let teamAutoSelected = false;
+  for (; ; ) {
+    if (!org) {
+      const orgMeta = {};
+      const resolved = await selectOrgForLink(
         client,
-        projectName,
-        path2,
-        {
-          autoConfirm,
-          nonInteractive,
-          gitProjectName
-        }
+        autoConfirm,
+        searchableTeamPicker,
+        orgMeta
       );
-      crossTeamMatches = searchResult.matches;
-      searchedTeamSlugs = searchResult.searchedTeamSlugs;
-      skippedLimitedTeams = searchResult.skippedLimitedTeams;
-    } catch (err) {
-      output_manager_default.debug(`Cross-team search failed: ${err}`);
-    } finally {
-      output_manager_default.stopSpinner();
-    }
-    if (crossTeamMatches.length > 0 && searchedTeamSlugs.length > 1 && !autoConfirm && !nonInteractive) {
-      printCrossTeamSearchScope({
-        searchedTeamSlugs
-      });
-    }
-    const linkedMatch = await linkCrossTeamMatches({
-      client,
-      path: path2,
-      matches: crossTeamMatches,
-      successEmoji,
-      autoConfirm,
-      nonInteractive,
-      pullEnv
-    });
-    if (linkedMatch) {
-      return linkedMatch;
+      if ("status" in resolved) {
+        return resolved;
+      }
+      org = resolved;
+      teamAutoSelected = orgMeta.choiceCount === 1;
     }
-    if (!autoConfirm && !nonInteractive && skippedLimitedTeams.length > 0) {
-      if (crossTeamMatches.length === 0) {
-        printAlignedLabel(
-          "Searched",
-          `${searchedTeamSlugs.length} ${searchedTeamSlugs.length === 1 ? "team" : "teams"} available without SSO`
-        );
-        output_manager_default.print("  No matching projects found\n");
+    let repoMatches = [];
+    if (showProjectSuggestions) {
+      output_manager_default.spinner("Searching for existing projects\u2026", 1e3);
+      try {
+        repoMatches = await searchProjectsByRepoRoot({
+          client,
+          cwd: path2,
+          gitProjectName,
+          orgs: [org],
+          autoConfirm,
+          nonInteractive
+        });
+      } catch (err) {
+        if (isPromptCanceledError(err)) {
+          throw err;
+        }
+        output_manager_default.debug(`Git-linked project search failed: ${err}`);
+      } finally {
+        output_manager_default.stopSpinner();
       }
-      const limitedTeamMatches = await searchSelectedLimitedTeams({
+    }
+    try {
+      projectOrNewProjectName = await inputProject(
         client,
-        path: path2,
+        org,
         projectName,
-        gitProjectName,
-        teams: skippedLimitedTeams
-      });
-      const linkedLimitedMatch = await linkCrossTeamMatches({
-        client,
-        path: path2,
-        matches: limitedTeamMatches,
-        successEmoji,
         autoConfirm,
-        nonInteractive,
-        pullEnv
-      });
-      if (linkedLimitedMatch) {
-        return linkedLimitedMatch;
-      }
-      if (limitedTeamMatches.length === 0) {
-        output_manager_default.print("  No matching projects found in the selected teams.\n");
-      }
-      skipAutoDetect = skipAutoDetect || crossTeamMatches.length > 0 || limitedTeamMatches.length > 0;
-    } else if (crossTeamMatches.length > 0) {
-      skipAutoDetect = true;
-    }
-  }
-  try {
-    org = await selectOrg(client, "Which team?", autoConfirm);
-  } catch (err) {
-    if (isAPIError(err)) {
-      if (err.code === "NOT_AUTHORIZED") {
-        output_manager_default.prettyError(err);
-        return { status: "error", exitCode: 1, reason: "NOT_AUTHORIZED" };
-      }
-      if (err.code === "TEAM_DELETED") {
-        output_manager_default.prettyError(err);
-        return { status: "error", exitCode: 1, reason: "TEAM_DELETED" };
+        false,
+        showProjectSuggestions,
+        searchableTeamPicker && !selectedOrg && !teamAutoSelected,
+        repoMatches
+      );
+    } catch (err) {
+      if (err instanceof Error && err.code === "HEADLESS") {
+        return { status: "error", exitCode: 1, reason: "HEADLESS" };
       }
+      throw err;
     }
-    throw err;
-  }
-  let projectOrNewProjectName;
-  try {
-    projectOrNewProjectName = await inputProject(
-      client,
-      org,
-      projectName,
-      autoConfirm,
-      skipAutoDetect
-    );
-  } catch (err) {
-    if (err instanceof Error && err.code === "HEADLESS") {
-      return { status: "error", exitCode: 1, reason: "HEADLESS" };
+    if (projectOrNewProjectName === BACK_TO_TEAM_SELECTION) {
+      org = void 0;
+      continue;
     }
-    throw err;
+    break;
   }
   if (typeof projectOrNewProjectName === "string") {
     newProjectName = projectOrNewProjectName;
+  } else if (isCrossTeamMatch(projectOrNewProjectName)) {
+    return await linkCrossTeamMatch({
+      client,
+      path: path2,
+      match: projectOrNewProjectName,
+      successEmoji,
+      autoConfirm,
+      pullEnv
+    });
   } else {
     const project = projectOrNewProjectName;
     await linkFolderToProject(
@@ -1530,6 +1474,9 @@ async function setupAndLink(client, path2, {
     await connectGitRepository(client, path2, project, autoConfirm, org);
     return { status: "linked", org, project };
   } catch (err) {
+    if (isPromptCanceledError(err)) {
+      throw err;
+    }
     if (isAPIError(err) && err.code === "too_many_projects") {
       output_manager_default.prettyError(err);
       return { status: "error", exitCode: 1, reason: "TOO_MANY_PROJECTS" };
@@ -1573,6 +1520,9 @@ async function connectGitRepository(client, path2, project, autoConfirm, org) {
       repoPath: `${repoInfo.org}/${repoInfo.repo}`
     });
   } catch (error) {
+    if (isPromptCanceledError(error)) {
+      return;
+    }
     output_manager_default.debug(`Failed to connect git repository: ${error}`);
   }
 }