@boardwalk-labs/runner 0.1.7 → 0.1.8

package/dist/daemon/identity.js

@@ -2,10 +2,20 @@
 // Persisted runner identity — the standing credential + coordinates a machine keeps between
 // restarts (`runner start` after a reboot skips registration). One JSON file per
 // (control plane, pool), mode 0600: the runner token is a credential.
-import { mkdir, readFile, writeFile, unlink } from "node:fs/promises";
+import { mkdir, readFile, writeFile, unlink, chmod } from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
 import { z } from "zod";
+/** Re-assert restrictive perms on a path (POSIX only). `mkdir`/`writeFile` set mode only when they
+ *  CREATE, so a pre-existing dir/file could be group/world-readable; this makes the credential
+ *  fail-safe regardless. No-op on Windows (no POSIX mode bits). Best-effort — a chmod failure must
+ *  not break enrollment. NOTE: this hardens the file at rest; it does NOT stop a same-UID process
+ *  (an in-process run program) from reading it — that requires per-run UID/container isolation. */
+async function hardenPerms(target, mode) {
+    if (process.platform === "win32")
+        return;
+    await chmod(target, mode).catch(() => undefined);
+}
 export const runnerIdentitySchema = z.strictObject({
     runner_id: z.string().min(1),
     runner_token: z.string().min(1),
@@ -25,15 +35,21 @@ function identityFile(dir, controlPlaneUrl, pool) {
 }
 export async function saveIdentity(dir, identity) {
     await mkdir(dir, { recursive: true, mode: 0o700 });
+    await hardenPerms(dir, 0o700); // re-assert: mkdir's mode only applies when it CREATES the dir
     const file = identityFile(dir, identity.control_plane_url, identity.pool);
     await writeFile(file, `${JSON.stringify(identity, null, 2)}\n`, { mode: 0o600 });
+    await hardenPerms(file, 0o600); // re-assert: writeFile's mode only applies to a NEW file
     return file;
 }
 export async function loadIdentity(dir, controlPlaneUrl, pool) {
     try {
-        const raw = await readFile(identityFile(dir, controlPlaneUrl, pool), "utf8");
+        const file = identityFile(dir, controlPlaneUrl, pool);
+        const raw = await readFile(file, "utf8");
         const parsed = runnerIdentitySchema.safeParse(JSON.parse(raw));
-        return parsed.success ? parsed.data : null;
+        if (!parsed.success)
+            return null;
+        await hardenPerms(file, 0o600); // repair perms if something loosened them since save
+        return parsed.data;
     }
     catch {
         return null;

package/dist/runtime/workspace_store.js

@@ -15,6 +15,7 @@ import { promisify } from "node:util";
 import { stat, mkdir, readFile, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
+import { extract as tarExtract } from "tar";
 import { createLogger } from "./support/index.js";
 const log = createLogger("WorkspaceStore");
 const exec = promisify(execFile);
@@ -107,7 +108,13 @@ export class TarWorkspaceArchiver {
     }
     async extract(srcPath, dir) {
         await mkdir(dir, { recursive: true });
-        await exec("tar", ["xzf", srcPath, "-C", dir]);
+        // Extract via node-tar, NOT `tar xzf`: extraction reads UNTRUSTED input (a program artifact
+        // from an arbitrary control plane on a self-hosted runner, or a prior run's workspace snapshot),
+        // and node-tar is hardened + portable — with default `preservePaths: false` it strips absolute
+        // paths and `..` members, and refuses to write THROUGH a symlink (unlinking it first), closing
+        // the traversal/symlink-escape gaps that differ between GNU tar and bsdtar. Same behavior on
+        // macOS and Linux, no dependency on which `tar` the OS ships.
+        await tarExtract({ file: srcPath, cwd: dir });
     }
 }
 /** Production fs — node's fs/promises. */

package/package.json

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