convex 1.34.0 → 1.35.0

package/src/cli/lib/expiration.test.ts

@@ -0,0 +1,159 @@
+import { describe, test, expect } from "vitest";
+import {
+  parseExpiration,
+  resolveExpiration,
+  validateExpiration,
+} from "./expiration.js";
+
+describe("parseExpiration", () => {
+  test('"none" returns kind "none"', () => {
+    expect(parseExpiration("none")).toEqual({ kind: "none" });
+  });
+
+  test("Unix seconds (< 1e12) converts to ms", () => {
+    const result = parseExpiration("1711828382");
+    expect(result).toEqual({ kind: "absolute", timestampMs: 1711828382000 });
+  });
+
+  test("Unix milliseconds (>= 1e12) used as-is", () => {
+    const result = parseExpiration("1711828382000");
+    expect(result).toEqual({ kind: "absolute", timestampMs: 1711828382000 });
+  });
+
+  test("UTC datetime", () => {
+    const result = parseExpiration("2026-03-30T18:53:02Z");
+    expect(result).toEqual({
+      kind: "absolute",
+      timestampMs: new Date("2026-03-30T18:53:02Z").getTime(),
+    });
+  });
+
+  test("rejects datetime without Z suffix", () => {
+    const result = parseExpiration("2026-03-30T18:53:02");
+    expect(result.kind).toBe("error");
+  });
+
+  test("rejects datetime with timezone offset", () => {
+    const result = parseExpiration("2026-03-30T18:53:02+01:00");
+    expect(result.kind).toBe("error");
+  });
+
+  test("rejects bare date without time", () => {
+    const result = parseExpiration("2026-03-30");
+    expect(result.kind).toBe("error");
+  });
+
+  test('relative: "in 1 hour"', () => {
+    expect(parseExpiration("in 1 hour")).toEqual({
+      kind: "relative",
+      amount: 1,
+      unit: "hour",
+    });
+  });
+
+  test('relative: "in 3 hours"', () => {
+    expect(parseExpiration("in 3 hours")).toEqual({
+      kind: "relative",
+      amount: 3,
+      unit: "hour",
+    });
+  });
+
+  test('relative: "in 7 days"', () => {
+    expect(parseExpiration("in 7 days")).toEqual({
+      kind: "relative",
+      amount: 7,
+      unit: "day",
+    });
+  });
+
+  test('relative: "in 45 minutes"', () => {
+    expect(parseExpiration("in 45 minutes")).toEqual({
+      kind: "relative",
+      amount: 45,
+      unit: "minute",
+    });
+  });
+
+  test("invalid input returns error", () => {
+    const result = parseExpiration("yesterday");
+    expect(result).toEqual({
+      kind: "error",
+      message: expect.stringContaining("Invalid expiration format"),
+    });
+  });
+
+  test("empty string returns error", () => {
+    const result = parseExpiration("");
+    expect(result).toEqual({
+      kind: "error",
+      message: expect.stringContaining("Invalid expiration format"),
+    });
+  });
+});
+
+describe("resolveExpiration", () => {
+  const now = 1700000000000;
+
+  test('"none" resolves to null', () => {
+    expect(resolveExpiration({ kind: "none" }, now)).toBeNull();
+  });
+
+  test("absolute resolves to timestampMs", () => {
+    expect(
+      resolveExpiration({ kind: "absolute", timestampMs: 1711828382000 }, now),
+    ).toBe(1711828382000);
+  });
+
+  test("relative hours", () => {
+    expect(
+      resolveExpiration({ kind: "relative", amount: 3, unit: "hour" }, now),
+    ).toBe(now + 3 * 60 * 60 * 1000);
+  });
+
+  test("relative days", () => {
+    expect(
+      resolveExpiration({ kind: "relative", amount: 7, unit: "day" }, now),
+    ).toBe(now + 7 * 24 * 60 * 60 * 1000);
+  });
+
+  test("relative minutes", () => {
+    expect(
+      resolveExpiration({ kind: "relative", amount: 45, unit: "minute" }, now),
+    ).toBe(now + 45 * 60 * 1000);
+  });
+});
+
+describe("validateExpiration", () => {
+  const now = 1700000000000;
+
+  test("past timestamp returns error", () => {
+    const result = validateExpiration(now - 1000, now);
+    expect(result).toEqual({
+      kind: "error",
+      message: expect.stringContaining("in the future"),
+    });
+  });
+
+  test("less than 30 minutes from now returns error", () => {
+    const result = validateExpiration(now + 10 * 60 * 1000, now);
+    expect(result).toEqual({
+      kind: "error",
+      message: expect.stringContaining("at least 30 minutes"),
+    });
+  });
+
+  test("more than 1 year from now returns error", () => {
+    const overOneYear = now + 366 * 24 * 60 * 60 * 1000;
+    const result = validateExpiration(overOneYear, now);
+    expect(result).toEqual({
+      kind: "error",
+      message: expect.stringContaining("at most 1 year"),
+    });
+  });
+
+  test("valid timestamp returns success", () => {
+    const twoHours = now + 2 * 60 * 60 * 1000;
+    expect(validateExpiration(twoHours, now)).toEqual({ kind: "success" });
+  });
+});

package/src/cli/lib/expiration.ts

@@ -0,0 +1,124 @@
+type ParsedExpirationSuccess =
+  | { kind: "none" }
+  | { kind: "absolute"; timestampMs: number }
+  | { kind: "relative"; amount: number; unit: "minute" | "hour" | "day" };
+
+type ParsedExpiration =
+  | ParsedExpirationSuccess
+  | { kind: "error"; message: string };
+
+const PARSE_ERROR_MESSAGE =
+  `Supported formats:\n` +
+  `  "none"                          — no expiration\n` +
+  `  "in 7 days"                     — relative (minutes, hours, days)\n` +
+  `  "2026-04-01T00:00:00Z"          — UTC datetime\n` +
+  `  "1711828382"                    — Unix timestamp (seconds)\n` +
+  `  "1711828382000"                 — Unix timestamp (milliseconds)`;
+
+const UNIT_MS = {
+  minute: 60 * 1000,
+  hour: 60 * 60 * 1000,
+  day: 24 * 60 * 60 * 1000,
+} as const;
+
+/**
+ * Parse an expiration input string into a structured representation.
+ * Does not depend on the current time.
+ */
+export function parseExpiration(input: string): ParsedExpiration {
+  const trimmed = input.trim();
+
+  if (trimmed.toLowerCase() === "none") {
+    return { kind: "none" };
+  }
+
+  // All digits → Unix timestamp
+  if (/^\d+$/.test(trimmed)) {
+    const n = Number(trimmed);
+
+    return {
+      kind: "absolute",
+      timestampMs:
+        n < 1e12 // 1e12 milliseconds is a date in 2001 → unambiguous
+          ? n * 1000 // seconds → convert to ms
+          : n, // already milliseconds
+    };
+  }
+
+  // UTC datetime: "2026-04-01T00:00:00Z"
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(trimmed)) {
+    const date = new Date(trimmed);
+    if (isNaN(date.getTime())) {
+      return {
+        kind: "error",
+        message: `Invalid UTC datetime: "${trimmed}". ${PARSE_ERROR_MESSAGE}`,
+      };
+    }
+    return { kind: "absolute", timestampMs: date.getTime() };
+  }
+
+  // Relative: "in 3 hours", "in 1 day", "in 45 minutes"
+  const relativeMatch = trimmed.match(/^in\s+(\d+)\s+(minute|hour|day)s?$/i);
+  if (relativeMatch) {
+    const amount = Number(relativeMatch[1]);
+    const unit = relativeMatch[2].toLowerCase() as "minute" | "hour" | "day";
+    return { kind: "relative", amount, unit };
+  }
+
+  return {
+    kind: "error",
+    message: `Invalid expiration format: "${trimmed}". ${PARSE_ERROR_MESSAGE}`,
+  };
+}
+
+/**
+ * Resolve a parsed expiration into a timestamp in milliseconds, or null for "none".
+ */
+export function resolveExpiration(
+  parsed: ParsedExpirationSuccess,
+  now?: number,
+): number | null {
+  switch (parsed.kind) {
+    case "none":
+      return null;
+    case "absolute":
+      return parsed.timestampMs;
+    case "relative": {
+      const base = now ?? Date.now();
+      return base + parsed.amount * UNIT_MS[parsed.unit];
+    }
+  }
+}
+
+type ValidationResult =
+  | { kind: "success" }
+  | { kind: "error"; message: string };
+
+/**
+ * Validate that a resolved expiration timestamp is acceptable.
+ */
+export function validateExpiration(
+  timestampMs: number,
+  now?: number,
+): ValidationResult {
+  const base = now ?? Date.now();
+  const thirtyMinutes = 30 * 60 * 1000;
+  const oneYear = 365 * 24 * 60 * 60 * 1000;
+
+  if (timestampMs <= base) {
+    return { kind: "error", message: "Expiration must be in the future." };
+  }
+  if (timestampMs - base < thirtyMinutes) {
+    return {
+      kind: "error",
+      message: "Expiration must be at least 30 minutes from now.",
+    };
+  }
+  if (timestampMs - base > oneYear) {
+    return {
+      kind: "error",
+      message: "Expiration must be at most 1 year from now.",
+    };
+  }
+  return { kind: "success" };
+}

package/src/cli/lib/generatedFunctionLogsApi.ts

@@ -33,6 +33,8 @@ export interface components {
             timestamp: number;
             udfType: components["schemas"]["UdfTypeJson"];
             usageStats: components["schemas"]["UsageStatsJson"];
+            /** Format: double */
+            userExecutionTime?: number | null;
         } | {
             componentPath?: string | null;
             executionId: string;
@@ -58,9 +60,10 @@ export interface components {
             udfPath?: string | null;
         };
         OccInfoJson: {
+            componentPath?: string | null;
             documentId?: string | null;
             /** Format: int64 */
-            retryCount: number;
+            retryCount?: number | null;
             tableName?: string | null;
             writeSource?: string | null;
         };
@@ -86,6 +89,10 @@ export interface components {
         /** @enum {string} */
         UdfTypeJson: "Query" | "Mutation" | "Action" | "HttpAction";
         UsageStatsJson: {
+            /** Format: int64 */
+            databaseIoReadBytes: number;
+            /** Format: int64 */
+            databaseIoWriteBytes: number;
             /** Format: int64 */
             databaseReadBytes: number;
             /** Format: int64 */
@@ -99,9 +106,17 @@ export interface components {
             /** Format: int64 */
             storageWriteBytes: number;
             /** Format: int64 */
+            textIndexQueryBytes: number;
+            /** Format: int64 */
+            textIndexWriteQueryBytes: number;
+            /** Format: int64 */
             vectorIndexReadBytes: number;
             /** Format: int64 */
+            vectorIndexReadQueryBytes: number;
+            /** Format: int64 */
             vectorIndexWriteBytes: number;
+            /** Format: int64 */
+            vectorIndexWriteQueryBytes: number;
         };
         Value: unknown;
     };

package/src/cli/lib/init.ts

@@ -26,6 +26,9 @@ export async function finalizeConfiguration(
     (envFileConfig.convexUrlEnvVar || envFileConfig.siteUrlEnvVar);
 
   if (isEnvFileConfigChanged) {
+    const deploymentEnvVarMessage = options.changedDeploymentEnvVar
+      ? `    name as CONVEX_DEPLOYMENT\n`
+      : "";
     const urlUpdateMessages = [];
     if (envFileConfig.convexUrlEnvVar) {
       urlUpdateMessages.push(
@@ -39,7 +42,7 @@ export async function finalizeConfiguration(
     }
     logFinishedStep(
       `${messageForDeploymentType(options.deploymentType, options.url)} and saved its:\n` +
-        `    name as CONVEX_DEPLOYMENT\n` +
+        deploymentEnvVarMessage +
         urlUpdateMessages.join("") +
         ` to ${envFileConfig.envFile}`,
     );
@@ -53,7 +56,8 @@ export async function finalizeConfiguration(
   }
   if (
     options.deploymentType === "anonymous" &&
-    process.env.CONVEX_AGENT_MODE !== "anonymous"
+    process.env.CONVEX_AGENT_MODE !== "anonymous" &&
+    ctx.bigBrainAuth() === null
   ) {
     logMessage(
       `Run \`npx convex login\` at any time to create an account and link this deployment.`,

package/src/cli/lib/insights.ts

@@ -163,7 +163,7 @@ export async function fetchRawInsightsData(
     from: fromDate,
     to: toDate,
   });
-  const bbFetch = await bigBrainFetch(ctx);
+  const bbFetch = bigBrainFetch(ctx);
   const res = await bbFetch(
     new URL(
       `dashboard/teams/${teamId}/usage/query?${queryParams.toString()}`,

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

@@ -35,7 +35,7 @@ import { handlePotentialUpgrade } from "./upgrade.js";
 import {
   isOffline,
   generateInstanceSecret,
-  choosePorts,
+  chooseLocalBackendPorts,
   LOCAL_BACKEND_INSTANCE_SECRET,
 } from "./utils.js";
 import { handleDashboard } from "./dashboard.js";
@@ -48,7 +48,7 @@ import { nodeFs } from "../../../bundler/fs.js";
 import { doInitConvexFolder } from "../codegen.js";
 import { readProjectConfig } from "../config.js";
 import { functionsDir } from "../utils/utils.js";
-import { maybeSetupAiFiles } from "../ai/index.js";
+import { attemptSetupAiFiles } from "../aiFiles/index.js";
 
 export async function handleAnonymousDeployment(
   ctx: Context,
@@ -80,7 +80,8 @@ export async function handleAnonymousDeployment(
   });
   if (
     deployment.kind === "first" &&
-    process.env.CONVEX_AGENT_MODE !== "anonymous"
+    process.env.CONVEX_AGENT_MODE !== "anonymous" &&
+    process.stdin.isTTY
   ) {
     logMessage(
       "This command, `npx convex dev`, will run your Convex backend locally and update it with the function you write in the `convex/` directory.",
@@ -146,11 +147,10 @@ export async function handleAnonymousDeployment(
     adminKey = data.adminKey;
   }
 
-  const [cloudPort, sitePort] = await choosePorts(ctx, {
-    count: 2,
-    startPort: 3210,
-    requestedPorts: [options.ports?.cloud ?? null, options.ports?.site ?? null],
-  });
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
+    ctx,
+    options.ports,
+  );
   const onActivity = async (isOffline: boolean, _wasOffline: boolean) => {
     await ensureBackendRunning(ctx, {
       cloudPort,
@@ -187,7 +187,12 @@ export async function handleAnonymousDeployment(
     const { configPath, projectConfig } = await readProjectConfig(ctx);
     const convexDir = path.resolve(functionsDir(configPath, projectConfig));
     const projectDir = path.resolve(path.dirname(configPath));
-    await maybeSetupAiFiles(ctx, convexDir, projectDir);
+    await attemptSetupAiFiles({
+      ctx,
+      aiFilesConfig: projectConfig.aiFiles,
+      convexDir,
+      projectDir,
+    });
   }
   return {
     adminKey,
@@ -354,6 +359,11 @@ async function chooseDeployment(
     return { deploymentName: generateDeploymentName(), kind: "new" };
   }
 
+  // Non-interactive terminal - auto-create a new deployment
+  if (!process.stdin.isTTY) {
+    return { deploymentName: generateDeploymentName(), kind: "new" };
+  }
+
   // Legacy deployments exist - prompt user to choose
   const newOrExisting = await promptSearch(ctx, {
     message: "Which project would you like to use?",

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

@@ -25,7 +25,7 @@ import { OnDeploymentActivityFunc } from "../deployment.js";
 import { promptSearch } from "../utils/prompts.js";
 import { LocalDeploymentError, printLocalDeploymentOnError } from "./errors.js";
 import {
-  choosePorts,
+  chooseLocalBackendPorts,
   printLocalDeploymentWelcomeMessage,
   isOffline,
   LOCAL_BACKEND_INSTANCE_SECRET,
@@ -93,11 +93,10 @@ export async function handleLocalDeployment(
         }
       : { kind: "version", version: options.backendVersion },
   );
-  const [cloudPort, sitePort] = await choosePorts(ctx, {
-    count: 2,
-    startPort: 3210,
-    requestedPorts: [options.ports?.cloud ?? null, options.ports?.site ?? null],
-  });
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
+    ctx,
+    options.ports,
+  );
   const { deploymentName, adminKey } = await bigBrainStart(ctx, {
     port: cloudPort,
     projectSlug: options.projectSlug,
@@ -207,11 +206,10 @@ async function handleOffline(
     kind: "version",
     version: config.backendVersion,
   });
-  const [cloudPort, sitePort] = await choosePorts(ctx, {
-    count: 2,
-    startPort: 3210,
-    requestedPorts: [options.ports?.cloud ?? null, options.ports?.site ?? null],
-  });
+  const { cloudPort, sitePort } = await chooseLocalBackendPorts(
+    ctx,
+    options.ports,
+  );
   saveDeploymentConfig(ctx, "local", deploymentName, config);
   await runLocalBackend(ctx, {
     binaryPath,

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

@@ -295,7 +295,7 @@ type LocalBackendStatus =
   | { kind: "different"; name: string }
   | { kind: "not-running" };
 
-async function fetchLocalBackendStatus(args: {
+export async function fetchLocalBackendStatus(args: {
   url: string;
   deploymentName: string;
 }): Promise<LocalBackendStatus> {

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

@@ -76,6 +76,7 @@ export async function handlePotentialUpgrade(
   );
   const confirmed =
     args.forceUpgrade ||
+    !process.stdin.isTTY ||
     (await promptYesNo(ctx, {
       message: `This deployment is using an older version of the Convex backend. Upgrade now?`,
       default: true,
@@ -102,16 +103,17 @@ export async function handlePotentialUpgrade(
       isLatestVersion: false,
     });
   }
-  const choice = args.forceUpgrade
-    ? "transfer"
-    : await promptOptions(ctx, {
-        message: "Transfer data from existing deployment?",
-        default: "transfer",
-        choices: [
-          { name: "transfer data", value: "transfer" },
-          { name: "start fresh", value: "reset" },
-        ],
-      });
+  const choice =
+    args.forceUpgrade || !process.stdin.isTTY
+      ? "transfer"
+      : await promptOptions(ctx, {
+          message: "Transfer data from existing deployment?",
+          default: "transfer",
+          choices: [
+            { name: "transfer data", value: "transfer" },
+            { name: "start fresh", value: "reset" },
+          ],
+        });
   const deploymentStatePath = deploymentStateDir(
     ctx,
     args.deploymentKind,

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

@@ -39,6 +39,18 @@ export async function choosePorts(
   return ports;
 }
 
+export async function chooseLocalBackendPorts(
+  ctx: Context,
+  ports?: { cloud?: number | null; site?: number | null },
+): Promise<{ cloudPort: number; sitePort: number }> {
+  const [cloudPort, sitePort] = await choosePorts(ctx, {
+    count: 2,
+    startPort: 3210,
+    requestedPorts: [ports?.cloud ?? null, ports?.site ?? null],
+  });
+  return { cloudPort, sitePort };
+}
+
 export async function isOffline(): Promise<boolean> {
   // TODO(ENG-7080) -- implement this for real
   return false;

package/src/cli/lib/mcp/tools/status.ts

@@ -97,7 +97,7 @@ export const StatusTool: ConvexTool<typeof inputSchema, typeof outputSchema> = {
     ];
     // Also get the prod cloud deployment if we're using a cloud-hosted dev-deployment
     if (
-      selectionWithinProject.kind === "ownDev" &&
+      selectionWithinProject.kind === "unspecified" &&
       !(
         deploymentSelection.kind === "existingDeployment" &&
         deploymentSelection.deploymentToActOn.deploymentFields === null