computesdk 1.9.6 → 1.10.0

package/dist/index.mjs

@@ -356,6 +356,54 @@ var GeneratedSandboxManager = class {
   async destroy(sandboxId) {
     await this.methods.destroy(this.config, sandboxId);
   }
+  async findOrCreate(options) {
+    if (!this.methods.findOrCreate) {
+      throw new Error(
+        `Provider '${this.providerName}' does not support findOrCreate.
+This feature requires gateway provider with named sandbox support.`
+      );
+    }
+    const result = await this.methods.findOrCreate(this.config, options);
+    return new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy,
+      this.providerInstance
+    );
+  }
+  async find(options) {
+    if (!this.methods.find) {
+      throw new Error(
+        `Provider '${this.providerName}' does not support find.
+This feature requires gateway provider with named sandbox support.`
+      );
+    }
+    const result = await this.methods.find(this.config, options);
+    if (!result) {
+      return null;
+    }
+    return new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy,
+      this.providerInstance
+    );
+  }
+  async extendTimeout(sandboxId, options) {
+    if (!this.methods.extendTimeout) {
+      throw new Error(
+        `Provider '${this.providerName}' does not support extendTimeout.
+This feature requires gateway provider with timeout extension support.`
+      );
+    }
+    await this.methods.extendTimeout(this.config, sandboxId, options);
+  }
 };
 var GeneratedTemplateManager = class {
   constructor(config, methods) {
@@ -602,14 +650,14 @@ var gateway = createProvider({
     sandbox: {
       create: async (config, options) => {
         const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/v1/sandbox`, config, {
+        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes`, config, {
           method: "POST",
           body: JSON.stringify(options || {})
         });
         if (!result.success || !result.data) {
           throw new Error(`Gateway returned invalid response: ${JSON.stringify(result)}`);
         }
-        const { sandboxId, url, token, provider, metadata } = result.data;
+        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
         if (process.env.COMPUTESDK_DEBUG) {
           console.log(`[Gateway] Sandbox created:`, {
             sandboxId,
@@ -631,7 +679,11 @@ var gateway = createProvider({
           provider,
           token: token || config.apiKey,
           // Use token from gateway, fallback to API key
-          metadata,
+          metadata: {
+            ...metadata,
+            ...name && { name },
+            ...namespace && { namespace }
+          },
           WebSocket: globalThis.WebSocket
         });
         await waitForComputeReady(sandbox);
@@ -639,7 +691,7 @@ var gateway = createProvider({
       },
       getById: async (config, sandboxId) => {
         const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/v1/sandbox/${sandboxId}`, config);
+        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes/${sandboxId}`, config);
         if (!result.success || !result.data) {
           return null;
         }
@@ -669,10 +721,97 @@ var gateway = createProvider({
       },
       destroy: async (config, sandboxId) => {
         const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        await gatewayFetch(`${gatewayUrl}/v1/sandbox/${sandboxId}`, config, {
+        await gatewayFetch(`${gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
           method: "DELETE"
         });
       },
+      findOrCreate: async (config, options) => {
+        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
+        const { name: requestedName, namespace: requestedNamespace, ...restOptions } = options;
+        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes/find-or-create`, config, {
+          method: "POST",
+          body: JSON.stringify({
+            namespace: requestedNamespace || "default",
+            name: requestedName,
+            ...restOptions
+          })
+        });
+        if (!result.success || !result.data) {
+          throw new Error(`Gateway returned invalid response: ${JSON.stringify(result)}`);
+        }
+        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
+        if (process.env.COMPUTESDK_DEBUG) {
+          console.log(`[Gateway] Named sandbox found/created:`, {
+            sandboxId,
+            name,
+            namespace,
+            url,
+            hasToken: !!token,
+            provider
+          });
+        }
+        const sandbox = new ClientSandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          metadata: {
+            ...metadata,
+            name,
+            namespace
+          },
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return { sandbox, sandboxId };
+      },
+      find: async (config, options) => {
+        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
+        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes/find`, config, {
+          method: "POST",
+          body: JSON.stringify({
+            namespace: options.namespace || "default",
+            name: options.name
+          })
+        });
+        if (!result.success || !result.data) {
+          return null;
+        }
+        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
+        if (process.env.COMPUTESDK_DEBUG) {
+          console.log(`[Gateway] Named sandbox found:`, {
+            sandboxId,
+            name,
+            namespace,
+            url
+          });
+        }
+        const sandbox = new ClientSandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          metadata: {
+            ...metadata,
+            name,
+            namespace
+          },
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return { sandbox, sandboxId };
+      },
+      extendTimeout: async (config, sandboxId, options) => {
+        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
+        const duration = options?.duration ?? 9e5;
+        if (process.env.COMPUTESDK_DEBUG) {
+          console.log(`[Gateway] Extending timeout for sandbox ${sandboxId} by ${duration}ms`);
+        }
+        await gatewayFetch(`${gatewayUrl}/v1/sandboxes/${sandboxId}/extend`, config, {
+          method: "POST",
+          body: JSON.stringify({ duration })
+        });
+      },
       // All operations delegate directly to ClientSandbox
       runCode: async (sandbox, code, runtime) => sandbox.runCode(code, runtime),
       runCommand: async (sandbox, command, args) => sandbox.runCommand(command, args),
@@ -1026,6 +1165,79 @@ var ComputeManager = class {
           }
           return await providerOrSandboxId.sandbox.destroy(sandboxId);
         }
+      },
+      /**
+       * Find existing or create new sandbox by (namespace, name)
+       *
+       * @example
+       * ```typescript
+       * // Find or create sandbox for a user's project
+       * const sandbox = await compute.sandbox.findOrCreate({
+       *   name: 'my-app',
+       *   namespace: 'user-123',
+       *   timeout: 1800000
+       * });
+       * ```
+       */
+      findOrCreate: async (options) => {
+        const provider = this.getDefaultProvider();
+        if (!provider.sandbox.findOrCreate) {
+          throw new Error(
+            `Provider '${provider.name}' does not support findOrCreate.
+This feature requires gateway provider with named sandbox support.`
+          );
+        }
+        return await provider.sandbox.findOrCreate(options);
+      },
+      /**
+       * Find existing sandbox by (namespace, name) without creating
+       *
+       * @example
+       * ```typescript
+       * // Find existing sandbox
+       * const sandbox = await compute.sandbox.find({
+       *   name: 'my-app',
+       *   namespace: 'user-123'
+       * });
+       * 
+       * if (sandbox) {
+       *   console.log('Found sandbox:', sandbox.sandboxId);
+       * }
+       * ```
+       */
+      find: async (options) => {
+        const provider = this.getDefaultProvider();
+        if (!provider.sandbox.find) {
+          throw new Error(
+            `Provider '${provider.name}' does not support find.
+This feature requires gateway provider with named sandbox support.`
+          );
+        }
+        return await provider.sandbox.find(options);
+      },
+      /**
+       * Extend sandbox timeout/expiration
+       *
+       * @example
+       * ```typescript
+       * // Extend timeout by 15 minutes (default)
+       * await compute.sandbox.extendTimeout('sandbox-123');
+       * 
+       * // Extend timeout by custom duration
+       * await compute.sandbox.extendTimeout('sandbox-123', {
+       *   duration: 1800000 // 30 minutes
+       * });
+       * ```
+       */
+      extendTimeout: async (sandboxId, options) => {
+        const provider = this.getDefaultProvider();
+        if (!provider.sandbox.extendTimeout) {
+          throw new Error(
+            `Provider '${provider.name}' does not support extendTimeout.
+This feature requires gateway provider with timeout extension support.`
+          );
+        }
+        return await provider.sandbox.extendTimeout(sandboxId, options);
       }
     };
   }
@@ -1137,6 +1349,18 @@ function createCompute(config) {
       },
       destroy: async (sandboxId) => {
         return await manager.sandbox.destroy(sandboxId);
+      },
+      findOrCreate: async (options) => {
+        const sandbox = await manager.sandbox.findOrCreate(options);
+        return sandbox;
+      },
+      find: async (options) => {
+        const sandbox = await manager.sandbox.find(options);
+        if (!sandbox) return null;
+        return sandbox;
+      },
+      extendTimeout: async (sandboxId, options) => {
+        return await manager.sandbox.extendTimeout(sandboxId, options);
       }
     }
   };