OR Key
drop another .md file to compare - side-by-side diff against deploy

deploy

Pushes your updates live safely.
description: "Triggers on prompt mention of 'deploy'."
personal 2 files
Export

What it does for you

Pushes your updates live safely.

What it produces

A recent result, so you can see the kind of work it returns.

loading…

How to get it

These run inside the Snappy workspace. Want this working in your business? I set skills like this up with you, in one focused week.

Work with me
For developers how this skill is built, graded, and how it runs

at a glance- the short version

actorExported functions in state/lib/deploy.ts.
auditorNone wired yet - eval is manual (Robert review).
eval modeshape
categorySystem
stages3

what's inside - the parts that make up a skill 3/4 present

A skill is just a few plain-text files. Only the main one is required. The rest are optional, added as the work needs them. This is what the skill is made of; how it runs is just below.

The skill
state/skills/deploy/SKILL.md present
the skill itself, in plain text
The main file. It says what the skill is and lays out the steps in plain English.
Code
state/lib/deploy.ts present
code the skill can run
Reusable code this skill can call when it needs to.
Scripts
state/bin/deploy/ not present
helper scripts
Optional. Added when a skill has a few commands to run.
Loader
state/skills/deploy/AGENTS.md present
what the AI loads on the fly
Loaded automatically the moment this skill is needed. Kept short on purpose.

how it's graded - what counts as a good run 5 criteria · 2 deterministic · 3 judge

Each row is one thing a good run has to get right. deterministic means a quick check decides, pass or fail. judge means the AI reads the result and rates it. Grading each piece on its own (instead of one overall score) shows exactly where a run fell short, so the fix is obvious.

name
kind
check
all_inputs_provided
deterministic
The run record includes values for checkStatus_input, vercelDeploy_input, and flyDeploy_input.
log_entry_created
deterministic
A new row exists in 'state/log/pending-eval.ndjson' for this skill execution.
checkstatus_function_called
judge
The 'checkStatus()' function was invoked with the provided 'checkStatus_input'.
verceldeploy_function_called
judge
The 'vercelDeploy()' function was invoked with the provided 'vercelDeploy_input'.
flydeploy_function_called
judge
The 'flyDeploy()' function was invoked with the provided 'flyDeploy_input'.

how it runs - the shared frame every skill uses 4/5 present

Every skill runs the same way. One part does the work, a separate part checks it, and a short loader hands the AI exactly what it needs for the job. Anything this skill doesn't use shows a one-line note saying why, on purpose, not by accident.

makes the work The worker
present
Exported functions in state/lib/deploy.ts. the worker
Does the actual work. Whatever it produces is what gets checked next.
checks the work The reviewer
present
None wired yet - eval is manual (Robert review). the checker
A separate checker grades the work, so the part that made it can't approve its own work.
frame
learns Self-correction
not present

This skill doesn't fix its own gaps yet.

tidies up Background fixes
present
queued for rewrite runs in the background
Bigger fixes that can't be made on the spot get queued and rewritten in the background later.
remembers Run history
present
state/log/pending-eval.ndjson pending runs
Every run is written down here, then reviewed by hand each week.
Critical rules the things this skill must not get wrong
No must-not-break rules called out for this skill. Anything important lives in the writeup below.

what it has learned - fixes written back in over time sample

When a run hits something this skill didn't handle, the fix gets written back into the skill so it doesn't happen again. FIXED means it was corrected on the spot. LOGGED means it's queued for a bigger rewrite. Either way, the skill gets a little better and never makes the same mistake twice.

  1. Loading feedback rows…

how the work flows- who makes it, who checks it

actor Exported functions in state/lib/deploy.ts.
1 generator
invoke
actor = Exported functions in state/lib/deploy.ts.
import from `state/lib/deploy.ts`  -  `checkStatus()`, `vercelDeploy()`, `flyDeploy()
+ eval for this step
auditor None wired yet - eval is manual (Robert review).
2 auditor
inspect
auditor = None wired yet - eval is manual (Robert review).
checkStatus()` first to see current state before deploying
+ eval for this step
3 data
eval log
`state/log/pending-eval.ndjson` (manual eval - skill: "deploy")
+ eval for this step

SKILL.md- the skill, written out in plain English

deploy

Deployment orchestrator for all snappy-* skills.

Ported from kernel snappy-deploy in Phase 0.5. See state/lib/deploy.ts for the full API surface.

Steps

  • checkStatus() - see state/lib/deploy.ts
  • vercelDeploy() - see state/lib/deploy.ts
  • flyDeploy() - see state/lib/deploy.ts

Eval

Actor: the exported functions in state/lib/deploy.ts. Auditor: none wired yet - eval is manual (Robert review). File a state/log/pending-eval.ndjson row on each run.

Score convention:

OutcomeScore
Pass on first try1.0
Failed first, auto-fix applied, re-check passed0.5
Still failing or unrecoverable0.0

Gotchas

via the Phase 0.5 driver. Only these rewrites were applied: already in state/lib/)

  1. realpathSync(process.argv[1]) CLI guard wrapped in try/catch
  • See the kernel SKILL.md for the original long-form guidance if you need it

(read-only reference at the kernel path above).

Graduation

This skill is prose. Graduate by defining a deterministic auditor and flipping eval: auto.

Rubric

criteria:
  - name: all_inputs_provided
    kind: deterministic
    check: "The run record includes values for checkStatus_input, vercelDeploy_input, and flyDeploy_input."
  - name: log_entry_created
    kind: deterministic
    check: "A new row exists in 'state/log/pending-eval.ndjson' for this skill execution."
  - name: checkstatus_function_called
    kind: judge
    check: "The 'checkStatus()' function was invoked with the provided 'checkStatus_input'."
  - name: verceldeploy_function_called
    kind: judge
    check: "The 'vercelDeploy()' function was invoked with the provided 'vercelDeploy_input'."
  - name: flydeploy_function_called
    kind: judge
    check: "The 'flyDeploy()' function was invoked with the provided 'flyDeploy_input'."

AGENTS.md- what the AI loads when this skill comes up

deploy - loader

Per-turn rules for the deploy skill. Full reference: state/skills/deploy/SKILL.md. Do not skip these.

Critical Rules

_(no failures recorded yet - this skill is a Phase 0.5 prose port from kernel snappy-deploy. No hard-won rules have surfaced yet. Read state/skills/deploy/SKILL.md and state/lib/deploy.ts before invoking.)_

Commands

| ui model | live composition via compose_inline, persisted as artifact lang_body, reopened with OpenArtifact | |invoke: import from state/lib/deploy.ts - checkStatus(), vercelDeploy(), flyDeploy() |verify: checkStatus() first to see current state before deploying |eval log: state/log/pending-eval.ndjson (manual eval - skill: "deploy")

Known Pitfalls

  • Audit-before-push, never parallel (feedback_audit_before_push.md). Dashboards/lints on drafts MUST complete before irreversible push pods fire - race lands defects live.
  • Deploy is irreversible blast radius - confirm before applying, don't run from a "keep going" interrupt
  • Cloudflare Pages one-shot HTML drop:
  • .env.cache CLOUDFLARE_API_TOKEN is scoped to the 7eb9… (robertjboulos) account and lacks Pages permissions - wrangler pages … will return Authentication error [code: 10000]. Unset both CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID and rely on the wrangler OAuth login (covers both accounts).
  • snappy-skills (skills.snappy.ai) lives on the Daniel@boulos.io account 91e4e6d01964d00df36b85bd7e1549eb - pass it via CLOUDFLARE_ACCOUNT_ID=91e4e6d01964d00df36b85bd7e1549eb to keep new Pages projects in the same account.
  • First-time deploy needs project-create first: wrangler pages project create <name> --production-branch=main, then wrangler pages deploy <dir> --project-name=<name> --branch=main --commit-dirty=true. Output is https://<sha>.<name>.pages.dev (deployment URL) and https://<name>.pages.dev (production alias).
  • Stage as index.html in a tmp dir (not the repo) - Pages deploys whatever is in the directory you pass.

Self-Test

An agent reading this should correctly:

  1. [ ] Run checkStatus() before deploying
  2. [ ] Wait for audit completion before triggering deploy
  3. [ ] Treat deploy as a confirm-required action, not a default

Found a gap? Edit this file. <!-- footer-injection-point -->

api.ts- the code it can call

#!/usr/bin/env npx tsx
/**
 * snappy-deploy/api.ts -- Deployment orchestrator for all snappy-* skills.
 *
 * Functions for checking service health, triggering Vercel deploys via API,
 * and wrapping Fly.io CLI deploys.
 *
 * Boundary: deploy = TRIGGER deployments (Vercel API, Fly CLI).
 *   snappy-infra = health probes + SSH to Mac Mini.
 *   snappy-box = the Box self-editing server API on Mac Mini.
 *
 * Usage:
 *   npx tsx api.ts status https://total-crm.fly.dev/health
 *   npx tsx api.ts vercel snappy-website
 *
 * Or import as module:
 *   import { checkStatus, vercelDeploy, flyDeploy } from "./deploy.ts";
 */

import { env } from "./env.ts";
import { execSync } from "child_process";
import { realpathSync } from "fs";

// --- Public API ---

/**
 * HTTP health check -- returns status code and response time.
 */
export async function checkStatus(url: string): Promise<{ url: string; status: number; ok: boolean; ms: number }> {
  const start = Date.now();
  try {
    const res = await fetch(url, { method: "GET", signal: AbortSignal.timeout(10000) });
    const ms = Date.now() - start;
    return { url, status: res.status, ok: res.ok, ms };
  } catch (err) {
    const ms = Date.now() - start;
    return { url, status: 0, ok: false, ms };
  }
}

/**
 * Trigger a Vercel deployment via the Deploy Hooks API or list recent deployments.
 * Requires VERCEL_TOKEN in .env.cache.
 */
export async function vercelDeploy(projectName: string): Promise<Record<string, unknown>> {
  const token = env("VERCEL_TOKEN");
  const res = await fetch(`https://api.vercel.com/v6/deployments?projectId=${encodeURIComponent(projectName)}&limit=1`, {
    headers: { Authorization: `Bearer ${token}` },
  });
  if (!res.ok) {
    const text = await res.text().catch(() => "");
    throw new Error(`Vercel API failed (${res.status}): ${text}`);
  }
  return res.json();
}

/**
 * Deploy to Fly.io via CLI. Runs `fly deploy` in the given directory.
 * Returns stdout from the deploy command.
 */
export function flyDeploy(appDir: string, configFile?: string): string {
  const configFlag = configFile ? ` --config ${configFile}` : "";
  const cmd = `cd ${appDir} && fly deploy .${configFlag}`;
  return execSync(cmd, { encoding: "utf-8" });
}

// --- CLI ---

if ((() => { try { return import.meta.url === `file://${realpathSync(process.argv[1])}`; } catch { return false; } })()) {
  (async () => {
    const [, , cmd, ...args] = process.argv;

    switch (cmd) {
      case "status": {
        const url = args[0];
        if (!url) { console.error("Usage: api.ts status <url>"); process.exit(1); }
        const result = await checkStatus(url);
        console.log(`${result.ok ? "OK" : "FAIL"}  ${result.status}  ${result.ms}ms  ${result.url}`);
        break;
      }
      case "vercel": {
        const project = args[0];
        if (!project) { console.error("Usage: api.ts vercel <project-name>"); process.exit(1); }
        const data = await vercelDeploy(project);
        console.log(JSON.stringify(data, null, 2));
        break;
      }
      default:
        console.log("Usage: npx tsx api.ts [status|vercel] ...");
    }
  })();
}

scripts- helper scripts it can run

prose-only skill - 1 inline code block live in SKILL.md above (no state/bin/ sidecar yet).

how we check it- the checks, plus the last 10 runs

rubric shape schema-shape check (no inline rubric)
recent no runs actor/auditor: unverifiable
deps none declared

no recent runs logged - the eval contract is declared but nothing has been graded yet