@ai-sdk/harness 1.0.52 → 1.0.54

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness
 
+## 1.0.54
+
+### Patch Changes
+
+- ai@7.0.48
+
+## 1.0.53
+
+### Patch Changes
+
+- bdde5d9: fix(harness): avoid placing harness bootstrap files in `/tmp` and instead use sandbox working directory
+- Updated dependencies [5fc7da5]
+- Updated dependencies [93b2acd]
+  - @ai-sdk/provider-utils@5.0.18
+  - ai@7.0.47
+
 ## 1.0.52
 
 ### Patch Changes

package/README.md

@@ -111,6 +111,15 @@ See the [harness adapters documentation](https://ai-sdk.dev/v7/docs/ai-sdk-harne
 
 Implement the `HarnessV1` factory and a `HarnessV1Session` whose `doPromptTurn` emits events; the agent surface, streaming, tool execution, and multi-turn state are handled for you. Read `startOpts.sandboxSession` for the network sandbox session the agent created and will stop on cleanup. Call `sandboxSession.restricted()` for the tool-safe file-IO/exec/spawn surface.
 
+Bootstrap recipe paths may be absolute or relative. Relative `bootstrapDir` and
+file paths are resolved against `sandboxSession.defaultWorkingDirectory`.
+The framework creates `bootstrapDir` before writing files, and bootstrap
+commands run from that directory by default. A relative command
+`workingDirectory` override is resolved against the sandbox's default working
+directory. Prefer a relative directory such as
+`.harness-bootstrap/my-harness` so bootstrap assets are kept with the sandbox's
+snapshot-persistent working tree.
+
 ```ts
 import type { HarnessV1, HarnessV1Session } from '@ai-sdk/harness';
 

package/dist/agent/index.d.ts

@@ -75,7 +75,9 @@ interface HarnessDiagnosticConsumer {
 
 /**
  * One file to write into the sandbox as part of an adapter's bootstrap recipe.
- * Paths should live under {@link HarnessV1Bootstrap.bootstrapDir}.
+ * Absolute paths are used as-is. Relative paths are resolved against the
+ * sandbox's default working directory. Paths should live under
+ * {@link HarnessV1Bootstrap.bootstrapDir}.
  */
 interface HarnessV1BootstrapFile {
     readonly path: string;
@@ -88,6 +90,11 @@ interface HarnessV1BootstrapFile {
  */
 interface HarnessV1BootstrapCommand {
     readonly command: string;
+    /**
+     * Absolute working directories are used as-is. Relative working directories
+     * are resolved against the sandbox's default working directory. When
+     * omitted, the command runs from the recipe's bootstrap directory.
+     */
     readonly workingDirectory?: string;
 }
 /**
@@ -103,15 +110,16 @@ interface HarnessV1Bootstrap {
      */
     readonly harnessId: string;
     /**
-     * Absolute path inside the sandbox where this recipe writes its state.
-     * The marker file lives directly under it. Files declared in {@link files}
-     * should also use this prefix so an adapter upgrade can sweep stale state
-     * by clearing the directory.
+     * Path inside the sandbox where this recipe writes its state. Absolute paths
+     * are used as-is. Relative paths are resolved against the sandbox's default
+     * working directory. The marker file lives directly under it. Files
+     * declared in {@link files} should also use this prefix so an adapter upgrade
+     * can sweep stale state by clearing the directory.
      */
     readonly bootstrapDir: string;
     /** Files to write into the sandbox before any command runs. */
     readonly files: ReadonlyArray<HarnessV1BootstrapFile>;
-    /** Commands to run after files are written, in order. */
+    /** Commands to run from the bootstrap directory after files are written. */
     readonly commands: ReadonlyArray<HarnessV1BootstrapCommand>;
 }
 

package/dist/agent/index.js

@@ -2683,6 +2683,7 @@ function toToolResultContinuation(input) {
 }
 
 // src/agent/internal/bootstrap-recipe.ts
+import { posix } from "path";
 var BOOTSTRAP_SCHEMA_VERSION = 1;
 async function hashHarnessBootstrap(recipe) {
   const encoder = new TextEncoder();
@@ -2717,30 +2718,72 @@ async function hashHarnessBootstrap(recipe) {
   }
   return hex;
 }
-function bootstrapMarkerPath(recipe, identity) {
-  return `${recipe.bootstrapDir}/.bootstrap-${identity}.ok`;
+function bootstrapMarkerPath({
+  recipe,
+  identity,
+  defaultWorkingDirectory
+}) {
+  return posix.join(
+    resolveBootstrapPath({
+      path: recipe.bootstrapDir,
+      defaultWorkingDirectory
+    }),
+    `.bootstrap-${identity}.ok`
+  );
 }
-async function applyBootstrapRecipe(session, recipe, identity, options) {
-  const markerPath = bootstrapMarkerPath(recipe, identity);
+async function applyBootstrapRecipe({
+  session,
+  recipe,
+  identity,
+  defaultWorkingDirectory,
+  abortSignal
+}) {
+  const markerPath = bootstrapMarkerPath({
+    recipe,
+    identity,
+    defaultWorkingDirectory
+  });
   const existingMarker = await session.readTextFile({
     path: markerPath,
-    abortSignal: options == null ? void 0 : options.abortSignal
+    abortSignal
   });
   if (existingMarker !== null) {
     return;
   }
+  const bootstrapDir = resolveBootstrapPath({
+    path: recipe.bootstrapDir,
+    defaultWorkingDirectory
+  });
+  const mkdirResult = await session.run({
+    command: 'mkdir -p "$BOOTSTRAP_DIR"',
+    workingDirectory: defaultWorkingDirectory,
+    env: { BOOTSTRAP_DIR: bootstrapDir },
+    abortSignal
+  });
+  if (mkdirResult.exitCode !== 0) {
+    throw new Error(
+      `Failed to create bootstrap directory for harness '${recipe.harnessId}' (exit ${mkdirResult.exitCode}): ${bootstrapDir}
+${mkdirResult.stderr || mkdirResult.stdout}`
+    );
+  }
   for (const file of recipe.files) {
     await session.writeTextFile({
-      path: file.path,
+      path: resolveBootstrapPath({
+        path: file.path,
+        defaultWorkingDirectory
+      }),
       content: file.content,
-      abortSignal: options == null ? void 0 : options.abortSignal
+      abortSignal
     });
   }
   for (const cmd of recipe.commands) {
     const result = await session.run({
       command: cmd.command,
-      workingDirectory: cmd.workingDirectory,
-      abortSignal: options == null ? void 0 : options.abortSignal
+      workingDirectory: cmd.workingDirectory == null ? bootstrapDir : resolveBootstrapPath({
+        path: cmd.workingDirectory,
+        defaultWorkingDirectory
+      }),
+      abortSignal
     });
     if (result.exitCode !== 0) {
       throw new Error(
@@ -2752,12 +2795,18 @@ ${result.stderr || result.stdout}`
   await session.writeTextFile({
     path: markerPath,
     content: "",
-    abortSignal: options == null ? void 0 : options.abortSignal
+    abortSignal
   });
 }
+function resolveBootstrapPath({
+  path,
+  defaultWorkingDirectory
+}) {
+  return posix.isAbsolute(path) ? path : posix.resolve(defaultWorkingDirectory, path);
+}
 
 // src/agent/internal/sandbox-bootstrap.ts
-import { posix } from "path";
+import { posix as posix2 } from "path";
 var SANDBOX_BOOTSTRAP_IDENTITY_VERSION = 1;
 function validateSandboxBootstrapSettings(settings) {
   if (settings.onBootstrap == null !== (settings.bootstrapHash == null)) {
@@ -2783,10 +2832,10 @@ function normalizeSandboxWorkDir(workDir) {
       "HarnessAgent: `sandboxConfig.workDir` must use POSIX path separators."
     );
   }
-  if (posix.isAbsolute(workDir)) {
+  if (posix2.isAbsolute(workDir)) {
     throw new Error("HarnessAgent: `sandboxConfig.workDir` must be relative.");
   }
-  const normalized = posix.normalize(workDir);
+  const normalized = posix2.normalize(workDir);
   if (normalized === "." || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(
       "HarnessAgent: `sandboxConfig.workDir` must stay inside the sandbox default working directory."
@@ -2841,20 +2890,26 @@ async function runSandboxBootstrap({
   recipeIdentity,
   workDir,
   onBootstrap,
+  defaultWorkingDirectory,
   abortSignal
 }) {
+  if (recipe == null && onBootstrap == null) return;
+  const resolvedDefaultWorkingDirectory = defaultWorkingDirectory != null ? defaultWorkingDirectory : await resolveDefaultWorkingDirectory({
+    session,
+    abortSignal
+  });
   if (recipe != null && recipeIdentity != null) {
-    await applyBootstrapRecipe(session, recipe, recipeIdentity, {
+    await applyBootstrapRecipe({
+      session,
+      recipe,
+      identity: recipeIdentity,
+      defaultWorkingDirectory: resolvedDefaultWorkingDirectory,
       abortSignal
     });
   }
   if (onBootstrap == null) return;
-  const defaultWorkingDirectory = await resolveDefaultWorkingDirectory({
-    session,
-    abortSignal
-  });
-  const bootstrapWorkDir = workDir == null ? defaultWorkingDirectory : joinSandboxPath({
-    base: defaultWorkingDirectory,
+  const bootstrapWorkDir = workDir == null ? resolvedDefaultWorkingDirectory : joinSandboxPath({
+    base: resolvedDefaultWorkingDirectory,
     path: workDir
   });
   await ensureSandboxDirectory({
@@ -2878,7 +2933,7 @@ async function resolveDefaultWorkingDirectory({
     );
   }
   const cwd = result.stdout.trim();
-  if (!posix.isAbsolute(cwd)) {
+  if (!posix2.isAbsolute(cwd)) {
     throw new Error(
       `Failed to resolve sandbox default working directory: expected an absolute path, got ${JSON.stringify(cwd)}.`
     );
@@ -2935,7 +2990,7 @@ function joinSandboxPath({
   base,
   path
 }) {
-  return posix.join(base, path);
+  return posix2.join(base, path);
 }
 
 // src/agent/internal/resolve-observability.ts
@@ -3180,12 +3235,13 @@ var HarnessAgent = class {
     });
     try {
       if (!isResumedSession && sandboxBootstrapPlan.recipe != null && sandboxBootstrapPlan.recipeIdentity != null) {
-        await applyBootstrapRecipe(
-          sandboxSession.restricted(),
-          sandboxBootstrapPlan.recipe,
-          sandboxBootstrapPlan.recipeIdentity,
-          { abortSignal }
-        );
+        await applyBootstrapRecipe({
+          session: sandboxSession.restricted(),
+          recipe: sandboxBootstrapPlan.recipe,
+          identity: sandboxBootstrapPlan.recipeIdentity,
+          defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+          abortSignal
+        });
       }
       await ensureSandboxDirectory({
         session: sandboxSession,
@@ -3573,14 +3629,13 @@ async function prepareHarnessSandboxTemplate(options) {
   });
   try {
     if (bootstrapPlan.recipe != null && bootstrapPlan.recipeIdentity != null) {
-      await applyBootstrapRecipe(
-        sandboxSession.restricted(),
-        bootstrapPlan.recipe,
-        bootstrapPlan.recipeIdentity,
-        {
-          abortSignal: options.abortSignal
-        }
-      );
+      await applyBootstrapRecipe({
+        session: sandboxSession.restricted(),
+        recipe: bootstrapPlan.recipe,
+        identity: bootstrapPlan.recipeIdentity,
+        defaultWorkingDirectory: sandboxSession.defaultWorkingDirectory,
+        abortSignal: options.abortSignal
+      });
     }
   } finally {
     await Promise.resolve(sandboxSession.stop()).catch(() => {
@@ -3607,6 +3662,7 @@ async function prepareSandboxForHarness(options) {
   const workDir = sandboxConfig.workDir == null ? void 0 : normalizeSandboxWorkDir(sandboxConfig.workDir);
   const recipeIdentities = {};
   const skippedHarnessIds = [];
+  let defaultWorkingDirectory;
   for (const harness of harnesses) {
     const recipe = await ((_b3 = harness.getBootstrap) == null ? void 0 : _b3.call(harness, {
       abortSignal: options.abortSignal
@@ -3617,7 +3673,15 @@ async function prepareSandboxForHarness(options) {
     }
     const recipeIdentity = await hashHarnessBootstrap(recipe);
     recipeIdentities[harness.harnessId] = recipeIdentity;
-    await applyBootstrapRecipe(options.session, recipe, recipeIdentity, {
+    defaultWorkingDirectory != null ? defaultWorkingDirectory : defaultWorkingDirectory = await resolveDefaultWorkingDirectory({
+      session: options.session,
+      abortSignal: options.abortSignal
+    });
+    await applyBootstrapRecipe({
+      session: options.session,
+      recipe,
+      identity: recipeIdentity,
+      defaultWorkingDirectory,
       abortSignal: options.abortSignal
     });
   }
@@ -3626,6 +3690,7 @@ async function prepareSandboxForHarness(options) {
       session: options.session,
       workDir,
       onBootstrap: sandboxConfig.onBootstrap,
+      defaultWorkingDirectory,
       abortSignal: options.abortSignal
     });
   }