computesdk 1.9.4 → 1.9.6

package/dist/index.js

@@ -22,20 +22,31 @@ var index_exports = {};
 __export(index_exports, {
   CommandExitError: () => import_client2.CommandExitError,
   GATEWAY_URL: () => GATEWAY_URL,
+  PROVIDER_AUTH: () => PROVIDER_AUTH,
+  PROVIDER_DASHBOARD_URLS: () => PROVIDER_DASHBOARD_URLS,
+  PROVIDER_ENV_MAP: () => PROVIDER_ENV_MAP,
   PROVIDER_ENV_VARS: () => PROVIDER_ENV_VARS,
+  PROVIDER_HEADERS: () => PROVIDER_HEADERS,
+  PROVIDER_NAMES: () => PROVIDER_NAMES,
   PROVIDER_PRIORITY: () => PROVIDER_PRIORITY,
   Sandbox: () => import_client.Sandbox,
   autoConfigureCompute: () => autoConfigureCompute,
+  buildProviderHeaders: () => buildProviderHeaders,
   calculateBackoff: () => calculateBackoff,
   compute: () => compute,
   createCompute: () => createCompute,
   createProvider: () => createProvider,
+  createProviderFromConfig: () => createProviderFromConfig,
   detectProvider: () => detectProvider,
   gateway: () => gateway,
+  getMissingEnvVars: () => getMissingEnvVars,
+  getProviderConfigFromEnv: () => getProviderConfigFromEnv,
   getProviderHeaders: () => getProviderHeaders,
   handleComputeRequest: () => handleComputeRequest,
   isCommandExitError: () => import_client2.isCommandExitError,
-  isGatewayModeEnabled: () => isGatewayModeEnabled
+  isGatewayModeEnabled: () => isGatewayModeEnabled,
+  isProviderAuthComplete: () => isProviderAuthComplete,
+  isValidProvider: () => isValidProvider
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -43,6 +54,159 @@ module.exports = __toCommonJS(index_exports);
 var import_client = require("@computesdk/client");
 var import_client2 = require("@computesdk/client");
 
+// src/provider-config.ts
+var PROVIDER_AUTH = {
+  e2b: [["E2B_API_KEY"]],
+  modal: [["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]],
+  railway: [["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]],
+  daytona: [["DAYTONA_API_KEY"]],
+  vercel: [
+    ["VERCEL_OIDC_TOKEN"],
+    ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]
+  ],
+  runloop: [["RUNLOOP_API_KEY"]],
+  cloudflare: [["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]],
+  codesandbox: [["CSB_API_KEY"]],
+  blaxel: [["BL_API_KEY", "BL_WORKSPACE"]]
+};
+var PROVIDER_NAMES = Object.keys(PROVIDER_AUTH);
+var PROVIDER_HEADERS = {
+  e2b: {
+    apiKey: "X-E2B-API-Key"
+  },
+  modal: {
+    tokenId: "X-Modal-Token-Id",
+    tokenSecret: "X-Modal-Token-Secret"
+  },
+  railway: {
+    apiToken: "X-Railway-API-Token"
+  },
+  daytona: {
+    apiKey: "X-Daytona-API-Key"
+  },
+  vercel: {
+    oidcToken: "X-Vercel-OIDC-Token",
+    token: "X-Vercel-Token",
+    teamId: "X-Vercel-Team-Id",
+    projectId: "X-Vercel-Project-Id"
+  },
+  runloop: {
+    apiKey: "X-Runloop-API-Key"
+  },
+  cloudflare: {
+    apiToken: "X-Cloudflare-API-Token",
+    accountId: "X-Cloudflare-Account-Id"
+  },
+  codesandbox: {
+    apiKey: "X-CSB-API-Key"
+  },
+  blaxel: {
+    apiKey: "X-BL-API-Key",
+    workspace: "X-BL-Workspace"
+  }
+};
+var PROVIDER_ENV_MAP = {
+  e2b: {
+    E2B_API_KEY: "apiKey"
+  },
+  modal: {
+    MODAL_TOKEN_ID: "tokenId",
+    MODAL_TOKEN_SECRET: "tokenSecret"
+  },
+  railway: {
+    RAILWAY_API_KEY: "apiToken",
+    RAILWAY_PROJECT_ID: "projectId",
+    RAILWAY_ENVIRONMENT_ID: "environmentId"
+  },
+  daytona: {
+    DAYTONA_API_KEY: "apiKey"
+  },
+  vercel: {
+    VERCEL_OIDC_TOKEN: "oidcToken",
+    VERCEL_TOKEN: "token",
+    VERCEL_TEAM_ID: "teamId",
+    VERCEL_PROJECT_ID: "projectId"
+  },
+  runloop: {
+    RUNLOOP_API_KEY: "apiKey"
+  },
+  cloudflare: {
+    CLOUDFLARE_API_TOKEN: "apiToken",
+    CLOUDFLARE_ACCOUNT_ID: "accountId"
+  },
+  codesandbox: {
+    CSB_API_KEY: "apiKey"
+  },
+  blaxel: {
+    BL_API_KEY: "apiKey",
+    BL_WORKSPACE: "workspace"
+  }
+};
+var PROVIDER_DASHBOARD_URLS = {
+  e2b: "https://e2b.dev/dashboard",
+  modal: "https://modal.com/settings",
+  railway: "https://railway.app/account/tokens",
+  daytona: "https://daytona.io/dashboard",
+  vercel: "https://vercel.com/account/tokens",
+  runloop: "https://runloop.ai/dashboard",
+  cloudflare: "https://dash.cloudflare.com/profile/api-tokens",
+  codesandbox: "https://codesandbox.io/dashboard/settings",
+  blaxel: "https://blaxel.ai/dashboard"
+};
+function isValidProvider(name) {
+  return name in PROVIDER_AUTH;
+}
+function buildProviderHeaders(provider, config) {
+  const headers = {};
+  const headerMap = PROVIDER_HEADERS[provider];
+  for (const [configKey, headerName] of Object.entries(headerMap)) {
+    const value = config[configKey];
+    if (value) {
+      headers[headerName] = value;
+    }
+  }
+  return headers;
+}
+function getProviderConfigFromEnv(provider) {
+  const config = {};
+  const envMap = PROVIDER_ENV_MAP[provider];
+  for (const [envVar, configKey] of Object.entries(envMap)) {
+    const value = process.env[envVar];
+    if (value) {
+      config[configKey] = value;
+    }
+  }
+  return config;
+}
+function isProviderAuthComplete(provider) {
+  const authOptions = PROVIDER_AUTH[provider];
+  for (const option of authOptions) {
+    const allPresent = option.every((envVar) => !!process.env[envVar]);
+    if (allPresent) return true;
+  }
+  return false;
+}
+function getMissingEnvVars(provider) {
+  const authOptions = PROVIDER_AUTH[provider];
+  let bestOption = null;
+  for (const option of authOptions) {
+    const missing = [];
+    let presentCount = 0;
+    for (const envVar of option) {
+      if (process.env[envVar]) {
+        presentCount++;
+      } else {
+        missing.push(envVar);
+      }
+    }
+    if (missing.length === 0) return [];
+    if (!bestOption || presentCount > bestOption.presentCount) {
+      bestOption = { presentCount, missing };
+    }
+  }
+  return bestOption?.missing ?? [];
+}
+
 // src/constants.ts
 var GATEWAY_URL = "https://gateway.computesdk.com";
 var PROVIDER_PRIORITY = [
@@ -487,7 +651,7 @@ var gateway = createProvider({
     sandbox: {
       create: async (config, options) => {
         const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/sandbox`, config, {
+        const result = await gatewayFetch(`${gatewayUrl}/v1/sandbox`, config, {
           method: "POST",
           body: JSON.stringify(options || {})
         });
@@ -524,7 +688,7 @@ var gateway = createProvider({
       },
       getById: async (config, sandboxId) => {
         const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/sandbox/${sandboxId}`, config);
+        const result = await gatewayFetch(`${gatewayUrl}/v1/sandbox/${sandboxId}`, config);
         if (!result.success || !result.data) {
           return null;
         }
@@ -554,7 +718,7 @@ var gateway = createProvider({
       },
       destroy: async (config, sandboxId) => {
         const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        await gatewayFetch(`${gatewayUrl}/sandbox/${sandboxId}`, config, {
+        await gatewayFetch(`${gatewayUrl}/v1/sandbox/${sandboxId}`, config, {
           method: "DELETE"
         });
       },
@@ -772,6 +936,82 @@ Check your COMPUTESDK_GATEWAY_URL environment variable.`
   });
 }
 
+// src/explicit-config.ts
+function buildProviderHeaders2(config) {
+  const headers = {};
+  const provider = config.provider;
+  const headerMap = PROVIDER_HEADERS[provider];
+  const providerConfig = config[provider];
+  if (!providerConfig || !headerMap) return headers;
+  for (const [configKey, headerName] of Object.entries(headerMap)) {
+    const value = providerConfig[configKey];
+    if (value) {
+      headers[headerName] = value;
+    }
+  }
+  return headers;
+}
+function validateProviderConfig(config) {
+  const provider = config.provider;
+  const authOptions = PROVIDER_AUTH[provider];
+  const providerConfig = config[provider];
+  const dashboardUrl = PROVIDER_DASHBOARD_URLS[provider];
+  if (!authOptions) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  for (const option of authOptions) {
+    const allPresent = option.every((envVar) => {
+      const configField = envVarToConfigField(provider, envVar);
+      return providerConfig?.[configField];
+    });
+    if (allPresent) return;
+  }
+  const configExample = buildConfigExample(provider, authOptions);
+  throw new Error(
+    `Missing ${provider} configuration. When using provider: '${provider}', you must provide:
+${configExample}
+
+Get your credentials at: ${dashboardUrl}`
+  );
+}
+function envVarToConfigField(provider, envVar) {
+  return PROVIDER_ENV_MAP[provider]?.[envVar] ?? envVar.toLowerCase();
+}
+function buildConfigExample(provider, authOptions) {
+  if (authOptions.length === 1) {
+    const fields = authOptions[0].map((envVar) => {
+      const field = envVarToConfigField(provider, envVar);
+      return `${field}: '...'`;
+    });
+    return `  ${provider}: { ${fields.join(", ")} }`;
+  }
+  const options = authOptions.map((option, i) => {
+    const fields = option.map((envVar) => {
+      const field = envVarToConfigField(provider, envVar);
+      return `${field}: '...'`;
+    });
+    return `  Option ${i + 1}:
+    ${provider}: { ${fields.join(", ")} }`;
+  });
+  return options.join("\n\n");
+}
+function createProviderFromConfig(config) {
+  if (!config.apiKey) {
+    throw new Error(
+      `Missing ComputeSDK API key. The 'apiKey' field is required.
+
+Get your API key at: https://computesdk.com/dashboard`
+    );
+  }
+  validateProviderConfig(config);
+  const providerHeaders = buildProviderHeaders2(config);
+  return gateway({
+    apiKey: config.apiKey,
+    provider: config.provider,
+    providerHeaders
+  });
+}
+
 // src/compute.ts
 var ComputeManager = class {
   constructor() {
@@ -895,7 +1135,27 @@ var ComputeManager = class {
     return provider;
   }
 };
-var compute = new ComputeManager();
+var singletonInstance = new ComputeManager();
+function computeFactory(config) {
+  const provider = createProviderFromConfig(config);
+  return createCompute({ provider });
+}
+var compute = new Proxy(
+  computeFactory,
+  {
+    get(_target, prop, _receiver) {
+      const singleton = singletonInstance;
+      const value = singleton[prop];
+      if (typeof value === "function") {
+        return value.bind(singletonInstance);
+      }
+      return value;
+    },
+    apply(_target, _thisArg, args) {
+      return computeFactory(args[0]);
+    }
+  }
+);
 function createCompute(config) {
   const manager = new ComputeManager();
   if (!config) {
@@ -1135,19 +1395,30 @@ async function handleComputeRequest(paramsOrRequestOrBody, provider) {
 0 && (module.exports = {
   CommandExitError,
   GATEWAY_URL,
+  PROVIDER_AUTH,
+  PROVIDER_DASHBOARD_URLS,
+  PROVIDER_ENV_MAP,
   PROVIDER_ENV_VARS,
+  PROVIDER_HEADERS,
+  PROVIDER_NAMES,
   PROVIDER_PRIORITY,
   Sandbox,
   autoConfigureCompute,
+  buildProviderHeaders,
   calculateBackoff,
   compute,
   createCompute,
   createProvider,
+  createProviderFromConfig,
   detectProvider,
   gateway,
+  getMissingEnvVars,
+  getProviderConfigFromEnv,
   getProviderHeaders,
   handleComputeRequest,
   isCommandExitError,
-  isGatewayModeEnabled
+  isGatewayModeEnabled,
+  isProviderAuthComplete,
+  isValidProvider
 });
 //# sourceMappingURL=index.js.map