computesdk 1.8.6 → 1.8.8

package/dist/index.mjs

@@ -10,11 +10,10 @@ function isCommandExitError(error) {
   return typeof error === "object" && error !== null && "name" in error && error.name === "CommandExitError" && "result" in error;
 }
 
-// src/compute.ts
-import { ComputeClient } from "@computesdk/client";
+// src/auth/license.ts
 async function authorizeApiKey(apiKey) {
   try {
-    const response = await fetch("https://preview.computesdk.com/__api/license/authorize", {
+    const response = await fetch("https://sandbox.computesdk.com/__api/license/authorize", {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -50,6 +49,8 @@ async function authorizeApiKey(apiKey) {
     throw new Error(`Failed to authorize API key (network error): ${error instanceof Error ? error.message : String(error)}`);
   }
 }
+
+// src/compute-daemon/dependencies.ts
 async function isCommandAvailable(sandbox, command) {
   const result = await sandbox.runCommand("sh", ["-c", `command -v ${command}`]);
   return result.exitCode === 0;
@@ -91,6 +92,8 @@ Please install curl and bash manually or use a different sandbox image.`
     );
   }
 }
+
+// src/compute-daemon/installer.ts
 async function isComputeInstalled(sandbox) {
   const result = await sandbox.runCommand("sh", ["-c", 'test -f /usr/local/bin/compute && echo "exists" || echo "missing"']);
   return result.stdout?.trim() === "exists";
@@ -109,18 +112,12 @@ async function runInstallScript(sandbox, accessToken) {
   const installResult = await sandbox.runCommand("bash", ["-c", installCommand]);
   if (installResult.exitCode !== 0) {
     const errorOutput = installResult.stderr || installResult.stdout || "unknown error";
-    throw new Error(`Failed to install compute CLI: ${errorOutput}`);
+    throw new Error(`Failed to install compute daemon: ${errorOutput}`);
   }
 }
-async function installComputeInSandbox(sandbox, config) {
-  let authResponse = null;
-  let accessToken = config?.accessToken;
-  if (config?.apiKey && !accessToken) {
-    authResponse = await authorizeApiKey(config.apiKey);
-    accessToken = authResponse.access_token;
-  }
+async function installComputeDaemon(sandbox, accessToken) {
   if (await isComputeInstalled(sandbox)) {
-    return authResponse;
+    return;
   }
   await ensureDependencies(sandbox);
   await downloadInstallScript(sandbox);
@@ -128,8 +125,12 @@ async function installComputeInSandbox(sandbox, config) {
   if (!await isComputeInstalled(sandbox)) {
     throw new Error("Compute binary not found at /usr/local/bin/compute after installation");
   }
-  return authResponse;
 }
+
+// src/sandbox/wrapper.ts
+import { ComputeClient } from "@computesdk/client";
+
+// src/compute-daemon/lifecycle.ts
 async function waitForComputeReady(client, maxRetries = 30, delayMs = 2e3) {
   let lastError = null;
   for (let i = 0; i < maxRetries; i++) {
@@ -140,7 +141,7 @@ async function waitForComputeReady(client, maxRetries = 30, delayMs = 2e3) {
       lastError = error instanceof Error ? error : new Error(String(error));
       if (i === maxRetries - 1) {
         throw new Error(
-          `Compute CLI failed to start after ${maxRetries} attempts (${maxRetries * delayMs / 1e3}s).
+          `Compute daemon failed to start after ${maxRetries} attempts (${maxRetries * delayMs / 1e3}s).
 Last error: ${lastError.message}
 This could indicate:
   1. The compute daemon failed to start in the sandbox
@@ -152,6 +153,28 @@ This could indicate:
     }
   }
 }
+
+// src/sandbox/wrapper.ts
+async function wrapWithComputeClient(originalSandbox, authResponse) {
+  const client = new ComputeClient({
+    sandboxUrl: authResponse.sandbox_url,
+    sandboxId: originalSandbox.sandboxId,
+    provider: originalSandbox.provider,
+    token: authResponse.access_token,
+    WebSocket: globalThis.WebSocket
+  });
+  await waitForComputeReady(client);
+  const wrappedSandbox = Object.assign(client, {
+    __originalSandbox: originalSandbox,
+    // Override getInstance to return the original provider's instance
+    getInstance: () => originalSandbox.getInstance(),
+    // Override getProvider to return the original provider
+    getProvider: () => originalSandbox.getProvider()
+  });
+  return wrappedSandbox;
+}
+
+// src/compute.ts
 var ComputeManager = class {
   constructor() {
     this.config = null;
@@ -181,9 +204,22 @@ var ComputeManager = class {
         const options = params?.options;
         const sandbox = await provider.sandbox.create(options);
         if (this.computeAuth.apiKey || this.computeAuth.accessToken) {
-          const authResponse = await installComputeInSandbox(sandbox, this.computeAuth);
+          let authResponse = null;
+          let accessToken = this.computeAuth.accessToken;
+          if (this.computeAuth.apiKey && !accessToken) {
+            authResponse = await authorizeApiKey(this.computeAuth.apiKey);
+            accessToken = authResponse.access_token;
+          }
+          await installComputeDaemon(sandbox, accessToken);
           if (authResponse) {
-            return await this.wrapWithComputeClient(sandbox, authResponse);
+            return await wrapWithComputeClient(sandbox, authResponse);
+          } else if (accessToken) {
+            const defaultAuthResponse = {
+              access_token: accessToken,
+              sandbox_url: "https://sandbox.computesdk.com",
+              preview_url: "https://preview.computesdk.com"
+            };
+            return await wrapWithComputeClient(sandbox, defaultAuthResponse);
           }
         }
         return sandbox;
@@ -272,28 +308,6 @@ var ComputeManager = class {
     }
     return provider;
   }
-  /**
-   * Wrap a provider sandbox with ComputeClient while preserving the original sandbox
-   * This adds powerful features like WebSocket terminals, file watchers, and signals
-   */
-  async wrapWithComputeClient(originalSandbox, authResponse) {
-    const client = new ComputeClient({
-      sandboxUrl: authResponse.sandbox_url,
-      sandboxId: originalSandbox.sandboxId,
-      provider: originalSandbox.provider,
-      token: authResponse.access_token,
-      WebSocket: globalThis.WebSocket
-    });
-    await waitForComputeReady(client);
-    const wrappedSandbox = Object.assign(client, {
-      __originalSandbox: originalSandbox,
-      // Override getInstance to return the original provider's instance
-      getInstance: () => originalSandbox.getInstance(),
-      // Override getProvider to return the original provider
-      getProvider: () => originalSandbox.getProvider()
-    });
-    return wrappedSandbox;
-  }
   // Future: compute.blob.*, compute.database.*, compute.git.* will be added here
   // blob = new BlobManager();
   // database = new DatabaseManager();  
@@ -560,80 +574,10 @@ function createBackgroundCommand(command, args = [], options) {
   const fullCommand = args.length > 0 ? `${command} ${args.join(" ")}` : command;
   return {
     command: "sh",
-    args: ["-c", `${fullCommand} &`],
+    args: ["-c", `nohup ${fullCommand} > /dev/null 2>&1 &`],
     isBackground: true
   };
 }
-var defaultFilesystemMethods = {
-  readFile: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "cat", [path]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to read file ${path}: ${result.stderr}`);
-    }
-    return result.stdout.replace(/\n$/, "");
-  },
-  writeFile: async (sandbox, path, content, runCommand) => {
-    const result = await runCommand(sandbox, "sh", ["-c", `echo ${JSON.stringify(content)} > ${JSON.stringify(path)}`]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to write file ${path}: ${result.stderr}`);
-    }
-  },
-  mkdir: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "mkdir", ["-p", path]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
-    }
-  },
-  readdir: async (sandbox, path, runCommand) => {
-    let result = await runCommand(sandbox, "ls", ["-la", path]);
-    let hasDetailedOutput = true;
-    if (result.exitCode !== 0) {
-      result = await runCommand(sandbox, "ls", ["-l", path]);
-    }
-    if (result.exitCode !== 0) {
-      result = await runCommand(sandbox, "ls", [path]);
-      hasDetailedOutput = false;
-    }
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
-    }
-    const lines = (result.stdout || "").split("\n").filter((line) => line.trim() && !line.startsWith("total"));
-    return lines.map((line) => {
-      if (hasDetailedOutput && line.includes(" ")) {
-        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()
-        };
-      } else {
-        const name = line.trim();
-        return {
-          name,
-          path: `${path}/${name}`,
-          isDirectory: false,
-          // Can't determine from simple ls
-          size: 0,
-          lastModified: /* @__PURE__ */ new Date()
-        };
-      }
-    });
-  },
-  exists: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "test", ["-e", path]);
-    return result.exitCode === 0;
-  },
-  remove: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "rm", ["-rf", path]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to remove ${path}: ${result.stderr}`);
-    }
-  }
-};
 var UnsupportedFileSystem = class {
   constructor(providerName) {
     this.providerName = providerName;
@@ -707,6 +651,16 @@ var GeneratedSandbox = class {
     return await this.methods.runCode(this.sandbox, code, runtime, this.config);
   }
   async runCommand(command, args, options) {
+    if (options?.background) {
+      const fullCommand = args?.length ? `${command} ${args.join(" ")}` : command;
+      const bgCommand = `nohup ${fullCommand} > /dev/null 2>&1 &`;
+      const result = await this.methods.runCommand(this.sandbox, "sh", ["-c", bgCommand], void 0);
+      return {
+        ...result,
+        isBackground: true,
+        pid: -1
+      };
+    }
     return await this.methods.runCommand(this.sandbox, command, args, options);
   }
   async getInfo() {
@@ -847,9 +801,6 @@ var GeneratedProvider = class {
   }
 };
 function createProvider(providerConfig) {
-  if (!providerConfig.methods.sandbox.filesystem) {
-    providerConfig.methods.sandbox.filesystem = defaultFilesystemMethods;
-  }
   return (config) => {
     return new GeneratedProvider(config, providerConfig);
   };