@cjhyy/code-shell-server 0.9.22 → 0.9.23

package/dist/project-runtime/backup.js

@@ -0,0 +1,500 @@
+import { createHash, randomUUID } from "node:crypto";
+import { execFile, spawn } from "node:child_process";
+import { constants, createWriteStream } from "node:fs";
+import { lstat, mkdir, open, readdir, realpath, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Transform } from "node:stream";
+import { HubAuthStore } from "../hub/auth-store.js";
+import { ProjectRegistry } from "./registry.js";
+const LABEL = "io.codeshell.project-runtime";
+const FORMAT = "codeshell.project-installation-backup";
+const MAX_CONTROL_FILE = 16 * 1024 * 1024;
+const SHA = /^[a-f0-9]{64}$/;
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const digest = (value) => ({
+    sha256: createHash("sha256").update(value).digest("hex"),
+    bytes: value.length,
+});
+function imageId(image) {
+    if (!/^sha256:[a-f0-9]{64}$/.test(image))
+        throw new Error("Backup helper must be a local immutable Docker image ID (sha256:...).");
+}
+async function regular(path, maximum) {
+    const before = await lstat(path);
+    if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1 || before.size > maximum)
+        throw new Error("Backup metadata must be a bounded regular file without links.");
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const after = await file.stat();
+        if (before.ino !== after.ino || before.dev !== after.dev || after.size > maximum)
+            throw new Error("Backup file changed while opening.");
+        const bytes = Buffer.alloc(after.size + 1);
+        let count = 0;
+        while (count < bytes.length) {
+            const result = await file.read(bytes, count, bytes.length - count, count);
+            if (!result.bytesRead)
+                break;
+            count += result.bytesRead;
+        }
+        if (count !== after.size)
+            throw new Error("Backup file changed while reading.");
+        return bytes.subarray(0, count);
+    }
+    finally {
+        await file.close();
+    }
+}
+async function directory(path) {
+    const metadata = await lstat(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink())
+        throw new Error("Expected an ordinary directory.");
+}
+async function exclusiveDestination(source, destination) {
+    const src = await realpath(source);
+    const parent = await realpath(dirname(destination));
+    const target = join(parent, relative(dirname(destination), destination));
+    const rel = relative(src, target);
+    if (!rel || (!rel.startsWith(`..${sep}`) && rel !== ".." && !rel.startsWith(sep)))
+        throw new Error("Backup/restore destination must be outside the source directory.");
+    await mkdir(target, { mode: 0o700 }); // Never replace an existing directory.
+    return target;
+}
+function docker(args) {
+    return new Promise((yes, no) => {
+        execFile("docker", args, { encoding: "utf8", timeout: 30_000, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => {
+            if (error)
+                no(new Error(`Docker ${args[0]} operation failed.`));
+            else
+                yes(stdout.trim());
+        });
+    });
+}
+async function inspect(kind, name) {
+    // Distinguish absence from daemon/permission errors through a successful inventory.
+    const names = (await docker([
+        kind === "container" ? "ps" : "volume",
+        ...(kind === "container" ? ["-a"] : ["ls"]),
+        "--format",
+        kind === "container" ? "{{.Names}}" : "{{.Name}}",
+    ])).split("\n");
+    if (!names.includes(name))
+        return null;
+    const rows = JSON.parse(await docker([kind, "inspect", name]));
+    if (!Array.isArray(rows) || rows.length !== 1)
+        throw new Error("Invalid Docker inventory.");
+    return rows[0];
+}
+function labels(installation, project) {
+    return {
+        [`${LABEL}.installation`]: installation,
+        [`${LABEL}.project`]: project.id,
+        [`${LABEL}.owner`]: project.ownerId,
+    };
+}
+function owns(row, expected) {
+    const actual = row?.Config?.Labels ?? row?.Labels;
+    if (!actual || Object.entries(expected).some(([key, value]) => actual[key] !== value))
+        throw new Error("Docker resource does not belong to the expected installation and project.");
+}
+const baseName = (installation, projectId) => `codeshell-${installation}-${projectId}`;
+async function stopped(installation, projects) {
+    for (const project of projects) {
+        const row = await inspect("container", baseName(installation, project.id));
+        if (!row)
+            continue;
+        owns(row, labels(installation, project));
+        if (row.State?.Running || row.State?.Restarting || row.State?.Paused)
+            throw new Error("Stop every project container before backing up.");
+    }
+}
+async function archive(volume, file, helperImage, restore, expected) {
+    const id = randomUUID();
+    const name = `codeshell-backup-${id}`;
+    const argv = [
+        "container",
+        "create",
+        "--name",
+        name,
+        "--label",
+        `io.codeshell.backup=${id}`,
+        "--pull=never",
+        "--network=none",
+        "--read-only",
+        "--user",
+        "0:0",
+        "--cap-drop=ALL",
+        "--cap-add=DAC_OVERRIDE",
+        "--security-opt=no-new-privileges:true",
+        "--memory=256m",
+        "--pids-limit=32",
+        "--mount",
+        `type=volume,source=${volume},target=/volume${restore ? "" : ",readonly"}`,
+        "--entrypoint",
+        "tar",
+    ];
+    if (restore)
+        argv.push("--cap-add=CHOWN", "--cap-add=FOWNER", "-i");
+    argv.push(helperImage, restore ? "-xpf" : "-cpf", "-", "-C", "/volume");
+    if (!restore)
+        argv.push(".");
+    let container;
+    try {
+        container = await docker(argv);
+        if (!/^[a-f0-9]{64}$/.test(container))
+            throw new Error("Invalid backup container identity.");
+        const child = spawn("docker", ["start", "-a", ...(restore ? ["-i"] : []), container], {
+            stdio: [restore ? "pipe" : "ignore", "pipe", "ignore"],
+        });
+        const timer = setTimeout(() => child.kill("SIGKILL"), 30 * 60_000);
+        const finished = new Promise((yes, no) => {
+            child.once("error", no);
+            child.once("close", (code) => code === 0 ? yes() : no(new Error("Volume archive operation failed.")));
+        });
+        // Opening the archive can fail before Promise.allSettled attaches its handlers.
+        void finished.catch(() => undefined);
+        if (restore)
+            child.stdout?.resume();
+        let input;
+        const hash = createHash("sha256");
+        let bytes = 0;
+        const hashing = new Transform({
+            transform(chunk, _encoding, callback) {
+                bytes += chunk.length;
+                hash.update(chunk);
+                callback(null, chunk);
+            },
+        });
+        try {
+            if (restore)
+                input = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+            const transfer = restore
+                ? pipeline(input.createReadStream(), hashing, child.stdin)
+                : pipeline(child.stdout, createWriteStream(file, { flags: "wx", mode: 0o600, flush: true }));
+            const results = await Promise.allSettled([
+                transfer.catch((error) => {
+                    child.kill("SIGKILL");
+                    throw error;
+                }),
+                finished,
+            ]);
+            for (const result of results)
+                if (result.status === "rejected")
+                    throw result.reason;
+            if (restore && expected)
+                same({ sha256: hash.digest("hex"), bytes }, expected);
+        }
+        finally {
+            clearTimeout(timer);
+            child.kill("SIGKILL");
+            await input?.close();
+        }
+    }
+    finally {
+        const row = await inspect("container", name);
+        if (row) {
+            owns(row, { "io.codeshell.backup": id });
+            await docker(["rm", "-f", row.Id]);
+        }
+    }
+}
+async function fileDigest(path) {
+    const metadata = await lstat(path);
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.nlink !== 1)
+        throw new Error("Archive must be a regular file without links.");
+    const hash = createHash("sha256");
+    let bytes = 0;
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const opened = await file.stat();
+        if (metadata.ino !== opened.ino || metadata.dev !== opened.dev || opened.nlink !== 1)
+            throw new Error("Archive changed while opening.");
+        for await (const chunk of file.createReadStream()) {
+            bytes += chunk.length;
+            hash.update(chunk);
+        }
+    }
+    finally {
+        await file.close();
+    }
+    return { sha256: hash.digest("hex"), bytes };
+}
+function same(actual, expected) {
+    if (actual.sha256 !== expected.sha256 || actual.bytes !== expected.bytes)
+        throw new Error("Backup checksum verification failed.");
+}
+async function controlBytes(root, path) {
+    const parts = path.split("/");
+    let parent = root;
+    await directory(parent);
+    for (const part of parts.slice(0, -1)) {
+        parent = join(parent, part);
+        await directory(parent);
+    }
+    return regular(join(root, path), MAX_CONTROL_FILE);
+}
+async function copyControl(source, destination, records, prefix = "") {
+    await directory(source);
+    for (const name of await readdir(source)) {
+        const key = prefix ? `${prefix}/${name}` : name;
+        if (["project-control.lock", "project-runtime-secrets", "administrator-setup.txt"].includes(key))
+            continue;
+        if (key === "restore-in-progress")
+            throw new Error("Cannot back up an incomplete restore.");
+        if (Object.keys(records).length >= 4096)
+            throw new Error("Control directory contains too many files.");
+        const src = join(source, name), dst = join(destination, name);
+        const metadata = await lstat(src);
+        if (metadata.isDirectory() && !metadata.isSymbolicLink()) {
+            await mkdir(dst, { mode: 0o700 });
+            await copyControl(src, dst, records, key);
+        }
+        else {
+            const bytes = await regular(src, MAX_CONTROL_FILE);
+            await writeFile(dst, bytes, { mode: 0o600, flag: "wx", flush: true });
+            records[key] = digest(bytes);
+        }
+    }
+}
+/** Offline, owner-only backup. It never stops projects or modifies their volumes. */
+export async function backupProjectInstallation(options) {
+    imageId(options.helperImage);
+    const source = resolve(options.dataDir);
+    await directory(source);
+    // Do not initialize a fresh registry as a side effect of a mistaken backup path.
+    await regular(join(source, "project-control/registry.json"), 512 * 1024);
+    const registry = new ProjectRegistry(source);
+    let destination;
+    try {
+        const rows = registry.all();
+        if (rows.some((row) => row.status !== "stopped"))
+            throw new Error("Stop all projects and the controller before backup.");
+        const auth = new HubAuthStore({ dataDir: source });
+        if (!auth.isInitialized())
+            throw new Error("Complete administrator setup before backing up.");
+        const installationId = registry.installationId;
+        const projects = rows.map(({ id, ownerId, generation }) => ({ id, ownerId, generation }));
+        await stopped(installationId, projects);
+        await docker(["image", "inspect", options.helperImage]);
+        destination = await exclusiveDestination(source, resolve(options.destination));
+        await mkdir(join(destination, "control"), { mode: 0o700 });
+        await mkdir(join(destination, "volumes"), { mode: 0o700 });
+        const manifest = {
+            format: FORMAT,
+            version: 1,
+            createdAt: new Date().toISOString(),
+            installationId,
+            helperImage: options.helperImage,
+            projects,
+            control: Object.create(null),
+            volumes: [],
+        };
+        await copyControl(source, join(destination, "control"), manifest.control);
+        for (const project of projects) {
+            let found = 0;
+            for (const kind of ["data", "workspace"]) {
+                const volume = `${baseName(installationId, project.id)}-${kind}`;
+                const row = await inspect("volume", volume);
+                if (!row)
+                    continue;
+                owns(row, labels(installationId, project));
+                const users = await docker(["ps", "-q", "--filter", `volume=${volume}`]);
+                if (users)
+                    throw new Error("A running container still uses a project volume.");
+                const file = `volumes/${project.id}-${kind}.tar`;
+                await archive(volume, join(destination, file), options.helperImage, false);
+                manifest.volumes.push({
+                    projectId: project.id,
+                    kind,
+                    file,
+                    digest: await fileDigest(join(destination, file)),
+                });
+                found++;
+            }
+            if (found !== 2 && !(found === 0 && project.generation === 0))
+                throw new Error("Project volume set is incomplete.");
+        }
+        await stopped(installationId, projects);
+        registry.all(); // Recheck registry ownership and unchanged bytes after asynchronous work.
+        const manifestBytes = JSON.stringify(manifest, null, 2) + "\n";
+        if (Buffer.byteLength(manifestBytes) > 1024 * 1024)
+            throw new Error("Backup manifest exceeds its supported size.");
+        await writeFile(join(destination, "manifest.json"), manifestBytes, {
+            mode: 0o600,
+            flag: "wx",
+            flush: true,
+        });
+        return {
+            destination,
+            projects: projects.length,
+            volumes: manifest.volumes.length,
+            installationId,
+        };
+    }
+    catch (error) {
+        if (destination)
+            await rm(destination, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        registry.close();
+    }
+}
+function validateManifest(value) {
+    if (value?.format !== FORMAT ||
+        value.version !== 1 ||
+        !UUID.test(value.installationId) ||
+        !Array.isArray(value.projects) ||
+        value.projects.length > 128 ||
+        !Array.isArray(value.volumes) ||
+        value.volumes.length > 256 ||
+        !value.control ||
+        typeof value.control !== "object" ||
+        Array.isArray(value.control))
+        throw new Error("Unsupported or invalid Cloud backup manifest.");
+    const ids = new Set();
+    for (const p of value.projects) {
+        if (!p ||
+            !UUID.test(p.id) ||
+            !UUID.test(p.ownerId) ||
+            ids.has(p.id) ||
+            !Number.isSafeInteger(p.generation) ||
+            p.generation < 0)
+            throw new Error("Invalid backup project identity.");
+        ids.add(p.id);
+    }
+    const paths = new Set();
+    for (const item of value.volumes) {
+        if (!item ||
+            !ids.has(item.projectId) ||
+            !["data", "workspace"].includes(item.kind) ||
+            item.file !== `volumes/${item.projectId}-${item.kind}.tar` ||
+            paths.has(item.file))
+            throw new Error("Invalid backup volume inventory.");
+        paths.add(item.file);
+    }
+    if (Object.keys(value.control).length > 4096)
+        throw new Error("Invalid control inventory.");
+    for (const [path, entry] of Object.entries(value.control)) {
+        if (!path ||
+            path.includes("\\") ||
+            path.split("/").some((part) => !part || part === "." || part === "..") ||
+            /[\0\r\n]/.test(path) ||
+            path === "restore-in-progress" ||
+            path.startsWith("project-control.lock/") ||
+            path === "project-control.lock" ||
+            !entry ||
+            !SHA.test(entry.sha256) ||
+            !Number.isSafeInteger(entry.bytes) ||
+            entry.bytes < 0 ||
+            entry.bytes > MAX_CONTROL_FILE)
+            throw new Error("Invalid backup control entry.");
+    }
+    for (const item of value.volumes)
+        if (!item.digest ||
+            !SHA.test(item.digest.sha256) ||
+            !Number.isSafeInteger(item.digest.bytes) ||
+            item.digest.bytes < 0)
+            throw new Error("Invalid backup archive digest.");
+    for (const project of value.projects) {
+        const count = value.volumes.filter((v) => v.projectId === project.id).length;
+        if (count !== 2 && !(count === 0 && project.generation === 0))
+            throw new Error("Incomplete backup volume set.");
+    }
+    for (const path of [
+        "project-control/registry.json",
+        "project-control/initialized",
+        "hub/auth.json",
+    ])
+        if (!Object.hasOwn(value.control, path))
+            throw new Error("Backup lacks required control data.");
+}
+/** Restore into a new directory and new Docker volumes. Original installation is untouched. */
+export async function restoreProjectInstallation(options) {
+    imageId(options.helperImage);
+    const source = resolve(options.source);
+    await directory(source);
+    await directory(join(source, "control"));
+    await directory(join(source, "volumes"));
+    const manifest = JSON.parse((await regular(join(source, "manifest.json"), 1024 * 1024)).toString());
+    validateManifest(manifest);
+    // Verify every archive before creating a destination or Docker resource.
+    for (const volume of manifest.volumes)
+        same(await fileDigest(join(source, volume.file)), volume.digest);
+    for (const [path, expected] of Object.entries(manifest.control))
+        same(digest(await controlBytes(join(source, "control"), path)), expected);
+    await docker(["image", "inspect", options.helperImage]);
+    const destination = await exclusiveDestination(source, resolve(options.destination));
+    const created = [];
+    let registry;
+    try {
+        await writeFile(join(destination, "restore-in-progress"), "1\n", {
+            mode: 0o600,
+            flag: "wx",
+            flush: true,
+        });
+        for (const [path, expected] of Object.entries(manifest.control)) {
+            const bytes = await controlBytes(join(source, "control"), path);
+            same(digest(bytes), expected);
+            await mkdir(dirname(join(destination, path)), { recursive: true, mode: 0o700 });
+            await writeFile(join(destination, path), bytes, { mode: 0o600, flag: "wx", flush: true });
+        }
+        registry = new ProjectRegistry(destination);
+        const rows = registry.all();
+        if (registry.installationId !== manifest.installationId ||
+            rows.some((p) => p.status !== "stopped") ||
+            JSON.stringify(rows.map(({ id, ownerId, generation }) => ({ id, ownerId, generation }))) !==
+                JSON.stringify(manifest.projects))
+            throw new Error("Backup control and volume identities disagree.");
+        const auth = new HubAuthStore({ dataDir: destination });
+        if (!auth.isInitialized())
+            throw new Error("Backup administrator is not initialized.");
+        auth.revokeAllSessions();
+        registry.renewInstallationForRestore();
+        const installationId = registry.installationId;
+        for (const volume of manifest.volumes) {
+            const project = manifest.projects.find((p) => p.id === volume.projectId);
+            const name = `${baseName(installationId, project.id)}-${volume.kind}`;
+            const expected = labels(installationId, project);
+            if (await inspect("volume", name))
+                throw new Error("Restore volume already exists; refusing to overwrite.");
+            await docker([
+                "volume",
+                "create",
+                ...Object.entries(expected).flatMap(([key, value]) => ["--label", `${key}=${value}`]),
+                name,
+            ]);
+            created.push({ name, expected });
+            owns(await inspect("volume", name), expected);
+            await archive(name, join(source, volume.file), options.helperImage, true, volume.digest);
+        }
+        // Runtime secrets are generated afresh; old bootstrap URLs and environment identities are not reused.
+        for (const path of ["project-runtime-secrets", "administrator-setup.txt", "environment.json"])
+            await rm(join(destination, path), { recursive: true, force: true });
+        registry.all();
+        await rm(join(destination, "restore-in-progress"));
+        return {
+            destination,
+            installationId,
+            previousInstallationId: manifest.installationId,
+            projects: rows.length,
+            volumes: created.length,
+        };
+    }
+    catch (error) {
+        // Only delete volumes created by this restore and still carrying its exact labels.
+        for (const { name, expected } of created.reverse()) {
+            try {
+                owns(await inspect("volume", name), expected);
+                await docker(["volume", "rm", name]);
+            }
+            catch {
+                /* Preserve a busy/changed volume for operator inspection. */
+            }
+        }
+        throw error; // Keep the marked offline directory as recovery evidence; never advertise success.
+    }
+    finally {
+        registry?.close();
+    }
+}

package/dist/project-runtime/control-server.d.ts

@@ -1,11 +1,15 @@
+import type { RemoteLinkConfiguration } from "@cjhyy/code-shell-core";
 import type { ProjectRuntimeProvider } from "./types.js";
 export interface ProjectControlServerOptions {
     host: string;
     port: number;
     dataDir: string;
     publicOrigin?: string;
+    remoteLink?: RemoteLinkConfiguration;
     staticRootDir?: string;
     runtimeImage?: string;
+    /** Trusted operator configuration, never accepted from project requests. */
+    runtimeSeccompProfile?: string;
     /** Dependency injection for lifecycle/transport integration tests. */
     provider?: ProjectRuntimeProvider;
 }

package/dist/project-runtime/control-server.js

@@ -1,5 +1,8 @@
+import { remoteLinkHostConfiguration } from "../links/remote-configuration.js";
+import { describeEnvironment } from "../environment-identity.js";
 import { createServer } from "node:http";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { extname } from "node:path";
 import { createHubAuth } from "../hub/auth-http.js";
 import { resolveSafe } from "../mobile-remote/mobile-static.js";
@@ -65,6 +68,9 @@ async function readBody(request) {
 }
 /** A small account/project gateway. It never creates a worker, executes tools or mounts cwd. */
 export async function startProjectControlServer(options) {
+    const remoteLink = remoteLinkHostConfiguration(options.remoteLink, options.publicOrigin);
+    if (existsSync(join(options.dataDir, "restore-in-progress")))
+        throw new Error("Cloud installation restore is incomplete; do not start this directory.");
     const registry = new ProjectRegistry(options.dataDir);
     let proxy;
     let manager;
@@ -100,6 +106,8 @@ export async function startProjectControlServer(options) {
                     installationId: registry.installationId,
                     dataDir: options.dataDir,
                     image: options.runtimeImage,
+                    seccompProfile: options.runtimeSeccompProfile,
+                    remoteLink,
                 });
         manager = new ProjectManager({
             registry,
@@ -144,6 +152,16 @@ export async function startProjectControlServer(options) {
                 return;
             if (await transport.handle(request, response))
                 return;
+            if (pathname === "/api/v1/environment") {
+                if (!auth.isOriginAllowed(request))
+                    throw new ProjectRegistryError(403, "请求来源无效。");
+                if (!(await auth.authenticate(request)))
+                    throw new ProjectRegistryError(401, "请先登录。");
+                if (request.method !== "GET")
+                    throw new ProjectRegistryError(405, "请求方法无效。");
+                json(response, 200, describeEnvironment(registry.installationId, "project-host"));
+                return;
+            }
             if (pathname === "/api/v1/projects" || pathname.startsWith("/api/v1/projects/")) {
                 if (!auth.isOriginAllowed(request))
                     throw new ProjectRegistryError(403, "请求来源无效。");

package/dist/project-runtime/docker-provider.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteLinkConfiguration } from "@cjhyy/code-shell-core";
 import type { ProjectRuntimeProvider, ProjectRuntimeRecord } from "./types.js";
 export declare const DEFAULT_PROJECT_RUNTIME_IMAGE = "codeshell-project-runtime:local";
 export declare const PROJECT_RUNTIME_SECRET_PATH = "/run/codeshell-project.json";
@@ -11,6 +12,9 @@ export interface DockerProjectProviderOptions {
     installationId: string;
     dataDir: string;
     image?: string;
+    /** Administrator-owned seccomp JSON; omitted keeps the Docker default. */
+    seccompProfile?: string;
+    remoteLink?: RemoteLinkConfiguration;
     limits?: {
         memoryMb?: number;
         cpus?: number;

package/dist/project-runtime/docker-provider.js

@@ -1,3 +1,5 @@
+import { readProjectSeccompProfile, materializeProjectSeccompProfile } from "./seccomp.js";
+import { remoteLinkHostConfiguration } from "../links/remote-configuration.js";
 import { execFile } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, open, rename, rm } from "node:fs/promises";
@@ -108,6 +110,9 @@ export function createDockerProjectProvider(options) {
     const image = options.image ?? DEFAULT_PROJECT_RUNTIME_IMAGE;
     if (!/^[A-Za-z0-9][A-Za-z0-9._/:@-]{0,255}$/.test(image))
         throw new ProjectRuntimeError("Invalid project runtime image.");
+    const seccomp = options.seccompProfile === undefined
+        ? undefined
+        : readProjectSeccompProfile(options.seccompProfile);
     const dataDir = resolve(options.dataDir);
     if (/[\0,\r\n]/.test(dataDir))
         throw new ProjectRuntimeError("Unsupported project metadata path.");
@@ -249,8 +254,13 @@ export function createDockerProjectProvider(options) {
             password: project.runtimePassword,
             publicOrigin,
             publicPathPrefix: `/p/${project.id}`,
+            ...(options.remoteLink
+                ? { remoteLink: remoteLinkHostConfiguration(options.remoteLink, publicOrigin) }
+                : {}),
         };
-        const configuration = createHash("sha256").update(JSON.stringify(secret)).digest("hex");
+        const configuration = createHash("sha256")
+            .update(JSON.stringify(seccomp ? { secret, seccomp: seccomp.sha256 } : secret))
+            .digest("hex");
         const configLabel = `${PROJECT_RUNTIME_LABEL}.configuration`;
         const generationLabel = `${PROJECT_RUNTIME_LABEL}.generation`;
         const imageResult = await invoke(["image", "inspect", image], signal);
@@ -329,6 +339,11 @@ export function createDockerProjectProvider(options) {
                 "--entrypoint",
                 "node",
             ];
+            if (seccomp) {
+                const path = await materializeProjectSeccompProfile(dataDir, seccomp);
+                interrupted(signal);
+                args.push("--security-opt", `seccomp=${path}`);
+            }
             for (const [key, value] of Object.entries({
                 ...expected,
                 [generationLabel]: String(project.generation),

package/dist/project-runtime/managed-entry.js

@@ -1,3 +1,4 @@
+import { remoteLinkHostConfiguration } from "../links/remote-configuration.js";
 import { constants } from "node:fs";
 import { lstat, open } from "node:fs/promises";
 import { HubAuthStore } from "../hub/auth-store.js";
@@ -46,6 +47,8 @@ export async function readManagedProjectSecret(file) {
     validateProjectPublicOrigin(secret.publicOrigin);
     if (secret.publicPathPrefix !== `/p/${secret.projectId}`)
         throw new Error("Invalid managed project public path.");
+    if (secret.remoteLink)
+        secret.remoteLink = remoteLinkHostConfiguration(secret.remoteLink, secret.publicOrigin);
     return secret;
 }
 /** Initialize this project's account and invalidate every grant from a previous process. */
@@ -85,6 +88,7 @@ export function managedProjectServerOptions(secret) {
         dataDir: "/data",
         authMode: "hub",
         publicOrigin: secret.publicOrigin,
+        remoteLink: remoteLinkHostConfiguration(secret.remoteLink, secret.publicOrigin),
         publicPathPrefix: secret.publicPathPrefix,
         workerEntryPath: resolveWorkerEntry(),
         workerCapabilityModules: resolveWorkerCapabilityModules(),

package/dist/project-runtime/registry.d.ts

@@ -37,6 +37,8 @@ export declare class ProjectRegistry {
     });
     /** Release the single-controller lease on shutdown or startup failure. */
     close(): void;
+    /** Offline restore only: new Docker namespace, same project credentials for restored data volumes. */
+    renewInstallationForRestore(): void;
     get installationId(): string;
     private validate;
     private assertStorage;

package/dist/project-runtime/registry.js

@@ -103,6 +103,21 @@ export class ProjectRegistry {
     close() {
         this.controllerLock.release();
     }
+    /** Offline restore only: new Docker namespace, same project credentials for restored data volumes. */
+    renewInstallationForRestore() {
+        if (this.all().some((project) => project.status !== "stopped"))
+            throw new Error("Stop all projects before restoring an installation.");
+        const next = structuredClone(this.data);
+        next.installationId = randomUUID();
+        for (const project of next.projects) {
+            if (project.generation > 0)
+                project.generation += 1;
+            project.updatedAt = Math.max(project.updatedAt, this.now());
+            delete project.error;
+        }
+        this.write(next);
+        this.data = next;
+    }
     get installationId() {
         this.assertStorage();
         return this.data.installationId;