Snapshot after npm install, then fork 10 copies

import { PromigenceClient, Sandbox } from "@promigence/sdk";

const client = new PromigenceClient(); // reads PROMIGENCE_API_KEY, or the key signup stored
const REPO = "https://github.com/your-org/your-app";

// 1. One sandbox, and the slow part, once
const setup = await Sandbox.create({ client, spendCap: 1, timeoutMs: 30 * 60_000 });
await setup.commands.run(`git clone --depth 1 ${REPO} /work/app && cd /work/app && npm install`, {
  timeoutMs: 15 * 60_000,
});

// 2. A snapshot of the sandbox as it is now
const snap = await client.sandboxes.snapshot(setup.sandboxId, { alias: "app-installed", moveAlias: true });
await setup.kill();

// 3. Ten copies, each with node_modules already installed
const copies = await Sandbox.fork(snap.snapshot_id, { client, count: 10, spendCap: 3, timeoutMs: 20 * 60_000 });

// 4. One attempt per copy, all at once
const results = await Promise.all(
  copies.map(async (sbx, i) => {
    const r = await sbx.commands.run("cd /work/app && node agent.js && npm test", {
      envs: { ATTEMPT: String(i) },
      timeoutMs: 15 * 60_000,
      throwOnExit: false,
    });
    return { sbx, attempt: i, passed: r.exitCode === 0 };
  }),
);

const winner = results.find((r) => r.passed);
console.log(winner ? `attempt ${winner.attempt} passed in ${winner.sbx.sandboxId}` : "no attempt passed");
await Promise.all(results.filter((r) => r !== winner).map((r) => r.sbx.kill()));

from concurrent.futures import ThreadPoolExecutor
from typing import List

from promigence import Promigence, Sandbox

REPO = "https://github.com/your-org/your-app"

with Promigence() as client:  # reads PROMIGENCE_API_KEY
    setup = Sandbox.create(client=client, spend_cap=1, timeout_ms=30 * 60_000)
    setup.commands.run(f"git clone --depth 1 {REPO} /work/app && cd /work/app && npm install", timeout_ms=15 * 60_000)
    snap = client.sandboxes.snapshot(setup.sandbox_id, alias="app-installed", move_alias=True)
    setup.kill()

    copies: List[Sandbox] = Sandbox.fork(
        snap["snapshot_id"], client=client, count=10, spend_cap=3, timeout_ms=20 * 60_000,
    )

    def attempt(i: int) -> bool:
        result = copies[i].commands.run(
            "cd /work/app && node agent.js && npm test",
            envs={"ATTEMPT": str(i)}, timeout_ms=15 * 60_000, throw_on_exit=False,
        )
        return result.exit_code == 0

    with ThreadPoolExecutor(max_workers=10) as pool:
        passed = list(pool.map(attempt, range(10)))

    winner = passed.index(True) if True in passed else None
    print(f"attempt {winner} passed" if winner is not None else "no attempt passed")
    for i, sbx in enumerate(copies):
        if i != winner:
            sbx.kill()

SID=$(promigence fork --count 1 --cap 1 --timeout 30m --fresh --json | jq -r '.sandboxes[0].sandbox_id')
promigence exec --sandbox "$SID" --timeout 15m -- \
  sh -c "git clone --depth 1 https://github.com/your-org/your-app /work/app && cd /work/app && npm install"
promigence sandbox snapshot "$SID" --alias app-installed --move-alias
promigence sandbox kill "$SID"

promigence run --snapshot app-installed --count 10 --cap 3 --timeout 20m \
  -- sh -c 'cd /work/app && ATTEMPT=$PROMIGENCE_INDEX node agent.js && npm test'

promigence snapshot create --image node:22 \
  --setup "git clone https://github.com/your-org/your-app /work/app && git -C /work/app checkout <40-char sha>" \
  --setup "cd /work/app && npm ci" \
  --verify "cd /work/app && npm test" \
  --alias app --wait --wait-timeout 10m