experimental-agent 0.0.5 → 0.1.2

package/dist/chunk-ORE6LK2L.mjs

@@ -0,0 +1,344 @@
+import {
+  MessageNotFoundError,
+  SandboxNotFoundError,
+  SessionNotFoundError,
+  StorageError
+} from "./chunk-HJGPUEFC.mjs";
+
+// src/storage/client.ts
+function getStorageClient(rpcFn, name) {
+  async function rpc(method, params) {
+    const result = await rpcFn({ name, method, params });
+    if ("error" in result) {
+      throw new StorageError({ reason: result.error.message });
+    }
+    return result.result;
+  }
+  return {
+    session: {
+      get: async (id) => {
+        try {
+          const result = await rpc("session.get", { id });
+          if (result === null) {
+            return new SessionNotFoundError({ id });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (session) => {
+        try {
+          return await rpc("session.set", session);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      delete: async (id) => {
+        try {
+          await rpc("session.delete", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (opts) => {
+        try {
+          return await rpc("session.list", {
+            tags: opts?.tags,
+            order: opts?.order,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      tag: {
+        set: async ({ sessionId, tags }) => {
+          try {
+            return await rpc("session.tag.set", { sessionId, tags });
+          } catch (e) {
+            if (e instanceof StorageError) {
+              return e;
+            }
+            return new StorageError({ reason: String(e), cause: e });
+          }
+        }
+      }
+    },
+    message: {
+      list: async (sessionId, opts) => {
+        try {
+          return await rpc("message.list", {
+            sessionId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      get: async (id) => {
+        try {
+          const result = await rpc("message.get", { id });
+          if (result === null) {
+            return new MessageNotFoundError({ id });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (message) => {
+        try {
+          return await rpc("message.set", message);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    part: {
+      listByMessage: async (messageId, opts) => {
+        try {
+          const result = await rpc("part.listByMessage", {
+            messageId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      listBySession: async (sessionId, opts) => {
+        try {
+          const result = await rpc("part.listBySession", {
+            sessionId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (part) => {
+        try {
+          return await rpc("part.set", part);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      delete: async (id) => {
+        try {
+          await rpc("part.delete", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    sandbox: {
+      get: async (key) => {
+        try {
+          const result = await rpc("sandbox.get", { key });
+          if (result === null) {
+            return new SandboxNotFoundError({ id: key });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      getBySession: async (sessionId) => {
+        try {
+          const result = await rpc("sandbox.getBySession", { sessionId });
+          if (result === null) {
+            return new SandboxNotFoundError({ id: sessionId });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (record) => {
+        try {
+          await rpc("sandbox.set", record);
+          return record;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (opts) => {
+        try {
+          return await rpc("sandbox.list", {
+            tags: opts?.tags,
+            order: opts?.order,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      tag: {
+        set: async ({ sandboxId, tags }) => {
+          try {
+            return await rpc("sandbox.tag.set", { sandboxId, tags });
+          } catch (e) {
+            if (e instanceof StorageError) {
+              return e;
+            }
+            return new StorageError({ reason: String(e), cause: e });
+          }
+        }
+      },
+      acquireLock: async (record, lockTimeoutMs) => {
+        try {
+          return await rpc("sandbox.acquireLock", {
+            record,
+            lockTimeoutMs
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    setup: {
+      get: async (key) => {
+        try {
+          return await rpc("setup.get", { key });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (snapshot) => {
+        try {
+          await rpc("setup.set", snapshot);
+          return snapshot;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      acquireLock: async (key, lockId, lockTimeoutMs) => {
+        try {
+          return await rpc("setup.acquireLock", {
+            key,
+            lockId,
+            lockTimeoutMs
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    command: {
+      get: async (id) => {
+        try {
+          return await rpc("command.get", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (command) => {
+        try {
+          return await rpc("command.set", command);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (sessionId, opts) => {
+        try {
+          const result = await rpc("command.list", {
+            sessionId,
+            includeFinished: opts?.includeFinished,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    }
+  };
+}
+var DEFAULT_NAMESPACE = "default";
+var LOCAL_STORAGE_VERSION = "v1";
+function getStorage(opts) {
+  const name = opts.config.name ?? DEFAULT_NAMESPACE;
+  return getStorageClient(opts.rpc, name);
+}
+
+export {
+  getStorageClient,
+  DEFAULT_NAMESPACE,
+  LOCAL_STORAGE_VERSION,
+  getStorage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/client.ts"],
  "sourcesContent": ["import type { z } from \"zod\";\nimport {\n  MessageNotFoundError,\n  SandboxNotFoundError,\n  SessionNotFoundError,\n  StorageError,\n} from \"../errors\";\nimport type { StorageMethods } from \"./rpc\";\nimport type {\n  Command,\n  ListResult,\n  Part,\n  SetupSnapshot,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n\ntype RpcResponse<T> =\n  | { result: T }\n  | { error: { code: string; message: string } };\n\nexport type RpcFn = (params: {\n  name?: string;\n  method: string;\n  params: unknown;\n}) => Promise<RpcResponse<unknown>>;\n\nexport function getStorageClient(rpcFn: RpcFn, name?: string): Storage {\n  async function rpc<M extends keyof StorageMethods>(\n    method: M,\n    params: z.infer<StorageMethods[M][\"params\"]>\n  ): Promise<z.infer<StorageMethods[M][\"result\"]>> {\n    const result = await rpcFn({ name, method, params });\n\n    if (\"error\" in result) {\n      throw new StorageError({ reason: result.error.message });\n    }\n\n    return result.result as z.infer<StorageMethods[M][\"result\"]>;\n  }\n\n  return {\n    session: {\n      get: async (id) => {\n        try {\n          const result = await rpc(\"session.get\", { id });\n          if (result === null) {\n            return new SessionNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (session) => {\n        try {\n          return await rpc(\"session.set\", session);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (id) => {\n        try {\n          await rpc(\"session.delete\", { id });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"session.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sessionId, tags }) => {\n          try {\n            return await rpc(\"session.tag.set\", { sessionId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    message: {\n      list: async (sessionId, opts) => {\n        try {\n          return await rpc(\"message.list\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      get: async (id) => {\n        try {\n          const result = await rpc(\"message.get\", { id });\n          if (result === null) {\n            return new MessageNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (message) => {\n        try {\n          return await rpc(\"message.set\", message);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    part: {\n      listByMessage: async (messageId, opts) => {\n        try {\n          const result = await rpc(\"part.listByMessage\", {\n            messageId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      listBySession: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"part.listBySession\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (part) => {\n        try {\n          return (await rpc(\"part.set\", part)) as Part;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (id) => {\n        try {\n          await rpc(\"part.delete\", { id });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    sandbox: {\n      get: async (key) => {\n        try {\n          const result = await rpc(\"sandbox.get\", { key });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: key });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      getBySession: async (sessionId) => {\n        try {\n          const result = await rpc(\"sandbox.getBySession\", { sessionId });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: sessionId });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (record) => {\n        try {\n          await rpc(\"sandbox.set\", record);\n          return record;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"sandbox.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sandboxId, tags }) => {\n          try {\n            return await rpc(\"sandbox.tag.set\", { sandboxId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n      acquireLock: async (record, lockTimeoutMs) => {\n        try {\n          return (await rpc(\"sandbox.acquireLock\", {\n            record,\n            lockTimeoutMs,\n          })) as import(\"./types\").SandboxRecord | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    setup: {\n      get: async (key) => {\n        try {\n          return (await rpc(\"setup.get\", { key })) as SetupSnapshot | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (snapshot) => {\n        try {\n          await rpc(\"setup.set\", snapshot);\n          return snapshot;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      acquireLock: async (key, lockId, lockTimeoutMs) => {\n        try {\n          return (await rpc(\"setup.acquireLock\", {\n            key,\n            lockId,\n            lockTimeoutMs,\n          })) as SetupSnapshot | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    command: {\n      get: async (id) => {\n        try {\n          return (await rpc(\"command.get\", { id })) as Command | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (command) => {\n        try {\n          return (await rpc(\"command.set\", command)) as Command;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"command.list\", {\n            sessionId,\n            includeFinished: opts?.includeFinished,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Command>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n  };\n}\n\nexport const DEFAULT_NAMESPACE = \"default\";\nexport const LOCAL_STORAGE_VERSION = \"v1\";\n\nexport function getStorage(opts: {\n  config: StorageConfig;\n  rpc: RpcFn;\n}): Storage {\n  const name = opts.config.name ?? DEFAULT_NAMESPACE;\n  return getStorageClient(opts.rpc, name);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/chunk-W4SSZPDX.mjs

@@ -0,0 +1,106 @@
+// src/sandbox/bindings/lifecycle-workflow.ts
+import { sleep } from "workflow";
+
+// src/sandbox/bindings/lifecycle-workflow-steps.ts
+var DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1e3;
+var DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+var SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1e3;
+var getTestCredentials = () => process.env.NODE_ENV === "test" ? {
+  token: process.env.TEST_VERCEL_TOKEN,
+  teamId: process.env.TEST_VERCEL_TEAM_ID,
+  projectId: process.env.TEST_VERCEL_PROJECT_ID
+} : {};
+async function checkAndSnapshotStep(input) {
+  "use step";
+  const { Sandbox: VercelSandboxSDK } = await import("./vercel-sdk-I6A4MVAN.mjs");
+  const { getStorage } = await import("./storage-LL6IA24R.mjs");
+  if (!input.rpc) {
+    throw new Error("RPC not found");
+  }
+  const storage = getStorage({
+    config: input.storageConfig,
+    rpc: input.rpc
+  });
+  const record = await storage.sandbox.get(input.id);
+  if (record instanceof Error) {
+    return { action: "exit", reason: "not_found" };
+  }
+  const currentSandboxId = record.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
+  if (currentSandboxId !== input.vercelSandboxId) {
+    return { action: "exit", reason: "sandboxId_changed" };
+  }
+  if (!currentSandboxId) {
+    return { action: "exit", reason: "not_found" };
+  }
+  const config = record.config;
+  if (config.type !== "vercel") {
+    return { action: "exit", reason: "not_found" };
+  }
+  const pollIntervalMs = config.lifecycle?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const idleTimeoutMs = config.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const snapshotBeforeTimeoutMs = config.lifecycle?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;
+  const now = Date.now();
+  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;
+  const idleDuration = now - lastActivity;
+  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;
+  let shouldSnapshotDueToTimeout = false;
+  try {
+    const sandbox = await VercelSandboxSDK.get({
+      sandboxId: currentSandboxId,
+      ...getTestCredentials()
+    });
+    if (sandbox.timeout < snapshotBeforeTimeoutMs) {
+      shouldSnapshotDueToTimeout = true;
+    }
+  } catch {
+    return { action: "exit", reason: "not_found" };
+  }
+  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {
+    try {
+      const sandbox = await VercelSandboxSDK.get({
+        sandboxId: currentSandboxId,
+        ...getTestCredentials()
+      });
+      const snapshot = await sandbox.snapshot();
+      await storage.sandbox.set({
+        ...record,
+        acquiringLockId: null,
+        acquiringLockAt: null,
+        providerMetadata: {
+          provider: "vercel",
+          sandboxId: null,
+          snapshotId: snapshot.snapshotId
+        }
+      });
+    } catch (e) {
+      return e instanceof Error ? e : new Error(String(e));
+    }
+    return {
+      action: "exit",
+      reason: shouldSnapshotDueToIdle ? "idle" : "timeout"
+    };
+  }
+  return { action: "continue", nextPollMs: pollIntervalMs };
+}
+
+// src/sandbox/bindings/lifecycle-workflow.ts
+var DEFAULT_POLL_MS = 2 * 60 * 1e3;
+async function sandboxLifecycleWorkflow({
+  input
+}) {
+  "use workflow";
+  let nextPollMs = DEFAULT_POLL_MS;
+  while (true) {
+    await sleep(nextPollMs);
+    const result = await checkAndSnapshotStep(input);
+    if (result instanceof Error || result.action === "exit") {
+      break;
+    }
+    nextPollMs = result.nextPollMs;
+  }
+}
+
+export {
+  sandboxLifecycleWorkflow
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/lifecycle-workflow.ts", "../src/sandbox/bindings/lifecycle-workflow-steps.ts"],
  "sourcesContent": ["import { sleep } from \"workflow\";\nimport type { SandboxLifecycleInput } from \"../types\";\nimport { checkAndSnapshotStep } from \"./lifecycle-workflow-steps\";\n\nexport type { SandboxLifecycleInput };\n\nconst DEFAULT_POLL_MS = 2 * 60 * 1000;\n\nexport async function sandboxLifecycleWorkflow({\n  input,\n}: {\n  input: SandboxLifecycleInput;\n}) {\n  \"use workflow\";\n\n  let nextPollMs = DEFAULT_POLL_MS;\n\n  while (true) {\n    await sleep(nextPollMs);\n\n    const result = await checkAndSnapshotStep(input);\n\n    if (result instanceof Error || result.action === \"exit\") {\n      break;\n    }\n\n    nextPollMs = result.nextPollMs;\n  }\n}\n", "import type { SandboxLifecycleInput } from \"../types\";\n\nconst DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;\nconst SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1000;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\nexport type LifecycleStepResult =\n  | { action: \"continue\"; nextPollMs: number }\n  | {\n      action: \"exit\";\n      reason: \"sandboxId_changed\" | \"idle\" | \"timeout\" | \"not_found\";\n    };\n\nexport async function checkAndSnapshotStep(\n  input: SandboxLifecycleInput\n): Promise<Error | LifecycleStepResult> {\n  \"use step\";\n\n  const { Sandbox: VercelSandboxSDK } = await import(\"./vercel-sdk\");\n  const { getStorage } = await import(\"../../storage\");\n  if (!input.rpc) {\n    throw new Error(\"RPC not found\");\n  }\n  const storage = getStorage({\n    config: input.storageConfig,\n    rpc: input.rpc,\n  });\n  const record = await storage.sandbox.get(input.id);\n  if (record instanceof Error) {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const currentSandboxId =\n    record.providerMetadata?.provider === \"vercel\"\n      ? record.providerMetadata.sandboxId\n      : null;\n\n  if (currentSandboxId !== input.vercelSandboxId) {\n    return { action: \"exit\", reason: \"sandboxId_changed\" };\n  }\n\n  if (!currentSandboxId) {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const config = record.config;\n  if (config.type !== \"vercel\") {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const pollIntervalMs =\n    config.lifecycle?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const idleTimeoutMs =\n    config.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;\n  const snapshotBeforeTimeoutMs =\n    config.lifecycle?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;\n\n  const now = Date.now();\n  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;\n  const idleDuration = now - lastActivity;\n  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;\n\n  let shouldSnapshotDueToTimeout = false;\n  try {\n    const sandbox = await VercelSandboxSDK.get({\n      sandboxId: currentSandboxId,\n      ...getTestCredentials(),\n    });\n    if (sandbox.timeout < snapshotBeforeTimeoutMs) {\n      shouldSnapshotDueToTimeout = true;\n    }\n  } catch {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {\n    try {\n      const sandbox = await VercelSandboxSDK.get({\n        sandboxId: currentSandboxId,\n        ...getTestCredentials(),\n      });\n      const snapshot = await sandbox.snapshot();\n      await storage.sandbox.set({\n        ...record,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId: snapshot.snapshotId,\n        },\n      });\n    } catch (e) {\n      return e instanceof Error ? e : new Error(String(e));\n    }\n    return {\n      action: \"exit\",\n      reason: shouldSnapshotDueToIdle ? \"idle\" : \"timeout\",\n    };\n  }\n\n  return { action: \"continue\", nextPollMs: pollIntervalMs };\n}\n"],
  "mappings": "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",
  "names": []
}
