@giselles-ai/sandkit 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,25 +1,35 @@
+import {
+  allowNpm,
+  npm
+} from "./chunk-T76VM5D2.js";
 import {
   github
-} from "./chunk-XM4HGRXW.js";
+} from "./chunk-5MXHFOJH.js";
+import {
+  getSandboxDriverFactory
+} from "./chunk-XN6DGLRP.js";
 import "./chunk-UDFWES6J.js";
 import "./chunk-BDPTYR6V.js";
 import "./chunk-RMMOQD5Y.js";
 import {
   createMemoryAdapter
 } from "./chunk-CSOBTLWV.js";
+import {
+  createId
+} from "./chunk-DLGUA3H7.js";
+import {
+  allowBun,
+  bun
+} from "./chunk-YGUNJGP7.js";
 import {
   codex
-} from "./chunk-FSDVHEEX.js";
+} from "./chunk-2M2AZUOC.js";
 import {
   gemini
-} from "./chunk-7DLK7LOM.js";
+} from "./chunk-6GHZO3Y5.js";
 import {
   aiGateway
-} from "./chunk-REGOUXVI.js";
-import {
-  getSandboxDriverFactory
-} from "./chunk-HVYCAAZQ.js";
-import "./chunk-DLGUA3H7.js";
+} from "./chunk-UEAKE56H.js";
 import {
   allowAll,
   allowService,
@@ -30,7 +40,7 @@ import {
   parseWorkspacePolicy,
   redactWorkspacePolicy,
   serializeWorkspacePolicy
-} from "./chunk-VISDS5T7.js";
+} from "./chunk-NKTNTBOY.js";
 
 // src/core/context.ts
 function resolveDeprecatedNetworkOption(options) {
@@ -397,7 +407,12 @@ var ManagedSandbox = class {
       normalized.command,
       normalized.args,
       normalized.policy,
-      () => this.executeCommand(normalized.command, normalized.args, normalized.policy)
+      () => this.executeCommand(
+        normalized.command,
+        normalized.args,
+        normalized.policy,
+        normalized.detached
+      )
     );
   }
   async normalizeRunCommandInput(inputOrCommand, args) {
@@ -405,13 +420,17 @@ var ManagedSandbox = class {
       return {
         command: inputOrCommand,
         args,
-        policy: await this.#resolveDefaultPolicy()
+        policy: await this.#resolveDefaultPolicy(),
+        timeoutMs: void 0,
+        detached: false
       };
     }
     return {
       command: inputOrCommand.command,
       args: inputOrCommand.args ?? [],
-      policy: inputOrCommand.policy ?? await this.#resolveDefaultPolicy()
+      policy: inputOrCommand.policy ?? await this.#resolveDefaultPolicy(),
+      timeoutMs: inputOrCommand.timeoutMs,
+      detached: "detached" in inputOrCommand ? inputOrCommand.detached : false
     };
   }
   ensureCommandShape(command, args) {
@@ -425,44 +444,35 @@ var ManagedSandbox = class {
   async runUnitOfWork(command, args, effectivePolicy, operation) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const runId = await this.startRun(command, args, effectivePolicy, now);
-    let commandError;
-    let commandResult;
-    try {
-      commandResult = await operation();
-    } catch (error) {
-      commandError = error;
-    }
-    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const commandStatus = commandError === void 0 ? commandResult?.exitCode === 0 ? "succeeded" : "failed" : "failed";
-    let providerCommit;
-    let finalizeError;
+    let commandHandle;
     try {
-      const commit = await this.snapshotWithFallback();
-      providerCommit = commit.state;
-      if (this.#onCommit) {
-        await this.persistCommit(commit);
+      commandHandle = await operation();
+    } catch (commandError) {
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      let providerCommit;
+      let finalizeError;
+      try {
+        const commit = await this.snapshotWithFallback();
+        providerCommit = commit.state;
+        if (this.#onCommit) {
+          await this.persistCommit(commit);
+        }
+      } catch (error) {
+        finalizeError = error;
+        providerCommit = void 0;
       }
-    } catch (error) {
-      finalizeError = error;
-      providerCommit = void 0;
-    }
-    const finalRunStatus = commandError === void 0 && finalizeError === void 0 ? commandStatus : "failed";
-    try {
-      if (runId) {
-        await this.finishRun({
-          runId,
-          status: finalRunStatus,
-          providerCommit,
-          finishedAt,
-          exitCode: commandResult?.exitCode,
-          stdout: commandResult?.stdout,
-          stderr: commandResult?.stderr
-        });
+      try {
+        if (runId) {
+          await this.finishRun({
+            runId,
+            status: "failed",
+            providerCommit,
+            finishedAt
+          });
+        }
+      } catch (error) {
+        finalizeError = finalizeError ?? error;
       }
-    } catch (error) {
-      finalizeError = finalizeError ?? error;
-    }
-    if (commandError !== void 0) {
       if (finalizeError !== void 0) {
         throw new AggregateError(
           [commandError, finalizeError],
@@ -471,13 +481,67 @@ var ManagedSandbox = class {
       }
       throw commandError;
     }
-    if (finalizeError !== void 0) {
-      throw finalizeError;
-    }
-    if (!commandResult) {
-      throw new Error("Command result was missing after successful execution.");
-    }
-    return commandResult;
+    const waitResult = (async () => {
+      let commandError;
+      let commandResult;
+      let providerCommit;
+      let finalizeError;
+      try {
+        commandResult = await commandHandle.wait();
+      } catch (error) {
+        commandError = error;
+      }
+      const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const commandStatus = commandError === void 0 ? commandResult?.exitCode === 0 ? "succeeded" : "failed" : "failed";
+      try {
+        const commit = await this.snapshotWithFallback();
+        providerCommit = commit.state;
+        if (this.#onCommit) {
+          await this.persistCommit(commit);
+        }
+      } catch (error) {
+        finalizeError = error;
+        providerCommit = void 0;
+      }
+      const finalRunStatus = commandError === void 0 && finalizeError === void 0 ? commandStatus : "failed";
+      try {
+        if (runId) {
+          await this.finishRun({
+            runId,
+            status: finalRunStatus,
+            providerCommit,
+            finishedAt,
+            exitCode: commandResult?.exitCode,
+            stdout: commandResult?.stdout,
+            stderr: commandResult?.stderr
+          });
+        }
+      } catch (error) {
+        finalizeError = finalizeError ?? error;
+      }
+      if (commandError !== void 0) {
+        if (finalizeError !== void 0) {
+          throw new AggregateError(
+            [commandError, finalizeError],
+            "Sandbox command failed and unit-of-work durability finalization did not complete."
+          );
+        }
+        throw commandError;
+      }
+      if (finalizeError !== void 0) {
+        throw finalizeError;
+      }
+      if (!commandResult) {
+        throw new Error("Command result was missing after successful execution.");
+      }
+      return commandResult;
+    })();
+    void waitResult.catch(() => {
+    });
+    return {
+      wait: async () => waitResult,
+      logs: commandHandle.logs
+    };
   }
   async startRun(command, args, effectivePolicy, at) {
     if (!this.#runLifecycle?.onRunStart) {
@@ -490,9 +554,9 @@ var ManagedSandbox = class {
       startedAt: at
     });
   }
-  async executeCommand(command, args, policy) {
+  async executeCommand(command, args, policy, detached) {
     await this.#driver.applyPolicy(policy);
-    return this.#driver.runCommand(command, [...args]);
+    return this.#driver.runCommand(command, [...args], { detached });
   }
   async finishRun(input) {
     if (!this.#runLifecycle?.onRunFinish) {
@@ -537,7 +601,9 @@ var ManagedSession = class {
     const normalized = await this.normalizeSessionInput(inputOrCommand, args);
     this.ensureCommandShape(normalized.command, normalized.args);
     await this.#driver.applyPolicy(normalized.policy);
-    return this.#driver.runCommand(normalized.command, [...normalized.args]);
+    return (await this.#driver.runCommand(normalized.command, [...normalized.args], {
+      detached: false
+    })).wait();
   }
   async commit() {
     await this.assertSessionActive();
@@ -615,6 +681,9 @@ var ManagedSession = class {
         policy: await this.resolveSessionPolicy()
       };
     }
+    if ("detached" in inputOrCommand) {
+      throw new Error("session exec does not support detached execution.");
+    }
     return {
       command: inputOrCommand.command,
       args: inputOrCommand.args ?? [],
@@ -669,11 +738,15 @@ var LazySandboxHandle = class {
     this.#getActiveLease = getActiveLease;
   }
   async runCommand(inputOrCommand, args = []) {
-    const sandbox = await this.#resolveSandbox();
+    const sandbox = typeof inputOrCommand === "string" ? await this.#resolveSandbox() : await this.#resolveSandbox(inputOrCommand);
     if (typeof inputOrCommand === "string") {
-      return sandbox.runCommand(inputOrCommand, args);
+      return sandbox.runCommand(inputOrCommand, args).then((command2) => command2.wait());
+    }
+    const command = await sandbox.runCommand(inputOrCommand);
+    if ("detached" in inputOrCommand && inputOrCommand.detached === true) {
+      return command;
     }
-    return sandbox.runCommand(inputOrCommand);
+    return command.wait();
   }
   async openSession(input) {
     return this.#openSession(input);
@@ -687,25 +760,169 @@ var LazySandboxHandle = class {
 };
 
 // src/core/workspace.ts
+var inFlightDurableCommands = /* @__PURE__ */ new Set();
 function setupStateFingerprint(command, args, policy) {
   return encodeURIComponent(
     JSON.stringify({
       command,
       args,
-      policy: policy ? {
+      policy: {
         id: describeWorkspacePolicyId(policy),
         config: asPolicySnapshotConfig(policy)
-      } : null
+      }
     })
   );
 }
 var sharedSetupStateId = (adapterId, setup) => {
-  if (setup?.policy) {
+  if (setup) {
     assertWorkspacePolicyIsDurable(setup.policy);
   }
   const fingerprint = setup ? setupStateFingerprint(setup.command, [...setup.args ?? []], setup.policy) : "no-bootstrap";
   return `${adapterId}:shared-bootstrap:${fingerprint}`;
 };
+function sharedSetupRecordId(ctx) {
+  if (!ctx.options.setup) {
+    return null;
+  }
+  return sharedSetupStateId(ctx.adapter.id, ctx.options.setup);
+}
+function assertNoDurableCommandInFlight(workspaceId) {
+  if (inFlightDurableCommands.has(workspaceId)) {
+    throw new Error(
+      "Cannot run a durable command while another durable command is still in flight."
+    );
+  }
+}
+function beginDurableCommand(workspaceId) {
+  assertNoDurableCommandInFlight(workspaceId);
+  inFlightDurableCommands.add(workspaceId);
+}
+function endDurableCommand(workspaceId) {
+  inFlightDurableCommands.delete(workspaceId);
+}
+async function readSharedSetupState(ctx) {
+  if (!ctx.options.setup) {
+    return null;
+  }
+  const sharedSetupId = sharedSetupRecordId(ctx);
+  if (!sharedSetupId) {
+    return null;
+  }
+  const setupState = await ctx.adapter.setupStates.getSetupState(sharedSetupId);
+  return setupState ? setupState.state : null;
+}
+async function persistSharedSetupState(ctx, state) {
+  const sharedSetupId = sharedSetupRecordId(ctx);
+  if (!sharedSetupId) {
+    return;
+  }
+  await ctx.adapter.setupStates.putSetupState({
+    id: sharedSetupId,
+    state: {
+      kind: state.kind,
+      sessionId: state.sessionId,
+      state: state.state
+    }
+  });
+}
+async function clearSharedSetupState(ctx) {
+  const sharedSetupId = sharedSetupRecordId(ctx);
+  if (!sharedSetupId) {
+    return;
+  }
+  await ctx.adapter.setupStates.deleteSetupState(sharedSetupId);
+}
+function isRecoverableSetupStateError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("Sandkit durable state corruption") && error.message.includes("sandkit_setup_states");
+}
+function assertSharedSetupAndPolicy(ctx) {
+  if (!ctx.options.setup) {
+    throw new Error("Sandkit setup is not configured.");
+  }
+  const { setup } = ctx.options;
+  if (!setup.policy) {
+    throw new Error("Shared setup policy is required.");
+  }
+  return setup;
+}
+async function bootstrapSharedSetupState(ctx, workspace, options) {
+  const setup = assertSharedSetupAndPolicy(ctx);
+  const sandbox = await ctx.driverFactory.createSandbox(workspace, {
+    ...options,
+    policy: setup.policy
+  });
+  const result = await runCommandAndWait(sandbox, setup.command, setup.args);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Workspace setup failed with exit code ${result.exitCode}. ${result.stderr.trim()}`.trim()
+    );
+  }
+  const state = await sandbox.snapshot();
+  await persistSharedSetupState(ctx, state);
+  return state;
+}
+async function runCommandAndWait(sandbox, command, args) {
+  const commandArgs = args ?? [];
+  return (await sandbox.runCommand(command, [...commandArgs])).wait();
+}
+async function resolveSharedSetupState(ctx, workspace, options) {
+  if (!ctx.options.setup) {
+    return null;
+  }
+  assertSharedSetupAndPolicy(ctx);
+  try {
+    const setupState = await readSharedSetupState(ctx);
+    if (!setupState) {
+      return bootstrapSharedSetupState(ctx, workspace, options);
+    }
+    return setupState;
+  } catch (error) {
+    if (!isRecoverableSetupStateError(error)) {
+      throw error;
+    }
+    await clearSharedSetupState(ctx);
+    return bootstrapSharedSetupState(ctx, workspace, options);
+  }
+}
+function createInternalSharedBootstrapWorkspaceRecord() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: createId("sandkit-internal-bootstrap"),
+    status: "inactive",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function bootstrapSharedSetup(ctx) {
+  if (!ctx.options.setup) {
+    return;
+  }
+  const setup = assertSharedSetupAndPolicy(ctx);
+  const sharedSetupId = sharedSetupRecordId(ctx);
+  if (!sharedSetupId) {
+    return;
+  }
+  const workspace = createInternalSharedBootstrapWorkspaceRecord();
+  const setupOptions = {
+    policy: setup.policy
+  };
+  let setupState;
+  try {
+    setupState = await readSharedSetupState(ctx);
+  } catch (error) {
+    if (!isRecoverableSetupStateError(error)) {
+      throw error;
+    }
+    await clearSharedSetupState(ctx);
+    setupState = null;
+  }
+  if (!setupState) {
+    await bootstrapSharedSetupState(ctx, workspace, setupOptions);
+  }
+}
 var WorkspaceHandle = class {
   #ctx;
   #record;
@@ -729,7 +946,7 @@ var WorkspaceHandle = class {
   get sandbox() {
     if (!this.#lazySandbox) {
       this.#lazySandbox = new LazySandboxHandle(
-        () => this.createOrResumeSandboxForCommand(),
+        (input) => this.createOrResumeSandboxForCommand(input),
         (input) => this.openSession(input),
         () => this.attachSession(),
         () => this.getActiveLease()
@@ -759,19 +976,29 @@ var WorkspaceHandle = class {
     }
     return readWorkspaceSandboxLease(this.#record);
   }
-  async createOrResumeSandboxForCommand() {
+  async createOrResumeSandboxForCommand(input) {
     await this.resolveLatestWorkspace();
     if (await this.resolveAttachableSession()) {
       throw new Error(
         "Cannot run command while a sandbox session is active. Use attachSession() to reuse it or commit the session first."
       );
     }
+    assertNoDurableCommandInFlight(this.#record.id);
+    beginDurableCommand(this.#record.id);
     const workspace = await this.resolveLatestWorkspace();
-    const sandbox = await this.resolveSandboxDriver(workspace);
-    return this.createManagedSandbox(sandbox);
+    try {
+      const sandbox = await this.resolveSandboxDriver(workspace, {
+        timeoutMs: normalizeRunCommandTimeoutMs(input?.timeoutMs)
+      });
+      return this.createManagedSandbox(sandbox);
+    } catch (error) {
+      endDurableCommand(this.#record.id);
+      throw error;
+    }
   }
   async openSession(input) {
     await this.resolveLatestWorkspace();
+    assertNoDurableCommandInFlight(this.#record.id);
     if (await this.resolveAttachableSession()) {
       throw new Error("A sandbox session is already active for this workspace.");
     }
@@ -862,78 +1089,61 @@ var WorkspaceHandle = class {
     if (currentState) {
       return this.#ctx.driverFactory.resumeSandbox(workspace, currentState, options);
     }
+    const setupState = await resolveSharedSetupState(this.#ctx, workspace, options);
+    if (!setupState) {
+      return this.#ctx.driverFactory.createSandbox(workspace, options);
+    }
     try {
-      const setupState = await this.#readSharedSetupState();
-      if (!setupState) {
-        return this.#bootstrapSetupState(workspace, options);
-      }
       return await this.#ctx.driverFactory.resumeSandbox(workspace, setupState, options);
     } catch (error) {
-      if (!this.#ctx.driverFactory.isSessionUnavailableError?.(error) && !this.#isRecoverableSetupStateError(error)) {
+      if (!this.#ctx.driverFactory.isSessionUnavailableError?.(error) && !isRecoverableSetupStateError(error)) {
         throw error;
       }
-      await this.#clearSharedSetupState();
-      return this.#bootstrapSetupState(workspace, options);
-    }
-  }
-  async #bootstrapSetupState(workspace, options) {
-    const setup = this.#ctx.options.setup;
-    if (!setup) {
-      return this.#ctx.driverFactory.createSandbox(workspace, options);
-    }
-    const setupPolicy = setup.policy ?? options.policy;
-    const sandbox = await this.#ctx.driverFactory.createSandbox(workspace, {
-      ...options,
-      policy: setupPolicy
-    });
-    const result = await sandbox.runCommand(setup.command, [...setup.args ?? []]);
-    if (result.exitCode !== 0) {
-      throw new Error(
-        `Workspace setup failed with exit code ${result.exitCode}. ${result.stderr.trim()}`.trim()
-      );
-    }
-    const setupState = await sandbox.snapshot();
-    await this.#persistSharedSetupState(setupState);
-    return this.#ctx.driverFactory.resumeSandbox(workspace, setupState, options);
-  }
-  async #readSharedSetupState() {
-    if (!this.#ctx.options.setup) {
-      return null;
-    }
-    const setupState = await this.#ctx.adapter.setupStates.getSetupState(
-      this.#sharedSetupStateId()
-    );
-    return setupState ? setupState.state : null;
-  }
-  async #persistSharedSetupState(state) {
-    await this.#ctx.adapter.setupStates.putSetupState({
-      id: this.#sharedSetupStateId(),
-      state: {
-        kind: state.kind,
-        sessionId: state.sessionId,
-        state: state.state
-      }
-    });
-  }
-  async #clearSharedSetupState() {
-    await this.#ctx.adapter.setupStates.deleteSetupState(this.#sharedSetupStateId());
-  }
-  #sharedSetupStateId() {
-    return sharedSetupStateId(this.#ctx.adapter.id, this.#ctx.options.setup);
-  }
-  #isRecoverableSetupStateError(error) {
-    if (!(error instanceof Error)) {
-      return false;
+      await clearSharedSetupState(this.#ctx);
+      const rerunSetupState = await bootstrapSharedSetupState(this.#ctx, workspace, options);
+      return this.#ctx.driverFactory.resumeSandbox(workspace, rerunSetupState, options);
     }
-    return error.message.includes("Sandkit durable state corruption") && error.message.includes("sandkit_setup_states");
   }
   createManagedSandbox(sandbox) {
-    return new ManagedSandbox(
+    const managed = new ManagedSandbox(
       sandbox,
       async () => this.resolveDefaultPolicy(),
       async (commit) => this.persistSandboxState(transitionAfterCommandCommit(commit, (/* @__PURE__ */ new Date()).toISOString())),
       this.createRunLifecycle(sandbox)
     );
+    const workspaceId = this.#record.id;
+    const originalRunCommand = managed.runCommand.bind(managed);
+    const wrappedRunCommand = async (inputOrCommand, args = []) => {
+      let releaseCalled = false;
+      const release = async () => {
+        if (releaseCalled) {
+          return;
+        }
+        releaseCalled = true;
+        endDurableCommand(workspaceId);
+      };
+      try {
+        const command = typeof inputOrCommand === "string" ? await originalRunCommand(inputOrCommand, args) : await originalRunCommand(inputOrCommand);
+        const completion = (async () => {
+          try {
+            return await command.wait();
+          } finally {
+            await release();
+          }
+        })();
+        void completion.catch(() => {
+        });
+        return {
+          wait: () => completion,
+          logs: command.logs
+        };
+      } catch (error) {
+        await release();
+        throw error;
+      }
+    };
+    managed.runCommand = wrappedRunCommand;
+    return managed;
   }
   makeSandboxDriverOptions(policy, timeoutMs) {
     const next = {
@@ -1039,6 +1249,15 @@ function normalizeSessionTimeoutMs(timeoutMs) {
   }
   return timeoutMs;
 }
+function normalizeRunCommandTimeoutMs(timeoutMs) {
+  if (timeoutMs === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(timeoutMs) || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("runCommand timeoutMs must be a positive integer in milliseconds.");
+  }
+  return timeoutMs;
+}
 function workspaceStateIsSession(state) {
   return state.kind === "session";
 }
@@ -1052,6 +1271,9 @@ var Sandkit = class {
   get context() {
     return this.#ctx;
   }
+  async bootstrap() {
+    await bootstrapSharedSetup(this.#ctx);
+  }
   async createWorkspace(input = {}) {
     const { id, name, policy, metadata, status, sandboxId, lastResumedAt } = input;
     const sandboxConfig = normalizeWorkspaceSandboxCreateConfig(input.sandbox);
@@ -1091,12 +1313,16 @@ export {
   Sandkit,
   aiGateway,
   allowAll,
+  allowBun,
+  allowNpm,
   allowService,
   allowServices,
+  bun,
   codex,
   createSandkit,
   denyAll,
   gemini,
-  github
+  github,
+  npm
 };
 //# sourceMappingURL=index.js.map