vercel 53.1.1 → 53.3.0

package/dist/chunks/{chunk-BAAZFRLH.js → chunk-QV34LTI7.js}

@@ -6,10 +6,10 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   getLocalPathConfig
-} from "./chunk-KFFW6MSL.js";
+} from "./chunk-4L73BR7G.js";
 import {
   table
-} from "./chunk-ABDTA3V2.js";
+} from "./chunk-KSIISCB2.js";
 import {
   VERCEL_DIR_PROJECT,
   VERCEL_DIR_README,
@@ -17,35 +17,40 @@ import {
   compileVercelConfig,
   createProject,
   detectProjects,
+  fetchProjectsForRepoUrl,
+  findProjectsFromPath,
+  findRepoRoot,
   findSourceVercelConfigFile,
   getLinkedProject,
   getProjectByNameOrId,
   getServicesConfigWriteBlocker,
   getTeams,
-  getUser,
   getVercelDirectory,
   humanizePath,
   isDirectory,
   linkFolderToProject,
+  linkRepoProject,
   parseGitConfig,
   pluckRemoteUrls,
+  pull,
   readJSONFile,
   require_dist3 as require_dist,
   require_frameworks,
   require_lib,
   require_slugify,
+  resolveGitRemote,
   selectAndParseRemoteUrl,
   selectOrg,
   writeServicesConfig
-} from "./chunk-SPXTKMOV.js";
+} from "./chunk-JJ36CB7A.js";
 import {
   printError
-} from "./chunk-JNOMOD7R.js";
+} from "./chunk-GQLARSTH.js";
 import {
   CantParseJSONFile,
   ProjectNotFound,
   isAPIError
-} from "./chunk-XZ7CVBQ4.js";
+} from "./chunk-EBEBY45K.js";
 import {
   output_manager_default
 } from "./chunk-ZQKJVHXY.js";
@@ -701,29 +706,63 @@ async function promptForInferredServicesSetup({
 
 // src/util/projects/search-project-across-teams.ts
 var import_slugify2 = __toESM(require_slugify(), 1);
-async function searchProjectAcrossTeams(client, projectName) {
-  const [user, teams] = await Promise.all([getUser(client), getTeams(client)]);
-  const orgs = [
-    ...user.version === "northstar" ? [] : [{ type: "user", id: user.id, slug: user.username }],
-    ...teams.map((t) => ({
-      type: "team",
-      id: t.id,
-      slug: t.slug
-    }))
-  ];
+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 searchPromises = orgs.flatMap(
+  const folderNameSearchPromises = orgs.flatMap(
     (org) => searchNames.map(
       (name) => getProjectByNameOrId(client, name, org.id).then(
-        (result) => result instanceof ProjectNotFound ? null : { project: result, org }
+        (result) => result instanceof ProjectNotFound ? null : { project: result, org, reason: "folder-name" }
       ).catch(() => null)
     )
   );
-  const results = await Promise.all(searchPromises);
+  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) {
@@ -732,23 +771,320 @@ async function searchProjectAcrossTeams(client, projectName) {
       matches.push(r);
     }
   }
-  return matches;
+  return {
+    matches,
+    searchedTeamSlugs,
+    skippedLimitedTeamSlugs: skippedSlugs,
+    skippedLimitedTeams: skippedTeams
+  };
+}
+async function searchProjectsByRepoRoot({
+  client,
+  cwd,
+  gitProjectName,
+  orgs,
+  autoConfirm,
+  nonInteractive
+}) {
+  const rootPath = await findRepoRoot(cwd);
+  if (!rootPath) {
+    return [];
+  }
+  let remote;
+  try {
+    remote = await resolveGitRemote(client, rootPath, {
+      yes: autoConfirm || nonInteractive
+    });
+  } catch (error) {
+    output_manager_default.debug(
+      `Failed to resolve Git remote for cross-team search: ${error}`
+    );
+    return [];
+  }
+  if (!remote) {
+    return [];
+  }
+  const relativePath = relative2(rootPath, cwd);
+  const results = await Promise.all(
+    orgs.map(async (org) => {
+      try {
+        const projects = await fetchProjectsForRepoUrl(
+          client,
+          remote.repoUrl,
+          org.id
+        );
+        const repoProjectConfigs = projects.filter(
+          (project) => !gitProjectName || project.id === gitProjectName || project.name === gitProjectName
+        ).map((project) => ({
+          id: project.id,
+          name: project.name,
+          directory: project.rootDirectory || ".",
+          orgId: org.id
+        }));
+        const matchingProjects = findProjectsFromPath(
+          repoProjectConfigs,
+          relativePath
+        );
+        return matchingProjects.map((match) => {
+          const project = projects.find((p) => p.id === match.id);
+          if (!project) {
+            return null;
+          }
+          return {
+            project,
+            org,
+            reason: "repo-root",
+            repo: {
+              ...remote,
+              directory: match.directory
+            }
+          };
+        }).filter(Boolean);
+      } catch (error) {
+        output_manager_default.debug(
+          `Failed to search Git-linked projects under ${org.slug}: ${error}`
+        );
+        return [];
+      }
+    })
+  );
+  return results.flat();
 }
 
 // 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.blue(match.org.slug)}/${match.project.name} ${formatMatchReason(
+    match
+  )}`;
+}
+function formatTeamList(slugs) {
+  const shown = slugs.slice(0, 5);
+  const suffix = slugs.length > shown.length ? `, and ${slugs.length - shown.length} more` : "";
+  return `${shown.join(", ")}${suffix}`;
+}
+function printCrossTeamSearchScope({
+  searchedTeamSlugs,
+  skippedLimitedTeamSlugs
+}) {
+  if (searchedTeamSlugs.length > 0) {
+    output_manager_default.log(`Searched teams: ${formatTeamList(searchedTeamSlugs)}`);
+  }
+  if (skippedLimitedTeamSlugs.length > 0) {
+    output_manager_default.log(
+      `Skipped ${skippedLimitedTeamSlugs.length} SSO-protected ${skippedLimitedTeamSlugs.length === 1 ? "team" : "teams"}`
+    );
+  }
+}
+async function maybePullEnvAfterLink(client, path2, autoConfirm, pullEnv) {
+  if (!pullEnv || !client.stdin.isTTY || client.nonInteractive) {
+    return;
+  }
+  const pullEnvConfirmed = autoConfirm || await client.input.confirm(
+    "Would you like to pull environment variables now?",
+    true
+  );
+  if (!pullEnvConfirmed) {
+    return;
+  }
+  const originalCwd = client.cwd;
+  try {
+    client.cwd = path2;
+    const args = autoConfirm ? ["--yes"] : [];
+    const exitCode = await pull(client, args, "vercel-cli:link");
+    if (exitCode !== 0) {
+      output_manager_default.error(
+        "Failed to pull environment variables. You can run `vc env pull` manually."
+      );
+    }
+  } catch (_error) {
+    output_manager_default.error(
+      "Failed to pull environment variables. You can run `vc env pull` manually."
+    );
+  } finally {
+    client.cwd = originalCwd;
+  }
+}
+async function linkCrossTeamMatch({
+  client,
+  path: path2,
+  match,
+  successEmoji,
+  autoConfirm,
+  pullEnv
+}) {
+  client.config.currentTeam = match.org.type === "team" ? match.org.id : void 0;
+  if (match.reason === "repo-root" && match.repo) {
+    await linkRepoProject(client, path2, {
+      project: match.project,
+      orgId: match.org.id,
+      orgSlug: match.org.slug,
+      remoteName: match.repo.remoteName,
+      successEmoji
+    });
+    await maybePullEnvAfterLink(client, path2, autoConfirm, pullEnv);
+    return {
+      status: "linked",
+      org: match.org,
+      project: match.project,
+      repoRoot: match.repo.rootPath
+    };
+  }
+  await linkFolderToProject(
+    client,
+    path2,
+    { projectId: match.project.id, orgId: match.org.id },
+    match.project.name,
+    match.org.slug,
+    successEmoji,
+    autoConfirm,
+    pullEnv
+  );
+  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: "Which SSO-protected teams should be searched?",
+    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 SSO-protected teams\u2026", 1e3);
+  try {
+    const result = await searchProjectAcrossTeams(client, projectName, path2, {
+      teams: selectedTeams,
+      skipLimited: false,
+      gitProjectName
+    });
+    printCrossTeamSearchScope({
+      searchedTeamSlugs: result.searchedTeamSlugs,
+      skippedLimitedTeamSlugs: []
+    });
+    return result.matches;
+  } catch (err) {
+    output_manager_default.debug(`Selected SSO-protected team search 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
+      });
+    }
+    const confirmed = await client.input.confirm(
+      `Found project ${formatCrossTeamMatch(match)}. Link to it?`,
+      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
+  });
+  const selected = await client.input.select({
+    message: "Found matching projects across teams. Which one do you want to link?",
+    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,
   successEmoji = "link",
   setupMsg = "Set up",
-  projectName = basename(path2),
+  projectName,
   nonInteractive = false,
   pullEnv = true,
   v0,
   searchAcrossTeams = false
 }) {
   const { config } = client;
+  const gitProjectName = projectName;
+  projectName = projectName ?? basename(path2);
   if (!isDirectory(path2)) {
     output_manager_default.error(`Expected directory but found file: ${path2}`);
     return { status: "error", exitCode: 1, reason: "PATH_IS_FILE" };
@@ -783,105 +1119,81 @@ async function setupAndLink(client, path2, {
   let skipAutoDetect = false;
   if (searchAcrossTeams) {
     let crossTeamMatches = [];
+    let searchedTeamSlugs = [];
+    let skippedLimitedTeamSlugs = [];
+    let skippedLimitedTeams = [];
     output_manager_default.spinner("Searching for existing projects\u2026", 1e3);
     try {
-      crossTeamMatches = await searchProjectAcrossTeams(client, projectName);
+      const searchResult = await searchProjectAcrossTeams(
+        client,
+        projectName,
+        path2,
+        {
+          autoConfirm,
+          nonInteractive,
+          gitProjectName
+        }
+      );
+      crossTeamMatches = searchResult.matches;
+      searchedTeamSlugs = searchResult.searchedTeamSlugs;
+      skippedLimitedTeamSlugs = searchResult.skippedLimitedTeamSlugs;
+      skippedLimitedTeams = searchResult.skippedLimitedTeams;
     } catch (err) {
       output_manager_default.debug(`Cross-team search failed: ${err}`);
     } finally {
       output_manager_default.stopSpinner();
     }
-    if (crossTeamMatches.length === 1) {
-      const match = crossTeamMatches[0];
-      if (autoConfirm || nonInteractive) {
-        config.currentTeam = match.org.type === "team" ? match.org.id : void 0;
-        await linkFolderToProject(
-          client,
-          path2,
-          { projectId: match.project.id, orgId: match.org.id },
-          match.project.name,
-          match.org.slug,
-          successEmoji,
-          autoConfirm,
-          pullEnv
+    if (crossTeamMatches.length > 0 && !autoConfirm && !nonInteractive) {
+      printCrossTeamSearchScope({
+        searchedTeamSlugs,
+        skippedLimitedTeamSlugs
+      });
+    }
+    const linkedMatch = await linkCrossTeamMatches({
+      client,
+      path: path2,
+      matches: crossTeamMatches,
+      successEmoji,
+      autoConfirm,
+      nonInteractive,
+      pullEnv
+    });
+    if (linkedMatch) {
+      return linkedMatch;
+    }
+    if (!autoConfirm && !nonInteractive && skippedLimitedTeams.length > 0) {
+      if (crossTeamMatches.length === 0) {
+        output_manager_default.log(
+          `No matching projects found in the ${searchedTeamSlugs.length} ${searchedTeamSlugs.length === 1 ? "team" : "teams"} available in your current session.`
         );
-        return { status: "linked", org: match.org, project: match.project };
       }
-      const confirmed = await client.input.confirm(
-        `Found project ${import_chalk6.default.blue(match.org.slug)}/${match.project.name}. Link to it?`,
-        true
-      );
-      if (confirmed) {
-        config.currentTeam = match.org.type === "team" ? match.org.id : void 0;
-        await linkFolderToProject(
-          client,
-          path2,
-          { projectId: match.project.id, orgId: match.org.id },
-          match.project.name,
-          match.org.slug,
-          successEmoji,
-          autoConfirm,
-          pullEnv
-        );
-        return { status: "linked", org: match.org, project: match.project };
+      const limitedTeamMatches = await searchSelectedLimitedTeams({
+        client,
+        path: path2,
+        projectName,
+        gitProjectName,
+        teams: skippedLimitedTeams
+      });
+      const linkedLimitedMatch = await linkCrossTeamMatches({
+        client,
+        path: path2,
+        matches: limitedTeamMatches,
+        successEmoji,
+        autoConfirm,
+        nonInteractive,
+        pullEnv
+      });
+      if (linkedLimitedMatch) {
+        return linkedLimitedMatch;
       }
-      skipAutoDetect = true;
-    } else if (crossTeamMatches.length > 1) {
-      const currentTeamMatch = autoConfirm ? crossTeamMatches.find((m) => m.org.id === config.currentTeam) : void 0;
-      if (currentTeamMatch) {
-        config.currentTeam = currentTeamMatch.org.type === "team" ? currentTeamMatch.org.id : void 0;
-        await linkFolderToProject(
-          client,
-          path2,
-          {
-            projectId: currentTeamMatch.project.id,
-            orgId: currentTeamMatch.org.id
-          },
-          currentTeamMatch.project.name,
-          currentTeamMatch.org.slug,
-          successEmoji,
-          autoConfirm,
-          pullEnv
+      if (limitedTeamMatches.length === 0) {
+        output_manager_default.log(
+          "No matching projects found in the selected SSO-protected teams."
         );
-        return {
-          status: "linked",
-          org: currentTeamMatch.org,
-          project: currentTeamMatch.project
-        };
-      }
-      if (!nonInteractive) {
-        const choices = crossTeamMatches.map((m) => ({
-          name: `${import_chalk6.default.blue(m.org.slug)}/${m.project.name}`,
-          value: m
-        }));
-        choices.push({
-          name: "Don't link to an existing project",
-          value: null
-        });
-        const selected = await client.input.select({
-          message: "Found matching projects across teams. Which one do you want to link?",
-          choices
-        });
-        if (selected) {
-          config.currentTeam = selected.org.type === "team" ? selected.org.id : void 0;
-          await linkFolderToProject(
-            client,
-            path2,
-            { projectId: selected.project.id, orgId: selected.org.id },
-            selected.project.name,
-            selected.org.slug,
-            successEmoji,
-            autoConfirm,
-            pullEnv
-          );
-          return {
-            status: "linked",
-            org: selected.org,
-            project: selected.project
-          };
-        }
-        skipAutoDetect = true;
       }
+      skipAutoDetect = skipAutoDetect || crossTeamMatches.length > 0 || limitedTeamMatches.length > 0;
+    } else if (crossTeamMatches.length > 0) {
+      skipAutoDetect = true;
     }
   }
   try {

package/dist/chunks/{chunk-YIK5Y7MI.js → chunk-RI23R2QO.js}

@@ -9,22 +9,22 @@ import {
 } from "./chunk-HTOH3MSD.js";
 import {
   getScope
-} from "./chunk-EYQEF55O.js";
+} from "./chunk-PR72OE3G.js";
 import {
   AGENT_REASON
 } from "./chunk-E3NE4SKN.js";
 import {
   getLinkedProject,
   getProjectByNameOrId
-} from "./chunk-SPXTKMOV.js";
+} from "./chunk-JJ36CB7A.js";
 import {
   buildCommandWithGlobalFlags,
   outputAgentError
-} from "./chunk-IABMY4Q3.js";
+} from "./chunk-AXQNAI65.js";
 import {
   ProjectNotFound,
   isAPIError
-} from "./chunk-XZ7CVBQ4.js";
+} from "./chunk-EBEBY45K.js";
 
 // src/commands/alerts/resolve-alerts-scope.ts
 function emitAlertsScopeError(client, jsonOutput, code, message, agent) {