fix: skip expired snapshots and fallback to fresh sandbox (#412)

* fix: skip expired snapshots and fallback to fresh sandbox on failure

Accounts with expired Vercel snapshots caused Sandbox.create() to throw
"Status code 400 is not ok" with no recovery path.

Changes:
- Extract getValidSnapshotId to its own lib file (SRP)
- Both processCreateSandbox and createSandboxFromSnapshot use it
- Add fallback: if snapshot creation fails, create a fresh sandbox
- DRY: processCreateSandbox uses createSandboxWithFallback helper
  so createSandbox({}) is only called once
- Add tests for getValidSnapshotId (5 tests)
- Add snapshot expiry and fallback tests to existing test files

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor: DRY createSandbox({}) in createSandboxFromSnapshot

Single createSandbox({}) call path instead of duplicating it in
both the catch block and the else branch.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor: extract createSandboxWithFallback to own lib file, add error logging

- Extract createSandboxWithFallback to lib/sandbox/createSandboxWithFallback.ts (SRP)
- processCreateSandbox and createSandboxFromSnapshot use it / follow same pattern
- Log snapshot creation errors before falling back to fresh sandbox
- Add 4 unit tests for createSandboxWithFallback

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor: DRY createSandboxFromSnapshot via shared createSandboxWithFallback

- createSandboxFromSnapshot now delegates to createSandboxWithFallback
  instead of duplicating snapshot/fresh fallback logic
- createSandboxWithFallback returns full SandboxCreateResult + fromSnapshot
- Update tests to match new delegation pattern

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor: consolidate processCreateSandbox to use createSandboxFromSnapshot

processCreateSandbox now delegates sandbox creation to
createSandboxFromSnapshot instead of calling getValidSnapshotId,
createSandboxWithFallback, and insertAccountSandbox directly.

This eliminates the duplicated snapshot lookup + fallback + DB insert
logic between the two functions. processCreateSandbox adds only
the prompt-triggering behavior on top.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: treat exact-expiry and unparsable timestamps as invalid snapshots

Use <= instead of < so snapshots expiring exactly now are treated as
expired. Add NaN check so unparsable expires_at values don't slip
through as valid.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sweetmantech

lib/sandbox/__tests__/createSandboxFromSnapshot.test.ts

@@ -3,16 +3,16 @@ import type { Sandbox } from "@vercel/sandbox";
 
 import { createSandboxFromSnapshot } from "../createSandboxFromSnapshot";
 
-const mockSelectAccountSnapshots = vi.fn();
+const mockGetValidSnapshotId = vi.fn();
 const mockInsertAccountSandbox = vi.fn();
-const mockCreateSandbox = vi.fn();
+const mockCreateSandboxWithFallback = vi.fn();
 
-vi.mock("@/lib/sandbox/createSandbox", () => ({
-  createSandbox: (...args: unknown[]) => mockCreateSandbox(...args),
+vi.mock("@/lib/sandbox/createSandboxWithFallback", () => ({
+  createSandboxWithFallback: (...args: unknown[]) => mockCreateSandboxWithFallback(...args),
 }));
 
-vi.mock("@/lib/supabase/account_snapshots/selectAccountSnapshots", () => ({
-  selectAccountSnapshots: (...args: unknown[]) => mockSelectAccountSnapshots(...args),
+vi.mock("@/lib/sandbox/getValidSnapshotId", () => ({
+  getValidSnapshotId: (...args: unknown[]) => mockGetValidSnapshotId(...args),
 }));
 
 vi.mock("@/lib/supabase/account_sandboxes/insertAccountSandbox", () => ({
@@ -28,43 +28,40 @@ describe("createSandboxFromSnapshot", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockCreateSandbox.mockResolvedValue({
+    mockCreateSandboxWithFallback.mockResolvedValue({
       sandbox: mockSandbox,
       response: {
         sandboxId: "sbx_new",
         sandboxStatus: "running",
         timeout: 1800000,
         createdAt: "2024-01-01T00:00:00.000Z",
       },
+      fromSnapshot: false,
     });
     mockInsertAccountSandbox.mockResolvedValue({
       data: { account_id: "acc_1", sandbox_id: "sbx_new" },
       error: null,
     });
   });
 
-  it("creates from snapshot when available", async () => {
-    mockSelectAccountSnapshots.mockResolvedValue([
-      { snapshot_id: "snap_abc", account_id: "acc_1" },
-    ]);
+  it("passes snapshotId to createSandboxWithFallback", async () => {
+    mockGetValidSnapshotId.mockResolvedValue("snap_abc");
 
     await createSandboxFromSnapshot("acc_1");
 
-    expect(mockCreateSandbox).toHaveBeenCalledWith({
-      source: { type: "snapshot", snapshotId: "snap_abc" },
-    });
+    expect(mockCreateSandboxWithFallback).toHaveBeenCalledWith("snap_abc");
   });
 
-  it("creates fresh sandbox when no snapshot exists", async () => {
-    mockSelectAccountSnapshots.mockResolvedValue([]);
+  it("passes undefined when no snapshot exists", async () => {
+    mockGetValidSnapshotId.mockResolvedValue(undefined);
 
     await createSandboxFromSnapshot("acc_1");
 
-    expect(mockCreateSandbox).toHaveBeenCalledWith({});
+    expect(mockCreateSandboxWithFallback).toHaveBeenCalledWith(undefined);
   });
 
   it("inserts account_sandbox record", async () => {
-    mockSelectAccountSnapshots.mockResolvedValue([]);
+    mockGetValidSnapshotId.mockResolvedValue(undefined);
 
     await createSandboxFromSnapshot("acc_1");
 
@@ -74,18 +71,53 @@ describe("createSandboxFromSnapshot", () => {
     });
   });
 
-  it("returns { sandbox, fromSnapshot: true } when snapshot exists", async () => {
-    mockSelectAccountSnapshots.mockResolvedValue([
-      { snapshot_id: "snap_abc", account_id: "acc_1" },
-    ]);
+  it("returns { sandbox, fromSnapshot: true } when snapshot used", async () => {
+    mockGetValidSnapshotId.mockResolvedValue("snap_abc");
+    mockCreateSandboxWithFallback.mockResolvedValue({
+      sandbox: mockSandbox,
+      response: {
+        sandboxId: "sbx_new",
+        sandboxStatus: "running",
+        timeout: 1800000,
+        createdAt: "2024-01-01T00:00:00.000Z",
+      },
+      fromSnapshot: true,
+    });
 
     const result = await createSandboxFromSnapshot("acc_1");
 
     expect(result).toEqual({ sandbox: mockSandbox, fromSnapshot: true });
   });
 
   it("returns { sandbox, fromSnapshot: false } when no snapshot", async () => {
-    mockSelectAccountSnapshots.mockResolvedValue([]);
+    mockGetValidSnapshotId.mockResolvedValue(undefined);
+
+    const result = await createSandboxFromSnapshot("acc_1");
+
+    expect(result).toEqual({ sandbox: mockSandbox, fromSnapshot: false });
+  });
+
+  it("returns { sandbox, fromSnapshot: false } for expired snapshot", async () => {
+    mockGetValidSnapshotId.mockResolvedValue(undefined);
+
+    const result = await createSandboxFromSnapshot("acc_1");
+
+    expect(mockCreateSandboxWithFallback).toHaveBeenCalledWith(undefined);
+    expect(result).toEqual({ sandbox: mockSandbox, fromSnapshot: false });
+  });
+
+  it("returns { sandbox, fromSnapshot: false } when snapshot creation fails", async () => {
+    mockGetValidSnapshotId.mockResolvedValue("snap_bad");
+    mockCreateSandboxWithFallback.mockResolvedValue({
+      sandbox: mockSandbox,
+      response: {
+        sandboxId: "sbx_new",
+        sandboxStatus: "running",
+        timeout: 1800000,
+        createdAt: "2024-01-01T00:00:00.000Z",
+      },
+      fromSnapshot: false,
+    });
 
     const result = await createSandboxFromSnapshot("acc_1");