Fix readonly Playground mount isolation

Author: chubes4

package.json

@@ -91,6 +91,7 @@
     "test:external-native-package-materialization": "tsx tests/external-native-package-materialization.test.ts",
     "test:runtime-sources-materialization": "tsx tests/runtime-sources-materialization.test.ts",
     "test:runtime-sources-playground-integration": "tsx tests/runtime-sources-playground-integration.test.ts",
+    "test:playground-readonly-mounts": "tsx tests/playground-readonly-mounts.test.ts",
     "test:browser-task-builder": "tsx tests/browser-task-builder.test.ts",
     "test:browser-runtime-generic-invoker": "tsx tests/browser-runtime-generic-invoker.test.ts",
     "test:browser-runtime-file-ops": "tsx tests/browser-runtime-file-ops.test.ts",

packages/runtime-playground/src/mount-materialization.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto"
-import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises"
-import { dirname, isAbsolute, join, relative, resolve } from "node:path"
+import { cp, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path"
 import { materializationPhaseResult, namedFileTreeSkipPolicyNames, phpStringArrayLiteral, type MaterializationPhaseResult, type MountSpec } from "@automattic/wp-codebox-core"
 import type { PlaygroundCliServer } from "./preview-server.js"
 import { SKIPPED_CAPTURE_DIRECTORIES } from "./artifacts.js"
@@ -32,6 +33,11 @@ export interface MountMaterializationResult {
 
 export type StagedInputMaterializationResult = MountMaterializationResult
 
+export interface ReadonlyMountStaging {
+  mounts: MountSpec[]
+  [Symbol.asyncDispose](): Promise<void>
+}
+
 interface HostMountFilePayload {
   target: string
   contentsBase64: string
@@ -56,6 +62,41 @@ interface HostMountFileMaterializationResponse {
 const HOST_MOUNT_FILE_BATCH_SIZE = 100
 const HOST_MOUNT_DIRECTORY_BATCH_SIZE = 500
 
+/**
+ * Playground's Node filesystem mount handler is writable. Snapshot readonly
+ * inputs into a runtime-owned directory before handing them to that handler.
+ */
+export async function stageReadonlyPlaygroundMounts(mounts: MountSpec[]): Promise<ReadonlyMountStaging> {
+  const readonlyMounts = mounts.filter((mount) => mount.mode === "readonly")
+  if (readonlyMounts.length === 0) {
+    return {
+      mounts,
+      async [Symbol.asyncDispose]() {},
+    }
+  }
+
+  const root = await mkdtemp(join(tmpdir(), "wp-codebox-readonly-mounts-"))
+  try {
+    const stagedMounts = await Promise.all(mounts.map(async (mount, index) => {
+      if (mount.mode !== "readonly") {
+        return mount
+      }
+      const source = join(root, `${index}-${basename(mount.source) || "mount"}`)
+      await cp(mount.source, source, { recursive: mount.type !== "file", dereference: true })
+      return { ...mount, source }
+    }))
+    return {
+      mounts: stagedMounts,
+      async [Symbol.asyncDispose]() {
+        await rm(root, { recursive: true, force: true })
+      },
+    }
+  } catch (error) {
+    await rm(root, { recursive: true, force: true })
+    throw error
+  }
+}
+
 function mountMaterializationResult(input: Omit<MountMaterializationResult, "phaseResult">): MountMaterializationResult {
   return {
     ...input,

packages/runtime-playground/src/playground-cli-runner.ts

@@ -13,6 +13,7 @@ import { createServer as createNetServer } from "node:net"
 import * as PlaygroundStorage from "@wp-playground/storage"
 import { resolveWordPressRelease } from "@wp-playground/wordpress"
 import { phpEnvAssignments, phpWpConfigDefineAssignments } from "./php-snippets.js"
+import { stageReadonlyPlaygroundMounts, type ReadonlyMountStaging } from "./mount-materialization.js"
 
 const DEFAULT_RUNTIME_PHP_INI_ENTRIES = { memory_limit: "512M" }
 
@@ -62,6 +63,7 @@ export async function startPlaygroundCliServer(spec: RuntimeCreateSpec, mounts:
     mounts: mounts.length,
   })
   emitProgress("preview:loading-client", "running", "Loading preview")
+  let readonlyMountStaging: ReadonlyMountStaging | undefined
   try {
     if (spec.preview?.port) {
       await assertPreviewPortAvailable(spec.preview.port)
@@ -74,6 +76,8 @@ export async function startPlaygroundCliServer(spec: RuntimeCreateSpec, mounts:
     const wordpressInstallMode = spec.environment.wordpressInstallMode ?? "install-from-existing-files"
     const bootstrapIniEntries = runtimeBootstrapPhpIniEntries(spec)
     const useProgrammaticRunner = shouldUseProgrammaticPlaygroundRunner(spec, options)
+    readonlyMountStaging = await stageReadonlyPlaygroundMounts(mounts)
+    const stagedMounts = readonlyMountStaging.mounts
     const wordpressStartupAsset = wordpressDirectory ? undefined : await resolvePlaygroundWordPressStartupAsset(spec.environment.version, spec.environment.assets?.wordpressZip)
     const cacheValidation = wordpressStartupAsset?.cacheValidation ?? {
       version: spec.environment.version ?? "mounted-wordpress-source",
@@ -99,7 +103,7 @@ export async function startPlaygroundCliServer(spec: RuntimeCreateSpec, mounts:
           ...spec.preview,
           port,
         },
-      }, mounts, {
+      }, stagedMounts, {
         bootstrapIniEntries: bootstrapIniEntries!,
         phpIniEntries: pluginRuntimePhpIniEntries(spec),
         wordpressDirectory: wordpressDirectory!,
@@ -119,7 +123,7 @@ export async function startPlaygroundCliServer(spec: RuntimeCreateSpec, mounts:
           skipBrowser: true,
           workers: 6,
           mount: [
-            ...mounts.map((mount) => ({
+            ...stagedMounts.map((mount) => ({
               hostPath: mount.source,
               vfsPath: mount.target,
             })),
@@ -154,12 +158,22 @@ export async function startPlaygroundCliServer(spec: RuntimeCreateSpec, mounts:
       upstreamUrl: server.serverUrl,
       lease: proxiedServer.previewLease ? previewLeaseDetail(proxiedServer.previewLease) : undefined,
     })
-    return proxiedServer
+    return {
+      ...proxiedServer,
+      async [Symbol.asyncDispose]() {
+        try {
+          await proxiedServer[Symbol.asyncDispose]()
+        } finally {
+          await readonlyMountStaging?.[Symbol.asyncDispose]()
+        }
+      },
+    }
   } catch (error) {
     emitProgress("preview:error", "failed", "Preview failed to start", {
       error: errorDetail(error),
     })
 
+    await readonlyMountStaging?.[Symbol.asyncDispose]()
     if (spec.preview?.port && errorHasCode(error, "EADDRINUSE")) {
       throw new PlaygroundPreviewPortUnavailableError(spec.preview.port, error)
     }

tests/playground-readonly-mounts.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict"
+import { createHash } from "node:crypto"
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { startPlaygroundCliServer, type PlaygroundCliModule } from "../packages/runtime-playground/src/playground-cli-runner.js"
+import type { RuntimeCreateSpec } from "../packages/runtime-core/src/index.js"
+
+const root = await mkdtemp(join(tmpdir(), "wp-codebox-readonly-mounts-"))
+const readonlySource = join(root, "readonly.bin")
+const readwriteSource = join(root, "readwrite.bin")
+const readonlyBytes = Buffer.from([0, 255, 1, 2, 3, 127, 128])
+const readwriteBytes = Buffer.from([10, 20, 30])
+await writeFile(readonlySource, readonlyBytes)
+await writeFile(readwriteSource, readwriteBytes)
+
+const spec: RuntimeCreateSpec = {
+  backend: "wordpress-playground",
+  environment: { version: "6.8", phpVersion: "8.4", blueprint: {} },
+  policy: { network: "deny", filesystem: "readwrite-mounts", commands: ["wordpress.run-php"], secrets: "none", approvals: "never" },
+}
+
+let mountedReadonlyPath = ""
+const cliModule: PlaygroundCliModule = {
+  async runCLI(options) {
+    const readonlyMount = options.mount.find((mount) => mount.vfsPath === "/readonly")
+    const readwriteMount = options.mount.find((mount) => mount.vfsPath === "/readwrite")
+    assert.ok(readonlyMount)
+    assert.ok(readwriteMount)
+    mountedReadonlyPath = readonlyMount.hostPath
+    // This is the host path Playground's writable Node mount handler receives.
+    await writeFile(readonlyMount.hostPath, Buffer.from("sandbox overwrite"))
+    await writeFile(readwriteMount.hostPath, Buffer.from("sandbox overwrite"))
+    return {
+      serverUrl: "http://127.0.0.1:65535",
+      playground: { async run() { return { text: "" } } },
+      async [Symbol.asyncDispose]() {},
+    }
+  },
+}
+
+try {
+  const beforeReadonlyHash = sha256(await readFile(readonlySource))
+  const server = await startPlaygroundCliServer(spec, [
+    { type: "file", source: readonlySource, target: "/readonly", mode: "readonly" },
+    { type: "file", source: readwriteSource, target: "/readwrite", mode: "readwrite" },
+  ], { cliModule })
+
+  assert.equal(sha256(await readFile(readonlySource)), beforeReadonlyHash, "readonly source bytes must survive a sandbox overwrite")
+  assert.deepEqual(await readFile(readwriteSource), Buffer.from("sandbox overwrite"), "readwrite mounts must retain host-write behavior")
+  assert.notEqual(mountedReadonlyPath, readonlySource, "readonly mounts must use a private staged path")
+
+  await server[Symbol.asyncDispose]()
+  await assert.rejects(access(mountedReadonlyPath), /ENOENT/, "readonly mount staging must be removed with the runtime")
+} finally {
+  await rm(root, { recursive: true, force: true })
+}
+
+function sha256(bytes: Buffer): string {
+  return createHash("sha256").update(bytes).digest("hex")
+}
+
+console.log("playground readonly mount isolation ok")