@boardwalk-labs/runner 0.2.0 → 0.2.1

package/dist/runtime/workspace_store.js

@@ -27,6 +27,24 @@ const exec = promisify(execFile);
  *  workspace never enters memory. NOT a security boundary (tenant isolation is the per-workflow key);
  *  purely a guardrail, like the run budget's `max_usd`. */
 export const WORKSPACE_SNAPSHOT_MAX_BYTES = 512 * 1024 * 1024;
+/**
+ * Resolve what this run persists (docs/WORKSPACE_PERSISTENCE.md §3): the manifest's declaration
+ * UNIONED with every `agent({ memory })` dir the run actually used.
+ *
+ * The union is why this is resolved at PERSIST time, not construction time: memory dirs are
+ * undeclared by design (`sdk/src/types.ts` — "`mcp` servers, `skills`, and `memory` — the manifest
+ * declares none of them"), so they are only known once the run has made the agent calls. A workflow
+ * whose manifest says nothing at all still persists, iff it used memory.
+ *
+ * `true` swallows the list: the whole workspace already contains every memory dir. An empty array
+ * means persist nothing, which is the common case and must stay cheap.
+ */
+export function resolvePersistSelection(declared, memoryDirs) {
+    if (declared === true)
+        return true;
+    const list = declared === undefined || declared === false ? [] : declared;
+    return [...new Set([...list, ...memoryDirs])];
+}
 export class WorkspaceStore {
     deps;
     tmpPath;
@@ -71,8 +89,15 @@ export class WorkspaceStore {
      *  only redundant archive is a self-hosted+persist run, where the broker returns a null URL. */
     async persist() {
         try {
+            // What this run actually compounds: the manifest's declaration ∪ the memory dirs it used.
+            // Nothing selected is the common case (a workflow that opted into neither) — return before any
+            // fs or broker work, so persistence costs a run that doesn't use it precisely nothing.
+            const selection = this.deps.selection();
+            const paths = selection === true ? undefined : await this.presentPaths(selection);
+            if (paths !== undefined && paths.length === 0)
+                return 0;
             await mkdir(dirname(this.tmpPath), { recursive: true }); // per-run TMPDIR may not exist yet
-            const size = await this.deps.archiver.archive(this.deps.workspaceRoot, this.tmpPath);
+            const size = await this.deps.archiver.archive(this.deps.workspaceRoot, this.tmpPath, paths);
             // Guardrail: an oversized snapshot is dropped (logged), never read into memory or uploaded — the
             // workflow re-does filesystem work next run, as it would without persistence. Checked on the
             // on-disk archive size so the big tarball never hits the worker's heap.
@@ -98,12 +123,23 @@ export class WorkspaceStore {
             return 0;
         }
     }
+    /** Narrow a selection to the dirs that exist: `tar` fails the whole archive on one missing member,
+     *  and declaring a dir the run hasn't written yet is ordinary (first run of `persist: ["cache"]`). */
+    async presentPaths(selection) {
+        const checked = await Promise.all(selection.map(async (p) => (await this.deps.fs.exists(join(this.deps.workspaceRoot, p))) ? p : null));
+        return checked.filter((p) => p !== null);
+    }
 }
 /** Production archiver — shells out to the runner image's `tar` (the runner has full shell tooling). */
 export class TarWorkspaceArchiver {
-    async archive(dir, destPath) {
-        // `-C dir .` archives the CONTENTS of dir (not the dir itself), so extract restores it in place.
-        await exec("tar", ["czf", destPath, "-C", dir, "."]);
+    async archive(dir, destPath, paths) {
+        // `-C dir <members>` archives relative to dir, so extract restores in place either way: `.` for
+        // the whole tree (`persist: true`), or exactly the named dirs (`persist: [...]` ∪ memory dirs).
+        // Members are workspace-relative and schema-validated (no `..`, no absolute, no backslashes —
+        // sdk/src/manifest.ts `persistPath`) and pre-filtered to those that exist; `--` keeps a name
+        // that starts with `-` from being read as a flag.
+        const members = paths === undefined ? ["."] : [...paths];
+        await exec("tar", ["czf", destPath, "-C", dir, "--", ...members]);
         return (await stat(destPath)).size;
     }
     async extract(srcPath, dir) {
@@ -128,6 +164,9 @@ export class NodeWorkspaceFs {
     rm(path) {
         return rm(path, { force: true });
     }
+    async exists(path) {
+        return (await stat(path).catch(() => null)) !== null;
+    }
 }
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boardwalk-labs/runner",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Boardwalk self-hosted runner: execute cloud-scheduled runs on your own machines. Currently: the canonical runner contract types.",
   "license": "Apache-2.0",
   "repository": {