vercel/board

verify-board

Prove board behavior from a fresh environment.

Voir la source

Mode d’emploi

  1. Copiez la commande et examinez le paquet avant de l’installer dans votre environnement agent.
  2. Consultez le document original pour les outils, identifiants et environnements requis.
  3. Décrivez les entrées et le livrable souhaité ; comparez la sortie aux sources.
npx skills add https://github.com/vercel/board --skill verify-board

Avant de commencer

  • L’installation n’inclut ni abonnement au modèle, ni quota API, ni accès aux fichiers.
  • Étoiles et installations reflètent l’activité, pas un test indépendant de qualité ou de sécurité.
Document Skill original

Rendu depuis le dépôt source en conservant titres, exemples, code, tableaux, liens et images.

verify-board

The surface is the vb CLI against a local board (vb serve, packages/board/src/cli/serve.ts): SQLite log and attachments under the project's .board/, a scheduler in its process, a local issuer, 127.0.0.1:4100, no sync. Everything runs in a fresh Vercel Sandbox, so nothing on this machine (your ~/.config/board, your BOARD_URL, a global vb) leaks into the result. The inspector (vb inspect --no-open) is a secondary surface; see features/README.md.

All scripts live in .claude/skills/verify-board/scripts/ and run from anywhere in the repo. Set V=.claude/skills/verify-board/scripts below.

Launch

bash
V=.claude/skills/verify-board/scripts
S=$($V/up.sh)                     # this checkout, working tree included (uncommitted changes too)
S=$($V/up.sh --published 0.9.0)   # or: board from npm, exactly what users install

up.sh prints progress on stderr and the sandbox name (verify-board-<UTC timestamp>-<4 hex>, distinct across parallel runs) as its last stdout line. It:

  1. creates the sandbox: npx --yes sandbox@4.8.1 create --scope vercel-labs --name <name> --timeout 45m --vcpus 4

(VERIFY_TIMEOUT, VERIFY_VCPUS override; the image is Node 24, user ubuntu, home /vercel);

  1. source mode: tars the working tree (git ls-files --cached --others --exclude-standard), copies

it in with sandbox cp, extracts to /vercel/board, then corepack pnpm install --frozen-lockfile --filter '@vercel/board...' && corepack pnpm --filter @vercel/board build; published mode: npm install @vercel/board@<version> in /vercel/cli;

  1. links /vercel/bin/vb to the CLI under test (a symlink, as npm would);
  2. in a fresh git init project at /vercel/proj, starts

setsid nohup vb serve --no-inspect --no-open > /vercel/serve.log &;

  1. readiness: polls vb whoami (with BOARD_URL set to it, as every call is) every 0.5s for 30s; on success prints the serve log

(serving a local board at http://127.0.0.1:4100/api/board as local:user:ubuntu, ...).

If any step fails, up.sh runs down.sh itself so nothing is stranded (VERIFY_KEEP=1 keeps the sandbox for debugging; then remove it yourself). The setup log is .verify/board/<timestamp>/up.log. The repo is private, so the sandbox can't git clone it: the tarball is the way in.

Teardown is $V/down.sh "$S" (see Cleanup).

Doctor

Read-only; changes nothing. Run it after up.sh and whenever a drive misbehaves.

bash
$V/doctor.sh "$S"
sandbox   verify-board-20261014-205253-3f2a running
vb        0.9.0
board     http://127.0.0.1:4100/api/board as ubuntu (local:user:ubuntu)

It checks that sandbox ls --all shows the sandbox running, that the sandbox's vb --version equals the version under test (packages/board/package.json of this checkout, or the --published version), and that the board answers vb whoami. Exit 1 on any miss. A stopped sandbox hit its timeout: tear it down and launch again.

Drive

Two wrappers. Both run in /vercel/proj (the served project) with BOARD_URL set to the board, pass stdout, stderr, and the exit code through, and append each call to the transcript.

bash
$V/vb.sh "$S" post dev "hello from a sandbox" --label kind=bug   # argv, no shell; prints the id
$V/vb.sh "$S" read dev --json
$V/sh.sh "$S" 'echo "from stdin" | vb reply 2 -'                  # a bash line, vb on PATH
$V/sh.sh "$S" '(sleep 3; vb post dev late) & vb wait dev --timeout 30s'

A worked drive, posting and threads end to end with checks that fail loudly:

bash
$V/drive-posting.sh "$S"     # posting and threads: ok (thread #2)

Real commands to reach for (see vb help and features/ for the rest):

WhatCommand
post, reply, edit, deletevb post dev "text" --label k=v, vb reply <id> "text", vb edit <id> "text", vb delete <id>
idempotent postvb post dev "text" --idempotency-key <key> (same id twice)
attachsh.sh 'printf x > f.txt && vb reply <id> "file" --attach f.txt', then vb download <attachment> -
readvb read dev, vb read <id>, filters --label k[=v], --by, --text, --re, --mentions, --json
react, labelvb react <id> eyes [--remove], vb label <id> k=v --unset k
livevb wait dev --timeout 30s (exit 1, reason: "timeout", on timeout), timeout 6 vb tail dev
who, wherevb whoami --json, vb channels, vb actors

Any other command in the sandbox: $V/sb.sh exec "$S" -- <cmd...> (not logged). Copy a file out: $V/sb.sh cp "$S:/vercel/proj/<path>" <local path>.

Never point the sandbox's vb at a remote board. Its board is the local one; the production factory board syncs to Slack and GitHub.

Evidence

Everything lands in .verify/board/<timestamp>/ in the repo (gitignored), which survives teardown:

FileWhat
metasandbox name, mode (source/published), version, commit, count of dirty files
up.logsetup output: create, install, build, serve
doctor.txteach doctor run
transcript.txtevery vb.sh/sh.sh call: $ command, output, [exit N] when nonzero
files/from collect.sh (run by down.sh): .board/ (local.db + WAL and local/ for its files, or board.db and attachments/ on an older board), serve.log, read.json (vb read <id> --json of every thread), files.txt
down.txtthe removal

Proof standards:

  • The real user path. Drive vb as a person or agent would, against the served board. No

calls into source, no test harness, no hand-written HTTP.

  • Action, then resulting state. Every write is followed by a read that shows it

(vb post then vb read <id>; vb label then vb read dev --label k=v). An exit code alone proves little; vb edit and vb delete print nothing on success.

  • Side effects. Show the files the action leaves: the attachment under

.board/local/ (an older board's .board/attachments/), the WAL growing, ~/.claude/settings.json in a throwaway HOME.

  • Errors too. A misuse exits 2 (error: Unknown command …, error: Missing …); a missing

thread exits 1 with error: Couldn't find message #N. With --json, stderr is one JSON document with its reason. Capture both when behavior at the edges is the claim.

  • Quote the transcript lines that prove the claim, and give the evidence path.

Cleanup

bash
$V/down.sh "$S"              # collect evidence, rm the sandbox, confirm `sandbox ls --all` no longer lists it
$V/down.sh "$S" --no-collect # when the sandbox is already broken

Remove only the sandbox you created, by its exact name. down.sh refuses anything that isn't verify-board-<YYYYMMDD-HHMMSS>-<hex>, and never removes by pattern: other agents may be running their own sandboxes in the same scope. After a failed attempt, run down.sh before trying again, then check $V/sb.sh ls --all --name-prefix "$S" for your name. Never commit .verify/.

Helpers

ScriptUse
sb.sh <cmd> [args]npx --yes sandbox@4.8.1 <cmd> --scope vercel-labs (SANDBOX_SCOPE overrides)
up.sh [--published <v>]create, upload or install, serve; prints the name
doctor.sh <name>read-only health check
vb.sh <name> <args…>vb in the sandbox, logged
sh.sh <name> '<line>'a bash line in the sandbox, vb on PATH, logged
drive-posting.sh <name>the worked posting-and-threads drive
collect.sh <name>copy .board/, the serve log, and read.json out
down.sh <name> [--no-collect]collect, remove, confirm
common.shsourced: paths, name check, sbx, sbx_script, run_logged

Each sandbox command costs a few seconds of round trip; batch related steps into one sh.sh line when timing doesn't matter. Pass multi-line text through stdin (sh.sh 'printf "a\nb" | vb post dev -'), not as a vb.sh argument.

du même dépôt

Autres Skills

Tous les Skills