convex 1.34.1 → 1.35.1

package/src/cli/deploymentSelection.test.ts

@@ -18,6 +18,8 @@ import {
   handleLocalDeployment,
   loadLocalDeploymentCredentials,
 } from "./lib/localDeployment/localDeployment.js";
+import { handleAnonymousDeployment } from "./lib/localDeployment/anonymous.js";
+import { loadProjectLocalConfig } from "./lib/localDeployment/filePaths.js";
 import {
   validateOrSelectTeam,
   validateOrSelectProject,
@@ -67,7 +69,7 @@ vi.mock("./lib/localDeployment/run.js", async (importOriginal) => {
         await action();
       },
     ),
-    assertLocalBackendRunning: vi.fn(),
+    fetchLocalBackendStatus: vi.fn().mockResolvedValue({ kind: "running" }),
   };
 });
 
@@ -135,7 +137,7 @@ vi.mock("./lib/updates.js", async (importOriginal) => {
   const actual = await importOriginal<typeof import("./lib/updates.js")>();
   return {
     ...actual,
-    checkVersion: vi.fn(),
+    checkVersionAndAiFilesStaleness: vi.fn(),
   };
 });
 
@@ -156,6 +158,24 @@ vi.mock("./lib/localDeployment/localDeployment.js", async (importOriginal) => {
   };
 });
 
+vi.mock("./lib/localDeployment/filePaths.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("./lib/localDeployment/filePaths.js")>();
+  return {
+    ...actual,
+    loadProjectLocalConfig: vi.fn().mockReturnValue(null),
+  };
+});
+
+vi.mock("./lib/localDeployment/anonymous.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("./lib/localDeployment/anonymous.js")>();
+  return {
+    ...actual,
+    handleAnonymousDeployment: vi.fn(),
+  };
+});
+
 vi.mock("./lib/login.js", async (importOriginal) => {
   const actual = await importOriginal<typeof import("./lib/login.js")>();
   return { ...actual, ensureLoggedIn: vi.fn() };
@@ -164,7 +184,7 @@ vi.mock("./lib/login.js", async (importOriginal) => {
 vi.mock("./lib/aiFiles/index.js", async (importOriginal) => {
   const actual =
     await importOriginal<typeof import("./lib/aiFiles/index.js")>();
-  return { ...actual, maybeSetupAiFiles: vi.fn() };
+  return { ...actual, attemptSetupAiFiles: vi.fn() };
 });
 
 vi.mock("./configure.js", async (importOriginal) => {
@@ -227,10 +247,14 @@ function setupBigBrainRoutes(routes: Record<string, (data?: any) => any>) {
 
 describe("deployment selection flows", () => {
   let savedEnv: NodeJS.ProcessEnv;
+  let savedIsTTY: boolean | undefined;
 
   beforeEach(() => {
     savedEnv = { ...process.env };
+    savedIsTTY = process.stdin.isTTY;
     process.env = {};
+    // Default to interactive TTY for existing tests
+    process.stdin.isTTY = true as any;
 
     vi.resetAllMocks();
     vi.mocked(readGlobalConfig).mockReturnValue(null);
@@ -261,10 +285,17 @@ describe("deployment selection flows", () => {
       new Error("validateOrSelectProject should be mocked"),
     );
     vi.mocked(ensureLoggedIn).mockResolvedValue(undefined);
+    vi.mocked(handleAnonymousDeployment).mockResolvedValue({
+      deploymentName: "anon-test",
+      deploymentUrl: "http://127.0.0.1:3210",
+      adminKey: "anon|admin|key",
+      onActivity: async () => {},
+    });
   });
 
   afterEach(() => {
     process.env = savedEnv;
+    process.stdin.isTTY = savedIsTTY as any;
   });
 
   // Suppress process.exit and stderr
@@ -475,7 +506,7 @@ describe("deployment selection flows", () => {
       expect(bigBrainAPIMaybeThrows).not.toHaveBeenCalled();
     });
 
-    it("resolves CONVEX_DEPLOYMENT to dev deployment by default", async () => {
+    it("resolves CONVEX_DEPLOYMENT to CONVEX_DEPLOYMENT by default", async () => {
       process.env.CONVEX_DEPLOYMENT = "dev:joyful-capybara-123";
       vi.mocked(readGlobalConfig).mockReturnValue({
         accessToken: "test-token",
@@ -488,10 +519,11 @@ describe("deployment selection flows", () => {
           teamId: 1,
           projectId: 1,
         }),
-        "deployment/provision_and_authorize": () => ({
+        "deployment/authorize_within_current_project": () => ({
           adminKey: "dev-key",
-          url: "https://swift-squirrel-234.convex.cloud",
-          deploymentName: "swift-squirrel-234",
+          url: "https://joyful-capybara-123.convex.cloud",
+          deploymentName: "joyful-capybara-123",
+          deploymentType: "dev",
         }),
       });
 
@@ -503,7 +535,7 @@ describe("deployment selection flows", () => {
       expect(deploymentFetch).toHaveBeenCalledWith(
         expect.anything(),
         expect.objectContaining({
-          deploymentUrl: "https://swift-squirrel-234.convex.cloud",
+          deploymentUrl: "https://joyful-capybara-123.convex.cloud",
           adminKey: "dev-key",
         }),
       );
@@ -516,11 +548,16 @@ describe("deployment selection flows", () => {
         }),
       );
 
-      // checkAccessToSelectedProject calls getTeamAndProjectSlugForDeployment
-      expect(bigBrainAPIMaybeThrows).toHaveBeenCalledWith(
+      expect(bigBrainAPI).toHaveBeenCalledWith(
         expect.objectContaining({
-          path: "deployment/joyful-capybara-123/team_and_project",
-          method: "GET",
+          path: "deployment/authorize_within_current_project",
+          data: expect.objectContaining({
+            selectedDeploymentName: "joyful-capybara-123",
+            projectSelection: expect.objectContaining({
+              kind: "deploymentName",
+              deploymentName: "joyful-capybara-123",
+            }),
+          }),
         }),
       );
     });
@@ -891,12 +928,18 @@ describe("deployment selection flows", () => {
             teamId: 1,
             projectId: 1,
           }),
-          "deployment/provision_and_authorize": () => ({
+          "teams/my-team/projects/my-project/deployments": () => true,
+          "deployment/authorize_within_current_project": () => ({
             adminKey: "dev-key",
             url: "https://joyful-capybara-123.convex.cloud",
             deploymentName: "joyful-capybara-123",
+            deploymentType: "dev",
           }),
         });
+        mockPlatformGet.mockResolvedValue({
+          data: { name: "joyful-capybara-123" },
+          error: undefined,
+        });
 
         const mockFetch = vi.fn().mockResolvedValue({ ok: true });
         vi.mocked(deploymentFetch).mockReturnValue(mockFetch as any);
@@ -905,10 +948,24 @@ describe("deployment selection flows", () => {
           from: "user",
         });
 
-        expect(bigBrainAPIMaybeThrows).toHaveBeenCalledWith(
+        expect(mockPlatformGet).toHaveBeenCalledWith(
+          "/teams/{team_id_or_slug}/projects/{project_slug}/deployment",
           expect.objectContaining({
-            path: "deployment/provision_and_authorize",
-            data: expect.objectContaining({ deploymentType: "dev" }),
+            params: expect.objectContaining({
+              path: {
+                team_id_or_slug: "my-team",
+                project_slug: "my-project",
+              },
+              query: { defaultDev: true },
+            }),
+          }),
+        );
+        expect(bigBrainAPI).toHaveBeenCalledWith(
+          expect.objectContaining({
+            path: "deployment/authorize_within_current_project",
+            data: expect.objectContaining({
+              selectedDeploymentName: "joyful-capybara-123",
+            }),
           }),
         );
       });
@@ -1150,12 +1207,18 @@ describe("deployment selection flows", () => {
             teamId: 1,
             projectId: 1,
           }),
-          "deployment/provision_and_authorize": () => ({
+          "teams/my-team/projects/other-project/deployments": () => true,
+          "deployment/authorize_within_current_project": () => ({
             adminKey: "other-project-dev-key",
             url: "https://other-project-dev.convex.cloud",
             deploymentName: "other-project-dev",
+            deploymentType: "dev",
           }),
         });
+        mockPlatformGet.mockResolvedValue({
+          data: { name: "other-project-dev" },
+          error: undefined,
+        });
 
         const mockFetch = vi.fn().mockResolvedValue({ ok: true });
         vi.mocked(deploymentFetch).mockReturnValue(mockFetch as any);
@@ -1165,13 +1228,23 @@ describe("deployment selection flows", () => {
           { from: "user" },
         );
 
-        expect(bigBrainAPIMaybeThrows).toHaveBeenCalledWith(
+        expect(mockPlatformGet).toHaveBeenCalledWith(
+          "/teams/{team_id_or_slug}/projects/{project_slug}/deployment",
           expect.objectContaining({
-            path: "deployment/provision_and_authorize",
+            params: expect.objectContaining({
+              path: {
+                team_id_or_slug: "my-team",
+                project_slug: "other-project",
+              },
+              query: { defaultDev: true },
+            }),
+          }),
+        );
+        expect(bigBrainAPI).toHaveBeenCalledWith(
+          expect.objectContaining({
+            path: "deployment/authorize_within_current_project",
             data: expect.objectContaining({
-              teamSlug: "my-team",
-              projectSlug: "other-project",
-              deploymentType: "dev",
+              selectedDeploymentName: "other-project-dev",
             }),
           }),
         );
@@ -1266,12 +1339,17 @@ describe("deployment selection flows", () => {
       it("resolves --deployment team:project:dev to dev deployment in fully qualified team/project", async () => {
         setupBigBrainRoutes({
           "teams/myteam/projects/myproject/deployments": () => true,
-          "deployment/provision_and_authorize": () => ({
+          "deployment/authorize_within_current_project": () => ({
             adminKey: "fq-dev-key",
             url: "https://fq-dev-deploy.convex.cloud",
             deploymentName: "fq-dev-deploy",
+            deploymentType: "dev",
           }),
         });
+        mockPlatformGet.mockResolvedValue({
+          data: { name: "fq-dev-deploy" },
+          error: undefined,
+        });
 
         const mockFetch = vi.fn().mockResolvedValue({ ok: true });
         vi.mocked(deploymentFetch).mockReturnValue(mockFetch as any);
@@ -1281,13 +1359,23 @@ describe("deployment selection flows", () => {
           { from: "user" },
         );
 
-        expect(bigBrainAPIMaybeThrows).toHaveBeenCalledWith(
+        expect(mockPlatformGet).toHaveBeenCalledWith(
+          "/teams/{team_id_or_slug}/projects/{project_slug}/deployment",
           expect.objectContaining({
-            path: "deployment/provision_and_authorize",
+            params: expect.objectContaining({
+              path: {
+                team_id_or_slug: "myteam",
+                project_slug: "myproject",
+              },
+              query: { defaultDev: true },
+            }),
+          }),
+        );
+        expect(bigBrainAPI).toHaveBeenCalledWith(
+          expect.objectContaining({
+            path: "deployment/authorize_within_current_project",
             data: expect.objectContaining({
-              teamSlug: "myteam",
-              projectSlug: "myproject",
-              deploymentType: "dev",
+              selectedDeploymentName: "fq-dev-deploy",
             }),
           }),
         );
@@ -1332,6 +1420,109 @@ describe("deployment selection flows", () => {
           ),
         ).rejects.toThrow();
       });
+
+      it("resolves --deployment local to local deployment credentials", async () => {
+        vi.mocked(loadProjectLocalConfig).mockReturnValue({
+          deploymentName: "local-my_team-my_project-abc",
+          config: {
+            ports: { cloud: 3210, site: 3211 },
+            adminKey: "local-key",
+            backendVersion: "1.0.0",
+          },
+        });
+        vi.mocked(loadLocalDeploymentCredentials).mockResolvedValue({
+          deploymentName: "local-my_team-my_project-abc",
+          deploymentUrl: "http://127.0.0.1:3210",
+          adminKey: "local-key",
+        });
+        // The local deployment name is resolved via Big Brain for project
+        // access checks (checkAccessToSelectedProject)
+        setupBigBrainRoutes({
+          "deployment/local-my_team-my_project-abc/team_and_project": () => ({
+            team: "my-team",
+            project: "my-project",
+            teamId: 1,
+            projectId: 1,
+          }),
+        });
+
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        vi.mocked(deploymentFetch).mockReturnValue(mockFetch as any);
+
+        await env.parseAsync(["set", "ABC", "DEF", "--deployment", "local"], {
+          from: "user",
+        });
+
+        expect(loadLocalDeploymentCredentials).toHaveBeenCalledWith(
+          expect.anything(),
+          "local-my_team-my_project-abc",
+        );
+        expect(deploymentFetch).toHaveBeenCalledWith(
+          expect.anything(),
+          expect.objectContaining({
+            deploymentUrl: "http://127.0.0.1:3210",
+            adminKey: "local-key",
+          }),
+        );
+      });
+
+      it("resolves --deployment local without CONVEX_DEPLOYMENT set", async () => {
+        delete process.env.CONVEX_DEPLOYMENT;
+
+        vi.mocked(loadProjectLocalConfig).mockReturnValue({
+          deploymentName: "local-my_team-my_project-abc",
+          config: {
+            ports: { cloud: 3210, site: 3211 },
+            adminKey: "local-key",
+            backendVersion: "1.0.0",
+          },
+        });
+        vi.mocked(loadLocalDeploymentCredentials).mockResolvedValue({
+          deploymentName: "local-my_team-my_project-abc",
+          deploymentUrl: "http://127.0.0.1:3210",
+          adminKey: "local-key",
+        });
+        setupBigBrainRoutes({
+          "deployment/local-my_team-my_project-abc/team_and_project": () => ({
+            team: "my-team",
+            project: "my-project",
+            teamId: 1,
+            projectId: 1,
+          }),
+        });
+
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        vi.mocked(deploymentFetch).mockReturnValue(mockFetch as any);
+
+        await env.parseAsync(["set", "ABC", "DEF", "--deployment", "local"], {
+          from: "user",
+        });
+
+        expect(deploymentFetch).toHaveBeenCalledWith(
+          expect.anything(),
+          expect.objectContaining({
+            deploymentUrl: "http://127.0.0.1:3210",
+            adminKey: "local-key",
+          }),
+        );
+      });
+
+      it("errors when --deployment local but no local deployment exists", async () => {
+        vi.mocked(loadProjectLocalConfig).mockReturnValue(null);
+
+        await expect(
+          env.parseAsync(["set", "ABC", "DEF", "--deployment", "local"], {
+            from: "user",
+          }),
+        ).rejects.toThrow();
+
+        expect(process.stderr.write).toHaveBeenCalledWith(
+          expect.stringContaining("No local deployment found"),
+        );
+        expect(process.stderr.write).toHaveBeenCalledWith(
+          expect.stringContaining("npx convex deployment create local"),
+        );
+      });
     });
   });
 
@@ -1627,7 +1818,7 @@ describe("deployment selection flows", () => {
       expect(devAgainstDeployment).not.toHaveBeenCalled();
     });
 
-    it("defaults to dev deployment with CONVEX_DEPLOYMENT", async () => {
+    it("resolves CONVEX_DEPLOYMENT to the configured deployment", async () => {
       process.env.CONVEX_DEPLOYMENT = "dev:joyful-capybara-123";
       vi.mocked(readGlobalConfig).mockReturnValue({
         accessToken: "test-token",
@@ -1640,7 +1831,7 @@ describe("deployment selection flows", () => {
           teamId: 1,
           projectId: 1,
         }),
-        "deployment/provision_and_authorize": () => ({
+        "deployment/authorize_within_current_project": () => ({
           adminKey: "dev-key",
           url: "https://joyful-capybara-123.convex.cloud",
           deploymentName: "joyful-capybara-123",
@@ -1650,10 +1841,12 @@ describe("deployment selection flows", () => {
 
       await dev.parseAsync([], { from: "user" });
 
-      expect(bigBrainAPIMaybeThrows).toHaveBeenCalledWith(
+      expect(bigBrainAPI).toHaveBeenCalledWith(
         expect.objectContaining({
-          path: "deployment/provision_and_authorize",
-          data: expect.objectContaining({ deploymentType: "dev" }),
+          path: "deployment/authorize_within_current_project",
+          data: expect.objectContaining({
+            selectedDeploymentName: "joyful-capybara-123",
+          }),
         }),
       );
       expect(devAgainstDeployment).toHaveBeenCalledWith(
@@ -1714,7 +1907,7 @@ describe("deployment selection flows", () => {
       expect(bigBrainAPIMaybeThrows).not.toHaveBeenCalled();
     });
 
-    it("uses --cloud flag with CONVEX_DEPLOYMENT to force cloud dev deployment", async () => {
+    it("resolves CONVEX_DEPLOYMENT with --cloud to the configured deployment", async () => {
       process.env.CONVEX_DEPLOYMENT = "dev:joyful-capybara-123";
       vi.mocked(readGlobalConfig).mockReturnValue({
         accessToken: "test-token",
@@ -1727,7 +1920,7 @@ describe("deployment selection flows", () => {
           teamId: 1,
           projectId: 1,
         }),
-        "deployment/provision_and_authorize": () => ({
+        "deployment/authorize_within_current_project": () => ({
           adminKey: "cloud-dev-key",
           url: "https://joyful-capybara-123.convex.cloud",
           deploymentName: "joyful-capybara-123",
@@ -1746,5 +1939,120 @@ describe("deployment selection flows", () => {
         expect.anything(),
       );
     });
+
+    describe("non-interactive terminal", () => {
+      beforeEach(() => {
+        process.stdin.isTTY = false as any;
+      });
+
+      it("non-interactive, not logged in, no config → uses anonymous deployment", async () => {
+        await dev.parseAsync(["--once"], { from: "user" });
+
+        expect(handleAnonymousDeployment).toHaveBeenCalled();
+        expect(bigBrainAPI).not.toHaveBeenCalled();
+        expect(bigBrainAPIMaybeThrows).not.toHaveBeenCalled();
+        expect(validateOrSelectTeam).not.toHaveBeenCalled();
+        expect(validateOrSelectProject).not.toHaveBeenCalled();
+      });
+
+      it("non-interactive, logged in, no CONVEX_DEPLOYMENT → uses anonymous deployment", async () => {
+        vi.mocked(readGlobalConfig).mockReturnValue({
+          accessToken: "test-token",
+        });
+
+        await dev.parseAsync(["--once"], { from: "user" });
+
+        expect(handleAnonymousDeployment).toHaveBeenCalled();
+        expect(validateOrSelectTeam).not.toHaveBeenCalled();
+        expect(validateOrSelectProject).not.toHaveBeenCalled();
+      });
+
+      it("non-interactive with CONVEX_DEPLOYMENT → resolves to the configured deployment", async () => {
+        process.env.CONVEX_DEPLOYMENT = "dev:joyful-capybara-123";
+        vi.mocked(readGlobalConfig).mockReturnValue({
+          accessToken: "test-token",
+        });
+
+        setupBigBrainRoutes({
+          "deployment/joyful-capybara-123/team_and_project": () => ({
+            team: "my-team",
+            project: "my-project",
+            teamId: 1,
+            projectId: 1,
+          }),
+          "deployment/authorize_within_current_project": () => ({
+            adminKey: "dev-key",
+            url: "https://joyful-capybara-123.convex.cloud",
+            deploymentName: "joyful-capybara-123",
+            deploymentType: "dev",
+          }),
+        });
+
+        await dev.parseAsync([], { from: "user" });
+
+        expect(devAgainstDeployment).toHaveBeenCalledWith(
+          expect.anything(),
+          expect.objectContaining({
+            url: "https://joyful-capybara-123.convex.cloud",
+            adminKey: "dev-key",
+          }),
+          expect.anything(),
+        );
+        expect(handleAnonymousDeployment).not.toHaveBeenCalled();
+      });
+
+      it("non-interactive with CONVEX_DEPLOY_KEY → uses deploy key", async () => {
+        process.env.CONVEX_DEPLOY_KEY = "project:identifier|secretkey";
+
+        setupBigBrainRoutes({
+          "deployment/provision_and_authorize": () => ({
+            adminKey: "dev-key",
+            url: "https://swift-squirrel-234.convex.cloud",
+            deploymentName: "swift-squirrel-234",
+            deploymentType: "dev",
+          }),
+        });
+
+        await dev.parseAsync([], { from: "user" });
+
+        expect(devAgainstDeployment).toHaveBeenCalledWith(
+          expect.anything(),
+          expect.objectContaining({
+            url: "https://swift-squirrel-234.convex.cloud",
+            adminKey: "dev-key",
+          }),
+          expect.anything(),
+        );
+        expect(handleAnonymousDeployment).not.toHaveBeenCalled();
+      });
+
+      it("non-interactive with CONVEX_SELF_HOSTED_URL → uses self-hosted", async () => {
+        process.env.CONVEX_SELF_HOSTED_URL = "http://localhost:3210";
+        process.env.CONVEX_SELF_HOSTED_ADMIN_KEY = "self-hosted-key";
+
+        await dev.parseAsync([], { from: "user" });
+
+        expect(devAgainstDeployment).toHaveBeenCalledWith(
+          expect.anything(),
+          expect.objectContaining({
+            url: "http://localhost:3210",
+            adminKey: "self-hosted-key",
+          }),
+          expect.anything(),
+        );
+        expect(handleAnonymousDeployment).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  it("dev --deployment crashes with helpful message pointing to deployment select", async () => {
+    await expect(
+      dev.parseAsync(["--deployment", "happy-animal-123"], { from: "user" }),
+    ).rejects.toThrow();
+
+    expect(process.stderr.write).toHaveBeenCalledWith(
+      expect.stringContaining("npx convex deployment select happy-animal-123"),
+    );
+    expect(devAgainstDeployment).not.toHaveBeenCalled();
   });
 });