[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_135":136},"routes/modules.$creator.$moduleId",{"_14":15,"_16":17,"_18":19,"_20":21},"routes/modules.$creator.$moduleId.endpoints",{"_11":12,"_13":-5},"error","Module not found","tools","module",{"_20":22,"_23":24,"_25":26,"_27":28,"_29":30,"_31":32,"_33":34,"_35":26,"_36":37,"_38":-5,"_39":-5,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_56":-5,"_57":49,"_58":59,"_60":61,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71,"_72":73,"_74":75,"_76":77,"_78":79,"_80":-5,"_81":-5,"_82":-5,"_83":49,"_84":-5,"_85":86,"_87":88,"_89":90,"_91":92,"_93":94,"_95":96,"_97":98},"apiUrl","https://odel.app/api","creator","kychee-com","moduleId","run402","@kychee-com/run402","displayName","Run402","tagline","x402 pay-per-call infra for agents: $0.03 image generation, Postgres, auth, storage, functions.","iconKey","https://avatars.githubusercontent.com/u/265859594?v=4","category","remote","status","published","visibility","public","metaDescription","deploymentType","external","workerName","bindingName","mcpConfig","{\"url\":\"https://mcp.run402.com/mcp\",\"transport\":\"streamable-http\",\"authType\":\"none\"}","pricingModel","free","creatorUserId","system:external-import","createdAt",1784607634000,"updatedAt",1788323306000,"sourceRegistry","official-mcp-registry","sourceUrl","https://registry.modelcontextprotocol.io/v0/servers?search=com.run402%2Fmcp","sourceVerified",false,"sourceMissingSince","importedAt","upstreamStars",24,"upstreamUpdatedAt",1788278821000,"detectedTransport","streamable-http","detectedAuthType","none","probeStatus","ok","lastProbedAt",1787632035000,"githubRepoUrl","https://github.com/kychee-com/run402","githubRepoFullName","kychee-com/run402","releaseId","ext-kychee-com-run402","version","4.16.0","descriptionMarkdown","

\n $\"run402$ \n

\n\n

run402: full-stack backend infrastructure for AI agents

\n\n

\n Postgres, auth, storage, serverless functions and atomic deploys —\n provisioned, operated and paid for by an agent through a typed SDK, a CLI\n or an MCP server. No cloud console, no signup. Open source.\n

\n\n[![Tests](https://github.com/kychee-com/run402/actions/workflows/test.yml/badge.svg)](https://github.com/kychee-com/run402/actions/workflows/test.yml)\n[![CodeQL](https://github.com/kychee-com/run402/actions/workflows/codeql.yml/badge.svg)](https://github.com/kychee-com/run402/actions/workflows/codeql.yml)\n[![npm: @run402/sdk](https://img.shields.io/npm/v/@run402/sdk?label=%40run402%2Fsdk)](https://www.npmjs.com/package/@run402/sdk)\n[![npm: run402](https://img.shields.io/npm/v/run402?label=run402)](https://www.npmjs.com/package/run402)\n[![npm: run402-mcp](https://img.shields.io/npm/v/run402-mcp?label=run402-mcp)](https://www.npmjs.com/package/run402-mcp)\n[![npm: @run402/functions](https://img.shields.io/npm/v/@run402/functions?label=%40run402%2Ffunctions)](https://www.npmjs.com/package/@run402/functions)\n[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)\n\n**Run402 is open-source backend infrastructure for AI agents and coding agents** — a backend-as-a-service addressed to a machine rather than to a person. An autonomous agent provisions a Postgres database, user auth, file storage, serverless functions and site hosting, ships them in one atomic deploy, and pays for the usage itself. Comparable in surface to Supabase, Firebase or Vercel; different in that there is no dashboard to sign into and no human-issued API key to copy.\n\nThis is the backend Kychee's open products run on. We needed a layer an agent can drive end to end, with room for whatever each app turns out to need, and nothing off the shelf had all of it, so we built it and opened it the same way we open the apps: this repo holds the agent surfaces (MIT), [`run402-core`](https://github.com/kychee-com/run402-core) holds the full backend (Apache-2.0), and [kysigned](https://github.com/kychee-com/kysigned) is the first product running on it.\n\nOne call to [run402](https://run402.com) gives an agent a full Postgres database, REST API, user auth, content-addressed file storage, static site hosting, serverless functions, and image generation, paid with x402 USDC on Base (or Stripe credits). The prototype tier is free on testnet.\n\n**Run402 is agent-first because agents are first-class participants, not because people disappear.** A person or agent acts through its own Run402 principal and authenticator, and its actions remain attributable. Identity answers who acted; memberships, roles, grants, delegates, freshness, and spend policy determine what that principal may do.\n\nAn autonomous agent may remain the legitimate owner of the org-of-one it creates. People may join through explicit co-ownership. Agents entering somebody else's organization receive bounded authority instead of borrowing a human account. Different keys. Equal standing. Explicit authority.\n\nThis monorepo ships every surface an agent can pick up:\n\n| Surface | Use when… |\n|---------|-----------|\n| [`@run402/sdk`](https://github.com/kychee-com/run402/blob/main/sdk/) | Calling run402 from TypeScript: typed kernel, isomorphic (Node 22 / Deno / Bun / V8 isolates) with a Node entry that auto-loads the local keystore + allowance + x402 fetch |\n| [`run402` CLI](https://github.com/kychee-com/run402/blob/main/cli/) | Terminal, scripts, CI, agent-controlled shells: JSON in, JSON out, exit code on failure |\n| [`run402-mcp`](https://github.com/kychee-com/run402/blob/main/src/) | Claude Desktop, Cursor, Cline, Claude Code: core run402 operations as MCP tools |\n| [OpenClaw skill](https://github.com/kychee-com/run402/blob/main/openclaw/) | OpenClaw agents (no MCP server required) |\n| [Run402 for Buzz](https://github.com/kychee-com/run402/blob/main/buzz/) | Buzz people and agents: install from run402.com, preflight/link one agent's dedicated identities, deploy a contextual demo, then offer human co-ownership through a normal HTTPS/passkey handoff; Buzz remains unchanged |\n| [`@run402/functions`](https://www.npmjs.com/package/@run402/functions) | Imported _inside_ deployed functions (`db(req?)`, `adminDb()`, `auth.user()`, `email`, `ai`, `assets`) and for TypeScript autocomplete in your editor. Source lives in the public [`run402-core`](https://github.com/kychee-com/run402-core) repo under `packages/functions`; run402 Cloud consumes the published npm package when it bundles function zips. |\n| [`@run402/astro`](https://github.com/kychee-com/run402/blob/main/astro/) | Astro integration for SSR, ISR cache, hosted auth components, and image variants |\n\nThese interfaces share a single typed kernel where appropriate: `@run402/sdk`. MCP tools, CLI subcommands, and OpenClaw scripts are thin shims over SDK calls. `@run402/functions` is the in-function helper that runs inside deployed code; the npm package on the registry is the artifact Cloud bundles. `@run402/astro` layers the SDK and functions runtime into Astro's build and SSR flow. Pick whichever interface fits your runtime.\n\n## 30-second start\n\n```bash\nnpm install -g run402@latest\nrun402 up --name my-app -y # bootstrap allowance/tier/project/link, then deploy manifest\nrun402 up verify # rerun app HTTP verification without deploying\nrun402 up --verify # deploy, then wait for gateway/edge coherence\nrun402 subdomains claim my-app # → https://my-app.run402.com\n```\n\nThat's a real Postgres database + a deployed static site, paid for autonomously with testnet USDC.\n\nBuy from any x402 seller with the same allowance and a default $0.10 ceiling:\n\n```bash\nrun402 pay https://seller.example/translate --method POST \\\n --body '{\"text\":\"hello\"}' --max-usd 0.05 \\\n --idempotency-key translation:1 --require-receipt\n```\n\nThe SDK equivalent is\n`r.pay.fetch(url, init, { maxUsdMicros, idempotencyKey, requireReceipt })`;\nMCP callers use `pay_url` with `require_receipt: true`. All three return the\nsame `x402-commerce-result.v1` settlement, movement/replay, delivery, offer,\nmerchant-receipt, signer-relationship, policy, and raw-evidence fields and pass\nunpriced URLs through with `payment: null`. Requiring a receipt rejects before\npayment when no wallet-rooted offer is eligible. If a promised receipt cannot\nbe verified after settlement, `PaymentPolicyError` retains the upstream\nresponse and paid result and tells the caller to reconcile—never to pay again.\nFor a\ntrusted Run402 `PAYMENT_INTENT_PENDING`, all three surfaces prescribe one\nrecovery path: wait for `Retry-After`, then repeat the same request with the\nsame payer and key. Never replace the key. The SDK and MCP can also re-present\nan ambiguous proof while their process remains alive; custom/arbitrary sellers\nremain ambiguous and require reconciliation.\n\nPrefer `run402 up` when a repo has `run402.deploy.json` or `app.json`. The CLI stays a thin shim over the Node SDK action runner (`r.actions.run(...)` / `r.up(...)`): it validates the manifest first, then recursively performs only the missing prerequisites. Project resolution is `--project`, `.run402/project.json`, manifest `project_id`, approved creation from `--name`, then approved active-project fallback. `--name` is project creation/link metadata only; it is not part of the deploy manifest and never renames an existing project. Use `--check` for local validation and `--plan` for gateway-reviewed intent before applying.\n\nIf an app manifest defines `verify.http[]`, `run402 up` verifies those URLs after deploy. Fresh run402 edge sentinel misses are reported as `propagation_pending` rather than permanent failures while the binding is still converging; tune that wait with `--propagation-budget-s` (default 120) or return immediately with `--no-propagation-wait`. `run402 up verify` reruns the same HTTP checks without uploading, deploying, creating projects, or mutating resources.\n\nThe CLI checks for newer `run402` releases opportunistically and fail-open. Success stdout stays the command result; stale-version notices are advisory JSON on stderr, or `cli.update_available` NDJSON events in `--json-stream`. `run402 doctor --refresh` is the explicit live npm check and reports the install context plus the safest upgrade command for local, global, or ephemeral installs.\n\nTyped deploy configs use the same commands. Executable configs are trusted local code, so v1 only runs them when passed explicitly:\n\n```bash\nrun402 up --manifest run402.deploy.ts --check\nrun402 up --manifest run402.deploy.ts --plan\nrun402 up --manifest run402.deploy.ts --require-plan plan_...\n```\n\n`--check` and `--print-spec` are local-only. `--plan` asks the gateway for a reviewed plan with `plan_id`, `plan_fingerprint`, warnings, diff, and one next action. `--require-plan` reapplies only if the normalized spec and reviewed gateway facts still match.\n\n```ts\nimport { defineConfig, dir, nodeFunction, sqlFile } from \"@run402/sdk/config\";\n\nexport default defineConfig(({ env }) => ({\n project: env.required(\"RUN402_PROJECT_ID\"),\n database: { migrations: [sqlFile(\"db/001_init.sql\")] },\n site: { replace: dir(\"dist\"), public_paths: { mode: \"implicit\" } },\n functions: { replace: { api: nodeFunction(\"dist/functions/api.js\") } },\n secrets: { require: [\"OPENAI_API_KEY\"] },\n}));\n```\n\nHelpers normalize to the same `ReleaseSpec` as JSON manifests. `dir()` walks deterministically and rejects unsafe files unless explicitly allowed, `sqlFile()` derives the migration id from the filename unless supplied, and `nodeFunction()` currently expects JavaScript output; point TypeScript functions at built `.js` files.\n\n## The patterns\n\n### Paste-and-go assets: content-addressed URLs with SRI\n\n`assets.put()` returns an `AssetRef` whose `scriptTag()` / `linkTag()` / `imgTag()` emitters produce HTML with the URL, the SRI integrity hash, and modern best-practice attributes (`defer`, `loading=\"lazy\"`, `decoding=\"async\"`, `crossorigin`) already wired. The URL is content-addressed (`pr-.run402.com/_blob/-<8hex>.`), served through the v1.33 CDN, and never needs invalidation:\n\n```ts\nimport { run402 } from \"@run402/sdk/node\";\nconst r = run402();\nconst p = await r.project(projectId);\n\nconst logo = await p.assets.put(\"logo.png\", { bytes: pngBytes });\nconst app = await p.assets.put(\"app.js\", { content: jsSource });\nconst style = await p.assets.put(\"app.css\", { content: css });\n\nconst html = `\n\n\n ${style.linkTag()}${app.scriptTag({ type: \"module\" })}\n ${logo.imgTag(\"Company logo\")}\n\n`;\n```\n\nBinary files must enter the SDK as bytes. In Node, use `readFile(path)` without\nan encoding; in browsers, use `File.arrayBuffer()`. Never read PNG, WASM,\nfonts, audio, video, archives, or other binary formats as UTF-8 and then hash\nor re-encode the resulting string: CAS can verify only the bytes it receives.\nThe SDK rejects string sources for known binary keys/MIME types with\n`BINARY_CONTENT_REQUIRES_BYTES` before making a request. Directory helpers\nsuch as `fileSetFromDir`, `dir`, and `assets.uploadDir` are byte-safe by\nconstruction.\n\n`immutable: true` is the default: the SDK computes the SHA-256 client-side, the gateway returns a content-hashed URL, and the browser refuses execution on byte mismatch. No cache-invalidation choreography, no waiting, no integrity-attribute construction.\n\n### Dark-by-default tables + the expose manifest\n\nTables you create are unreachable via `/rest/v1/*` until you declare them in a manifest. That closes the \"agent created a table, forgot to set RLS, data leaked\" footgun. The manifest is convergent: applying it twice is a no-op; items removed between applies have their policies, grants, triggers, and views dropped.\n\n```bash\ncat > manifest.json <<'EOF'\n{\n \"$schema\": \"https://run402.com/schemas/manifest.v1.json\",\n \"version\": \"1\",\n \"tables\": [\n { \"name\": \"items\", \"expose\": true, \"policy\": \"user_owns_rows\",\n \"owner_column\": \"user_id\", \"force_owner_on_insert\": true },\n { \"name\": \"audit\", \"expose\": false }\n ],\n \"views\": [\n { \"name\": \"leaderboard\", \"base\": \"items\", \"select\": [\"user_id\", \"score\"], \"expose\": true }\n ],\n \"rpcs\": [\n { \"name\": \"compute_streak\", \"signature\": \"(user_id uuid)\", \"grant_to\": [\"authenticated\"] }\n ]\n}\nEOF\n\nrun402 projects validate-expose --file manifest.json\nrun402 projects apply-expose --file manifest.json\nrun402 projects get-expose \n```\n\nBuilt-in policies: `user_owns_rows` (rows where `owner_column = auth.uid()`; with `force_owner_on_insert: true` a BEFORE INSERT trigger sets it), `public_read_authenticated_write` (anyone reads, any authenticated user writes), `public_read_write_UNRESTRICTED` (fully open; requires `i_understand_this_is_unrestricted: true`), and `custom` (escape hatch: your own `CREATE POLICY` SQL).\n\nUse `run402 projects validate-expose` or the MCP `validate_manifest` tool for a non-mutating feedback loop before applying. Optional migration SQL is used only to check manifest references; it is not executed as a PostgreSQL dry run, and this does not validate deploy manifests.\n\n**Auth-as-SDLC:** put the same JSON under `database.expose` in your v2 `ReleaseSpec`. The gateway validates it against your migration SQL during deploy and rejects mismatches with a structured `errors` array listing every violation.\n\n### Slick deploys: `deployDir` + plan/commit + progress\n\n`deployDir` walks a local directory, hashes every file client-side, asks the gateway _which_ bytes it doesn't already have, and PUTs only those. Re-deploying an unchanged tree returns immediately with `bytes_uploaded: 0`.\n\n```ts\nimport { run402 } from \"@run402/sdk/node\";\n\nconst r = run402();\nconst { url, bytes_uploaded, bytes_total } = await r.sites.deployDir({\n project: projectId,\n dir: \"./dist\",\n onEvent: (e) => process.stderr.write(JSON.stringify(e) + \"\\n\"),\n});\n```\n\nProgress events stream over `onEvent` (or stderr from the CLI) as unified\n`DeployEvent` JSON objects from the v2 deploy primitive.\n\nCLI:\n\n```bash\nrun402 sites deploy-dir ./dist --project prj_… > result.json 2> events.log\n```\n\n### Same-origin web routes: static site + function ingress\n\nApply-v1 routes and static public paths are release resources: they activate atomically with the site, functions, migrations, secrets, and subdomains in the same `deploy apply`. Release static asset paths such as `events.html` are distinct from browser-visible public static paths such as `/events`. Use `site.public_paths` for ordinary clean static URLs; keep routes for function ingress and exact, method-aware static aliases.\n\n```json\n{\n \"project_id\": \"prj_...\",\n \"site\": {\n \"replace\": {\n \"index.html\": { \"data\": \"

\" },\n \"events.html\": { \"data\": \"

Events

\" }\n },\n \"public_paths\": {\n \"mode\": \"explicit\",\n \"replace\": {\n \"/events\": { \"asset\": \"events.html\", \"cache_class\": \"html\" }\n }\n }\n },\n \"functions\": {\n \"replace\": {\n \"api\": {\n \"runtime\": \"node22\",\n \"source\": {\n \"data\": \"export default async function handler(req) { const url = new URL(req.url); return Response.json({ ok: true, path: url.pathname }); }\"\n }\n },\n \"login\": {\n \"runtime\": \"node22\",\n \"source\": { \"data\": \"export default async function handler(req) { return Response.json({ ok: true }); }\" }\n }\n }\n },\n \"routes\": {\n \"replace\": [\n { \"pattern\": \"/api/*\", \"methods\": [\"GET\", \"POST\", \"OPTIONS\"], \"target\": { \"type\": \"function\", \"name\": \"api\" } },\n { \"pattern\": \"/login\", \"methods\": [\"POST\"], \"target\": { \"type\": \"function\", \"name\": \"login\" } }\n ]\n }\n}\n```\n\n`site.public_paths.mode: \"explicit\"` means only the complete `public_paths.replace` table is directly reachable as static URLs. In the example, `/events` serves the release asset `events.html`, while `/events.html` is not public unless separately declared. `mode: \"implicit\"` restores filename-derived public reachability and can widen access, so review gateway warnings before confirming it.\n\nOmit `routes` or pass `routes: null` to carry forward base routes. Use `routes: { \"replace\": [] }` to clear the route table. Route entries are an ordered `replace` list, not a path-keyed map. Function targets use `{ \"type\": \"function\", \"name\": \"\" }`. Static route targets use exact patterns only, methods `[\"GET\"]` or `[\"GET\",\"HEAD\"]`, and `{ \"pattern\": \"/events\", \"methods\": [\"GET\",\"HEAD\"], \"target\": { \"type\": \"static\", \"file\": \"events.html\" } }` where `file` is a release static asset path, not a public path, URL, CAS hash, rewrite, or redirect. Use static route targets for method-aware aliases such as static `GET /login` plus function `POST /login`; in explicit public path mode the backing asset can stay private by filename. Direct `/functions/v1/:name` calls remain API-key protected; browser-routed paths are public same-origin ingress.\n\nFunction routes can charge a fixed tenant x402 price before the handler runs by adding `pricing: { \"mode\": \"always\", \"amount_usd_micros\": 250000, \"pay_to\": \"org_default_payout\" }` to the route entry. `250000` is $0.25 per matching action. The portable ReleaseSpec contract also accepts `receipt: \"on_fulfillment\"` on a priced function route; a compatible host then requires the function to return `payment.fulfilled(response)` before it authors a receipt. Run402-hosted advertising remains gated off until the standard delegated-signer carrier is available—receipt intent never silently downgrades. Omit `networks` for production mainnet only; include `\"testnet\"` explicitly for testnet acceptance. Static aliases cannot be priced, direct function invocation is not monetized, and service/admin keys do not bypass a priced browser route. The owning org must have a resolvable payout wallet: set it with `r.org(orgId).setPayoutWallet({ walletAddress })`, `run402 org payout-wallet `, or MCP `set_org_payout_wallet`. Conditional credit systems should expose one fixed-price route such as `POST /api/credits`, then keep the rest of the app behind unpriced routes and app-local authorization.\n\nMatching is exact or final-prefix-wildcard only. `/admin` and `/admin/` are exact trailing-slash equivalents; `/admin/*` matches children but not `/admin`, `/admin/`, `/admin.css`, or `/administrator`, so deploy both `/admin` and `/admin/*` for a routed section root. Query strings are ignored for matching and preserved in the handler's full public `req.url`. Exact routes beat prefix routes; longest prefix wins; method-compatible dynamic routes beat static assets. A `POST /login` route can coexist with static `GET /login` HTML. Unsafe method mismatch returns `405`, and matched dynamic route failures fail closed instead of falling back to static files.\n\nRouted functions use the Node 22 Fetch Request -> Response contract: `export default async function handler(req) { ... }`. `req.method` is the browser method, and `req.url` is the full public URL on managed subdomains, deployment hosts, and verified custom domains. Derive OAuth callbacks from it, for example `new URL(\"/admin/oauth/google/callback\", new URL(req.url).origin)`. Append multiple cookies with `headers.append(\"Set-Cookie\", value)`; redirects, cookies, and query strings are preserved. On priced routes, import `getRoutedPaymentContext` from `@run402/functions`, read `const paymentContext = getRoutedPaymentContext(req)`, and key app-side idempotency by `paymentContext.paymentId`. For a receipt-enabled route, return `payment.fulfilled(response)` only after the response represents completed delivery; the helper fails closed outside a settled, current, receipt-enabled routed invocation. The context helper reads gateway-confirmed `x-run402-payment-*` headers and returns `null` for unpriced or direct calls. The raw `run402.routed_http.v1` envelope is internal; do not write route handlers against it.\n\n**Recipe: static home page + SPA shell.** A SPA site ships `index.html` as the shell serving every unmatched route (match `spa_fallback`), so by default `GET /` serves the shell too. To serve a real static home page at `/` while keeping the shell for app routes, ship `home.html` at the site root alongside `index.html` and add an exact root static route alias: `\"routes\": { \"replace\": [ { \"pattern\": \"/\", \"target\": { \"type\": \"static\", \"file\": \"home.html\" } } ] }`. Route matching runs before all static resolution (including the implicit `/` -> `index.html` root mapping), and SPA-fallback derivation is independent of the route table, so `GET /` serves `home.html` (`route_static_alias`), unmatched app routes such as `/dashboard` still serve the shell (`spa_fallback`), and named static pages keep serving unchanged (`static_exact`). Expect two non-blocking plan lints: `STATIC_ALIAS_SHADOWS_STATIC_PATH` (warn: the alias overrides what `/` would otherwise serve; accurate and expected here) and `STATIC_ALIAS_DUPLICATE_CANONICAL_URL` (info: `/home.html` stays directly reachable in implicit public-path mode; add `` to `home.html` if duplicate-content SEO matters). Omitting `routes` on later deploys carries the alias forward; `routes.replace` is total, so a pipeline that sends it must include the alias every time. Verify with `run402 deploy resolve --url https:/// --method GET` or `deploy_diagnose_url` and confirm `match: \"route_static_alias\"` with `target_file: \"home.html\"`.\n\nAvoid routing every static file, broad method lists by default, wildcard static route targets, leading-slash static files, directory shorthand, and one-static-route-target-per-page tables that exhaust route limits. Also watch wildcard function routes that shadow direct public static paths. Warning codes to handle include `STATIC_ALIAS_SHADOWS_STATIC_PATH`, `STATIC_ALIAS_RELATIVE_ASSET_RISK`, `STATIC_ALIAS_DUPLICATE_CANONICAL_URL`, `STATIC_ALIAS_EXTENSIONLESS_NON_HTML`, and `STATIC_ALIAS_TABLE_NEAR_LIMIT`; inspect active routes, `static_public_paths`, and resolve diagnostics to distinguish the route pattern from the backing `asset_path`.\n\nDiagnose public URLs with the URL-first CLI or MCP/SDK equivalents:\n\n```bash\nrun402 deploy diagnose --project prj_123 https://example.com/events --method GET\nrun402 deploy resolve --project prj_123 --url https://example.com/events?utm=x#hero --method GET\nrun402 deploy resolve --project prj_123 --host example.com --path /events --method GET\n```\n\n`deploy_diagnose_url` and `r.project(id).apply.resolve({ url, method: \"GET\" })` return `would_serve`, `diagnostic_status`, `match`, normalized request data, warnings, full resolution JSON, `edge_propagation`, and next steps. When returned, `asset_path`, `reachability_authority`, and `direct` explain which release asset backs the public URL and whether reachability came from implicit file-path mode, explicit `site.public_paths`, or a route-only static alias. Stable-host diagnostics may also include `authorization_result`, `cas_object` (`sha256`, `exists`, `expected_size`, `actual_size`), hostname-specific `response_variant`, route/static fields such as `allow`, `route_pattern`, `target_type`, `target_name`, and `target_file`, and `edge_propagation` (`settled`, `propagating`, or `sync_pending`). Known `match` literals are `host_missing`, `manifest_missing`, `active_release_missing`, `unsupported_manifest_version`, `path_error`, `none`, `static_exact`, `static_index`, `spa_fallback`, `spa_fallback_missing`, `route_function`, `route_static_alias`, and `route_method_miss`; preserve unknown future strings. Known `authorization_result` values include `authorized`, `not_public`, `not_applicable`, `manifest_missing`, `target_missing`, `active_release_missing`, `unsupported_manifest_version`, `path_error`, `missing_cas_object`, `unfinalized_or_deleting_cas_object`, `size_mismatch`, and `unauthorized_cas_object`. Known `fallback_state` values include `active_release_missing`, `unsupported_manifest_version`, and `negative_cache_hit`; preserve unknown future strings. `result` is the diagnostic body status, not the HTTP status of the SDK call, so host misses can still be successful CLI/MCP/SDK calls with `would_serve: false`. Do not treat resolve/diagnose as a fetch, cache purge, or cache-policy oracle; route method misses should inspect `allow`, CAS authorization/health failures should inspect or redeploy the affected static asset, and fresh host misses should inspect `edge_propagation` or rerun `run402 up verify`. Branch on structured JSON fields such as `cache_class` and preserve unknown cache classes.\n\nRelease observability exposes stable asset identity and public reachability. Inventories include `release_generation`, `static_manifest_sha256`, nullable `static_manifest_metadata` (`file_count`, `total_bytes`, `cache_classes`, `cache_class_sources`, `spa_fallback`), and `static_public_paths[]` when returned. `site.paths` lists release static assets; `static_public_paths[]` lists browser-visible public paths with `public_path`, `asset_path`, `reachability_authority`, `direct`, cache class, and content type. Plan and release diffs expose `static_assets` counters: unchanged/changed/added/removed, `newly_uploaded_cas_bytes`, `reused_cas_bytes`, `deployment_copy_bytes_eliminated`, `legacy_immutable_warnings`, `previous_immutable_failures`, and `cas_authorization_failures`.\n\nRuntime route failure codes to branch on: `ROUTE_MANIFEST_LOAD_FAILED` (manifest/propagation), `ROUTED_INVOKE_WORKER_SECRET_MISSING` (custom-domain Worker secret), `ROUTED_INVOKE_AUTH_FAILED` (internal invoke signature), `ROUTED_ROUTE_STALE` (selected route failed release revalidation), `ROUTE_METHOD_NOT_ALLOWED` (method mismatch), `PAYOUT_WALLET_REQUIRED` / `PAYOUT_WALLET_AMBIGUOUS` / `PAYOUT_WALLET_UNRESOLVED` (priced-route payout setup), `PAYMENT_PROOF_MISMATCH` (stale or wrong x402 proof), and `ROUTED_RESPONSE_TOO_LARGE` (body over 6 MiB).\n\n### GitHub Actions OIDC deploys: link once, deploy with the same CLI\n\nFor repo-driven deploys, run402 does not need service keys or allowance files in GitHub secrets. Run a local link command once:\n\n```bash\nrun402 ci link github --project prj_... --manifest run402.deploy.json\n# Optional route authority for CI route declarations:\nrun402 ci link github --project prj_... --manifest run402.deploy.json --route-scope /admin --route-scope /api/*\n```\n\nThat creates a deploy-scoped `/ci/v1/*` binding and writes a workflow that grants `id-token: write`, checks out the repo, and runs the existing deploy primitive:\n\n```yaml\npermissions:\n contents: read\n id-token: write\n\njobs:\n deploy:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: Deploy to run402\n run: npx --yes run402@3.7.5 deploy apply --manifest 'run402.deploy.json' --project 'prj_...'\n```\n\nCI deploys are intentionally narrow: `site`, `functions`, `database`, absent/current `base`, and route declarations only when the binding has covering `--route-scope` patterns. Without route scopes, CI cannot ship `routes`. Keep secrets, domains, subdomains, checks, non-current base, and broader trust changes in a local allowance-backed deploy. If the gateway returns `CI_ROUTE_SCOPE_DENIED`, re-link with exact scopes like `/admin` or final-wildcard scopes like `/api/*`, or deploy locally. Manage bindings with `run402 ci list` and `run402 ci revoke`.\n\n### In-function helpers: caller-context vs BYPASSRLS\n\nInside a deployed function, import from `@run402/functions`. Two distinct DB clients keep RLS clean:\n\n```ts\nimport { db, adminDb, auth, email, ai } from \"@run402/functions\";\n\nexport default async (req: Request) => {\n const user = await auth.requireUser();\n\n // Caller-context: db() mints a 60s actor JWT so run402.current_user_id() resolves in RLS.\n // No .eq(\"user_id\", user.id) needed: RLS already binds the visitor's rows; the redundant\n // filter is a deploy-fail (R402_AUTH_REDUNDANT_USER_FILTER) under @run402/functions v3.0+.\n const mine = await db().from(\"items\").select(\"*\");\n\n // BYPASSRLS: for platform-authored writes (audit logs, cron cleanup, webhook handlers).\n await adminDb().from(\"audit\").insert({ event: \"items_read\", user_id: user.id });\n\n // Send mail from the configured default outbound mailbox.\n if (mine.length === 0) {\n await email.send({ to: user.email, subject: \"Welcome\", html: \"

hi

\" });\n }\n\n return Response.json(mine);\n};\n```\n\n`adminDb().sql(query, params?)` runs raw parameterized SQL and always bypasses RLS. It returns a flat `Promise[]>` (just the rows, no envelope):\n\n```ts\nimport { adminDb, auth } from \"@run402/functions\";\n\nexport default async (req: Request) => {\n const user = await auth.requireUser();\n\n const rows = await adminDb().sql(\n \"SELECT count(*)::int AS n FROM items WHERE user_id = $1\",\n [user.id],\n );\n const n = (rows[0]?.n as number | undefined) ?? 0;\n return Response.json({ count: n });\n};\n```\n\n`@run402/functions` is auto-bundled into deployed code; install it in your editor for full TypeScript autocomplete (also works at build time for static-site generation with `RUN402_SERVICE_KEY` + `RUN402_PROJECT_ID` set).\n\n`ai.generateImage({ prompt, aspect? })` is available inside deployed functions for live app flows such as generated avatars or OG images. It calls the project runtime image endpoint with `RUN402_SERVICE_KEY`, so deployed functions do not need allowance wallets or x402 signing code. Aspects are `square`, `landscape`, and `portrait`; the result is `{ image, content_type, aspect }` with base64 image bytes. Runtime image generation is billed, rate-limited, and spend-capped against the project organization; public routed functions should authenticate/rate-limit their users before calling it.\n\n`assets.put(key, source, opts?)` uploads bytes from inside a deployed function through the same CAS-backed apply substrate as deploy-time assets. It uses `RUN402_SERVICE_KEY`, accepts a string, `Uint8Array`, or `{ content | bytes }`, and returns an SDK-compatible `AssetRef` with mutable and immutable URLs.\n\n**Calling from outside a function entirely** (raw `curl`/`fetch` from CI scripts, bash bootstrappers, non-TS runtimes): service-key writes go to `/admin/v1/rest/`, not `/rest/v1/*`. The gateway 403s service-role tokens on `/rest/v1/*` so a leaked key can't silently bypass RLS, which means `curl ... > /dev/null` against the wrong path looks like success but writes nothing. SQL-shaped admin work uses `POST /projects/v1/admin/:id/sql` (or `run402 projects sql`).\n\n```bash\ncurl -X POST https://api.run402.com/admin/v1/rest/audit \\\n -H \"Authorization: Bearer $RUN402_SERVICE_KEY\" \\\n -H \"Content-Type: application/json\" \\\n -d '{\"event\":\"seed\",\"ts\":\"2026-04-30\"}'\n```\n\n### repos: your repository history, encrypted before it leaves the machine\n\n`run402 repos` is a Git remote whose contents are encrypted on your own machine and stored as a chain of signed, admitted heads. It exists so your repository history outlives the machine it was written on — without that outliving requiring you to hand Run402 the plaintext. The wire protocol is `r402s/v0`. One noun, thirteen verbs (`repo` singular resolves identically): `run402 gitvault ` answers `COMMAND_MOVED`/`COMMAND_REMOVED`, and `r.gitvault` is the SDK's name (`gitvault` stays the protocol/infrastructure name; `repos` is what you type).\n\nThree claims, three different strengths. These are the entire approved claims vocabulary for this feature:\n\n1. **Run402 cannot decrypt your gitvault or repository history. Deployment artifacts remain a disclosed plaintext custody boundary.** Cryptographic, against Run402 itself: in the vault lane, source payload and repository-history content are ciphertext-only; the substrate retains only enumerated plaintext metadata and holds zero vault keys. The deploy lane is separate and disclosed — the platform custodially holds the plaintext artifacts of every deploy. It can read what you deployed; it cannot read what you did not.\n2. **Activation requires vault admission by default; an explicit, audited override can bypass it.** An operational platform invariant, enforced and auditable — not cryptographic against the platform that enforces it.\n3. **Retention is an operational promise of the platform, not a cryptographic guarantee against it** (the host controls timestamps and bytes).\n\n**The vault-only track — three lines, muscle memory intact, nothing to pay:**\n\n```bash\nrun402 init # once per machine\nrun402 repos create my-notes # project + vault + origin remote, one free call\ngit push -u origin main # publishes, encrypted before it leaves the machine\n```\n\n`origin` is claimed additively: when the directory has no `origin` yet, the scaffold names ours `origin` — `git push origin main` just works, no side-remote name to remember. An existing `origin` is never touched; the fallback is `run402` instead, and the response says which happened and why. The free path is the whole path — no slug, no fee, no ceremony. When you want pretty `run402::/` addresses (clone-by-name, push-to-create), claim an org slug once — the optional named-address upgrade described below.\n\n**Named addressing.** `run402::/` works alongside the id-form `run402::/` in the same slot — pick an org slug once (`run402 org slug `, owner-only, a small one-time claim fee), and every repo under it is `run402::/`. Pushing a name that doesn't exist yet **push-to-creates** it: the project and vault are allocated atomically, and a losing concurrent pusher resolves cleanly to the winner's repo instead of erroring — its work is not lost, it just wasn't the creator. The first time a named remote resolves on a checkout, the resolved id is **pinned** into that checkout's local git config — every later push/fetch follows the pin directly, so a later rename of the org slug or repo name never breaks an existing clone. The id-form address needs no pin (a project id never changes) and stays the cold-restart path: an agent that lost its local state but still holds authority on the project can always fall back to `run402::/`.\n\n**One thing to know up front: V0 is single-principal.** Exactly one machine (this keystore) can open the vault until human envelopes ship. State it plainly, don't bury it — see \"If you lose the keystore\" below.\n\nThe explicit, ceremonial form still works, and allocates the SAME way `git push` does lazily on first use — useful for scripts, or for the receipt to land in JSON stdout instead of stderr:\n\n```bash\n# 1. Provision. Inside a repository that already exists, this adds the origin\n# remote (run402::/). Not a repository yet?\n# `run402 init --git-remote` creates one first. It needs a project selected\n# (`run402 projects use `, or RUN402_PROJECT_ID).\nrun402 init\n\n# 2. Allocate the repo's vault explicitly. Separate from `run402 init` on\n# purpose: this is the step that mints key material on this machine and\n# prints a one-shot recovery receipt. Idempotent — an existing vault comes\n# back deduplicated. (Skip this step and git push / repos snapshot\n# against an unallocated project allocates the SAME way, lazily, on\n# first use — the two paths don't stack; this one just does it now,\n# explicitly, so the receipt lands in JSON stdout instead of stderr.)\nrun402 repos create --project \n\n# 3. Snapshot — capture the working tree, encrypt it, publish a signed head.\nrun402 repos snapshot --message \"wip: refactor the parser\"\ngit push origin main # ...or push your own branches, via git-remote-run402\n\n# 4. View, then fsck: walk the head chain from your authenticated pin.\nrun402 repos view\nrun402 repos fsck --budget 500\n\n# Restore anywhere, with plain git.\ngit clone run402::/ restored\n```\n\nCloning needs a Run402 principal on this machine — a wallet with an allowance and a keystore holding an envelope for this vault — this is encrypted git, not a shareable link.\n\nA fresh clone installs local `refs/r402/retain/` refs for every retained deploy-capture tip no branch reaches, so a plain `git fsck` is silent — `git for-each-ref refs/r402/` lists what is retained. Clones made by a client older than this one (or a checkout whose ref write degraded) may still show dangling commits under `git fsck`; harmless, not corruption — one `run402 repos fsck` run installs the missing refs. A retained ref locally pins that history against `git gc` until the vault prunes the capture, at which point the next fetch retracts it.\n\n`repos snapshot` is the CAPTURE lane — the protocol deploy ref plus the HEAD target — because a dirty tree captures as a synthetic commit that sits on no branch. Your own branches and tags reach the vault through `git push origin `.\n\n**Allocating a vault does NOT gate the project's deploys.** `gitvault_policy` stays unset until you set it — a vault created by a first `git push` or `repos create` never silently changes how you deploy. A deploy against a vaulted, ungated project proceeds ungated and its result carries a typed `next_actions` entry offering `run402 repos policy required`; every later ungated deploy carries a `warnings[]` entry naming the drift, until the policy is set either way — never a block, never an interactive prompt. Once `gitvault_policy` is `required`, a deploy must present a vaulted capture at commit — `run402 deploy apply` produces one automatically on any machine holding the keystore; un-gate with `run402 repos policy grandfathered --reason \"\"` (owner + step-up, audited, reversible with `run402 repos policy required`). Vaulting your source is never gated on a deploy, either way. `run402 doctor` reports the policy, whether this machine can satisfy it, and where the keystore lives.\n\nBefore `snapshot` reports that anything landed, the client compares every finalization receipt against its local expected manifest and reads the admitted head back from storage — a 200 alone is never enough. Maintenance is one verb, `run402 repos gc` — `git gc`'s own two halves (checkpoint publication + prune planning), never described as \"exactly `git gc`\" since the deletion ceremony is stricter: it plans locally, and submits only when handed both verifier receipts — one from this CLI, one from the independent `r402s-verify` — with `--submit --intent-core --verifier-receipt `; only the control-plane-signed completion says what was deleted.\n\nFrom the SDK, with identical semantics — vault reads run anywhere, and the verbs that touch a git working tree or the on-disk keystore are Node-only:\n\n```ts\nimport { run402 } from \"@run402/sdk/node\";\nconst r = run402();\n\nconst vault = await r.gitvault.forProject(projectId); // cold restart: no local state needed\nconst pushed = await r.gitvault.push({ project_id: projectId, snapshot: { message: \"wip\" } });\nconst state = await r.gitvault.verify({ project_id: projectId });\n```\n\n**The encrypted second remote — the zero-migration pattern.** Keep GitHub/GitLab as the primary (collaboration, CI, reviews, unchanged) and add GitVault as the second remote: `git remote add gitvault run402::/` + `git push gitvault --all`, and a complete, continuously updated copy of your history exists that the storage provider itself cannot read. The reason this matters, said plainly and as capability rather than accusation: a host that can READ private repositories can — under a future policy, an acquisition, a training pipeline, a subpoena, or a breach — index them, train models on them, or hand them to someone who will. Run402 cannot decrypt your gitvault or repository history. Deployment artifacts remain a disclosed plaintext custody boundary.\n\n**A vault-only project is first-class.** `run402 init` (or `run402 repos create `), then `git push origin …`, then `gc` / `fsck` / `access`, and never a deploy — a supported shape, not a degraded one. One consequence is worth stating plainly: a vault-only project has no deploy lane, so the disclosed plaintext custody boundary is empty and there is consequently no custodial restore path.\n\n**If you lose the keystore.** The vault protects source history from host-side loss while a principal keystore survives. The \"while\" clause is load-bearing: in V0-A, **whole-machine or whole-keystore loss is terminal for vault history until human envelopes ship**, and `run402 repos view` prints that sentence verbatim. Back up the keystore directory `run402 repos view` reports as `keystore.root` and prints under the terminal-loss statement — `~/.config/run402/gitvault` for the default wallet, `~/.config/run402/profiles//gitvault` for a named one. The recovery receipt is an integrity anchor, not a decryption key — it proves the vault you are served is the one you created, and it decrypts nothing. It is not a secret; the more copies the better. The reminder gets louder as the vault gets more valuable: quiet at genesis, a STANDING `run402 doctor` warning once the vault crosses any of ≥10 generations / ≥10 MB / ≥14 days since genesis — cleared only by adding a second principal, never by an attestation, because V0 cannot verify one is true.\n\n**The exit ramp: mirror your own copy.** `run402 repos mirror [--profile | --ambient]` (S3 or a plain directory) configures a second, customer-owned copy of the vault's ciphertext — the destination and credential *name* live in a config file beside the keystore, never in `run402.config.json`, never a raw secret. Once set, every `snapshot` dual-pushes to it automatically, reported as a separate `mirror_push` field beside the vault result; a mirror failure never blocks, slows, or changes the actual publish. `run402 repos mirror --backfill` (idempotent, resumable) catches it up on demand; `run402 repos fsck --mirror` is a KEYLESS integrity probe — it reports the recoverable generation without touching key material. `run402 repos recover --out ` needs no server at all: it reads the mirror, verifies the chain, and decrypts with the local keystore alone. Named `recover` rather than `restore`, which already means something else in git. Two things to know before you rely on it: it proves *validity, never freshness* — an older mirror looks identical to a genuinely short history — and a mirror without the keystore **or an equivalent key** recovers nothing, since mirroring ciphertext does not create a second key; the V0 terminal-loss statement above is unchanged.\n\n**The human backup path (gitvault-recovery-custody).** A human org member who completed source enrollment at console.run402.com/account holds an *equivalent key* with no keystore at all: their member key lives as sealed wrappers (passkey PRF and/or a source recovery code), and `run402 repos recovery-bundle` downloads the versioned recovery bundle (key identity + wrapper ciphertexts — still nothing the platform can open). Kept with a vault mirror — copy it to `member-recovery-bundles/.json` under the mirrored prefix — that bundle + the source recovery code + the vault's recovery receipt recover the repository with **no run402 server and no keystore**: `run402 repos recover --out --receipt ` (the code is prompted with hidden input; `--bundle ` if the bundle isn't in the mirror). A raw passkey PRF output is deliberately NOT a recovery input — the no-server path for a human is the recovery code. `run402 doctor`'s `recovery_posture` check tells you whether each vault-owning org actually has this backstop configured.\n\n```bash\nrun402 repos mirror s3://acme-vault-mirror --profile acme --region us-east-1\nrun402 repos mirror --backfill\nrun402 repos recover s3://acme-vault-mirror --out ./restored --repo src_1a2b3c\nrun402 repos recovery-bundle --out ./bundle.json # the member's no-keystore recovery half\nrun402 repos recover ./mirror-copy --out ./restored --receipt ./recovery-receipt.json --bundle ./bundle.json\n```\n\n**Verify it without trusting our client.** `r402s-verify` is an independent-lineage verifier for the same protocol — a separate language, separate authorship, and a separate primitive stack, deliberately sharing no implementation code with the SDK. That non-sharing is the point: a differential verifier that reuses the code it is checking verifies nothing. It lives on the `r402s-verify` branch of this repository with its own workflow, ships prebuilt release binaries, and also builds with `cargo build --release`. The full protocol specification and threat model it verifies against are published in [`docs/gitvault/`](https://github.com/kychee-com/run402/blob/main/docs/gitvault/README.md), and the frozen conformance vectors in [`test-vectors/r402s-v0/`](https://github.com/kychee-com/run402/blob/main/test-vectors/r402s-v0/README.md).\n\n**Cost.** There is no separate repos price — a vault's bytes count against the same organization-pooled storage budget your projects already share, charged once per unique object with a 4 KiB per-object accounting floor and a 1 MiB per-vault minimum.\n\n## SDK: `@run402/sdk`\n\n```bash\nnpm install @run402/sdk\n```\n\nTwo entry points:\n\n- **`@run402/sdk`**: isomorphic. Bring your own `CredentialsProvider` (a session-token shim, a remote vault, anything that resolves project keys + auth headers). Works in Node 22, Deno, Bun, V8 isolates.\n- **`@run402/sdk/node`**: Node-only convenience. Reads local profile state plus the project-key credential cache (`credentials/project-keys.v1.json`) and signs x402 payments from one deterministic source: an explicit opaque `paymentSigner`, explicit `allowancePath`, the supplied provider's `readAllowance()`, or the default active-profile allowance. Auth and payer may intentionally differ; a selected payment source never falls back to an ambient wallet. `r.paymentPayer()` reports only safe public payer/source provenance. Also exposes `sites.deployDir(...)`, `fileSetFromDir(...)`, typed deploy-manifest helpers (`loadDeployManifest`, `normalizeDeployManifest`), and `resolveRun402TargetProfile()` for app build scripts that need the same Core/Cloud target the CLI uses.\n\n```ts\nimport { run402 } from \"@run402/sdk/node\";\n\nconst r = run402();\nconst project = await r.projects.provision({ tier: \"prototype\" });\nconst p = await r.project(project.project_id);\nawait p.assets.put(\"hello.txt\", { content: \"hi\" });\n```\n\nThe SDK is organised into focused namespaces: `actions` (Node recursive action runner), `pay` (bounded arbitrary-URL x402 buyer), `projects`, `snapshots`, `branches`, `archives`, `assets`, `cache`, `ci`, `sites`, `functions`, `jobs`, `secrets`, `subdomains`, `domains`, `email` (+ `webhooks`), `auth`, `apps`, `tier`, `billing`, `contracts`, `ai`, `allowance`, `service`, `admin`, `operator` (the human/email operator session: browser-delegated `login` + `overview` across every wallet that verified your email), `wallets` (signed server-side wallet label), `orgs` (org-owned control plane + `r.org(id)` sub-client), `grants` (per-project capability grants), and `identityLinks` (public, protocol-discriminated human/agent Nostr attribution), plus the `r.project(id).apply` hero for atomic mixed writes (release slices + assets slice via `/apply/v1/*`). Every operation throws a typed `Run402Error` subclass on failure: `PaymentRequired`, `PaymentBuyerError`, `ProjectNotFound`, `Unauthorized`, `ApiError`, `NetworkError`, `LocalError`, `Run402DeployError`. `apply()` automatically re-plans safe current-base `BASE_RELEASE_CONFLICT` races and emits `apply.retry` progress events. See [`sdk/README.md`](https://github.com/kychee-com/run402/blob/main/sdk/README.md).\n\n## Buzz/Nostr identity links\n\nHumans and agents can publicly attribute separately held Buzz/Nostr identities to their Run402 principal. Agent links use the EOA-plus-kind-1 protocol; human links use a normal browser, fresh passkey, and released Buzz consent ceremony at . Both produce the same public `idlnk_…` resource shape with a discriminating `proof_protocol`. One principal may have several active Nostr subjects, while one active Nostr subject belongs to only one principal. This is attribution only: Nostr identities never authenticate, authorize, pay, deploy, or receive transfers. Run402 never accepts or derives from an `nsec`, Nostr private key, mnemonic, seed, passkey, session credential, or derivation path.\n\nThe human-facing install is a Buzz message—no terminal required:\n\n```text\nPlease install the run402.com skill.\n```\n\nThat is the entire human instruction. In a managed Buzz context, first-party discovery routes it to `run402-buzz`; the agent reads the apex install router and installs the self-contained skill into its workspace (normally the user-home `.buzz` directory). The request means install and connect: after verifying the inert files, the agent loads the installed skill directly and continues through preflight, setup, and identity linking in the same turn. It does not stop at “available next turn” or ask a second setup question. For a Codex runtime, prefer supplying the working directory and environment separately to the agent's command runner:\n\n```text\nworking_directory: /.buzz\nenvironment: { \"DO_NOT_TRACK\": \"1\" }\ncommand: npx --yes skills@latest add https://run402.com -s run402-buzz -a codex -y\n```\n\nShell-only POSIX environments use:\n\n```sh\ncd \"$HOME/.buzz\"\nDO_NOT_TRACK=1 npx --yes skills@latest add https://run402.com -s run402-buzz -a codex -y\n```\n\nWindows PowerShell uses:\n\n```powershell\nSet-Location (Join-Path $HOME '.buzz')\n$env:DO_NOT_TRACK = '1'\nnpx --yes skills@latest add https://run402.com -s run402-buzz -a codex -y\n```\n\nClaude Code uses `-a claude-code`, Goose uses `-a goose`, a confirmed `.agents/skills` consumer may use `-a universal`, and Claude Code plus Codex uses `-a claude-code codex`. `universal` is the shared path, not all runtimes; do not use the invalid explicit target `-a claude`. The skill bytes come from immutable digest-verified artifacts at `run402.com`; first-run `npx` can still require npm. GitHub is the one availability-only fallback, while any integrity failure stops before setup. Success reports the observed first-party digest and exact managed-workspace path; a GitHub source or global runtime path is never mislabeled first-party.\n\nThe file installation stage is inert. Continuing onboarding publishes a durable public kind-1 Nostr event and durable Run402 proof connecting the two public identities; revocation does not erase their history, and a Buzz-managed event may also expose its owner's public NIP-OA attestation. The agent initializes only if needed, creates or reuses the link, independently verifies it, and immediately offers one context-relevant quick test or demo with `Deployment: none` retained in the expanded receipt. On Windows the setup helper runs npm's and Run402's JavaScript entrypoints through the exact managed Node runtime with `shell: false`, avoiding `.cmd` process-boundary failures. It waits for explicit approval before building or deploying. After independently verifying the live app, it creates an inert durable offer and posts a normal HTTPS “Become an owner” handoff. The browser owns human login/passkey and the existing Buzz six-digit consent callback; no human terminal command or Buzz change is required.\n\nSee the [`buzz/` guide](https://github.com/kychee-com/run402/blob/main/buzz/README.md) for prerequisites, the no-secret signer model, released-client fixtures, migration guidance, and the full workflow, or inspect the exact [`run402-buzz` listing on skills.sh](https://skills.sh/kychee-com/run402/run402-buzz). The low-level CLI commands remain available for debugging, but they are not a competing onboarding path.\n\nThe community control plane keeps four concepts separate: installing the skill is inert shared capability; installing a community associates a Buzz relay community with a Run402 organization after dual consent; human adoption records a terminal consent receipt, creates the human's public Buzz identity link, and adds an ordinary owner membership without demoting the founder agent; agent enrollment gives each later agent principal only bounded, expiring grants to named existing projects. The completed receipt, public attribution, and membership remain independent: revoking the link does not remove org authority, and removing the membership does not revoke the link or rewrite the receipt. Buzz itself remains unchanged: approval uses already-shipped browser-fragment/kind-1 behavior plus released NIP-11/NIP-43 evidence, while Run402 owns offers, organizations, descriptor discovery, and lifecycle. `run402 buzz status` capability-detects older gateways; MCP only renders exact HTTPS/CLI handoffs. See the [Fizz/Honey workflow](https://github.com/kychee-com/run402/blob/main/buzz/references/community-control-plane.md).\n\n**Astro SSR + ISR cache (v1.52+).** For Astro apps, use `@run402/astro` 1.0+: `export default run402();` in `astro.config.mjs` returns an `AstroUserConfig` composing the SSR adapter (Lambda + SnapStart + ISR cache + AsyncLocalStorage request-context), image integration, and build-time detectors. Functions opt into the SSR class via `FunctionSpec.class: \"ssr\"` in `ReleaseSpec`; the gateway provisions SnapStart and caches HTML responses keyed by `(host, path, search, method, locale, release_id)`. Cache is bypass-by-default (no-store unless `Cache-Control` explicitly allows it AND no `Set-Cookie` AND no auth-taint flag from `auth.*` helpers / payment primitives). Invalidate from in-function code or out-of-band: `r.cache.invalidate(url)` / `r.cache.invalidatePrefix({ host, prefix })` / `r.cache.invalidateAll({ host })` (SDK), `run402 cache invalidate ` (CLI). Inspect cached state with `r.cache.inspect(url)` / `run402 cache inspect `. Agent DX helpers also in the CLI: `run402 doctor` (5 health checks), `run402 dev` (Astro dev with `.env.local`), `run402 logs --request-id req_...` (correlate across functions). Full reference at [`astro/README.md`](https://github.com/kychee-com/run402/blob/main/astro/README.md) and [`cli/llms-cli.txt`](https://github.com/kychee-com/run402/blob/main/cli/llms-cli.txt) (R402_* SSR Runtime Error Codes section).\n\n## CLI: `run402`\n\n```bash\nnpm install -g run402@latest\n```\n\nEvery subcommand prints JSON to stdout, JSON errors to stderr, exits 0 on success and 1 on failure: designed for an agent shell, not a human. Full reference: [`cli/llms-cli.txt`](https://github.com/kychee-com/run402/blob/main/cli/llms-cli.txt) (also at ).\n\n```bash\nrun402 up --name my-app -y # recursive SDK action runner: init/tier/project/link/deploy\nrun402 up verify # rerun app HTTP verification without a deploy\nrun402 init # one-shot allowance + faucet + tier check\nrun402 pay https://seller.example/resource --max-usd 0.05 --require-receipt\nrun402 status # organization snapshot (wallet, rail, balances, tier, projects)\nrun402 projects provision --name my-app\nrun402 projects sql \"CREATE TABLE …\"\nrun402 projects validate-expose --file manifest.json\nrun402 projects apply-expose --file manifest.json\nrun402 sites deploy-dir ./dist\nrun402 deploy verify op_... --project --wait # confirm gateway/edge release coherence\nrun402 deploy release active --project # inspect current-live release inventory\nrun402 deploy diagnose --project https://example.com/events --method GET\nrun402 apply --manifest app.json --rehearse --json\nrun402 snapshots list prj_...\nrun402 branches create prj_... --ttl-days 7 --json\nrun402 functions deploy --file fn.ts\nrun402 functions runs create --event-type reminder.send --idempotency-key reminder:123 --delay 10m\nrun402 ci link github --project # GitHub Actions OIDC deploy binding (--route-scope for CI routes)\nrun402 assets put ./asset.png --immutable\nrun402 assets diagnose # inspect live CDN state for a public URL\nrun402 cdn wait-fresh --sha # poll until a mutable URL serves the new SHA\n```\n\n`up` is the only compound CLI command: it calls the SDK action runner, emits `steps[]`, and writes `.run402/project.json` when it needs to remember the workspace project. Against run402 Core it skips Cloud allowance/tier prerequisites and fails closed if no Core project is selected.\n\nFor database-bearing deploys, rehearse before commit. `run402 apply --manifest app.json --rehearse --json` plans, uploads missing CAS bytes, creates a contained branch, runs migrations/checks there, and exits nonzero on a failed rehearsal. If you already have a persisted plan id, use `run402 deploy rehearse --project --json`. Manual restore points live under `run402 snapshots create|list|get|restore|delete`; restore is a two-step plan/confirm flow. Branch projects live under `run402 branches create|list|renew|delete`, default to a 7-day TTL, use sandboxed email by default, and are marked noindex.\n\nPortable archives export the supported run402 Core runtime slice of a Cloud project for local Core import. This is the no-lock-in trust path, separate from allowance/spend-cap financial-risk controls.\n\n```bash\nrun402 cloud archives create --scope portable-runtime-v1 --auth stubs --consistency pause-writes --wait --output ./project.r402ar --json\nrun402 archives verify ./project.r402ar --json\nrun402 core projects import ./project.r402ar --name imported-project --env-file ./required.env --json\nrun402 projects export --output ./project.r402ar --json\nrun402 core projects apply ./project.r402ar --name imported-project --env-file ./required.env --json\n```\n\n`projects export` is an alias for the Cloud archive export flow; `core projects apply` is an alias for Core archive import. Archive v1 excludes secret values, auth credentials, logs, billing/allowance state, Cloud operations metadata, Cloud import, and existing-project merge import. Verify is local/offline and checks integrity plus compatibility; archives remain untrusted input until Core import verifies and stages them.\n\nThe active project is sticky: `run402 projects use ` server-validates `` and stores it as the default for subsequent ``-taking subcommands, so most commands work without it. Local key material is managed separately under `run402 credentials project-keys ...`; that cache is never project inventory.\n\n## MCP server: `run402-mcp`\n\n```bash\nnpx -y run402-mcp # standalone test\n```\n\n### Buying only? Load 6 tools instead of 198\n\nThe full server registers **198 tools (~43,000 tokens)** before you do anything. If your agent only wants to *buy* — generate an image for $0.03 and nothing else — that is a fifth to a third of a context window spent on 192 tools it will never call.\n\n```bash\nRUN402_MCP_PROFILE=buyer npx -y run402-mcp\n```\n\n| profile | tools | approx. tokens |\n|---|---:|---:|\n| *(unset — default)* | 198 | ~43,200 |\n| `buyer` | **7** | **~740** |\n\nThe seven: `generate_image` · `init` · `check_balance` · `allowance_status` · `allowance_export` · `request_faucet` · `redeem_voucher` — enough to bootstrap a wallet, fund it (from the faucet or a promo code), check it, and buy. **Local, so it can actually pay:** an x402 payment needs a signing key, so a wallet-less remote server cannot make one.\n\nDefault is unchanged when the variable is unset. An unknown profile name **exits 1** with the known-profile list rather than silently serving the full surface or nothing.\n\n### Remote endpoint (no install)\n\nA hosted streamable-HTTP MCP server runs at **`https://mcp.run402.com/mcp`** with free discovery tools only: `run402_quickstart`, `x402_price_check` (decode any URL's x402 challenge, unpaid), and `experiment_scoreboard`. It never handles funds — paid capabilities (image generation, deploys, payments) require the local server below, which holds *your* wallet. Registry entry `com.run402/mcp` lists both (`packages[]` npm + `remotes[]`). The remote itself runs as a run402 function — the platform hosting its own MCP server.\n\nStdio MCP transports must keep stdout reserved for JSON-RPC. Use the package bin (`npx -y run402-mcp`) or `node dist/index.js` from a built checkout. If a host insists on `npm start`, set `npm_config_loglevel=silent`; npm's lifecycle banner is stdout and otherwise appears as non-JSON prelude. The repo `.npmrc` and Docker image set this for source/container hosts.\n\n### Claude Desktop\n\nAdd to `~/Library/Application Support/Claude/claude_desktop_config.json`:\n\n```json\n{\n \"mcpServers\": {\n \"run402\": { \"command\": \"npx\", \"args\": [\"-y\", \"run402-mcp\"] }\n }\n}\n```\n\n### Cursor\n\nAdd to `.cursor/mcp.json`:\n\n```json\n{\n \"mcpServers\": {\n \"run402\": { \"command\": \"npx\", \"args\": [\"-y\", \"run402-mcp\"] }\n }\n}\n```\n\n### Cline\n\nAdd to your Cline MCP settings:\n\n```json\n{\n \"mcpServers\": {\n \"run402\": { \"command\": \"npx\", \"args\": [\"-y\", \"run402-mcp\"] }\n }\n}\n```\n\n### Claude Code\n\n```bash\nclaude mcp add run402 -- npx -y run402-mcp\n```\n\n## OpenClaw skill\n\n```bash\ncp -r openclaw ~/.openclaw/skills/run402\ncd ~/.openclaw/skills/run402/scripts && npm install\n```\n\nEach script re-exports from `cli/lib/*.mjs`: the OpenClaw command surface is identical to the CLI command surface by construction. See [`openclaw/README.md`](https://github.com/kychee-com/run402/blob/main/openclaw/README.md).\n\n## MCP tools\n\nThe full MCP surface: every tool is a thin shim over an SDK call.\n\n### Database\n\n| Tool | Description |\n|------|-------------|\n| `provision_postgres_project` | Provision a new database. Auto-handles x402 payment. |\n| `run_sql` | Execute SQL (DDL or queries). Returns a markdown table. |\n| `rest_query` | Query/mutate via PostgREST. |\n| `apply_expose` | Apply the declarative authorization manifest (tables, views, RPCs). Convergent: drops items removed between applies. |\n| `validate_manifest` | Validate the auth/expose manifest without applying it. Accepts manifest object/string, optional `migration_sql`, optional `project_id`. |\n| `get_expose` | Return the current manifest. `source` is either `applied` (from the tracking table) or `introspected` (regenerated from live DB state). |\n| `get_schema` | Introspect tables, columns, types, constraints, RLS policies. |\n| `get_usage` | Per-project usage report (API calls, storage, lease expiry). |\n| `promote_user` / `demote_user` | Manage `project_admin` role on a project user. |\n| `delete_project` | Cascade purge: schema, Lambdas, S3 site files, deployments, secrets, published versions. Irreversible. |\n\n### Asset storage (content-addressed CDN)\n\n| Tool | Description |\n|------|-------------|\n| `assets_put` | Upload an asset (any size, up to 5 TiB) via direct-to-S3 presigned URLs. Returns an `AssetRef` with `scriptTag()` / `linkTag()` / `imgTag()` emitters. |\n| `assets_get` | Download an asset to a local file. |\n| `assets_ls` | Keyset-paginated list with prefix filter. |\n| `assets_rm` | Delete an asset. |\n| `assets_sign` | Time-boxed presigned GET URL for a private asset. |\n| `diagnose_public_url` | Live CDN state for a public URL: expected vs observed SHA, cache headers, invalidation status. |\n| `wait_for_cdn_freshness` | Poll a mutable URL until it serves the expected SHA-256. |\n\n### Sites & subdomains\n\n| Tool | Description |\n|------|-------------|\n| `deploy_site` | Deploy a static site from inline file bytes. |\n| `deploy_site_dir` | Deploy a static site from a local directory. Routes through the unified apply primitive (CAS-backed); only uploads bytes the gateway doesn't have. |\n| `claim_subdomain` | Claim `.run402.com` (idempotent; reassigns to latest deployment on subsequent deploys). |\n| `list_subdomains` / `delete_subdomain` | Manage subdomains. |\n| `domains_ensure` / `domains_get` / `domains_list` / `domains_check` | Manage project-scoped web/email ProjectDomain desired state and health checks. |\n| `domains_apply` / `domains_repair` / `domains_test_receive` / `domains_activate` / `domains_disconnect` | Apply safe provider actions, repair run402-owned routing, verify inbound receive, activate mailbox addresses, or disconnect a domain. |\n| `deploy` / `deploy_resume` / `deploy_rehearse` / `deploy_list` / `deploy_events` / `deploy_verify_edge` | Apply, resume, rehearse persisted plans on contained branches, list, inspect deploy operations, and verify gateway/edge coherence. |\n| `deploy_release_get` / `deploy_release_active` / `deploy_release_diff` | Inspect release inventory and release-to-release diffs without starting a new deploy mutation. |\n| `deploy_diagnose_url` | URL-first deploy resolver diagnostics. Params: `project_id`, either `url` or `host`/`path`, optional `method`; returns `would_serve`, `diagnostic_status`, `match`, warnings, next steps, and fenced JSON. |\n\n### Snapshots & branches\n\n| Tool | Description |\n|------|-------------|\n| `create_project_snapshot` / `list_project_snapshots` / `get_project_snapshot` | Create and inspect manual project restore points. Snapshot artifacts are internal and are never downloadable as portable archives. |\n| `restore_project_snapshot` | Two-step restore: first returns a restore plan plus confirm token; second call with `confirm` flips the project to the materialized snapshot and reports next actions. |\n| `delete_project_snapshot` | Delete a manual snapshot and release its CAS references. |\n| `create_project_branch` / `list_project_branches` / `renew_project_branch` / `delete_project_branch` | Create contained, expiring data branches from a snapshot or live project, extend their TTL, or clean them up. |\n\n### CI/OIDC bindings\n\n| Tool | Description |\n|------|-------------|\n| `ci_create_binding` | Create a GitHub Actions CI deploy binding fro","changelogMarkdown","videoKey","requiredSecretsJson","publishedAt","priceCents","trialDays",0,"iconType","image","upstream",{"_115":116,"_117":118,"_119":120,"_121":122,"_123":124,"_125":126},"requiredSecrets",[],"tags",[101,102,103,104,105,106,107,108,109,110,111,112,113,114],"assets",[],"stats",{"_99":86,"_100":86},"ratingAvg","reviewCount","agent-infrastructure","ai-agent","ai-agents","ai-infrastructure","backend-as-a-service","coding-agents","database","developer-tools","micropayments","openclaw","postgresql","serverless","supabase-alternative","x402","topics",[101,102,103,104,105,106,107,108,132,109,133,110,134,112,113,114],"license","MIT","language","TypeScript","registryName","com.run402/mcp","homepage","https://run402.com","packages",[127],{"_128":129,"_130":131,"_76":77},"registryType","npm","identifier","run402-mcp","mcp","model-context-protocol","postgres","ENV",{"_137":138,"_139":140,"_141":142},"ENVIRONMENT","production","TURNSTILE_SITE_KEY","0x4AAAAAAB8-rEI2gNDf_QhU","SENTRY_DSN","https://45fd1229f78089d5c3ee78be128030e1@o4510583261757440.ingest.de.sentry.io/4510584253448272"]