fix(runtime): wire packaged intake sandbox

Author: cat9999aaa

apps/daemon/src/runtime/__test__/docker-intake-sandbox.test.ts

@@ -0,0 +1,268 @@
+import { join } from "node:path";
+
+import type { SandboxLaunch } from "@siteops/release-manifest/intake";
+import { describe, expect, it } from "vitest";
+
+import {
+  FIXED_ARCHIVE_IMAGE,
+  PackagedIntakeRuntimeError,
+  createFixedArchiveDockerSandboxRunner,
+  type DockerCommand,
+  type DockerCommandExecutor,
+  type DockerCommandResult,
+} from "../docker-intake-sandbox.js";
+import { createSandboxLauncher } from "../intake-sandbox.js";
+
+const CONTAINER_ID = "a".repeat(64);
+const CONTAINER_NAME = "siteops-intake-00000000-0000-4000-8000-000000000001";
+const FIXED_ARCHIVE_SCRIPT = [
+  "set -eu",
+  "umask 077",
+  "mkdir /workspace/staged",
+  "cp -R /source/. /workspace/staged/",
+  "find /workspace/staged -exec touch -t 197001010000.00 {} +",
+  "find /workspace/staged -type d -exec chmod 0555 {} +",
+  "find /workspace/staged -type f -exec chmod 0444 {} +",
+  "cd /workspace/staged",
+  "find . -mindepth 1 -type f -print0 |",
+  "  LC_ALL=C sort -z |",
+  "  cpio -o -0 -H newc -R 10001:10001 --ignore-devno --renumber-inodes > /output/release.cpio",
+].join("\n");
+
+const launch = (root: string): SandboxLaunch => ({
+  network: "none",
+  privileged: false,
+  sourceMount: "read_only",
+  workspacePath: join(root, "workspace"),
+  sourcePath: join(root, "workspace", "source"),
+  outputPath: join(root, "workspace", "output"),
+});
+
+describe("fixed-archive Docker intake sandbox", () => {
+  it("uses only the fixed image and archive command under the bounded plan", async () => {
+    const commands: DockerCommand[] = [];
+    const executor: DockerCommandExecutor = {
+      execute: (command: DockerCommand): Promise<DockerCommandResult> => {
+        commands.push(command);
+        return Promise.resolve({
+          stdout: command.args[0] === "create" ? `${CONTAINER_ID}\n` : "",
+          stderr: "",
+        });
+      },
+    };
+    const root = "/var/lib/siteops/intake/workspaces/intake-safe";
+    const sandboxLaunch = launch(root);
+    const runner = createFixedArchiveDockerSandboxRunner(
+      executor,
+      () => CONTAINER_NAME,
+    );
+
+    const receipt = await createSandboxLauncher(runner)(sandboxLaunch);
+
+    expect(commands).toEqual([
+      {
+        executable: "docker",
+        args: [
+          "create",
+          "--name",
+          CONTAINER_NAME,
+          "--pull",
+          "never",
+          "--network",
+          "none",
+          "--user",
+          "10001:10001",
+          "--read-only",
+          "--cap-drop",
+          "ALL",
+          "--security-opt",
+          "no-new-privileges:true",
+          "--cpus",
+          "1",
+          "--memory",
+          "268435456",
+          "--pids-limit",
+          "64",
+          "--mount",
+          `type=bind,src=${sandboxLaunch.sourcePath},dst=/source,readonly`,
+          "--tmpfs",
+          "/tmp:rw,noexec,nosuid,nodev,size=8388608,uid=10001,gid=10001,mode=1777",
+          "--tmpfs",
+          "/workspace:rw,noexec,nosuid,nodev,size=33554432,uid=10001,gid=10001,mode=0700",
+          "--tmpfs",
+          "/output:rw,noexec,nosuid,nodev,size=33554432,uid=10001,gid=10001,mode=0700",
+          "--entrypoint",
+          "/bin/sh",
+          FIXED_ARCHIVE_IMAGE,
+          "-ceu",
+          FIXED_ARCHIVE_SCRIPT,
+        ],
+        timeoutMs: 60_000,
+      },
+      {
+        executable: "docker",
+        args: ["start", "--attach", CONTAINER_NAME],
+        timeoutMs: 60_000,
+      },
+      {
+        executable: "docker",
+        args: [
+          "cp",
+          `${CONTAINER_NAME}:/output/release.cpio`,
+          join(sandboxLaunch.outputPath, "release.cpio"),
+        ],
+        timeoutMs: 60_000,
+      },
+      {
+        executable: "docker",
+        args: ["rm", "--force", CONTAINER_NAME],
+        timeoutMs: 60_000,
+      },
+    ]);
+    expect(receipt).toEqual({
+      artifactPath: join(sandboxLaunch.outputPath, "release.cpio"),
+      resolvedDependencies: [
+        {
+          uri: "https://registry-1.docker.io/v2/library/alpine",
+          digest:
+            "sha256:eafc1edb577d2e9b458664a15f23ea1c370214193226069eb22921169fc7e43f",
+        },
+      ],
+    });
+  });
+
+  it("fails closed with a typed error when Docker is unavailable", async () => {
+    const unavailable = Object.assign(new Error("spawn docker ENOENT"), {
+      code: "ENOENT",
+    });
+    let invocationCount = 0;
+    const executor: DockerCommandExecutor = {
+      execute: () => {
+        invocationCount += 1;
+        return Promise.reject(unavailable);
+      },
+    };
+    const runner = createFixedArchiveDockerSandboxRunner(
+      executor,
+      () => CONTAINER_NAME,
+    );
+
+    const result = createSandboxLauncher(runner)(launch("/tmp/unavailable"));
+
+    await expect(result).rejects.toMatchObject({
+      name: "PackagedIntakeRuntimeError",
+      code: "docker_unavailable",
+      operation: "create",
+    });
+    expect(invocationCount).toBe(1);
+  });
+
+  it("removes the container after denied execution", async () => {
+    const commands: DockerCommand[] = [];
+    const executor: DockerCommandExecutor = {
+      execute: (command: DockerCommand): Promise<DockerCommandResult> => {
+        commands.push(command);
+        if (command.args[0] === "create") {
+          return Promise.resolve({
+            stdout: `${CONTAINER_ID}\n`,
+            stderr: "",
+          });
+        }
+        if (command.args[0] === "start") {
+          return Promise.reject(
+            new Error(
+              "permission denied while trying to connect to the Docker daemon socket",
+            ),
+          );
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    };
+    const runner = createFixedArchiveDockerSandboxRunner(
+      executor,
+      () => CONTAINER_NAME,
+    );
+
+    const result = createSandboxLauncher(runner)(launch("/tmp/denied"));
+
+    await expect(result).rejects.toEqual(
+      expect.objectContaining<Partial<PackagedIntakeRuntimeError>>({
+        name: "PackagedIntakeRuntimeError",
+        code: "docker_access_denied",
+        operation: "start",
+      }),
+    );
+    expect(commands.map(({ args }) => args[0])).toEqual([
+      "create",
+      "start",
+      "rm",
+    ]);
+  });
+
+  it("reports cleanup failure as typed and never retries without isolation", async () => {
+    const executor: DockerCommandExecutor = {
+      execute: (command: DockerCommand): Promise<DockerCommandResult> => {
+        if (command.args[0] === "create") {
+          return Promise.resolve({
+            stdout: `${CONTAINER_ID}\n`,
+            stderr: "",
+          });
+        }
+        if (command.args[0] === "rm") {
+          return Promise.reject(new Error("Docker cleanup failed"));
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    };
+    const runner = createFixedArchiveDockerSandboxRunner(
+      executor,
+      () => CONTAINER_NAME,
+    );
+
+    const result = createSandboxLauncher(runner)(launch("/tmp/cleanup"));
+
+    await expect(result).rejects.toMatchObject({
+      name: "PackagedIntakeRuntimeError",
+      code: "sandbox_cleanup_failed",
+      operation: "cleanup",
+    });
+  });
+
+  it("force-removes the preassigned container after an ambiguous create timeout", async () => {
+    const commands: DockerCommand[] = [];
+    const executor: DockerCommandExecutor = {
+      execute: (command: DockerCommand): Promise<DockerCommandResult> => {
+        commands.push(command);
+        if (command.args[0] === "create") {
+          return Promise.reject(new Error("Docker create timed out"));
+        }
+        if (command.args[0] === "rm") {
+          return Promise.reject(
+            new Error(`No such container: ${CONTAINER_NAME}`),
+          );
+        }
+        return Promise.resolve({ stdout: "", stderr: "" });
+      },
+    };
+    const runner = createFixedArchiveDockerSandboxRunner(
+      executor,
+      () => CONTAINER_NAME,
+    );
+
+    const result = createSandboxLauncher(runner)(launch("/tmp/create-timeout"));
+
+    await expect(result).rejects.toMatchObject({
+      name: "PackagedIntakeRuntimeError",
+      code: "sandbox_execution_failed",
+      operation: "create",
+    });
+    expect(commands).toHaveLength(2);
+    expect(commands[0]?.args).toContain("--name");
+    expect(commands[0]?.args).toContain(CONTAINER_NAME);
+    expect(commands[1]).toEqual({
+      executable: "docker",
+      args: ["rm", "--force", CONTAINER_NAME],
+      timeoutMs: 60_000,
+    });
+  });
+});