convex 1.37.0 → 1.38.0

package/src/cli/lib/deploymentSelection.ts

@@ -34,6 +34,7 @@ import {
   ENV_VAR_FILE_PATH,
   bigBrainAPI,
   processDeployKeyValue,
+  readDeployKeyFromEnv,
   typedPlatformClient,
 } from "./utils/utils.js";
 import * as dotenv from "dotenv";
@@ -94,7 +95,7 @@ export async function initializeBigBrainAuth(
       });
     }
     const config = dotenv.parse(existingFile);
-    const rawDeployKey = config[CONVEX_DEPLOY_KEY_ENV_VAR_NAME];
+    const rawDeployKey = readDeployKeyFromEnv((name) => config[name]);
     const deployKey = await processDeployKeyValue(ctx, rawDeployKey);
     if (deployKey !== undefined) {
       const bigBrainAuth = getBigBrainAuth(ctx, {
@@ -117,7 +118,7 @@ export async function initializeBigBrainAuth(
   }
   dotenv.config({ path: ENV_VAR_FILE_PATH });
   dotenv.config();
-  const rawDeployKey = process.env[CONVEX_DEPLOY_KEY_ENV_VAR_NAME];
+  const rawDeployKey = readDeployKeyFromEnv((name) => process.env[name]);
   const deployKey = await processDeployKeyValue(ctx, rawDeployKey);
   if (deployKey !== undefined) {
     const bigBrainAuth = getBigBrainAuth(ctx, {
@@ -518,11 +519,8 @@ async function getDeploymentSelectionFromEnv(
 ): Promise<
   { kind: "success"; metadata: DeploymentSelection } | { kind: "unknown" }
 > {
-  const rawDeployKey = getEnv(CONVEX_DEPLOY_KEY_ENV_VAR_NAME);
-  const deployKey = await processDeployKeyValue(
-    ctx,
-    rawDeployKey === null ? undefined : rawDeployKey,
-  );
+  const rawDeployKey = readDeployKeyFromEnv(getEnv);
+  const deployKey = await processDeployKeyValue(ctx, rawDeployKey);
   if (deployKey !== undefined) {
     const deployKeyType = isPreviewDeployKey(deployKey)
       ? "preview"

package/src/cli/lib/env.ts

@@ -19,6 +19,7 @@ import { formatEnvValueForDotfile } from "./formatEnvValueForDotfile.js";
 import {
   CONVEX_DEPLOY_KEY_ENV_VAR_NAME,
   CONVEX_DEPLOYMENT_ENV_VAR_NAME,
+  CONVEX_DEPLOYMENT_TOKEN_ENV_VAR_NAME,
   CONVEX_SELF_HOSTED_URL_VAR_NAME,
   CONVEX_SELF_HOSTED_ADMIN_KEY_VAR_NAME,
 } from "./utils/utils.js";
@@ -230,6 +231,7 @@ async function envSetFromContent(
   const envVarsToSet: [string, string][] = [];
   const managedVars = new Set<string>([
     CONVEX_DEPLOY_KEY_ENV_VAR_NAME,
+    CONVEX_DEPLOYMENT_TOKEN_ENV_VAR_NAME,
     CONVEX_DEPLOYMENT_ENV_VAR_NAME,
     CONVEX_SELF_HOSTED_URL_VAR_NAME,
     CONVEX_SELF_HOSTED_ADMIN_KEY_VAR_NAME,

package/src/cli/lib/localDeployment/anonymous.ts

@@ -147,10 +147,11 @@ export async function handleAnonymousDeployment(
     adminKey = data.adminKey;
   }
 
-  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
-    ctx,
-    options.ports,
-  );
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(ctx, {
+    requestedPorts: options.ports,
+    suggestedPorts:
+      deployment.kind === "existing" ? deployment.config.ports : undefined,
+  });
   const onActivity = async (isOffline: boolean, _wasOffline: boolean) => {
     await ensureBackendRunning(ctx, {
       cloudPort,

package/src/cli/lib/localDeployment/errors.ts

@@ -7,8 +7,6 @@ export function printLocalDeploymentOnError() {
   // ctx.crash.
   logFailure(`Hit an error while running local deployment.`);
   logMessage(
-    "Your error has been reported to our team, and we'll be working on it. " +
-      "To opt out, run `npx convex disable-local-deployments`. " +
-      "Then re-run your original command.",
+    "Your error has been reported to our team, and we'll be working on it.",
   );
 }

package/src/cli/lib/localDeployment/localDeployment.ts

@@ -1,5 +1,9 @@
 import { Context } from "../../../bundler/context.js";
-import { logVerbose } from "../../../bundler/log.js";
+import {
+  logFinishedStep,
+  logVerbose,
+  showSpinner,
+} from "../../../bundler/log.js";
 import {
   bigBrainPause,
   bigBrainRecordActivity,
@@ -19,6 +23,7 @@ import {
   ensureBackendStopped,
   localDeploymentUrl,
   runLocalBackend,
+  withRunningBackend,
 } from "./run.js";
 import { handlePotentialUpgrade } from "./upgrade.js";
 import { OnDeploymentActivityFunc } from "../deployment.js";
@@ -31,6 +36,10 @@ import {
   LOCAL_BACKEND_INSTANCE_SECRET,
 } from "./utils.js";
 import { ensureBackendBinaryDownloaded } from "./download.js";
+import { defaultEnvBackend } from "../defaultEnv.js";
+import { deploymentEnvBackend } from "../env.js";
+import { getProjectDetails } from "../deploymentSelection.js";
+
 export type DeploymentDetails = {
   deploymentName: string;
   deploymentUrl: string;
@@ -61,7 +70,8 @@ export async function handleLocalDeployment(
     projectSlug: options.projectSlug,
     teamSlug: options.teamSlug,
   });
-  if (existingDeploymentForProject === null) {
+  const isFirstTime = existingDeploymentForProject === null;
+  if (isFirstTime) {
     printLocalDeploymentWelcomeMessage();
   }
   ctx.registerCleanup(async (_exitCode, err) => {
@@ -93,10 +103,10 @@ export async function handleLocalDeployment(
         }
       : { kind: "version", version: options.backendVersion },
   );
-  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
-    ctx,
-    options.ports,
-  );
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(ctx, {
+    requestedPorts: options.ports,
+    suggestedPorts: existingDeploymentForProject?.config.ports,
+  });
   const { deploymentName, adminKey } = await bigBrainStart(ctx, {
     port: cloudPort,
     projectSlug: options.projectSlug,
@@ -129,6 +139,16 @@ export async function handleLocalDeployment(
     forceUpgrade: options.forceUpgrade,
   });
 
+  if (isFirstTime) {
+    await importDefaultEnvVars(ctx, {
+      teamSlug: options.teamSlug,
+      projectSlug: options.projectSlug,
+      deploymentName,
+      deploymentUrl: localDeploymentUrl(cloudPort),
+      adminKey,
+    });
+  }
+
   // Periodically report activity to BigBrain every 60 seconds.
   // Uses self-scheduling setTimeout to avoid overlapping requests.
   let activityTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -206,10 +226,11 @@ async function handleOffline(
     kind: "version",
     version: config.backendVersion,
   });
-  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
-    ctx,
-    options.ports,
-  );
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(ctx, {
+    requestedPorts: options.ports,
+    // FIXME: This doesn’t try to reuse the ports already assigned in the config.
+    // Please update this if we ever support offline mode (currently this is dead code).
+  });
   saveDeploymentConfig(ctx, "local", deploymentName, config);
   await runLocalBackend(ctx, {
     binaryPath,
@@ -378,3 +399,57 @@ async function chooseFromExistingLocalDeployments(ctx: Context): Promise<{
     })),
   });
 }
+
+/** Copies the default dev env vars from big brain the first time the local dev backend is started */
+export async function importDefaultEnvVars(
+  ctx: Context,
+  {
+    teamSlug,
+    projectSlug,
+    deploymentName,
+    deploymentUrl,
+    adminKey,
+  }: {
+    teamSlug: string;
+    projectSlug: string;
+    deploymentName: string;
+    deploymentUrl: string;
+    adminKey: string;
+  },
+) {
+  showSpinner("Importing default env vars...");
+
+  const project = await getProjectDetails(ctx, {
+    kind: "teamAndProjectSlugs",
+    teamSlug,
+    projectSlug,
+  });
+  const defaults = await defaultEnvBackend(ctx, project.id, "dev").list();
+  if (defaults.length === 0) {
+    logFinishedStep("No default env vars to import.");
+    return;
+  }
+
+  const deployment = {
+    deploymentUrl,
+    deploymentFields: {
+      deploymentName,
+      deploymentType: "local" as const,
+      projectSlug,
+      teamSlug,
+    },
+  };
+
+  await withRunningBackend({
+    ctx,
+    deployment,
+    action: async () => {
+      await deploymentEnvBackend(ctx, { deploymentUrl, adminKey }).update(
+        defaults.map((v) => ({ name: v.name, value: v.value })),
+      );
+      logFinishedStep(
+        `Imported ${defaults.length} environment ${defaults.length === 1 ? "variable" : "variables"} from default environment variables: ${defaults.map((v) => v.name).join(", ")}`,
+      );
+    },
+  });
+}

package/src/cli/lib/localDeployment/utils.ts

@@ -9,10 +9,14 @@ export async function choosePorts(
   {
     count,
     requestedPorts,
+    suggestedPorts,
     startPort,
   }: {
     count: number;
+    /** Ports that must mandatorily be used when provided. */
     requestedPorts?: Array<number | null>;
+    /** Ports that will be tried preferentially when provided, but are not required. */
+    suggestedPorts?: Array<number | null>;
     startPort: number;
   },
 ): Promise<Array<number>> {
@@ -30,6 +34,15 @@ export async function choosePorts(
       }
       ports.push(port);
     } else {
+      const suggestedPort = suggestedPorts?.[ports.length] ?? null;
+      if (suggestedPort !== null) {
+        const port = await detect(suggestedPort);
+        if (port === suggestedPort) {
+          ports.push(suggestedPort);
+          continue;
+        }
+      }
+
       const portToTry =
         ports.length > 0 ? ports[ports.length - 1] + 1 : startPort;
       const port = await detect(portToTry);
@@ -41,12 +54,28 @@ export async function choosePorts(
 
 export async function chooseLocalBackendPorts(
   ctx: Context,
-  ports?: { cloud?: number | null; site?: number | null },
+  options?: {
+    suggestedPorts?:
+      | { cloud?: number | null; site?: number | null }
+      | undefined;
+    requestedPorts?:
+      | { cloud?: number | null; site?: number | null }
+      | undefined;
+  },
 ): Promise<{ cloudPort: number; sitePort: number }> {
+  const { suggestedPorts, requestedPorts } = options ?? {};
+
   const [cloudPort, sitePort] = await choosePorts(ctx, {
     count: 2,
     startPort: 3210,
-    requestedPorts: [ports?.cloud ?? null, ports?.site ?? null],
+    requestedPorts: [
+      requestedPorts?.cloud ?? null,
+      requestedPorts?.site ?? null,
+    ],
+    suggestedPorts: [
+      suggestedPorts?.cloud ?? null,
+      suggestedPorts?.site ?? null,
+    ],
   });
   return { cloudPort, sitePort };
 }
@@ -65,11 +94,6 @@ export function printLocalDeploymentWelcomeMessage() {
       "To learn more, read the docs: https://docs.convex.dev/cli/local-deployments",
     ),
   );
-  logMessage(
-    chalkStderr.cyan(
-      "To opt out at any time, run `npx convex disable-local-deployments`",
-    ),
-  );
 }
 
 export function generateInstanceSecret(): string {

package/src/cli/lib/utils/globalConfig.ts

@@ -15,13 +15,10 @@ export function globalConfigPath(): string {
 // GlobalConfig is deleted on logout. It is primarily used for the accessToken.
 export type GlobalConfig = {
   accessToken: string;
-  // Means "Don't use local dev unless CLI version is at least 1.19" (actual version TBD)
-  optOutOfLocalDevDeploymentsUntilBetaOver?: boolean | undefined;
 };
 
 const schema = z.object({
   accessToken: z.string().min(1),
-  optOutOfLocalDevDeploymentsUntilBetaOver: z.boolean().optional(),
 });
 
 export function readGlobalConfig(ctx: Context): GlobalConfig | null {

package/src/cli/lib/utils/utils.ts

@@ -38,6 +38,8 @@ export const BIG_BRAIN_URL = `${provisionHost}/api/`;
 const PLATFORM_MANAGEMENT_API_URL = `${provisionHost}/v1/`;
 export const ENV_VAR_FILE_PATH = ".env.local";
 export const CONVEX_DEPLOY_KEY_ENV_VAR_NAME = "CONVEX_DEPLOY_KEY";
+// Alias for CONVEX_DEPLOY_KEY. Accepted anywhere CONVEX_DEPLOY_KEY is.
+export const CONVEX_DEPLOYMENT_TOKEN_ENV_VAR_NAME = "CONVEX_DEPLOYMENT_TOKEN";
 export const CONVEX_DEPLOYMENT_ENV_VAR_NAME = "CONVEX_DEPLOYMENT";
 export const CONVEX_SELF_HOSTED_URL_VAR_NAME = "CONVEX_SELF_HOSTED_URL";
 export const CONVEX_SELF_HOSTED_ADMIN_KEY_VAR_NAME =
@@ -85,6 +87,19 @@ export async function processDeployKeyValue(
   return deployKey;
 }
 
+/**
+ * Reads the deploy key from environment variables, accepting either
+ * CONVEX_DEPLOY_KEY or its alias CONVEX_DEPLOYMENT_TOKEN. CONVEX_DEPLOY_KEY
+ * takes precedence when both are set.
+ */
+export function readDeployKeyFromEnv(
+  getEnv: (name: string) => string | undefined | null,
+): string | undefined {
+  const fromDeployKey = getEnv(CONVEX_DEPLOY_KEY_ENV_VAR_NAME);
+  const fromToken = getEnv(CONVEX_DEPLOYMENT_TOKEN_ENV_VAR_NAME);
+  return fromDeployKey || fromToken || undefined;
+}
+
 export function parsePositiveInteger(value: string) {
   const parsedValue = parseInteger(value);
   if (parsedValue <= 0) {

package/src/index.ts

@@ -1 +1 @@
-export const version = "1.37.0";
+export const version = "1.38.0";

package/src/server/audit_logging.ts

@@ -1,3 +1,4 @@
+import { version } from "../index.js";
 import { performAsyncSyscall } from "./impl/syscall.js";
 import { LogVar, varNames } from "./logVars.js";
 
@@ -65,11 +66,9 @@ export function cloneWithSentinels(body: AuditLogBody): {
   return result;
 }
 
-/**
- * @internal
- */
 export const audit = async (body: AuditLogBody): Promise<void> => {
   await performAsyncSyscall("1.0/auditLog", {
     body: cloneWithSentinels(body),
+    version,
   });
 };

package/src/server/components/index.ts

@@ -1,4 +1,4 @@
-import { PropertyValidators, convexToJson } from "../../values/index.js";
+import { convexToJson } from "../../values/index.js";
 import { version } from "../../index.js";
 import {
   AnyFunctionReference,
@@ -151,7 +151,6 @@ type CommonDefinitionData = {
 };
 
 type ComponentDefinitionData = CommonDefinitionData & {
-  _args: PropertyValidators;
   _name: string;
   _onInitCallbacks: Record<string, (argsStr: string) => string>;
 };
@@ -369,19 +368,10 @@ function serializeChildComponents(
 function exportComponentForAnalysis(
   this: ComponentDefinition<any> & ComponentDefinitionData,
 ): ComponentDefinitionAnalysis {
-  const args: [string, { type: "value"; value: string }][] = Object.entries(
-    this._args,
-  ).map(([name, validator]) => [
-    name,
-    {
-      type: "value",
-      value: JSON.stringify(validator.json),
-    },
-  ]);
   const definitionType: ComponentDefinitionType = {
     type: "childComponent" as const,
     name: this._name,
-    args,
+    args: [],
   };
   const childComponents = serializeChildComponents(this._childComponents);
   const httpMounts = buildHttpMounts(this._childComponents);
@@ -424,7 +414,6 @@ export function defineComponent<Exports extends ComponentExports = any>(
   const ret: RuntimeComponentDefinition = {
     _isRoot: false,
     _name: name,
-    _args: {},
     _childComponents: [],
     _exportTree: {},
     _onInitCallbacks: {},
@@ -432,8 +421,7 @@ export function defineComponent<Exports extends ComponentExports = any>(
     export: exportComponentForAnalysis,
     use,
 
-    // pretend to conform to ComponentDefinition, which temporarily expects __args
-    ...({} as { __args: any; __exports: any }),
+    ...({} as { __exports: any }),
   };
   return ret as any as ComponentDefinition<Exports>;
 }

package/src/server/impl/registration_impl.ts

@@ -60,11 +60,12 @@ async function invokeMutation<
     scheduler: setupMutationScheduler(),
     meta: setupMutationMeta(visibility),
 
-    runQuery: (reference: any, args?: any) => runUdf("query", reference, args),
-    runSnapshotQuery: (reference: any, args?: any) =>
-      runUdf("snapshotQuery", reference, args),
-    runMutation: (reference: any, args?: any) =>
-      runUdf("mutation", reference, args),
+    runQuery: (reference: any, args?: any, options?: any) =>
+      runUdf("query", reference, args, options?.transactionLimits),
+    runSnapshotQuery: (reference: any, args?: any, options?: any) =>
+      runUdf("snapshotQuery", reference, args, options?.transactionLimits),
+    runMutation: (reference: any, args?: any, options?: any) =>
+      runUdf("mutation", reference, args, options?.transactionLimits),
   };
   const result = await invokeFunction(func, mutationCtx, args as any);
   validateReturnValue(result);
@@ -337,7 +338,8 @@ async function invokeQuery<
     auth: setupAuth(requestId),
     storage: setupStorageReader(requestId),
     meta: setupQueryMeta(visibility),
-    runQuery: (reference: any, args?: any) => runUdf("query", reference, args),
+    runQuery: (reference: any, args?: any, options?: any) =>
+      runUdf("query", reference, args, options?.transactionLimits),
   };
   const result = await invokeFunction(func, queryCtx, args as any);
   validateReturnValue(result);
@@ -750,13 +752,17 @@ async function runUdf(
   udfType: "query" | "mutation" | "snapshotQuery",
   f: any,
   args?: Record<string, Value>,
+  transactionLimits?: Record<string, number>,
 ): Promise<any> {
   const queryArgs = parseArgs(args);
-  const syscallArgs = {
+  const syscallArgs: Record<string, any> = {
     udfType,
     args: convexToJson(queryArgs),
     ...getFunctionAddress(f),
   };
+  if (transactionLimits) {
+    syscallArgs.transactionLimits = transactionLimits;
+  }
   const result = await performAsyncSyscall("1.0/runUdf", syscallArgs);
   return jsonToConvex(result);
 }

package/src/server/index.ts

@@ -204,13 +204,7 @@ export type {
  */
 export type { Index, SearchIndex, VectorIndex } from "./schema.js";
 
-/**
- * @internal
- */
 export { log } from "./log.js";
-/**
- * @internal
- */
 export type { AuditLogBody, AuditLogValue } from "./audit_logging.js";
 
 export type {

package/src/server/log.ts

@@ -3,13 +3,31 @@ import { vars } from "./logVars.js";
 
 // Type annotations are needed for the `unique symbol` types in `vars` to typecheck correctly
 interface Log {
+  /**
+   * Emit a durable audit log. This functionality is only available for Convex
+   * Enterprise (see https://www.convex.dev/enterprise/pricing).
+   *
+   * Use dynamic variables from `log.vars` to include deferred values that will
+   * be resolved when emitting the log. Cached query hits will replay audit logs
+   * with updated values.
+   * ```ts
+   * await log.audit({
+   *   action: "document.viewed",
+   *   actor: { userId },
+   *   source: {
+   *     ip: log.vars.ip,
+   *     userAgent: log.vars.userAgent,
+   *   },
+   *   timestamp: log.vars.now,
+   * });
+   * ```
+   *
+   * The log body must be JSON-serializable.
+   */
   audit: typeof audit;
   vars: typeof vars;
 }
 
-/**
- * @internal
- */
 export const log: Log = {
   audit,
   vars,

package/src/server/logVars.ts

@@ -9,9 +9,6 @@ export type LogVar =
   | typeof USER_AGENT
   | typeof NOW;
 
-/**
- * @internal
- */
 export const varNames: Record<symbol, string> = {
   [REQUEST_ID]: "requestId",
   [IP]: "ip",

package/src/server/meta.ts

@@ -106,9 +106,6 @@ export interface QueryMeta {
  * @public
  */
 export interface MutationMeta extends QueryMeta {
-  /**
-   * @internal
-   */
   getRequestMetadata(): Promise<RequestMetadata>;
 }
 
@@ -120,9 +117,5 @@ export interface MutationMeta extends QueryMeta {
 export interface ActionMeta {
   getFunctionMetadata(): Promise<FunctionMetadata>;
   getDeploymentMetadata(): Promise<DeploymentMetadata>;
-
-  /**
-   * @internal
-   */
   getRequestMetadata(): Promise<RequestMetadata>;
 }

package/dist/cjs/cli/disableLocalDev.js

@@ -1,121 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var disableLocalDev_exports = {};
-__export(disableLocalDev_exports, {
-  disableLocalDeployments: () => disableLocalDeployments
-});
-module.exports = __toCommonJS(disableLocalDev_exports);
-var import_extra_typings = require("@commander-js/extra-typings");
-var import_context = require("../bundler/context.js");
-var import_log = require("../bundler/log.js");
-var import_configure = require("./configure.js");
-var import_globalConfig = require("./lib/utils/globalConfig.js");
-var import_deploymentSelection = require("./lib/deploymentSelection.js");
-const disableLocalDeployments = new import_extra_typings.Command("disable-local-deployments").description(
-  "Stop using a local deployment for the current project, or globally disable local depoyments with --global"
-).option(
-  "--global",
-  "Disable local deployments on this machine until a future release when this feature is more stable."
-).option("--undo-global", "Re-enable local deployments on this machine.").allowExcessArguments(false).action(async (cmdOptions) => {
-  const ctx = await (0, import_context.oneoffContext)({
-    url: void 0,
-    adminKey: void 0,
-    envFile: void 0
-  });
-  if (cmdOptions.undoGlobal) {
-    return disableLocalDeploymentsGloballyUntilBetaOver(true);
-  }
-  if (cmdOptions.global) {
-    return disableLocalDeploymentsGloballyUntilBetaOver(
-      !!cmdOptions.undoGlobal
-    );
-  }
-  const deploymentSelection = await (0, import_deploymentSelection.getDeploymentSelection)(ctx, {
-    url: void 0,
-    adminKey: void 0,
-    envFile: void 0
-  });
-  const configuredDeployment = (0, import_deploymentSelection.deploymentNameAndTypeFromSelection)(deploymentSelection);
-  if (configuredDeployment?.type !== null && configuredDeployment?.type !== "local") {
-    (0, import_log.logFinishedStep)("Local development is already not being used.");
-    return;
-  }
-  await (0, import_configure.deploymentCredentialsOrConfigure)(ctx, deploymentSelection, "ask", {
-    prod: false,
-    localOptions: {
-      forceUpgrade: false
-    },
-    cloud: true
-  });
-  (0, import_log.logFinishedStep)(
-    "You are no longer using a local deployment for development."
-  );
-});
-async function disableLocalDeploymentsGloballyUntilBetaOver(reenable) {
-  const ctx = await (0, import_context.oneoffContext)({
-    url: void 0,
-    adminKey: void 0,
-    envFile: void 0
-  });
-  if (!process.stdin.isTTY) {
-    return ctx.crash({
-      exitCode: 1,
-      errorType: "fatal",
-      printedMessage: "`disable-local-deployments --global` is not for scripting, it is temporary and only for interactive use."
-    });
-  }
-  const config = (0, import_globalConfig.readGlobalConfig)(ctx);
-  if (config === null) {
-    return ctx.crash({
-      exitCode: 1,
-      errorType: "fatal",
-      printedMessage: "Log in first with `npx convex login"
-    });
-  }
-  if (reenable) {
-    if (!("optOutOfLocalDevDeploymentsUntilBetaOver" in config) || !config.optOutOfLocalDevDeploymentsUntilBetaOver) {
-      (0, import_log.logFinishedStep)(
-        "You are already opted into allowing local deployents on this machine."
-      );
-      return;
-    }
-    await (0, import_globalConfig.modifyGlobalConfig)(ctx, {
-      ...config,
-      optOutOfLocalDevDeploymentsUntilBetaOver: false
-    });
-    (0, import_log.logFinishedStep)(
-      "You have been opted back into allowing local deployents on this machine."
-    );
-    return;
-  }
-  if ("optOutOfLocalDevDeploymentsUntilBetaOver" in config && config.optOutOfLocalDevDeploymentsUntilBetaOver) {
-    (0, import_log.logFinishedStep)(
-      "You are already opted out of local deployents on this machine."
-    );
-    return;
-  }
-  await (0, import_globalConfig.modifyGlobalConfig)(ctx, {
-    ...config,
-    optOutOfLocalDevDeploymentsUntilBetaOver: true
-  });
-  (0, import_log.logFinishedStep)(
-    "You have been opted out of local deployents on this machine until the beta is over. Run `npx convex disable-local-deployments --undo-global` to opt back in."
-  );
-}
-//# sourceMappingURL=disableLocalDev.js.map