@deepagents/context 2.4.0 → 3.0.1

package/README.md

@@ -35,6 +35,11 @@ See the docs for the full API surface:
 
 - [Sandbox](https://januarylabs.github.io/deepagents/docs/context/sandbox)
 - [Subcommand Builders](https://januarylabs.github.io/deepagents/docs/context/subcommand)
+- [GCS Cloud Storage Volumes](https://januarylabs.github.io/deepagents/docs/context/recipes/gcs-cloud-storage)
+
+For same-host Linux Docker daemons, `gcs({ hostPath, mountPath })` provides a
+typed bind-volume helper over a host `gcsfuse` mount. For remote daemons, keep
+cloud wiring in the daemon/plugin layer and attach the resulting named volume.
 
 ## Basic Usage
 

package/dist/index.js

@@ -6595,11 +6595,9 @@ function resolveRealCwd(ctx) {
 // packages/context/src/lib/sandbox/daytona-sandbox.ts
 import "bash-tool";
 import { randomUUID } from "node:crypto";
-import { createRequire } from "node:module";
 var DAYTONA_DEFAULT_DESTINATION = "/home/daytona";
 var DAYTONA_EXIT_POLL_INTERVAL_MS = 250;
 var DAYTONA_EXIT_POLL_TIMEOUT_MS = 3e4;
-var requireOptional = createRequire(import.meta.url);
 var DaytonaSandboxError = class extends Error {
   constructor(message2, cause) {
     super(message2);
@@ -6607,15 +6605,6 @@ var DaytonaSandboxError = class extends Error {
     this.cause = cause;
   }
 };
-var DaytonaNotAvailableError = class extends DaytonaSandboxError {
-  constructor(cause) {
-    super(
-      "@daytona/sdk is not installed. Install it with: npm install @daytona/sdk",
-      cause
-    );
-    this.name = "DaytonaNotAvailableError";
-  }
-};
 var DaytonaCreationError = class extends DaytonaSandboxError {
   constructor(message2, cause) {
     super(`Failed to create Daytona sandbox: ${message2}`, cause);
@@ -6628,71 +6617,66 @@ var DaytonaCommandError = class extends DaytonaSandboxError {
     this.name = "DaytonaCommandError";
   }
 };
-async function createDaytonaSandbox(options = {}) {
+async function createDaytonaSandbox(client, options = {}) {
   validateDaytonaOptions(options);
-  const { Daytona } = await importDaytonaSdk();
-  let client;
-  try {
-    client = new Daytona(createDaytonaConfig(options));
-  } catch (error) {
-    const err = toError(error);
-    throw new DaytonaCreationError(err.message, err);
-  }
-  const attached = options.sandboxId !== void 0;
-  const deleteOnDispose = options.deleteOnDispose ?? !attached;
+  const sdk = await import("@daytona/sdk");
   let sandbox;
   try {
-    sandbox = attached ? await client.get(options.sandboxId) : await client.create(createDaytonaParams(options), {
-      timeout: options.createTimeout,
-      onSnapshotCreateLogs: options.onSnapshotCreateLogs
-    });
-    if (attached && sandbox.state && sandbox.state !== "started") {
-      await sandbox.start?.(options.startTimeout ?? options.createTimeout);
+    if (options.sandboxId !== void 0) {
+      sandbox = await client.get(options.sandboxId);
+      await startIfStopped(sandbox, options);
+    } else {
+      sandbox = await acquireReusedSandbox(client, options, sdk);
     }
   } catch (error) {
-    const err = toError(error);
-    throw new DaytonaCreationError(err.message, err);
+    throw normalizeDaytonaError(error, sdk);
   }
   return createDaytonaSandboxMethods({
-    client,
     sandbox,
-    commandTimeout: options.commandTimeout,
-    deleteOnDispose,
-    deleteTimeout: options.deleteTimeout
+    commandTimeout: options.commandTimeout
   });
 }
-async function importDaytonaSdk() {
+var UNRECOVERABLE_SANDBOX_STATES = /* @__PURE__ */ new Set([
+  "error",
+  "build_failed",
+  "destroyed"
+]);
+async function acquireReusedSandbox(client, options, sdk) {
+  let existing;
   try {
-    const mod = requireOptional("@daytona/sdk");
-    if (typeof mod.Daytona !== "function") {
-      throw new DaytonaSandboxError(
-        "@daytona/sdk did not export a Daytona constructor"
-      );
-    }
-    return { Daytona: mod.Daytona };
+    existing = await client.get(options.name);
   } catch (error) {
-    if (error instanceof DaytonaSandboxError) {
-      throw error;
-    }
-    const err = toError(error);
-    if (isMissingDaytonaSdk(err)) {
-      throw new DaytonaNotAvailableError(err);
+    if (error instanceof sdk.DaytonaNotFoundError) {
+      return createSandbox(client, options);
     }
-    throw err;
+    throw error;
+  }
+  if (existing.state && UNRECOVERABLE_SANDBOX_STATES.has(existing.state)) {
+    await deleteSandboxQuietly(existing, options);
+    return createSandbox(client, options);
   }
+  await startIfStopped(existing, options);
+  return existing;
 }
-function createDaytonaConfig(options) {
-  return compactObject({
-    apiKey: options.apiKey,
-    jwtToken: options.jwtToken,
-    organizationId: options.organizationId,
-    apiUrl: options.apiUrl,
-    target: options.target,
-    otelEnabled: options.otelEnabled,
-    _experimental: options.experimental
-  });
+async function deleteSandboxQuietly(sandbox, options) {
+  try {
+    await sandbox.delete(options.deleteTimeout);
+  } catch {
+  }
 }
-function createDaytonaParams(options) {
+async function startIfStopped(sandbox, options) {
+  if (sandbox.state && sandbox.state !== "started") {
+    await sandbox.start(options.startTimeout ?? options.createTimeout);
+  }
+}
+function normalizeDaytonaError(error, sdk) {
+  const err = toError(error);
+  if (err instanceof sdk.DaytonaError) {
+    return err;
+  }
+  return new DaytonaCreationError(err.message, err);
+}
+function createSandbox(client, options) {
   const base = compactObject({
     name: options.name,
     user: options.user,
@@ -6708,18 +6692,22 @@ function createDaytonaParams(options) {
     networkAllowList: options.networkAllowList,
     ephemeral: options.ephemeral
   });
-  if (options.image) {
-    return compactObject({
+  if (options.image !== void 0) {
+    const params2 = compactObject({
       ...base,
       image: options.image,
       resources: options.resources
     });
+    return client.create(params2, {
+      timeout: options.createTimeout,
+      onSnapshotCreateLogs: options.onSnapshotCreateLogs
+    });
   }
   const params = compactObject({
     ...base,
     snapshot: options.snapshot
   });
-  return Object.keys(params).length > 0 ? params : void 0;
+  return client.create(params, { timeout: options.createTimeout });
 }
 function validateDaytonaOptions(options) {
   if (options.image && options.snapshot) {
@@ -6732,6 +6720,11 @@ function validateDaytonaOptions(options) {
       'Daytona sandbox options can only include "resources" when creating from "image". The Daytona SDK does not apply resources during default or snapshot creation.'
     );
   }
+  if (options.sandboxId === void 0 && options.name === void 0) {
+    throw new DaytonaSandboxError(
+      'Daytona sandbox options require "name" (get-or-create) or "sandboxId" (attach). An unnamed sandbox cannot be reclaimed, since dispose() does not delete it.'
+    );
+  }
   if (!options.sandboxId) {
     return;
   }
@@ -6764,8 +6757,7 @@ function validateDaytonaOptions(options) {
   }
 }
 function createDaytonaSandboxMethods(args) {
-  const { client, sandbox, commandTimeout, deleteOnDispose, deleteTimeout } = args;
-  let disposed = false;
+  const { sandbox, commandTimeout } = args;
   const executeCommand = async (command, options) => {
     if (options?.signal?.aborted) {
       return abortedCommandResult();
@@ -6848,17 +6840,6 @@ function createDaytonaSandboxMethods(args) {
       }
     },
     async dispose() {
-      if (disposed) return;
-      disposed = true;
-      try {
-        if (deleteOnDispose) {
-          if (sandbox.delete) await sandbox.delete(deleteTimeout);
-          else if (client.delete) await client.delete(sandbox, deleteTimeout);
-        }
-      } finally {
-        await client[Symbol.asyncDispose]?.().catch(() => {
-        });
-      }
     }
   };
 }
@@ -7084,10 +7065,6 @@ function compactObject(input) {
   }
   return output;
 }
-function isMissingDaytonaSdk(error) {
-  const maybeCode = error.code;
-  return maybeCode === "ERR_MODULE_NOT_FOUND" || maybeCode === "MODULE_NOT_FOUND" || error.message.includes("@daytona/sdk");
-}
 function toError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
@@ -8517,7 +8494,7 @@ function soul() {
 }
 
 // packages/context/src/lib/store/postgres.store.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 
 // packages/context/src/lib/store/ddl.postgres.ts
 function storeDDL(schema) {
@@ -8629,7 +8606,7 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
   }
   static #requirePg() {
     try {
-      const require2 = createRequire2(import.meta.url);
+      const require2 = createRequire(import.meta.url);
       return require2("pg");
     } catch {
       throw new Error(
@@ -9225,7 +9202,7 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
 };
 
 // packages/context/src/lib/store/sqlserver.store.ts
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 
 // packages/context/src/lib/store/ddl.sqlserver.ts
 function storeDDL2(schema) {
@@ -9367,7 +9344,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   }
   static #requireMssql() {
     try {
-      const require2 = createRequire3(import.meta.url);
+      const require2 = createRequire2(import.meta.url);
       return require2("mssql");
     } catch {
       throw new Error(
@@ -10357,7 +10334,7 @@ function asStaticWordPartText(parts, options = {}) {
 }
 
 // packages/context/src/lib/stream/postgres-notify-change-source.ts
-import { createRequire as createRequire4 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 
 // packages/context/src/lib/stream/ddl.stream.postgres-notify.ts
 var DEFAULT_POSTGRES_STREAM_CHANGES_CHANNEL = "deepagents_stream_changes";
@@ -10459,7 +10436,7 @@ var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
   }
   static #requirePg() {
     try {
-      const require2 = createRequire4(import.meta.url);
+      const require2 = createRequire3(import.meta.url);
       return require2("pg");
     } catch {
       throw new Error(
@@ -10714,7 +10691,7 @@ function assertIdentifier(value, label) {
 }
 
 // packages/context/src/lib/stream/postgres.stream-store.ts
-import { createRequire as createRequire5 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 
 // packages/context/src/lib/stream/ddl.stream.postgres.ts
 function postgresStreamDDL(schema) {
@@ -10788,7 +10765,7 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
   }
   static #requirePg() {
     try {
-      const require2 = createRequire5(import.meta.url);
+      const require2 = createRequire4(import.meta.url);
       return require2("pg");
     } catch {
       throw new Error(
@@ -11649,7 +11626,6 @@ export {
   DEFAULT_WATCH_POLLING,
   DaytonaCommandError,
   DaytonaCreationError,
-  DaytonaNotAvailableError,
   DaytonaSandboxError,
   DockerNotAvailableError,
   DockerSandboxError,