Preview environments

name: preview
on:
  pull_request:
    types: [opened, synchronize, reopened, closed]

# one run per PR at a time; a newer push replaces a waiting one
concurrency: preview-${{ github.event.pull_request.number }}

permissions:
  contents: read
  pull-requests: write

defaults:
  run:
    shell: bash

env:
  BOXD_API_KEY: ${{ secrets.BOXD_API_KEY }}
  NEON_API_KEY: ${{ secrets.NEON_API_KEY }}
  NEON_PROJECT_ID: ${{ vars.NEON_PROJECT_ID }}
  GH_TOKEN: ${{ github.token }}
  PR: ${{ github.event.pull_request.number }}
  BRANCH: ${{ github.head_ref }}

jobs:
  up:
    if: github.event.action != 'closed'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v2
      - run: bun install
      - run: bun run preview-up.ts "$PR" "$BRANCH" | tee up.log
      # the URL never changes, so comment on open and reopen only
      - if: github.event.action != 'synchronize'
        run: gh pr comment "$PR" --repo "$GITHUB_REPOSITORY" --body "$(grep '^Preview:' up.log)"

  down:
    if: github.event.action == 'closed'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: oven-sh/setup-bun@v2
      - run: bun install
      - run: bun run preview-down.ts "$PR"

import { Boxd, Machine, NotFoundError } from "@boxd-sh/sdk";
import { createNeonClient } from "@neon/sdk";

const [prNumber, branch] = process.argv.slice(2);
const name = `myapp-pr-${prNumber}`;           // the machine and its Neon branch share it
const projectId = process.env.NEON_PROJECT_ID!;

const boxd = new Boxd();                       // reads BOXD_API_KEY
const neon = createNeonClient({ apiKey: process.env.NEON_API_KEY!, throwOnError: true });

// One Neon branch per pull request, made from the project's default branch.
// A later push finds it again, so the preview keeps its data.
const branches = await neon.branches.list({ projectId, search: name }).all();
const existing = branches.find((b) => b.name === name);
const databaseUrl = existing
  ? await neon.postgres.connectionString({ projectId, branchId: existing.id, pooled: false })
  : (await neon.branches.createAndConnect({ projectId, name, pooled: false })).connectionString;

// Recreate the machine from the latest snapshot, with the branch as its DATABASE_URL.
await boxd.machines.delete(name).catch((err) => {
  if (!(err instanceof NotFoundError)) throw err;
});
const machine = await boxd.machines.create({
  name,
  fromSnapshot: "my-workspace",
  spec: Machine.spec().env("DATABASE_URL", databaseUrl),
  config: { autoSuspendTimeout: 300 },
});
await boxd.machines.waitUntilReady(machine.id);
await boxd.machines.setAutoHibernateTimeout(machine.id, 1800);   // hibernate after 30 min idle

// Stop the app first: until it restarts, it still holds the snapshot's database connection.
const deploy = `set -e
sudo systemctl stop myapp
cd ~/myapp
printf 'DATABASE_URL=%s\\n' "$DATABASE_URL" > .env
chmod 600 .env
git fetch origin "$BRANCH"
git checkout -B preview FETCH_HEAD
npm ci
npm run migrate
sudo systemctl start myapp`;
const r = await boxd.machines.exec(machine.id, {
  command: ["bash", "-c", deploy],
  env: { BRANCH: branch },                     // passed as a variable, never pasted into the script
});
if (!r.success) throw new Error(r.stderr);     // fail the job, don't post a stale preview

console.log(`Preview: ${machine.access.url}`);
await boxd.close();

import { Boxd, NotFoundError } from "@boxd-sh/sdk";
import { createNeonClient } from "@neon/sdk";

const name = `myapp-pr-${process.argv[2]}`;
const projectId = process.env.NEON_PROJECT_ID!;

const boxd = new Boxd();
const neon = createNeonClient({ apiKey: process.env.NEON_API_KEY!, throwOnError: true });

await boxd.machines.delete(name).catch((err) => {
  if (!(err instanceof NotFoundError)) throw err;
});

const branches = await neon.branches.list({ projectId, search: name }).all();
const branch = branches.find((b) => b.name === name);
if (branch) await neon.branches.delete({ projectId, branchId: branch.id });

await boxd.close();