并排迁移 sandbox

import { getSandbox, Sandbox as SandboxBase } from "sandbox-0x";

// Preview tokens, named tunnels, and outbound rules set at runtime.
const STORAGE_0X = [
    "portTokens",
    "tunnels",
    "tunnels:meta",
    "OUTBOUND_CONFIGURATION",
];

export class Sandbox extends SandboxBase<Env> {
    // A 0.12 container keeps its files only while it runs.
    isRunning(): boolean {
        return this.ctx.container?.running ?? false;
    }

    exportStorage(): Promise<Map<string, unknown>> {
        return this.ctx.storage.get(STORAGE_0X);
    }
}

FROM node:24-trixie-slim

COPY --from=docker.io/cloudflare/sandbox:1.0.1 /usr/local/bin/sandbox-shim /usr/local/bin/sandbox-shim

WORKDIR /workspace
CMD ["sleep", "infinity"]

export class SandboxV1 extends DurableObject<Env> {
    // ...

    private moving: Promise<void> | null = null;

    async moveFrom0x(name: string): Promise<void> {
        // Requests that arrive during the copy wait for the same copy.
        this.moving ??= this.copyFrom0x(name).finally(() => {
            this.moving = null;
        });
        await this.moving;
    }

    private async copyFrom0x(name: string): Promise<void> {
        if (await this.ctx.storage.get("moved")) {
            return;
        }

        const stub0x = this.env.Sandbox.getByName(name);
        const stored = await stub0x.exportStorage();
        await this.ctx.storage.put(Object.fromEntries(stored));

        if (await stub0x.isRunning()) {
            const legacy = getSandbox(this.env.Sandbox, name);
            // Stop the background processes, so no file changes during the copy.
            await legacy.killAllProcesses();

            const path = "/tmp/workspace.tar.gz";
            const packed = await legacy.exec(`tar -czf ${path} -C /workspace .`);

            if (!packed.success) {
                throw new Error(packed.stderr);
            }

            const archive = await legacy.readFile(path, {
                encoding: "base64",
            });

            await this.ensureRunning();
            const extract = await this.container.exec(
                ["sh", "-c", "base64 -d | tar -xzf - -C /workspace"],
                { stdin: new Blob([archive.content]).stream() },
            );
            const result = await extract.output();

            if (result.exitCode !== 0) {
                const stderr = new TextDecoder().decode(result.stderr);
                throw new Error(stderr);
            }

            // destroy() would delete named tunnels and DNS records.
            await legacy.stop();
            await this.ctx.storage.put("moved", true);
            return;
        }

        await this.ctx.storage.put("moved", true);
    }
}

async function sandboxFor(env: Env, name: string) {
    const sandbox = env.SandboxV1.getByName(name);
    await sandbox.moveFrom0x(name);
    return sandbox;
}