feat(api): add GET /api/subscriptions/status

app/api/subscriptions/status/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCorsHeaders } from "@/lib/networking/getCorsHeaders";
+import { getSubscriptionStatusHandler } from "@/lib/stripe/getSubscriptionStatusHandler";
+
+/**
+ * OPTIONS handler for CORS preflight requests.
+ *
+ * @returns A 200 NextResponse carrying the CORS headers.
+ */
+export async function OPTIONS() {
+  return new NextResponse(null, {
+    status: 200,
+    headers: getCorsHeaders(),
+  });
+}
+
+/**
+ * GET /api/subscriptions/status?accountId=
+ *
+ * Returns whether the account has an active paid subscription (direct or via organization).
+ * Requires `x-api-key` or `Authorization: Bearer`; the caller must be allowed to access
+ * the requested account (same rules as account_id override on other routes).
+ *
+ * @param request - The incoming HTTP request (query `accountId`, auth headers).
+ * @returns JSON `{ isPro }`, or 400/401/403 with `{ error }` per API docs.
+ */
+export async function GET(request: NextRequest) {
+  return getSubscriptionStatusHandler(request);
+}
+
+export const dynamic = "force-dynamic";
+export const fetchCache = "force-no-store";
+export const revalidate = 0;

lib/sandbox/__tests__/createSandbox.test.ts

@@ -4,7 +4,7 @@ import { createSandbox } from "../createSandbox";
 import { Sandbox } from "@vercel/sandbox";
 
 const mockSandbox = {
-  name: "sbx_test123",
+  sandboxId: "sbx_test123",
   status: "running",
   timeout: 1800000,
   createdAt: new Date("2024-01-01T00:00:00Z"),

lib/sandbox/__tests__/createSandboxFromSnapshot.test.ts

@@ -21,7 +21,7 @@ vi.mock("@/lib/supabase/account_sandboxes/insertAccountSandbox", () => ({
 
 describe("createSandboxFromSnapshot", () => {
   const mockSandbox = {
-    name: "sbx_new",
+    sandboxId: "sbx_new",
     status: "running",
     runCommand: vi.fn(),
   } as unknown as Sandbox;

lib/sandbox/__tests__/getActiveSandbox.test.ts

@@ -24,7 +24,7 @@ describe("getActiveSandbox", () => {
     mockSelectAccountSandboxes.mockResolvedValue([{ sandbox_id: "sbx_123", account_id: "acc_1" }]);
 
     const mockSandbox = {
-      name: "sbx_123",
+      sandboxId: "sbx_123",
       status: "running",
       runCommand: vi.fn(),
     };
@@ -35,7 +35,7 @@ describe("getActiveSandbox", () => {
     expect(mockSelectAccountSandboxes).toHaveBeenCalledWith({
       accountIds: ["acc_1"],
     });
-    expect(Sandbox.get).toHaveBeenCalledWith({ name: "sbx_123" });
+    expect(Sandbox.get).toHaveBeenCalledWith({ sandboxId: "sbx_123" });
     expect(result).toBe(mockSandbox);
   });
 
@@ -54,7 +54,7 @@ describe("getActiveSandbox", () => {
     ]);
 
     const mockSandbox = {
-      name: "sbx_stopped",
+      sandboxId: "sbx_stopped",
       status: "stopped",
     };
     vi.mocked(Sandbox.get).mockResolvedValue(mockSandbox as unknown as Sandbox);

lib/sandbox/__tests__/getOrCreateSandbox.test.ts

@@ -21,7 +21,7 @@ describe("getOrCreateSandbox", () => {
 
   it("returns existing sandbox with created=false and fromSnapshot=true", async () => {
     const mockSandbox = {
-      name: "sbx_existing",
+      sandboxId: "sbx_existing",
       status: "running",
     } as unknown as Sandbox;
 
@@ -40,7 +40,7 @@ describe("getOrCreateSandbox", () => {
 
   it("creates new sandbox from snapshot with created=true, fromSnapshot=true", async () => {
     const mockSandbox = {
-      name: "sbx_new",
+      sandboxId: "sbx_new",
       status: "running",
     } as unknown as Sandbox;
 
@@ -63,7 +63,7 @@ describe("getOrCreateSandbox", () => {
 
   it("creates fresh sandbox with created=true, fromSnapshot=false", async () => {
     const mockSandbox = {
-      name: "sbx_fresh",
+      sandboxId: "sbx_fresh",
       status: "running",
     } as unknown as Sandbox;
 

lib/sandbox/__tests__/getSandboxStatus.test.ts

@@ -16,7 +16,7 @@ describe("getSandboxStatus", () => {
 
   it("returns sandbox status when sandbox exists", async () => {
     const mockSandbox = {
-      name: "sbx_123",
+      sandboxId: "sbx_123",
       status: "running",
       timeout: 600000,
       createdAt: new Date("2024-01-01T00:00:00.000Z"),
@@ -25,7 +25,7 @@ describe("getSandboxStatus", () => {
 
     const result = await getSandboxStatus("sbx_123");
 
-    expect(Sandbox.get).toHaveBeenCalledWith({ name: "sbx_123" });
+    expect(Sandbox.get).toHaveBeenCalledWith({ sandboxId: "sbx_123" });
     expect(result).toEqual({
       sandboxId: "sbx_123",
       sandboxStatus: "running",
@@ -52,7 +52,7 @@ describe("getSandboxStatus", () => {
 
   it("handles stopped sandbox status", async () => {
     const mockSandbox = {
-      name: "sbx_stopped",
+      sandboxId: "sbx_stopped",
       status: "stopped",
       timeout: 0,
       createdAt: new Date("2024-01-01T00:00:00.000Z"),
@@ -71,7 +71,7 @@ describe("getSandboxStatus", () => {
 
   it("handles pending sandbox status", async () => {
     const mockSandbox = {
-      name: "sbx_pending",
+      sandboxId: "sbx_pending",
       status: "pending",
       timeout: 600000,
       createdAt: new Date("2024-01-01T00:00:00.000Z"),

lib/sandbox/__tests__/processCreateSandbox.test.ts

@@ -14,7 +14,7 @@ vi.mock("@/lib/trigger/triggerPromptSandbox", () => ({
 }));
 
 const mockSandbox = {
-  name: "sbx_123",
+  sandboxId: "sbx_123",
   status: "running",
   timeout: 600000,
   createdAt: new Date("2024-01-01T00:00:00.000Z"),

lib/sandbox/createSandbox.ts

@@ -1,10 +1,12 @@
 import ms from "ms";
 import { Sandbox } from "@vercel/sandbox";
 
+type VercelSandbox = InstanceType<typeof Sandbox>;
+
 export interface SandboxCreatedResponse {
-  sandboxId: Sandbox["name"];
-  sandboxStatus: Sandbox["status"];
-  timeout: Sandbox["timeout"];
+  sandboxId: VercelSandbox["sandboxId"];
+  sandboxStatus: VercelSandbox["status"];
+  timeout: VercelSandbox["timeout"];
   createdAt: string;
 }
 
@@ -54,7 +56,7 @@ export async function createSandbox(
   return {
     sandbox,
     response: {
-      sandboxId: sandbox.name,
+      sandboxId: sandbox.sandboxId,
       sandboxStatus: sandbox.status,
       timeout: sandbox.timeout,
       createdAt: sandbox.createdAt.toISOString(),

lib/sandbox/createSandboxFromSnapshot.ts

@@ -23,7 +23,7 @@ export async function createSandboxFromSnapshot(
 
   await insertAccountSandbox({
     account_id: accountId,
-    sandbox_id: sandbox.name,
+    sandbox_id: sandbox.sandboxId,
   });
 
   return { sandbox, fromSnapshot };

lib/sandbox/getActiveSandbox.ts

@@ -19,7 +19,7 @@ export async function getActiveSandbox(accountId: string): Promise<Sandbox | nul
   const mostRecent = sandboxes[0];
 
   try {
-    const sandbox = await Sandbox.get({ name: mostRecent.sandbox_id });
+    const sandbox = await Sandbox.get({ sandboxId: mostRecent.sandbox_id });
 
     if (sandbox.status === "running") {
       return sandbox;

lib/sandbox/getOrCreateSandbox.ts

@@ -21,7 +21,7 @@ export async function getOrCreateSandbox(accountId: string): Promise<GetOrCreate
   if (existing) {
     return {
       sandbox: existing,
-      sandboxId: existing.name,
+      sandboxId: existing.sandboxId,
       created: false,
       fromSnapshot: true,
     };
@@ -31,7 +31,7 @@ export async function getOrCreateSandbox(accountId: string): Promise<GetOrCreate
 
   return {
     sandbox,
-    sandboxId: sandbox.name,
+    sandboxId: sandbox.sandboxId,
     created: true,
     fromSnapshot,
   };

lib/sandbox/getSandboxStatus.ts

@@ -9,10 +9,10 @@ import type { SandboxCreatedResponse } from "./createSandbox";
  */
 export async function getSandboxStatus(sandboxId: string): Promise<SandboxCreatedResponse | null> {
   try {
-    const sandbox = await Sandbox.get({ name: sandboxId });
+    const sandbox = await Sandbox.get({ sandboxId });
 
     return {
-      sandboxId: sandbox.name,
+      sandboxId: sandbox.sandboxId,
       sandboxStatus: sandbox.status,
       timeout: sandbox.timeout,
       createdAt: sandbox.createdAt.toISOString(),

lib/sandbox/processCreateSandbox.ts

@@ -23,7 +23,7 @@ export async function processCreateSandbox(
   const { sandbox } = await createSandboxFromSnapshot(accountId);
 
   const result: SandboxCreatedResponse = {
-    sandboxId: sandbox.name,
+    sandboxId: sandbox.sandboxId,
     sandboxStatus: sandbox.status,
     timeout: sandbox.timeout,
     createdAt: sandbox.createdAt.toISOString(),
@@ -35,7 +35,7 @@ export async function processCreateSandbox(
     try {
       const handle = await triggerPromptSandbox({
         prompt,
-        sandboxId: sandbox.name,
+        sandboxId: sandbox.sandboxId,
         accountId,
       });
       runId = handle.id;

lib/stripe/__tests__/getSubscriptionStatusHandler.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { NextRequest, NextResponse } from "next/server";
+import { getSubscriptionStatusHandler } from "@/lib/stripe/getSubscriptionStatusHandler";
+import { validateGetSubscriptionStatusRequest } from "@/lib/stripe/validateGetSubscriptionStatusRequest";
+import { getSubscriptionIsPro } from "@/lib/stripe/getSubscriptionIsPro";
+
+vi.mock("@/lib/networking/getCorsHeaders", () => ({
+  getCorsHeaders: vi.fn(() => ({ "Access-Control-Allow-Origin": "*" })),
+}));
+
+vi.mock("@/lib/stripe/validateGetSubscriptionStatusRequest", () => ({
+  validateGetSubscriptionStatusRequest: vi.fn(),
+}));
+
+vi.mock("@/lib/stripe/getSubscriptionIsPro", () => ({
+  getSubscriptionIsPro: vi.fn(),
+}));
+
+const ACCOUNT = "123e4567-e89b-12d3-a456-426614174000";
+
+describe("getSubscriptionStatusHandler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+  afterEach(() => vi.mocked(console.error).mockRestore());
+
+  it("returns validation response unchanged", async () => {
+    const err = NextResponse.json({ error: "accountId is required" }, { status: 400 });
+    vi.mocked(validateGetSubscriptionStatusRequest).mockResolvedValue(err);
+    const req = new NextRequest(`http://localhost/api/subscriptions/status`);
+    expect(await getSubscriptionStatusHandler(req)).toBe(err);
+    expect(getSubscriptionIsPro).not.toHaveBeenCalled();
+  });
+
+  it("returns 200 { isPro: true }", async () => {
+    vi.mocked(validateGetSubscriptionStatusRequest).mockResolvedValue({ accountId: ACCOUNT });
+    vi.mocked(getSubscriptionIsPro).mockResolvedValue(true);
+
+    const res = await getSubscriptionStatusHandler(
+      new NextRequest(`http://localhost/api/subscriptions/status?accountId=${ACCOUNT}`),
+    );
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ isPro: true });
+    expect(getSubscriptionIsPro).toHaveBeenCalledWith(ACCOUNT);
+  });
+
+  it("returns 200 { isPro: false }", async () => {
+    vi.mocked(validateGetSubscriptionStatusRequest).mockResolvedValue({ accountId: ACCOUNT });
+    vi.mocked(getSubscriptionIsPro).mockResolvedValue(false);
+
+    const res = await getSubscriptionStatusHandler(
+      new NextRequest(`http://localhost/api/subscriptions/status?accountId=${ACCOUNT}`),
+    );
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toEqual({ isPro: false });
+  });
+
+  it("returns 500 when getSubscriptionIsPro throws", async () => {
+    vi.mocked(validateGetSubscriptionStatusRequest).mockResolvedValue({ accountId: ACCOUNT });
+    vi.mocked(getSubscriptionIsPro).mockRejectedValue(new Error("stripe down"));
+
+    const res = await getSubscriptionStatusHandler(
+      new NextRequest(`http://localhost/api/subscriptions/status?accountId=${ACCOUNT}`),
+    );
+    expect(res.status).toBe(500);
+    await expect(res.json()).resolves.toEqual({ error: "Internal server error" });
+  });
+});