Implement native sidecar containment

.github/workflows/ci.yml

@@ -10,6 +10,31 @@ permissions:
   contents: read
 
 jobs:
+  linux-preview-containment:
+    name: Ubuntu 24.04 containment preview
+    runs-on: ubuntu-24.04
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with:
+          python-version: 3.13.11
+      - name: Build Landlock, seccomp, and cgroup launcher
+        run: python tools/build-native-containment.py --output-root dist/containment
+      - name: Verify the launcher fails closed outside its delegated scope
+        shell: bash
+        run: |
+          set +e
+          output="$(dist/containment/open-chords-containment-launcher \
+            --expected-unit=not-the-current.scope \
+            --workspace="$RUNNER_TEMP" \
+            --runtime-root="$GITHUB_WORKSPACE" \
+            -- /bin/true 2>&1)"
+          status=$?
+          set -e
+          test "$status" -eq 70
+          test "$output" = 'OC_CONTAINMENT_V1 {"error":"cgroup_scope_unverified"}'
+
   native:
     name: ${{ matrix.name }}
     strategy:
@@ -104,8 +129,11 @@ jobs:
           --native-root build/native/${{ matrix.profile }}
           --output-root dist/analysis-sidecar
           --platform-profile ${{ matrix.profile }}
-      - name: Run frozen sidecar decode smoke
+      - name: Validate frozen Windows runtime outside sandbox
+        if: runner.os == 'Windows'
         run: pnpm test:frozen-sidecar
+      - name: Build native containment broker
+        run: python tools/build-native-containment.py --output-root dist/containment
       - name: Build installable Forge artifact
         run: pnpm make -- --arch=${{ matrix.arch }}
       - name: Verify installed trust boundary

apps/desktop/src/main/containment-build-metadata.ts

@@ -0,0 +1,4 @@
+declare const OPEN_CHORDS_EMBEDDED_CONTAINMENT_MANIFEST_SHA256: string;
+
+export const EXPECTED_CONTAINMENT_MANIFEST_SHA256 =
+  OPEN_CHORDS_EMBEDDED_CONTAINMENT_MANIFEST_SHA256;

apps/desktop/src/main/index.ts

@@ -12,7 +12,7 @@ import { installDesktopIpc, publishProjectEvent } from "./desktop-ipc.ts";
 import { LocalMediaService } from "./local-media.ts";
 import { createMediaCleanupBeforeQuitHandler } from "./media-shutdown.ts";
 import { PACKAGED_SIDECAR_PROOF_ARGUMENT } from "./packaged-sidecar-proof-constants.ts";
-import { runPackagedSidecarProof } from "./packaged-sidecar-proof.ts";
+import { packagedProofFailureCode, runPackagedSidecarProof } from "./packaged-sidecar-proof.ts";
 import { openProjectLibrary } from "./project-library.ts";
 import { installRendererProtocol, registerRendererScheme } from "./renderer-protocol.ts";
 import {
@@ -28,7 +28,10 @@ if (process.argv.includes(PACKAGED_SIDECAR_PROOF_ARGUMENT)) {
     .then(runPackagedSidecarProof)
     .then(
       () => app.exit(0),
-      () => app.exit(1),
+      (cause: unknown) => {
+        process.stderr.write(`Packaged sidecar proof failed: ${packagedProofFailureCode(cause)}\n`);
+        app.exit(1);
+      },
     );
 } else {
   registerRendererScheme();

apps/desktop/src/main/packaged-sidecar-proof-failures.ts

@@ -0,0 +1,12 @@
+export function throwCombinedFailures(
+  message: string,
+  primaryFailure: { cause: unknown } | undefined,
+  cleanupFailures: readonly unknown[],
+): void {
+  const failures = [
+    ...(primaryFailure === undefined ? [] : [primaryFailure.cause]),
+    ...cleanupFailures,
+  ];
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, message);
+}

apps/desktop/src/main/packaged-sidecar-proof-workspace.ts

@@ -0,0 +1,185 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { cpSync, mkdirSync, realpathSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { throwCombinedFailures } from "./packaged-sidecar-proof-failures.ts";
+import {
+  isExpectedWindowsProfileRoot,
+  isExpectedWindowsRuntimeRoot,
+} from "./windows-app-container-path.ts";
+
+const WORKSPACE_FAILURE_CODES = [
+  "cleanup_failed",
+  "setup_prepare_failed",
+  "setup_response_failed",
+  "setup_validation_failed",
+  "setup_workspace_failed",
+] as const;
+
+type WorkspaceFailureCode = (typeof WORKSPACE_FAILURE_CODES)[number];
+
+class PackagedWorkspaceFailure extends Error {
+  readonly code: WorkspaceFailureCode;
+
+  constructor(code: WorkspaceFailureCode) {
+    super(code);
+    this.name = "PackagedWorkspaceFailure";
+    this.code = code;
+  }
+}
+
+export interface PreparedPackagedWorkspace {
+  cleanup(): void;
+  runtimeRoot: string;
+  windowsProfile?: string;
+  workspace: string;
+}
+
+export function packagedWorkspaceFailureCode(cause: unknown): WorkspaceFailureCode | undefined {
+  return cause instanceof PackagedWorkspaceFailure ? cause.code : undefined;
+}
+
+export function preparePackagedWorkspace(
+  platform: "darwin" | "win32",
+  helperPath: string,
+  packagedRuntimeRoot: string,
+): PreparedPackagedWorkspace {
+  const identifier = randomUUID();
+  if (platform === "darwin") {
+    const workspace = join(
+      homedir(),
+      "Library",
+      "Containers",
+      "io.github.qisoft.open-chords.analysis-service",
+      "Data",
+      "jobs",
+      identifier,
+    );
+    mkdirSync(workspace, { recursive: true, mode: 0o700 });
+    return {
+      cleanup: () => rmSync(workspace, { force: true, recursive: true }),
+      runtimeRoot: packagedRuntimeRoot,
+      workspace,
+    };
+  }
+  const profile = `OpenChords.Analysis.${identifier}`;
+  let reportedRoots: string[];
+  try {
+    reportedRoots = execFileSync(helperPath, [`--prepare=${profile}`], {
+      encoding: "utf8",
+      env: {},
+      windowsHide: true,
+    })
+      .trim()
+      .split(/\r?\n/);
+  } catch {
+    throwCombinedFailures(
+      "AppContainer profile preparation and cleanup failed",
+      { cause: new PackagedWorkspaceFailure("setup_prepare_failed") },
+      privateCleanupFailures(destroyWindowsProfile(helperPath, profile)),
+    );
+    throw new PackagedWorkspaceFailure("setup_prepare_failed");
+  }
+  if (reportedRoots.length !== 3) {
+    throwCombinedFailures(
+      "AppContainer profile response and cleanup failed",
+      { cause: new PackagedWorkspaceFailure("setup_response_failed") },
+      privateCleanupFailures(destroyWindowsProfile(helperPath, profile)),
+    );
+    throw new PackagedWorkspaceFailure("setup_response_failed");
+  }
+  const reportedProfileRoot = reportedRoots[0]!;
+  const reportedLocalAppDataRoot = reportedRoots[1]!;
+  const reportedRuntimeRoot = reportedRoots[2]!;
+  const localAppDataRoot = canonicalWindowsLocalAppDataRoot(reportedLocalAppDataRoot);
+  const profileRoot = canonicalWindowsProfileRoot(reportedProfileRoot, localAppDataRoot);
+  const runtimeRoot = canonicalWindowsRuntimeRoot(reportedRuntimeRoot, localAppDataRoot, profile);
+  if (profileRoot === null || runtimeRoot === null) {
+    throwCombinedFailures(
+      "AppContainer profile validation and cleanup failed",
+      { cause: new PackagedWorkspaceFailure("setup_validation_failed") },
+      privateCleanupFailures(destroyWindowsProfile(helperPath, profile)),
+    );
+    throw new PackagedWorkspaceFailure("setup_validation_failed");
+  }
+  const workspace = join(profileRoot, "jobs", identifier);
+  try {
+    cpSync(packagedRuntimeRoot, runtimeRoot, { recursive: true });
+    mkdirSync(workspace, { recursive: true });
+  } catch {
+    throwCombinedFailures(
+      "AppContainer workspace setup and cleanup failed",
+      { cause: new PackagedWorkspaceFailure("setup_workspace_failed") },
+      privateCleanupFailures(destroyWindowsProfile(helperPath, profile)),
+    );
+  }
+  return {
+    cleanup() {
+      throwCombinedFailures(
+        "AppContainer profile cleanup failed",
+        undefined,
+        destroyWindowsProfile(helperPath, profile),
+      );
+    },
+    runtimeRoot,
+    windowsProfile: profile,
+    workspace,
+  };
+}
+
+function canonicalWindowsLocalAppDataRoot(reportedRoot: string): string | null {
+  try {
+    return realpathSync(reportedRoot);
+  } catch {
+    return null;
+  }
+}
+
+function canonicalWindowsProfileRoot(
+  reportedRoot: string,
+  localAppDataRoot: string | null,
+): string | null {
+  if (localAppDataRoot === null) return null;
+  try {
+    const packagesRoot = realpathSync(join(localAppDataRoot, "Packages"));
+    const profileRoot = realpathSync(reportedRoot);
+    return isExpectedWindowsProfileRoot(profileRoot, packagesRoot) ? profileRoot : null;
+  } catch {
+    return null;
+  }
+}
+
+function canonicalWindowsRuntimeRoot(
+  reportedRoot: string,
+  localAppDataRoot: string | null,
+  profile: string,
+): string | null {
+  if (localAppDataRoot === null) return null;
+  try {
+    const runtimeRoot = realpathSync(reportedRoot);
+    return isExpectedWindowsRuntimeRoot(runtimeRoot, localAppDataRoot, profile)
+      ? runtimeRoot
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function privateCleanupFailures(failures: readonly unknown[]): PackagedWorkspaceFailure[] {
+  return failures.map(() => new PackagedWorkspaceFailure("cleanup_failed"));
+}
+
+function destroyWindowsProfile(helperPath: string, profile: string): unknown[] {
+  const failures: unknown[] = [];
+  try {
+    execFileSync(helperPath, [`--destroy=${profile}`], {
+      env: {},
+      windowsHide: true,
+    });
+  } catch (cause) {
+    failures.push(cause);
+  }
+  return failures;
+}