@computesdk/vercel 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -1,21 +1,24 @@
-import { ComputeSpecification, SandboxConfig, Runtime, ExecutionResult, SandboxInfo } from 'computesdk';
+import * as computesdk from 'computesdk';
+import { Runtime } from 'computesdk';
 
-declare class VercelProvider implements ComputeSpecification {
-    readonly specificationVersion: "v1";
-    readonly provider = "vercel";
-    readonly sandboxId: string;
-    private sandbox;
-    private readonly token;
-    private readonly teamId;
-    private readonly projectId;
-    private readonly runtime;
-    private readonly timeout;
-    constructor(config: SandboxConfig);
-    private ensureSandbox;
-    doExecute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
-    doKill(): Promise<void>;
-    doGetInfo(): Promise<SandboxInfo>;
+/**
+ * Vercel-specific configuration options
+ */
+interface VercelConfig {
+    /** Vercel API token - if not provided, will fallback to VERCEL_TOKEN environment variable */
+    token?: string;
+    /** Vercel team ID - if not provided, will fallback to VERCEL_TEAM_ID environment variable */
+    teamId?: string;
+    /** Vercel project ID - if not provided, will fallback to VERCEL_PROJECT_ID environment variable */
+    projectId?: string;
+    /** Default runtime environment */
+    runtime?: Runtime;
+    /** Execution timeout in milliseconds */
+    timeout?: number;
 }
-declare function vercel(config?: Partial<SandboxConfig>): VercelProvider;
+/**
+ * Create a Vercel provider instance using the factory pattern
+ */
+declare const vercel: (config: VercelConfig) => computesdk.Provider;
 
-export { VercelProvider, vercel };
+export { type VercelConfig, vercel };

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,222 +15,331 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  VercelProvider: () => VercelProvider,
   vercel: () => vercel
 });
 module.exports = __toCommonJS(index_exports);
 var import_sandbox = require("@vercel/sandbox");
-var import_ms = __toESM(require("ms"));
-var VercelProvider = class {
-  constructor(config) {
-    this.specificationVersion = "v1";
-    this.provider = "vercel";
-    this.sandbox = null;
-    this.sandboxId = `vercel-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    this.timeout = config.timeout || 3e5;
-    this.token = process.env.VERCEL_TOKEN || "";
-    this.teamId = process.env.VERCEL_TEAM_ID || "";
-    this.projectId = process.env.VERCEL_PROJECT_ID || "";
-    if (!this.token) {
-      throw new Error(
-        `Missing Vercel token. Set VERCEL_TOKEN environment variable. Get your token from https://vercel.com/account/tokens`
-      );
-    }
-    if (!this.teamId) {
-      throw new Error(
-        `Missing Vercel team ID. Set VERCEL_TEAM_ID environment variable.`
-      );
-    }
-    if (!this.projectId) {
-      throw new Error(
-        `Missing Vercel project ID. Set VERCEL_PROJECT_ID environment variable.`
-      );
-    }
-    if (config.runtime && !["node", "python"].includes(config.runtime)) {
-      throw new Error("Vercel provider only supports Node.js and Python runtimes");
-    }
-    this.runtime = config.runtime || "node";
-  }
-  async ensureSandbox() {
-    if (this.sandbox) {
-      return this.sandbox;
-    }
-    try {
-      const runtimeImage = this.runtime === "node" ? "node22" : "python3.13";
-      this.sandbox = await import_sandbox.Sandbox.create({
-        runtime: runtimeImage,
-        timeout: (0, import_ms.default)(`${this.timeout}ms`),
-        resources: { vcpus: 2 }
-        // Default to 2 vCPUs
-      });
-      return this.sandbox;
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.message.includes("unauthorized") || error.message.includes("token")) {
-          throw new Error(
-            `Vercel authentication failed. Please check your VERCEL_TOKEN environment variable. Get your token from https://vercel.com/account/tokens`
-          );
+var import_computesdk = require("computesdk");
+var vercel = (0, import_computesdk.createProvider)({
+  name: "vercel",
+  methods: {
+    sandbox: {
+      // Collection operations (map to compute.sandbox.*)
+      create: async (config, options) => {
+        const oidcToken = typeof process !== "undefined" && process.env?.VERCEL_OIDC_TOKEN;
+        const token = config.token || typeof process !== "undefined" && process.env?.VERCEL_TOKEN || "";
+        const teamId = config.teamId || typeof process !== "undefined" && process.env?.VERCEL_TEAM_ID || "";
+        const projectId = config.projectId || typeof process !== "undefined" && process.env?.VERCEL_PROJECT_ID || "";
+        if (!oidcToken && (!token || !teamId || !projectId)) {
+          if (!oidcToken && !token) {
+            throw new Error(
+              `Missing Vercel authentication. Either:
+1. Use OIDC token: Run 'vercel env pull' to get VERCEL_OIDC_TOKEN, or
+2. Use traditional method: Provide 'token' in config or set VERCEL_TOKEN environment variable. Get your token from https://vercel.com/account/tokens`
+            );
+          }
+          if (!oidcToken && !teamId) {
+            throw new Error(
+              `Missing Vercel team ID. Provide 'teamId' in config or set VERCEL_TEAM_ID environment variable.`
+            );
+          }
+          if (!oidcToken && !projectId) {
+            throw new Error(
+              `Missing Vercel project ID. Provide 'projectId' in config or set VERCEL_PROJECT_ID environment variable.`
+            );
+          }
         }
-        if (error.message.includes("team") || error.message.includes("project")) {
+        const runtime = options?.runtime || config.runtime || "node";
+        const timeout = config.timeout || 3e5;
+        try {
+          let sandbox;
+          if (options?.sandboxId) {
+            throw new Error(
+              `Vercel provider does not support reconnecting to existing sandboxes. Vercel sandboxes are ephemeral and must be created fresh each time.`
+            );
+          } else {
+            if (oidcToken) {
+              sandbox = await import_sandbox.Sandbox.create();
+            } else {
+              sandbox = await import_sandbox.Sandbox.create({
+                token,
+                teamId,
+                projectId
+              });
+            }
+          }
+          return {
+            sandbox,
+            sandboxId: sandbox.sandboxId
+          };
+        } catch (error) {
+          if (error instanceof Error) {
+            if (error.message.includes("unauthorized") || error.message.includes("token")) {
+              throw new Error(
+                `Vercel authentication failed. Please check your VERCEL_TOKEN environment variable. Get your token from https://vercel.com/account/tokens`
+              );
+            }
+            if (error.message.includes("team") || error.message.includes("project")) {
+              throw new Error(
+                `Vercel team/project configuration failed. Please check your VERCEL_TEAM_ID and VERCEL_PROJECT_ID environment variables.`
+              );
+            }
+          }
           throw new Error(
-            `Vercel team/project configuration error. Please check your VERCEL_TEAM_ID and VERCEL_PROJECT_ID environment variables.`
+            `Failed to create Vercel sandbox: ${error instanceof Error ? error.message : String(error)}`
           );
         }
-        if (error.message.includes("Memory limit exceeded")) {
-          throw new Error(
-            `Vercel execution failed due to memory limits. Consider optimizing your code or using smaller data sets.`
-          );
+      },
+      getById: async (config, sandboxId) => {
+        const oidcToken = typeof process !== "undefined" && process.env?.VERCEL_OIDC_TOKEN;
+        try {
+          let sandbox;
+          if (oidcToken) {
+            sandbox = await import_sandbox.Sandbox.get({ sandboxId });
+          } else {
+            const token = config.token || process.env.VERCEL_TOKEN;
+            const teamId = config.teamId || process.env.VERCEL_TEAM_ID;
+            const projectId = config.projectId || process.env.VERCEL_PROJECT_ID;
+            sandbox = await import_sandbox.Sandbox.get({
+              sandboxId,
+              token,
+              teamId,
+              projectId
+            });
+          }
+          return {
+            sandbox,
+            sandboxId
+          };
+        } catch (error) {
+          return null;
         }
-        if (error.message.includes("quota") || error.message.includes("limit")) {
+      },
+      list: async (_config) => {
+        throw new Error(
+          `Vercel provider does not support listing sandboxes. Vercel sandboxes are ephemeral and designed for single-use execution.`
+        );
+      },
+      destroy: async (config, sandboxId) => {
+        const oidcToken = typeof process !== "undefined" && process.env?.VERCEL_OIDC_TOKEN;
+        try {
+          let sandbox;
+          if (oidcToken) {
+            sandbox = await import_sandbox.Sandbox.get({ sandboxId });
+          } else {
+            const token = config.token || process.env.VERCEL_TOKEN;
+            const teamId = config.teamId || process.env.VERCEL_TEAM_ID;
+            const projectId = config.projectId || process.env.VERCEL_PROJECT_ID;
+            sandbox = await import_sandbox.Sandbox.get({
+              sandboxId,
+              token,
+              teamId,
+              projectId
+            });
+          }
+          await sandbox.stop();
+        } catch (error) {
+        }
+      },
+      // Instance operations (map to individual Sandbox methods)
+      runCode: async (sandbox, code, runtime, config) => {
+        const startTime = Date.now();
+        try {
+          const effectiveRuntime = runtime || config?.runtime || // Strong Python indicators
+          (code.includes("print(") || code.includes("import ") || code.includes("def ") || code.includes("sys.") || code.includes("json.") || code.includes("__") || code.includes('f"') || code.includes("f'") ? "python" : "node");
+          const encoded = Buffer.from(code).toString("base64");
+          let command;
+          if (effectiveRuntime === "python") {
+            command = await sandbox.runCommand("sh", ["-c", `echo "${encoded}" | base64 -d | python3`]);
+          } else {
+            command = await sandbox.runCommand("sh", ["-c", `echo "${encoded}" | base64 -d | node`]);
+          }
+          const finishedCommand = await command.wait();
+          let stdout = "";
+          let stderr = "";
+          for await (const log of finishedCommand.logs()) {
+            if (log.stream === "stdout") {
+              stdout += log.data;
+            } else if (log.stream === "stderr") {
+              stderr += log.data;
+            }
+          }
+          if (finishedCommand.exitCode !== 0 && stderr) {
+            if (stderr.includes("SyntaxError") || stderr.includes("invalid syntax") || stderr.includes("Unexpected token") || stderr.includes("Unexpected identifier")) {
+              throw new Error(`Syntax error: ${stderr.trim()}`);
+            }
+          }
+          return {
+            stdout,
+            stderr,
+            exitCode: finishedCommand.exitCode,
+            executionTime: Date.now() - startTime,
+            sandboxId: sandbox.sandboxId,
+            provider: "vercel"
+          };
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Syntax error")) {
+            throw error;
+          }
           throw new Error(
-            `Vercel quota exceeded. Please check your usage in the Vercel dashboard.`
+            `Vercel execution failed: ${error instanceof Error ? error.message : String(error)}`
           );
         }
-      }
-      throw new Error(
-        `Failed to initialize Vercel sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async doExecute(code, runtime) {
-    if (runtime && !["node", "python"].includes(runtime)) {
-      throw new Error("Vercel provider only supports Node.js and Python runtimes");
-    }
-    const startTime = Date.now();
-    const actualRuntime = runtime || this.runtime;
-    try {
-      const sandbox = await this.ensureSandbox();
-      let command;
-      let args = [];
-      if (actualRuntime === "node") {
-        command = "node";
-        args = ["-e", code];
-      } else if (actualRuntime === "python") {
-        command = "python";
-        args = ["-c", code];
-      } else {
-        throw new Error(`Unsupported runtime: ${actualRuntime}`);
-      }
-      const result = await sandbox.runCommand({
-        cmd: command,
-        args
-      });
-      let stdout = "";
-      let stderr = "";
-      let exitCode = 0;
-      const stdoutPromise = new Promise((resolve) => {
-        if (result.stdout) {
-          result.stdout.on("data", (data) => {
-            stdout += data.toString();
-          });
-          result.stdout.on("end", resolve);
-        } else {
-          resolve();
+      },
+      runCommand: async (sandbox, command, args = []) => {
+        const startTime = Date.now();
+        try {
+          const cmd = await sandbox.runCommand(command, args);
+          const finishedCommand = await cmd.wait();
+          let stdout = "";
+          let stderr = "";
+          for await (const log of finishedCommand.logs()) {
+            if (log.stream === "stdout") {
+              stdout += log.data;
+            } else if (log.stream === "stderr") {
+              stderr += log.data;
+            }
+          }
+          return {
+            stdout,
+            stderr,
+            exitCode: finishedCommand.exitCode,
+            executionTime: Date.now() - startTime,
+            sandboxId: sandbox.sandboxId,
+            provider: "vercel"
+          };
+        } catch (error) {
+          return {
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            exitCode: 127,
+            // Standard "command not found" exit code
+            executionTime: Date.now() - startTime,
+            sandboxId: sandbox.sandboxId,
+            provider: "vercel"
+          };
         }
-      });
-      const stderrPromise = new Promise((resolve) => {
-        if (result.stderr) {
-          result.stderr.on("data", (data) => {
-            stderr += data.toString();
+      },
+      getInfo: async (sandbox) => {
+        return {
+          id: "vercel-unknown",
+          provider: "vercel",
+          runtime: "node",
+          // Vercel default
+          status: "running",
+          createdAt: /* @__PURE__ */ new Date(),
+          timeout: 3e5,
+          metadata: {
+            vercelSandboxId: "vercel-unknown"
+          }
+        };
+      },
+      // Optional filesystem methods - Vercel has shell-based filesystem support
+      filesystem: {
+        readFile: async (sandbox, path) => {
+          const cmd = await sandbox.runCommand("cat", [path]);
+          const finishedCommand = await cmd.wait();
+          if (finishedCommand.exitCode !== 0) {
+            let stderr = "";
+            for await (const log of finishedCommand.logs()) {
+              if (log.stream === "stderr") {
+                stderr += log.data;
+              }
+            }
+            throw new Error(`Failed to read file ${path}: ${stderr}`);
+          }
+          let content = "";
+          for await (const log of finishedCommand.logs()) {
+            if (log.stream === "stdout") {
+              content += log.data;
+            }
+          }
+          return content.replace(/\n$/, "");
+        },
+        writeFile: async (sandbox, path, content) => {
+          const cmd = await sandbox.runCommand("sh", ["-c", `echo ${JSON.stringify(content)} > ${JSON.stringify(path)}`]);
+          const finishedCommand = await cmd.wait();
+          if (finishedCommand.exitCode !== 0) {
+            let stderr = "";
+            for await (const log of finishedCommand.logs()) {
+              if (log.stream === "stderr") {
+                stderr += log.data;
+              }
+            }
+            throw new Error(`Failed to write file ${path}: ${stderr}`);
+          }
+        },
+        mkdir: async (sandbox, path) => {
+          const cmd = await sandbox.runCommand("mkdir", ["-p", path]);
+          const finishedCommand = await cmd.wait();
+          if (finishedCommand.exitCode !== 0) {
+            let stderr = "";
+            for await (const log of finishedCommand.logs()) {
+              if (log.stream === "stderr") {
+                stderr += log.data;
+              }
+            }
+            throw new Error(`Failed to create directory ${path}: ${stderr}`);
+          }
+        },
+        readdir: async (sandbox, path) => {
+          const cmd = await sandbox.runCommand("ls", ["-la", path]);
+          const finishedCommand = await cmd.wait();
+          let stdout = "";
+          let stderr = "";
+          for await (const log of finishedCommand.logs()) {
+            if (log.stream === "stdout") {
+              stdout += log.data;
+            } else if (log.stream === "stderr") {
+              stderr += log.data;
+            }
+          }
+          if (finishedCommand.exitCode !== 0) {
+            throw new Error(`Failed to list directory ${path}: ${stderr}`);
+          }
+          const lines = (stdout || "").split("\n").filter((line) => line.trim() && !line.startsWith("total"));
+          return lines.map((line) => {
+            const parts = line.trim().split(/\s+/);
+            const name = parts[parts.length - 1];
+            const isDirectory = line.startsWith("d");
+            return {
+              name,
+              path: `${path}/${name}`,
+              isDirectory,
+              size: parseInt(parts[4]) || 0,
+              lastModified: /* @__PURE__ */ new Date()
+            };
           });
-          result.stderr.on("end", resolve);
-        } else {
-          resolve();
-        }
-      });
-      const exitPromise = new Promise((resolve, reject) => {
-        result.on("exit", (code2) => {
-          exitCode = code2;
-          resolve(code2);
-        });
-        result.on("error", reject);
-      });
-      await Promise.all([stdoutPromise, stderrPromise, exitPromise]);
-      return {
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode,
-        executionTime: Date.now() - startTime,
-        sandboxId: this.sandboxId,
-        provider: this.provider
-      };
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.message.includes("timeout")) {
-          throw new Error(
-            `Vercel execution timeout (${this.timeout}ms). Consider increasing the timeout or optimizing your code.`
-          );
-        }
-        if (error.message.includes("memory") || error.message.includes("Memory")) {
-          throw new Error(
-            `Vercel execution failed due to memory limits. Consider optimizing your code or using smaller data sets.`
-          );
+        },
+        exists: async (sandbox, path) => {
+          const cmd = await sandbox.runCommand("test", ["-e", path]);
+          const finishedCommand = await cmd.wait();
+          return finishedCommand.exitCode === 0;
+        },
+        remove: async (sandbox, path) => {
+          const cmd = await sandbox.runCommand("rm", ["-rf", path]);
+          const finishedCommand = await cmd.wait();
+          if (finishedCommand.exitCode !== 0) {
+            let stderr = "";
+            for await (const log of finishedCommand.logs()) {
+              if (log.stream === "stderr") {
+                stderr += log.data;
+              }
+            }
+            throw new Error(`Failed to remove ${path}: ${stderr}`);
+          }
         }
       }
-      throw new Error(
-        `Vercel execution failed: ${error instanceof Error ? error.message : String(error)}`
-      );
     }
   }
-  async doKill() {
-    if (!this.sandbox) {
-      return;
-    }
-    try {
-      await this.sandbox.stop();
-      this.sandbox = null;
-    } catch (error) {
-      throw new Error(
-        `Failed to kill Vercel sandbox: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async doGetInfo() {
-    await this.ensureSandbox();
-    return {
-      id: this.sandboxId,
-      provider: this.provider,
-      runtime: this.runtime,
-      status: this.sandbox ? "running" : "stopped",
-      createdAt: /* @__PURE__ */ new Date(),
-      timeout: this.timeout,
-      metadata: {
-        vercelSandboxId: this.sandboxId,
-        teamId: this.teamId,
-        projectId: this.projectId,
-        vcpus: 2,
-        // Default vCPUs
-        region: "global"
-        // Vercel sandboxes can run globally
-      }
-    };
-  }
-};
-function vercel(config) {
-  const fullConfig = {
-    provider: "vercel",
-    runtime: "node",
-    timeout: 3e5,
-    ...config
-  };
-  return new VercelProvider(fullConfig);
-}
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  VercelProvider,
   vercel
 });
 //# sourceMappingURL=index.js.map