@depup/vercel 50.32.5-depup.0

package/dist/chunks/edit-FQE7JGU3.js

@@ -0,0 +1,509 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  editRoute
+} from "./chunk-P3SKP5WM.js";
+import {
+  applyFlagMutations,
+  cloneRoute,
+  convertRouteToCurrentRoute,
+  generateRoute,
+  generatedRouteToAddInput,
+  hasAnyTransformFlags,
+  populateRouteEnv,
+  printGeneratedRoutePreview,
+  printRouteConfig,
+  routingRuleToCurrentRoute,
+  runInteractiveEditLoop
+} from "./chunk-TEVP63TU.js";
+import {
+  getRouteVersions
+} from "./chunk-AHU7WNL2.js";
+import {
+  ensureProjectLink,
+  getRoutes,
+  offerAutoPromote,
+  parseSubcommandArgs,
+  resolveRoute
+} from "./chunk-TNBMKNET.js";
+import {
+  editSubcommand
+} from "./chunk-U6XOC6E4.js";
+import "./chunk-AQLVWVEN.js";
+import "./chunk-P4I4DMEU.js";
+import {
+  stamp_default
+} from "./chunk-SOTR4CXR.js";
+import "./chunk-7EHTK7LP.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  getCommandName
+} from "./chunk-ZLCMHY2G.js";
+import "./chunk-3XFFP2BA.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/routes/edit.ts
+var import_chalk = __toESM(require_source(), 1);
+async function edit(client, argv) {
+  const parsed = await parseSubcommandArgs(argv, editSubcommand);
+  if (typeof parsed === "number")
+    return parsed;
+  const link = await ensureProjectLink(client);
+  if (typeof link === "number")
+    return link;
+  const { project, org } = link;
+  const teamId = org.type === "team" ? org.id : void 0;
+  const { args, flags } = parsed;
+  const skipConfirmation = flags["--yes"];
+  const identifier = args[0];
+  const { RoutesEditTelemetryClient } = await import("./routes-Q5CWG44T.js");
+  const telemetry = new RoutesEditTelemetryClient({
+    opts: { store: client.telemetryEventStore }
+  });
+  telemetry.trackCliArgumentNameOrId(identifier);
+  telemetry.trackCliFlagYes(skipConfirmation);
+  telemetry.trackCliOptionName(flags["--name"]);
+  telemetry.trackCliOptionDescription(
+    flags["--description"]
+  );
+  telemetry.trackCliOptionSrc(flags["--src"]);
+  telemetry.trackCliOptionSrcSyntax(
+    flags["--src-syntax"]
+  );
+  telemetry.trackCliOptionAction(flags["--action"]);
+  telemetry.trackCliOptionDest(flags["--dest"]);
+  telemetry.trackCliOptionStatus(flags["--status"]);
+  telemetry.trackCliFlagNoDest(flags["--no-dest"]);
+  telemetry.trackCliFlagNoStatus(flags["--no-status"]);
+  telemetry.trackCliFlagClearConditions(
+    flags["--clear-conditions"]
+  );
+  telemetry.trackCliFlagClearHeaders(
+    flags["--clear-headers"]
+  );
+  telemetry.trackCliFlagClearTransforms(
+    flags["--clear-transforms"]
+  );
+  telemetry.trackCliOptionSetResponseHeader(
+    flags["--set-response-header"]
+  );
+  telemetry.trackCliOptionAppendResponseHeader(
+    flags["--append-response-header"]
+  );
+  telemetry.trackCliOptionDeleteResponseHeader(
+    flags["--delete-response-header"]
+  );
+  telemetry.trackCliOptionSetRequestHeader(
+    flags["--set-request-header"]
+  );
+  telemetry.trackCliOptionAppendRequestHeader(
+    flags["--append-request-header"]
+  );
+  telemetry.trackCliOptionDeleteRequestHeader(
+    flags["--delete-request-header"]
+  );
+  telemetry.trackCliOptionSetRequestQuery(
+    flags["--set-request-query"]
+  );
+  telemetry.trackCliOptionAppendRequestQuery(
+    flags["--append-request-query"]
+  );
+  telemetry.trackCliOptionDeleteRequestQuery(
+    flags["--delete-request-query"]
+  );
+  telemetry.trackCliOptionHas(flags["--has"]);
+  telemetry.trackCliOptionMissing(flags["--missing"]);
+  telemetry.trackCliOptionAi(flags["--ai"]);
+  if (!identifier) {
+    output_manager_default.error(
+      `Route name or ID is required. Usage: ${getCommandName("routes edit <name-or-id>")}`
+    );
+    return 1;
+  }
+  const { versions } = await getRouteVersions(client, project.id, { teamId });
+  const existingStagingVersion = versions.find((v) => v.isStaging);
+  output_manager_default.spinner("Fetching routes");
+  const { routes } = await getRoutes(client, project.id, { teamId });
+  output_manager_default.stopSpinner();
+  if (routes.length === 0) {
+    output_manager_default.error("No routes found in this project.");
+    return 1;
+  }
+  const originalRoute = await resolveRoute(client, routes, identifier);
+  if (!originalRoute) {
+    output_manager_default.error(
+      `No route found matching "${identifier}". Run ${import_chalk.default.cyan(
+        getCommandName("routes list")
+      )} to see all routes.`
+    );
+    return 1;
+  }
+  const aiPrompt = flags["--ai"];
+  if (aiPrompt) {
+    const conflictingFlags = [
+      "--name",
+      "--description",
+      "--src",
+      "--src-syntax",
+      "--action",
+      "--dest",
+      "--status",
+      "--no-dest",
+      "--no-status",
+      "--has",
+      "--missing",
+      "--set-response-header",
+      "--append-response-header",
+      "--delete-response-header",
+      "--set-request-header",
+      "--append-request-header",
+      "--delete-request-header",
+      "--set-request-query",
+      "--append-request-query",
+      "--delete-request-query",
+      "--clear-conditions",
+      "--clear-headers",
+      "--clear-transforms"
+    ];
+    const usedConflicts = conflictingFlags.filter((f) => flags[f] !== void 0);
+    if (usedConflicts.length > 0) {
+      output_manager_default.error(
+        `Cannot use --ai with ${usedConflicts.join(", ")}. Use --ai alone to describe changes.`
+      );
+      return 1;
+    }
+    return await handleAIEdit(
+      client,
+      project.id,
+      teamId,
+      originalRoute,
+      aiPrompt,
+      skipConfirmation,
+      existingStagingVersion
+    );
+  }
+  const route = cloneRoute(originalRoute);
+  const hasEditFlags = flags["--name"] !== void 0 || flags["--description"] !== void 0 || flags["--src"] !== void 0 || flags["--src-syntax"] !== void 0 || flags["--action"] !== void 0 || flags["--dest"] !== void 0 || flags["--status"] !== void 0 || flags["--no-dest"] !== void 0 || flags["--no-status"] !== void 0 || flags["--has"] !== void 0 || flags["--missing"] !== void 0 || flags["--clear-conditions"] !== void 0 || flags["--clear-headers"] !== void 0 || flags["--clear-transforms"] !== void 0 || hasAnyTransformFlags(flags);
+  if (hasEditFlags) {
+    const error = applyFlagMutations(route, flags);
+    if (error) {
+      output_manager_default.error(error);
+      return 1;
+    }
+  } else {
+    if (!client.stdin.isTTY) {
+      output_manager_default.error(
+        `No edit flags provided. When running non-interactively, use flags like --name, --dest, --src, etc. Run ${getCommandName("routes edit --help")} for all options.`
+      );
+      return 1;
+    }
+    output_manager_default.log(`
+Editing route "${originalRoute.name}"`);
+    printRouteConfig(route);
+    const editMode = await client.input.select({
+      message: "How would you like to edit this route?",
+      choices: [
+        { name: "Describe changes (AI-powered)", value: "ai" },
+        { name: "Edit manually (field by field)", value: "manual" }
+      ]
+    });
+    if (editMode === "ai") {
+      telemetry.trackCliOptionAi("interactive");
+      return await handleAIEdit(
+        client,
+        project.id,
+        teamId,
+        originalRoute,
+        void 0,
+        skipConfirmation,
+        existingStagingVersion
+      );
+    }
+    await runInteractiveEditLoop(client, route);
+  }
+  populateRouteEnv(route.route);
+  if (JSON.stringify(route) === JSON.stringify(originalRoute)) {
+    output_manager_default.log("No changes made.");
+    return 0;
+  }
+  const editStamp = stamp_default();
+  output_manager_default.spinner(`Updating route "${route.name}"`);
+  try {
+    const { version } = await editRoute(
+      client,
+      project.id,
+      originalRoute.id,
+      {
+        route: {
+          name: route.name,
+          description: route.description,
+          enabled: route.enabled,
+          srcSyntax: route.srcSyntax,
+          route: route.route
+        }
+      },
+      { teamId }
+    );
+    output_manager_default.log(
+      `${import_chalk.default.cyan("Updated")} route "${route.name}" ${import_chalk.default.gray(editStamp())}`
+    );
+    await offerAutoPromote(
+      client,
+      project.id,
+      version,
+      !!existingStagingVersion,
+      { teamId, skipPrompts: skipConfirmation }
+    );
+    return 0;
+  } catch (e) {
+    const error = e;
+    output_manager_default.error(error.message || "Failed to update route");
+    return 1;
+  }
+}
+async function handleAIEdit(client, projectId, teamId, originalRoute, aiPrompt, skipConfirmation, existingStagingVersion) {
+  const currentRoute = routingRuleToCurrentRoute(originalRoute);
+  let prompt = aiPrompt;
+  let currentGenerated;
+  for (; ; ) {
+    if (!prompt) {
+      prompt = await client.input.text({
+        message: "Describe what you'd like to change:",
+        validate: (val) => {
+          if (!val)
+            return "A description is required";
+          if (val.length > 2e3)
+            return "Description must be 2000 characters or less";
+          return true;
+        }
+      });
+    }
+    output_manager_default.spinner("Generating updated route...");
+    let errorMessage;
+    try {
+      const result = await generateRoute(
+        client,
+        projectId,
+        { prompt, currentRoute },
+        { teamId }
+      );
+      if (result.error) {
+        errorMessage = result.error;
+      } else if (!result.route) {
+        errorMessage = "Could not apply changes. Try rephrasing.";
+      } else {
+        currentGenerated = result.route;
+      }
+    } catch (e) {
+      const error = e;
+      errorMessage = error.message || "Failed to generate updated route";
+    }
+    if (currentGenerated) {
+      break;
+    }
+    output_manager_default.error(errorMessage);
+    if (skipConfirmation || !client.stdin.isTTY) {
+      return 1;
+    }
+    const retry = await client.input.select({
+      message: "What would you like to do?",
+      choices: [
+        { name: "Try again with a different description", value: "retry" },
+        { name: "Cancel", value: "cancel" }
+      ]
+    });
+    if (retry === "cancel") {
+      output_manager_default.log("No changes made.");
+      return 0;
+    }
+    prompt = void 0;
+  }
+  printGeneratedRoutePreview(currentGenerated);
+  if (skipConfirmation) {
+    return await applyAIEdit(
+      client,
+      projectId,
+      teamId,
+      originalRoute,
+      currentGenerated,
+      existingStagingVersion,
+      skipConfirmation
+    );
+  }
+  if (!client.stdin.isTTY) {
+    output_manager_default.error(
+      `Cannot interactively confirm route changes in a non-TTY environment. Use ${getCommandName('routes edit <name-or-id> --ai "..." --yes')} to skip confirmation.`
+    );
+    return 1;
+  }
+  for (; ; ) {
+    const choice = await client.input.select({
+      message: "What would you like to do?",
+      choices: [
+        { name: "Confirm changes", value: "confirm" },
+        { name: "Edit again with AI", value: "ai-edit" },
+        { name: "Edit manually", value: "manual" },
+        { name: "Discard", value: "discard" }
+      ],
+      pageSize: 4,
+      loop: false
+    });
+    if (choice === "confirm") {
+      return await applyAIEdit(
+        client,
+        projectId,
+        teamId,
+        originalRoute,
+        currentGenerated,
+        existingStagingVersion,
+        skipConfirmation
+      );
+    }
+    if (choice === "ai-edit") {
+      const editPrompt = await client.input.text({
+        message: "Describe what you'd like to change:",
+        validate: (val) => {
+          if (!val)
+            return "A description is required";
+          if (val.length > 2e3)
+            return "Description must be 2000 characters or less";
+          return true;
+        }
+      });
+      output_manager_default.spinner("Updating route...");
+      try {
+        const editResult = await generateRoute(
+          client,
+          projectId,
+          {
+            prompt: editPrompt,
+            currentRoute: convertRouteToCurrentRoute(currentGenerated)
+          },
+          { teamId }
+        );
+        if (editResult.error) {
+          output_manager_default.error(editResult.error);
+          output_manager_default.log("Keeping previous route:");
+          printGeneratedRoutePreview(currentGenerated);
+          continue;
+        }
+        if (!editResult.route) {
+          output_manager_default.error("Could not apply changes. Try rephrasing.");
+          output_manager_default.log("Keeping previous route:");
+          printGeneratedRoutePreview(currentGenerated);
+          continue;
+        }
+        currentGenerated = editResult.route;
+        printGeneratedRoutePreview(currentGenerated);
+      } catch (e) {
+        const error = e;
+        output_manager_default.error(error.message || "Failed to update route");
+        output_manager_default.log("Keeping previous route:");
+        printGeneratedRoutePreview(currentGenerated);
+      }
+      continue;
+    }
+    if (choice === "manual") {
+      const routeInput = generatedRouteToAddInput(currentGenerated);
+      const manualRoute = cloneRoute(originalRoute);
+      manualRoute.name = routeInput.name;
+      manualRoute.description = routeInput.description;
+      manualRoute.srcSyntax = routeInput.srcSyntax;
+      manualRoute.route = routeInput.route;
+      await runInteractiveEditLoop(client, manualRoute);
+      populateRouteEnv(manualRoute.route);
+      const editStamp = stamp_default();
+      output_manager_default.spinner(`Updating route "${manualRoute.name}"`);
+      try {
+        const { version } = await editRoute(
+          client,
+          projectId,
+          originalRoute.id,
+          {
+            route: {
+              name: manualRoute.name,
+              description: manualRoute.description,
+              enabled: manualRoute.enabled,
+              srcSyntax: manualRoute.srcSyntax,
+              route: manualRoute.route
+            }
+          },
+          { teamId }
+        );
+        output_manager_default.log(
+          `${import_chalk.default.cyan("Updated")} route "${manualRoute.name}" ${import_chalk.default.gray(editStamp())}`
+        );
+        await offerAutoPromote(
+          client,
+          projectId,
+          version,
+          !!existingStagingVersion,
+          { teamId, skipPrompts: skipConfirmation }
+        );
+        return 0;
+      } catch (e) {
+        const error = e;
+        output_manager_default.error(error.message || "Failed to update route");
+        return 1;
+      }
+    }
+    output_manager_default.log("No changes made.");
+    return 0;
+  }
+}
+async function applyAIEdit(client, projectId, teamId, originalRoute, generated, existingStagingVersion, skipConfirmation) {
+  const routeInput = generatedRouteToAddInput(generated);
+  populateRouteEnv(routeInput.route);
+  const editStamp = stamp_default();
+  output_manager_default.spinner(`Updating route "${routeInput.name}"`);
+  try {
+    const { version } = await editRoute(
+      client,
+      projectId,
+      originalRoute.id,
+      {
+        route: {
+          name: routeInput.name,
+          description: routeInput.description,
+          enabled: originalRoute.enabled,
+          srcSyntax: routeInput.srcSyntax,
+          route: routeInput.route
+        }
+      },
+      { teamId }
+    );
+    output_manager_default.log(
+      `${import_chalk.default.cyan("Updated")} route "${routeInput.name}" ${import_chalk.default.gray(editStamp())}`
+    );
+    await offerAutoPromote(
+      client,
+      projectId,
+      version,
+      !!existingStagingVersion,
+      {
+        teamId,
+        skipPrompts: skipConfirmation
+      }
+    );
+    return 0;
+  } catch (e) {
+    const error = e;
+    output_manager_default.error(error.message || "Failed to update route");
+    return 1;
+  }
+}
+export {
+  edit as default
+};

package/dist/chunks/emit-flags-datafiles-QYKPNWPX.js

@@ -0,0 +1,17 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  emitFlagsDatafiles
+} from "./chunk-NUKAG3YM.js";
+import "./chunk-QXRJ52T4.js";
+import "./chunk-3XFFP2BA.js";
+import "./chunk-FDJURQMQ.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+export {
+  emitFlagsDatafiles
+};

package/dist/chunks/enable-VCNMX63U.js

@@ -0,0 +1,122 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  editRoute
+} from "./chunk-P3SKP5WM.js";
+import {
+  getRouteVersions
+} from "./chunk-AHU7WNL2.js";
+import {
+  ensureProjectLink,
+  getRoutes,
+  offerAutoPromote,
+  parseSubcommandArgs,
+  resolveRoute
+} from "./chunk-TNBMKNET.js";
+import {
+  enableSubcommand
+} from "./chunk-U6XOC6E4.js";
+import "./chunk-AQLVWVEN.js";
+import "./chunk-P4I4DMEU.js";
+import {
+  stamp_default
+} from "./chunk-SOTR4CXR.js";
+import "./chunk-7EHTK7LP.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  getCommandName
+} from "./chunk-ZLCMHY2G.js";
+import "./chunk-3XFFP2BA.js";
+import {
+  output_manager_default
+} from "./chunk-FDJURQMQ.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/routes/enable.ts
+var import_chalk = __toESM(require_source(), 1);
+async function enable(client, argv) {
+  const parsed = await parseSubcommandArgs(argv, enableSubcommand);
+  if (typeof parsed === "number")
+    return parsed;
+  const link = await ensureProjectLink(client);
+  if (typeof link === "number")
+    return link;
+  const { project, org } = link;
+  const teamId = org.type === "team" ? org.id : void 0;
+  const { args } = parsed;
+  const identifier = args[0];
+  if (!identifier) {
+    output_manager_default.error(
+      `Route name or ID is required. Usage: ${getCommandName("routes enable <name-or-id>")}`
+    );
+    return 1;
+  }
+  const { versions } = await getRouteVersions(client, project.id, { teamId });
+  const existingStagingVersion = versions.find((v) => v.isStaging);
+  output_manager_default.spinner("Fetching routes");
+  const { routes } = await getRoutes(client, project.id, { teamId });
+  output_manager_default.stopSpinner();
+  if (routes.length === 0) {
+    output_manager_default.error("No routes found in this project.");
+    return 1;
+  }
+  const route = await resolveRoute(client, routes, identifier);
+  if (!route) {
+    output_manager_default.error(
+      `No route found matching "${identifier}". Run ${import_chalk.default.cyan(
+        getCommandName("routes list")
+      )} to see all routes.`
+    );
+    return 1;
+  }
+  if (route.enabled !== false) {
+    output_manager_default.log(`Route "${route.name}" is already enabled.`);
+    return 0;
+  }
+  const enableStamp = stamp_default();
+  output_manager_default.spinner(`Enabling route "${route.name}"`);
+  try {
+    const { version } = await editRoute(
+      client,
+      project.id,
+      route.id,
+      {
+        route: {
+          name: route.name,
+          description: route.description,
+          enabled: true,
+          srcSyntax: route.srcSyntax,
+          route: route.route
+        }
+      },
+      { teamId }
+    );
+    output_manager_default.log(
+      `${import_chalk.default.cyan("Enabled")} route "${route.name}" ${import_chalk.default.gray(enableStamp())}`
+    );
+    await offerAutoPromote(
+      client,
+      project.id,
+      version,
+      !!existingStagingVersion,
+      { teamId }
+    );
+    return 0;
+  } catch (e) {
+    const error = e;
+    output_manager_default.error(error.message || "Failed to enable route");
+    return 1;
+  }
+}
+export {
+  enable as default
+};