foldrun 26.0.0 → 26.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/docs/api.md CHANGED
@@ -225,7 +225,7 @@ paying for the steps around it.
225
225
  | Route | Methods | |
226
226
  |---|---|---|
227
227
  | `/api/workspaces/<ws>/runs?limit=&before=` | GET | `{ runs: [{ id, flow, status, verdict, outcome, startedAt, finishedAt, ... }], next }`, newest first; `next` is the cursor for the page after (`<startedAt>~<runId>`, null on the last page) — pass it back as `before`, which also takes a time (runs that started before it) or a run id of the workspace (runs older than it); a position, not an offset, so runs starting meanwhile shift nothing and one cursor pages every workspace (`foldrun runs --before`, `--page`, `--all`); a `before` that is none of these is a `400`; search (see [Runs](runs#searching-runs)) with `tool` (a step called a tool whose name contains it), `tool_error=1`, `agent`, `model` (contains), `min_tokens` (`50k`), `min_secs`, `customer` (one end customer's runs, exactly), `context` (one [conversation](runs#conversations)'s runs, its id exactly; each run in it carries `context: { id, key, a2a? }`) — `limit` counts the matches — `verdict` is the word the summary leads with (`GOOD`, `QUIET`, `BLOCKED`, `BAD` or null) and `outcome` the one word every page shows (`running`, `queued`, `waiting`, `good`, `done`, `quiet`, `blocked`, `bad`, `failed`, `stopped`); `failure` is why a run failed (null otherwise) — `{ agent, reason, class, kind, message, fix }` and, for a limit, `used`, `allowed`, `unit` and `scope`, for a refused site `host` (see [Runs](runs#why-it-failed)), `chargedUsd` is what the account was charged for the run (one credit is one cent), null until the ledger settles it, while `costUsd` is the provider's token cost — off the run index (see [Runs](runs#the-runs-list)); a finished run's steps carry `agent`, `status`, `costUsd` and `tokens` (`{ input, output, cacheRead, cacheWrite }`, see [Runs](runs#the-record)), and the run its summed `tokens` — not their reply or trace |
228
- | `/api/workspaces/<ws>/runs/<id>/calls/<call>` | GET | one tool call's recorded content (see [Runs](runs#what-a-run-records)): `{ call: { id, tool, input, output, inputChars, outputChars, truncated, inputCut, outputCut } }` — what it was given and what it gave back, secrets masked, each at most 65,536 characters; `inputChars`/`outputChars` are the whole length, `inputCut`/`outputCut` say which part was cut (`truncated`: either). `<call>` is the tool event's `call`; an event with `captured: true` has content here. 404 when nothing was recorded: the workspace says `capture: metadata`, or the run is from before 19 Oct 2026. 502 when it was recorded but cannot be read now (the object store or the database is unavailable) — never an empty answer. A run's steps also carry `calls`, each model call (`n`, `at`, `ms`, `model`, `stop`, `tokens`, `tools`, and `subagent` / `attempt` when a sub-agent or a later attempt made it); a step that handed jobs to `sandbox: own` sub-agents carries `delegations` (`id`, `agent`, `status`, `costUsd`, `ms`), and each job is a step of its own with `subagentOf` (the delegating agent), `delegation` (that `id`) and `wrote` (the workspace paths it changed — copied into the delegating step's sandbox too, up to 4 MiB a job); and the run its `revision` (the workspace's latest revision when a worker picked it up — a deploy's commit, or the id an edit through `/source` was saved as) and `drivenAt` (when that was) |
228
+ | `/api/workspaces/<ws>/runs/<id>/calls/<call>` | GET | one tool call's recorded content (see [Runs](runs#what-a-run-records)); needs `workspace:write` (an editor or above — a viewer sees the run but not what its tools were given and returned): `{ call: { id, tool, input, output, inputChars, outputChars, truncated, inputCut, outputCut } }` — what it was given and what it gave back, secrets masked, each at most 65,536 characters; `inputChars`/`outputChars` are the whole length, `inputCut`/`outputCut` say which part was cut (`truncated`: either). `<call>` is the tool event's `call`; an event with `captured: true` has content here. 404 when nothing was recorded: the workspace says `capture: metadata`, or the run is from before 19 Oct 2026. 502 when it was recorded but cannot be read now (the object store or the database is unavailable) — never an empty answer. A run's steps also carry `calls`, each model call (`n`, `at`, `ms`, `model`, `stop`, `tokens`, `tools`, and `subagent` / `attempt` when a sub-agent or a later attempt made it); a step that handed jobs to `sandbox: own` sub-agents carries `delegations` (`id`, `agent`, `status`, `costUsd`, `ms`), and each job is a step of its own with `subagentOf` (the delegating agent), `delegation` (that `id`) and `wrote` (the workspace paths it changed — copied into the delegating step's sandbox too, up to 4 MiB a job); and the run its `revision` (the workspace's latest revision when a worker picked it up — a deploy's commit, or the id an edit through `/source` was saved as) and `drivenAt` (when that was) |
229
229
  | `/api/workspaces/<ws>/runs/<id>/trace` | GET | the run as one tree (see [Runs](runs#the-trace-tree)): `{ tree, failure }`. Each span is `{ id, kind, label, start, end, status, children, … }`, where `kind` is `run`, `step`, `model` (one model call: `model`, `stop`, `tokens`), `tool` (`call`, `captured` when its input and output were recorded) or `error` (`text`); `start`/`end` are epoch milliseconds and `status` is `ok`, `error`, `running`, `waiting`, `skipped` or `pending`. A tool call sits under the model call that asked for it. `failure` is the ids from the root to the first thing that went wrong, which the run page opens on; `[]` when nothing did |
230
230
  | `/api/workspaces/<ws>/runs/<id>/compare?with=` | GET | this run beside another of the same flow (see [Runs](runs#compare-with-the-last-good-run)): `{ comparison: { base, run, revisionChanged, changedFiles, steps }, chosen }`. Each step is `{ step, agent, base, run, changes }`: both sides' status, instruction, model, seconds, tokens, model calls, tool counts, tool errors, first errors and first line said, and `changes` in words (`status: completed → failed`, `new error: …`, `instruction changed`, `tools: +web ×3`, `took 12s → 48s`, …). `changedFiles` lists the files changed between the revisions the two ran (null when one is unknown). `with` names the other run; unasked it is the newest earlier run of the flow that finished well, else the run this one re-ran (`chosen` says which) |
231
231
  | `/api/workspaces/<ws>/runs/<id>` | GET, DELETE | the whole run: every step, its output, cost, timing, its money — `chargedUsd` (what the account was charged, the ledger's line; `null` until the run settles: the worker settles it as it ends, and an hourly pass retries one that failed to), `estimatedUsd` (its list price, the figure until then) and `settled` — `failure` (why it failed, the same object the runs list gives — see [Runs](runs#why-it-failed); null when it did not), the runner `image` it ran on and — for a step that browsed through the account's pod from slim — its `browserPod` reconnects and fallback ([runs](runs#the-record)). `?wait=true&timeout=<s>` instead blocks until the run stops (or `timeout`, default 300, max 900) and answers the verdict the run routes give — `200` once the run has ended, however it ended: `ok: true` when it completed, `ok: false` with its `status` and `failure` when it failed or was stopped (a run that fails is the answer, not a fault in the call — it was a `500` before 29 Oct 2026); `202` still going (`timedOut`) or parked on a person (`awaitingApproval`). A start refused before any run exists — a paused account or workspace (`423`), an agent or flow that is not there (`404`), `overlap: skip` (`409`) — is answered as such and waits for nothing. Ask in short pieces: whatever sits in front of the platform cuts a request that stays silent too long (Cloudflare at 100 s, an AWS ALB at 60 s), and a flow can run for many minutes — the CLI's `--wait` asks 25 s at a time and comes back here on every `202`. DELETE erases the run's record and archived outputs (a run still going is stopped first; the ledger line stays) and needs `workspace:manage` — an admin — since 30 Oct 2026 (it was `run:start`) |
@@ -419,7 +419,8 @@ Reads return which secrets exist, never their values.
419
419
  | `/api/account/backups` | GET | what is backed up for this account: `policy` (`schedule`, `keepLocal`, `keepOffsiteDays`, `encrypted`, `covers`, `excludes`), `last`, `backups` (each nightly archive that holds this account, newest first: `id`, `at`, `bytes`, `files`, `runs` (always null: they measured the whole archive, which holds every account on the server, so they are not shown to one — 30 Oct 2026), `sha256` (the archive inside the encryption — what a decrypt must reproduce), `kinds` — files, database, keys — `verified`, `offsite`, `keepDays`, `encrypted` (sealed with age before it left the server; false for archives taken before October 2026), `recipient` (the key's fingerprint, `sha256:<16 hex>`, or null)), `requests` (earlier restore requests) and `workspaces` (`name`, `head`, `history`, `lastChange`) — what a restore can reach. See [Backups and restore](backups-and-restore.md) |
420
420
  | `/api/account/backups/requests` | GET, POST | ask the platform team to restore what an account cannot restore itself. POST `{ what, target, workspace?, backupId?, note? }` (`what` is runs, state, storage or everything) records the request, mails the operator and audits it as `backup.restore_requested`; answers 201 `{ ok, request }` with `notified` saying whether the mail went. Restores nothing. `workspace:manage`, and a member scoped to some workspaces must name one. GET lists this account's requests |
421
421
  | `/api/account/api` | GET, PATCH | how this account meets the API — GET `{ version: { current, pinned, effective, supported, supportMonths }, limits: { plan, windowSeconds, perCredential: { read, write }, perAccount: { read, write } }, usage }`. `usage` is the last 30 days — `{ days, versions: [{ version, requests, lastSeen }], deprecated: [{ route, requests, lastSeen, deprecatedAt, sunsetAt, link, callers: [{ credential, requests, lastSeen }] }] }`, `credential` naming a key by its label and prefix — or `null` when it could not be read. A caller scoped to some workspaces gets `usage: null` and `usageHidden: true`: who calls which route is the whole account's; PATCH `{ version: "YYYY-MM-DD" \| null }` pins the version API-key requests without a `Foldrun-Version` header get (null: always current); the dashboard always gets current. `keys:manage`; PATCH also needs every workspace (403 to a member or key scoped to some), since the pin is every key's. See [api-usage](api-usage.md) |
422
- | `/api/account/flags` | GET | the feature flags as they stand for this account — `{ flags: [{ name, description, owner, default, on, source, rollout }] }`, `source` being what decided it: `account` (an override for this account), `global` (the install-wide setting), `rollout` (a percentage of accounts, by a stable hash of account and flag; `rollout` is the percentage) or `default`. Read-only, every role; only the platform's operator changes a flag (a self-hosted install runs every flag at its default). See [Feature flags](feature-flags.md) |
422
+ | `/api/account/beta` | GET PUT | the account's beta: `GET` → `{ beta, flags: [{ name, description, on, source }] }` (the beta flags as they stand for it); `PUT { beta: true \| false }` joins or leaves it (an admin of every workspace; `403` for a key or person given only some) and answers the same plus `changed`. Audited as `account.beta_joined` / `account.beta_left`. See [Beta features](feature-flags#beta-features) |
423
+ | `/api/account/flags` | GET | the feature flags as they stand for this account — `{ flags: [{ name, description, owner, default, beta, on, source, rollout }] }`, `source` being what decided it: `account` (an override for this account), `global` (the install-wide setting), `beta` (a flag marked beta, the account being in the beta), `rollout` (a percentage of accounts, by a stable hash of account and flag; `rollout` is the percentage) or `default`. Read-only, every role; only the platform's operator changes a flag (a self-hosted install runs every flag at its default). See [Feature flags](feature-flags.md) |
423
424
  | `/api/openapi.json` | GET | this API as an OpenAPI 3.1 document — every route and method, bearer auth, the rate-limit, version and Idempotency-Key headers, and request/response schemas for runs, flow runs, deploy, source, secrets, keys and billing. No key needed. Generated from the route files by `scripts/gen-openapi.mjs`; the dashboard renders it at Docs → API reference, `foldrun api spec` saves it |
424
425
  | `/api/account` | GET, PATCH | the account's defaults from its AGENTS.md frontmatter — `timezone`, `budget` (a USD cap — a number for a month, `"60/day"`, `"60/week"`, or `{ usd, period }`; null is no limit), `notify` (`{ url?, email?, events }`), `concurrency`, `compute` (`{ vcpu, memGiB, diskGiB }` — the account's own cap on what its running steps hold together, lower than the plan's; PATCH writes it as `compute: { vcpu, memory, disk }`, merged over what is set: a figure not sent is kept, `null` drops one, `compute: null` drops all), `deploy_block` (`none`, `secrets` or `security` — answered as `deployBlock`), `network_enforce` (answered as `networkEnforce`), `owner`, `alerts` (as written), `judge` (`{ model?, effort? }`), `telemetry` (`{ otlp, headers }` — header values are `${SECRET}` names; answered as `{ endpoint, headers }`); PATCH sets the keys sent, null clears one, and edits the file in place. To a caller scoped to some workspaces GET says these are set, never where they go: `notify` loses its `url` and carries `hidden: true` when one is set, and `telemetry` is `{ endpoint: "", headers: {}, hidden: true }`. PATCH needs every workspace |
425
426
  | `/api/customers` | GET, PATCH | your own users' limits and block list ([end customers](runs#end-customers)): GET `{ limits: { startsPerMinute, maxOpenRuns, gatewayRpm, gatewayConcurrency, dailyModelUsd }, defaults, blocked: [{ customer, by, reason, at }] }` — anyone in the account; PATCH changes the limits (whole numbers 1–100,000; `dailyModelUsd` dollars a day, kept to the cent; `null` puts one back to the default) — an admin over every workspace (`403` otherwise), audited as `customer.limits` |
@@ -474,11 +475,12 @@ person: a key names an account, never a who.
474
475
  | `/api/billing/stripe` | POST | Stripe's webhook — signature-verified, not for you. Every delivery is logged. Beside top-ups it turns plan cycles: one grant per (subscription, plan, period), whichever of the checkout, `invoice.paid` (either invoice shape) or `customer.subscription.updated` arrives first; `invoice.payment_failed` marks the plan past due and starts dunning (an email, a grace period, then new runs paused — see budgets-and-billing.md), `invoice.paid` and `invoice.voided` end it, `customer.subscription.deleted` ends the plan that subscription paid for — what is left of the bundle expires, the levers come off, money the customer added stays. `charge.refunded` debits a refunded top-up (never a plan fee), `charge.dispute.created` debits a chargeback and `charge.dispute.closed` returns it when won. Answers 500 — so Stripe redelivers — only when a lookup the event needs failed. The full event list is in budgets-and-billing.md |
475
476
  | `/api/billing/partner/topups/rate` | GET | foldrun.ir only, HMAC-signed (see [Paying in Toman](budgets-and-billing#paying-in-toman-foldrunir)) — the Toman rate it sells at: `{ tomanPerUsd, setAt, min, max }`; `503` while no rate is set or it has gone stale |
476
477
  | `/api/billing/partner/topups/quote` | POST | foldrun.ir only — `{ account, usd }` (account: a sign-in email or the account id) → `{ account: { label }, usd, toman, rial, tomanPerUsd, setAt }`. Nothing written; `label` is masked (`o•••r@a•••e.co · ac••`). `404` no such account, `400` an amount outside $5–$500 or over the gateway's 100,000,000 Toman |
477
- | `/api/billing/partner/topups` | POST | foldrun.ir only — `{ account, usd, toman }` opens an order with the Toman figure locked for 30 minutes: `201 { order: { id, label, usd, toman, rial, tomanPerUsd, status, authority, refId, expiresAt, creditedAt } }`. `409 { error, quote }` when the rate moved since the customer saw `toman`; `429` past the daily ceiling (`billing.ir_daily_usd`, counting open, paid and failed orders) |
478
+ | `/api/billing/partner/topups` | GET, POST | foldrun.ir only. POST: `{ account, usd, toman, plan? }` opens an order with the Toman figure locked for 30 minutes: `201 { order: { id, label, usd, toman, rial, tomanPerUsd, status, authority, refId, plan, planStatus, expiresAt, creditedAt } }`. `plan` is `{ plan: "pro" \| "max", newOnly?, maxUsd? }`, the coding plan the payment is for, kept with the order and started when it is paid. `409 { error, quote }` when the rate moved since the customer saw `toman`; `429` past the daily ceiling (`billing.ir_daily_usd`, counting open, paid and failed orders). GET `?status=pending\|failed&olderThanMinutes=10&limit=50`: `{ orders: [{ id, authority, usd, toman, rial, status, plan, createdAt, expiresAt }] }`, the storefront's own orders that have a gateway session and no credit yet, made less than a day ago, oldest first. The storefront verifies each at the gateway and sends the paid ones to `/paid` |
478
479
  | `/api/billing/partner/topups/<id>` | GET | foldrun.ir only — one of its orders; `status` pending, credited or failed |
479
480
  | `/api/billing/partner/topups/<id>/authority` | POST | foldrun.ir only — `{ authority }`, the Zarinpal session the customer is sent to. Once per order (`409` for another; a retry is a new order) |
480
- | `/api/billing/partner/topups/<id>/paid` | POST | foldrun.ir only, after Zarinpal verified the payment — `{ authority, refId, cardPan?, fee? }` credits the ORDER's dollars (never a figure in the request) as a top-up noted `zarinpal:<refId> order:<id>`, once per authority: `{ order, credited }`, credited false on a repeat. A failed or expired order is still credited — the money arrived — up to a day after it was made; later is `409` and the platform team credits it by hand |
481
+ | `/api/billing/partner/topups/<id>/paid` | POST | foldrun.ir only, after Zarinpal verified the payment — `{ authority, refId, cardPan?, fee? }` credits the ORDER's dollars (never a figure in the request) as a top-up noted `zarinpal:<refId> order:<id>`, once per authority: `{ order, credited }`, credited false on a repeat. An order made with a `plan` also starts that plan here: the answer's `order.planStatus` is `active`, or `failed` when it could not start (the payment is credited either way). A failed or expired order is still credited — the money arrived — up to a day after it was made; later is `409` and the platform team credits it by hand |
481
482
  | `/api/billing/partner/topups/<id>/failed` | POST | foldrun.ir only — `{ reason }`: the customer cancelled or the gateway refused. A credited order stays credited |
483
+ | `/api/billing/partner/signups` | POST | foldrun.ir only — `{ email, ip? }` for a customer with no account: this platform mails `email` a sign-up link (`/signup?link=…`, seven days) and answers `202 { status: "sent" }`; an address that already has a login answers `200 { status: "exists" }` and nothing is mailed. The account is opened on this platform's own sign-up page, verified from the start, and the person is sent back to the storefront's charge page with the address filled in (`billing.ir_site_url`, else https://foldrun.ir). Limited per address (3 an hour), per customer address `ip` (5 an hour) and per storefront (200 an hour): `429` with `Retry-After` |
482
484
 
483
485
  ## Versions
484
486
 
@@ -486,7 +488,7 @@ What a platform runs, and what changed. See [Versions and releases](versions).
486
488
 
487
489
  | Route | Methods | |
488
490
  |---|---|---|
489
- | `/api/version` | GET | open, no key. `{ version, released_at, build, api, components: { core, platform, web, docs, infra, cli }, packages: { core, cli }, browsers, browser_versions }` — `version` is `vYYYY.MM.DD.N` (`dev` on an install the deploy did not build); `components` are short commit shas (`cli` is the CLI commit released alongside); `packages.cli` is that CLI's npm version; `api` is the API contract's date version; `browsers` is the engines the runner image was built with (its `/opt/browser/engines.json`, read by the deploy — see [Engines](tools#engines)), `null` when the deploy did not say; `browser_versions` is their versions where the manifest has a dotted one (`{ chromium: "153.0.8010.12", chrome: "154.0.8037.58", lightpanda: "0.4.1" }`), which `foldrun check` compares with a pinned `user_agent`, `null` when none. `Cache-Control: no-store` |
491
+ | `/api/version` | GET | open, but only the name is open: without a key, a session or the scraper's token (`FOLDRUN_METRICS_TOKEN`) it answers `{ version, api }` and nothing else. With one of them — a key of any role — `{ version, released_at, build, api, components: { core, platform, web, docs, infra, cli }, packages: { core, cli }, browsers, browser_versions }` (the same fields as before). `version` is `vYYYY.MM.DD.N` (`dev` on an install the deploy did not build); `components` are short commit shas (`cli` is the CLI commit released alongside); `packages.cli` is that CLI's npm version; `api` is the API contract's date version; `browsers` is the engines the runner image was built with (its `/opt/browser/engines.json`, read by the deploy — see [Engines](tools#engines)), `null` when the deploy did not say; `browser_versions` is their versions where the manifest has a dotted one (`{ chromium: "153.0.8010.12", chrome: "154.0.8037.58", lightpanda: "0.4.1" }`), which `foldrun check` compares with a pinned `user_agent`, `null` when none. `Cache-Control: no-store` |
490
492
  | `/api/changelog?limit=` | GET | `{ version, api, releases: [{ version, released_at, previous, components, notes }] }`. `api` is the API's own changelog: `{ current, supportMonths, versions: [{ version, changes }], deprecations: [{ route, deprecatedAt, sunsetAt, link }] }` — every version a caller may pin, newest first, with the breaking changes it introduced, and the routes on their way out. `releases` newest first — 10 by default, at most 50. `notes` is `{ features, fixes, docs, other }`, each a list of `{ repo, sha, subject }` grouped from commit subjects, or `null` when the deploy could not read what changed. Needs a key or a session |
491
493
 
492
494
  Every `/api` response carries the version in its headers, refusals included,
@@ -502,7 +504,7 @@ X-Foldrun-Cli: 0.6.0 # the CLI released with this version (absent
502
504
 
503
505
  | Route | Methods | |
504
506
  |---|---|---|
505
- | `/api/auth/signup` | POST | `email`, `password`, `account`, `invite`, `setup`. An install with `FOLDRUN_SETUP_TOKEN` set creates its first account only with `setup` equal to it (403 otherwise); once an account exists the token does nothing. Without an invite, a new account comes in by the first-account exception or free sign-up (`signup.open`) — decided again inside the write, so two first sign-ups at once make one owner; an invite needs no switch. A body with `plan` is refused (400): paid sign-up is not offered by this route yet. Rate limited per address and per caller. With signups closed every address gets the same refusal, so the form cannot be used to discover which addresses are registered |
507
+ | `/api/auth/signup` | POST | `email`, `password`, `account`, `invite`, `setup`, `link`. A `link` is a sign-up link the platform mailed (today: for a foldrun.ir customer, `POST /api/billing/partner/signups`): it opens a new account for the one address it was sent to even while sign-up is closed, verified from the start and with no trial credit, and the answer carries `next`, where the person goes after (`400` for a link that is expired or for another address, `409` once that address has an account). An install with `FOLDRUN_SETUP_TOKEN` set creates its first account only with `setup` equal to it (403 otherwise); once an account exists the token does nothing. Without an invite, a new account comes in by the first-account exception or free sign-up (`signup.open`) — decided again inside the write, so two first sign-ups at once make one owner; an invite needs no switch. A body with `plan` is refused (400): paid sign-up is not offered by this route yet. Rate limited per address and per caller. With signups closed every address gets the same refusal, so the form cannot be used to discover which addresses are registered |
506
508
  | `/api/auth/login` | POST | `email`, `password`. Wrong passwords are limited per account: 8 a quarter hour from one caller when a trusted proxy names the caller (`FOLDRUN_TRUST_PROXY`), so a stranger failing as someone locks out only themselves, and 40 from every caller together, reaching which mails the person; with no caller address, 8 per account from anyone. A 429 carries `Retry-After` |
507
509
  | `/api/auth/logout` | POST | ends the session |
508
510
  | `/api/auth/session` | GET | who am I |
@@ -237,9 +237,16 @@ account rather than bought.
237
237
  together, counted by the cores, memory and disk each step's sandbox is
238
238
  capped at (disk is what a step may write: its `size:` class's — 2, 8 or 20
239
239
  GiB — or its own `resources: { disk }`). **One step, at most** is the largest
240
- single step the plan runs: `heavy` (4 vCPU · 8 GiB · 20 GiB disk) on every
241
- plan, and up to 8 vCPU · 16 GiB · 40 GiB disk with `resources:` on Pro and
242
- Scale.
240
+ single step the plan runs: `heavy` (4 vCPU · 8 GiB · 20 GiB disk) on Starter,
241
+ and up to 8 vCPU · 16 GiB · 40 GiB disk with `resources:` on Pro and Scale.
242
+ A step asking for more than its plan's figure fails at once, before it
243
+ starts.
244
+
245
+ **Free's limits hold on every account with no paid plan.** Its steps may
246
+ hold 2 vCPU · 4 GiB · 10 GiB disk each and 2 vCPU · 4 GiB between them. A
247
+ step at the default size on foldrun.io (3 vCPU · 6 GiB) is bigger than
248
+ that, so on Free give each agent `size: small` (or `resources:` within the
249
+ figures); a paid plan runs the default size.
243
250
 
244
251
  **Two kinds of credit, kept apart.** One balance, two pots:
245
252
 
@@ -254,11 +261,11 @@ account that wants them buys credits. The Usage page and
254
261
  `GET /api/usage` show the two pots separately.
255
262
 
256
263
  **Free: 300 credits every month.** Free credits are plan credits, so they
257
- never pay for tokens on foldrun's models. They **do not roll over**: what is
258
- unused is lost at the end of the month (UTC), so an account cannot stockpile
259
- them. The grant for a new month is made when the account has run something
260
- since the last one, and an account gets it once a month however it is
261
- opened or closed.
264
+ never pay for tokens on foldrun's models. They **do not roll over**: a month after
265
+ the last grant, what is unused is lost and a new 300 land, so an account
266
+ cannot stockpile them. A month the account did not use renews the same way,
267
+ and an account that was idle for months gets one new month, not the ones it
268
+ missed. An account whose paid plan ends goes back to Free's month.
262
269
 
263
270
  **How long a credit lasts.** On a paid plan, credits land when the invoice is
264
271
  paid, and what is unused **rolls over** into the next cycle up to **twice** the
@@ -572,6 +579,16 @@ account filled in, wherever foldrun.ir is selling.
572
579
  within a day of the order; later than that the platform team credits it
573
580
  by hand (Zarinpal returns a payment nobody verified within 72 hours).
574
581
 
582
+ No account yet? When the address typed has no foldrun account, foldrun.ir
583
+ offers to make one: foldrun (not foldrun.ir) mails that address a sign-up
584
+ link. Opening it shows foldrun's own sign-up page with the address filled in
585
+ — choose an account name and a password — and the account starts with the
586
+ address already confirmed. It works even while sign-up is otherwise closed,
587
+ for that one address, for seven days. Then foldrun sends the person back to
588
+ foldrun.ir's charge page with the address filled in, to pay. foldrun.ir never
589
+ sees the password or a session: signing in, API keys and everything else
590
+ happen here.
591
+
575
592
  The credit is bought credit like any other: it expires 12 months after
576
593
  purchase if unused. The platform operator sets, in the console's Settings
577
594
  under Billing:
package/docs/cli.md CHANGED
@@ -168,7 +168,7 @@ claude.ai or Claude Code there, nor any MCP configuration on disk.
168
168
  | `foldrun api spec` | the platform's OpenAPI 3.1 document, from `GET /api/openapi.json` (no key needed) — to stdout, or `--out <file>`. Every other command sends `Foldrun-Version` (the API version this CLI was built for), an `Idempotency-Key` on each write (reused on its own retry), and waits out one `429` for `Retry-After` before saying so. See [Using the API](api-usage) |
169
169
  | `foldrun api version` | Settings → API keys → API: the API version this account's requests get when they send no `Foldrun-Version`, whether it is pinned, every version still served, the rate limits, and the last 30 days: requests by version, and any deprecated route the account still calls — by which key or person, and when it stops answering. `api version pin <YYYY-MM-DD>` pins it, `unpin` goes back to current (`PATCH /api/account/api`; an admin's) |
170
170
  | `foldrun changelog` | What's new: first the API — its current version, the breaking changes each dated version brought, and the routes deprecated with their sunset dates — then the platform's release notes, newest first — features, fixes, docs — and which release this install runs (`GET /api/changelog`; `--limit <n>` up to 50, `--json`) |
171
- | `foldrun version` | this CLI's version, its `@foldrun/core`'s, and — when a platform is known (`--url`, `--profile`, `FOLDRUN_URL` or where you signed in) — that platform's: version, release time, API version, each component's commit and the browsers its runner image has (with versions where known: `chrome 154.0.8037.58`), from `GET /api/version` (no key needed). Warns when the platform was released with a newer CLI than this one. An unreachable platform is a dim line, not a failure. `--json` prints `{ cli, core, platform }`. `foldrun --version` (or `-v`) prints only the CLI's version, offline. See [Versions and releases](versions) |
171
+ | `foldrun version` | this CLI's version, its `@foldrun/core`'s, and — when a platform is known (`--url`, `--profile`, `FOLDRUN_URL` or where you signed in) — that platform's: version, release time, API version, each component's commit and the browsers its runner image has (with versions where known: `chrome 154.0.8037.58`), from `GET /api/version` (sent with your key; signed out, a platform names only its version and API date). Warns when the platform was released with a newer CLI than this one. An unreachable platform is a dim line, not a failure. `--json` prints `{ cli, core, platform }`. `foldrun --version` (or `-v`) prints only the CLI's version, offline. See [Versions and releases](versions) |
172
172
  | `foldrun doctor` | check the road to the platform, one line each: Node (22 or newer), the CLI and core versions, which of `FOLDRUN_URL`, `FOLDRUN_TOKEN`, `FOLDRUN_TIMEOUT`, `HTTPS_PROXY` are set (never their values), which model credential a local run would use (by its variable, never its value), the account it would act as, DNS for the platform's host, and a timed `GET /api/healthz`. The first thing to run when a command cannot reach the platform |
173
173
  | `foldrun storage <verb>` | what a workspace PRODUCED, as opposed to what you wrote — `source` is the other half. `ls [prefix]` lists every file with its size, when it was written, how long ago and which run wrote it (`run:<id>`, `user:<email>` for an upload, `api-key` for a key), newest first, plus what the store holds against its quota. `cat <path>` prints a text file and refuses one that is not text; `cat <path> --preview` asks the platform to read it instead and prints what is in it — a PDF or Word document as paragraphs, a spreadsheet or CSV as a table, a deck as slides, an archive as its listing. `get <path>` downloads it beside you — `--file <path>` names somewhere else, `--force` overwrites. `put <file|folder>...` uploads any files, of any type, into storage under their own names, walking folders whole (`.git`, `node_modules` and `.DS_Store` are skipped); `--into <folder/>` puts them under a folder, `--as <path>` renames a single file, and large files go straight to the bucket by a presigned URL, so size is not capped by the platform's request limit; `rm <path>` removes one. `share <path>` mints a public link to one produced file (7 days; `--ttl <days>`, `--forever`) and prints the URL; `shares` lists the live links (`--all` includes expired and revoked); `unshare <token|id>` revokes one — the link answers 404 from then on and the token is never reused. Only an admin, or the person who made a link, sees its token; anyone else sees the link with its token masked and an id (`sh_…`) to unshare it by. `--to <workspace>` from anywhere; inside a workspace folder it is already known. `ls --all` lists every workspace's storage, as the account's Storage page: a block per workspace with its files, size and quota, the busiest first, then the empty ones by name (`[prefix]` narrows each; `--json` is `{ workspaces: [...] }`, one storage document per workspace; a workspace that could not be read is a non-zero exit) |
174
174
  | `foldrun storage text <path>` | a file already in a workspace's storage, as text: `POST /api/workspaces/<ws>/storage/extract` with `{ path, lang, ocr, engine, wait, write }`. Prints the text, and the platform writes it beside the file as `<path>.txt` (`wrote <path>.txt` on stderr) unless `--no-write`. The same `--lang`, `--ocr`, `--engine`, `--wait` and `--json` as `foldrun text`, and the same polling when it answers 202. `--to <workspace>` or `--workspace <name>` from anywhere; inside a workspace folder it is already known |
@@ -194,7 +194,7 @@ claude.ai or Claude Code there, nor any MCP configuration on disk.
194
194
  | `foldrun gallery` | the tools (`web`, `docs`, `video`) and skills (`modern-website`, `motion-video`) the platform ships to every account, by shelf, and for each whether this account keeps its own copy and whether that copy still matches; `--json` for a script. `pull` lays the shelf down under `~/.foldrun/gallery/<host>/` for offline runs (`foldrun run` and `foldrun eval` refresh it themselves before each run); `upgrade <name>` replaces the account's copy of a tool or skill with the current gallery version, the old one a revision back. `foldrun check` knows the gallery's names, so a signed-out check warns rather than calling them missing |
195
195
  | `foldrun identity` | keyless cloud identity: the issuer your cloud must trust and the subject each agent's tokens carry (`GET /api/identity`); `--to <workspace>` fills the workspace in, `--json` |
196
196
  | `foldrun jobs` | the four jobs — governance, guardrail, observability, evaluation — and every `AGENTS.md` field of each, with what is set (`GET /api/account/jobs`). `--to <workspace>` shows the workspace's value beside the account's and how the two combine; `--json` the document. `account set <job>.<field>` and `workspace set <job>.<field>` refuse a field that scope cannot set and name the `AGENTS.md` to write it in. See [The four jobs](four-jobs) |
197
- | `foldrun account` | the account's own defaults — the AGENTS.md frontmatter every workspace under it inherits: `timezone`, `notify`, `budget`, `concurrency`, `deploy_block`, `network_enforce`. `foldrun account set timezone Australia/Sydney`, `set notify email you@example.com` (`--events failed,awaiting-approval,completed`), `set notify url https://…`, `set budget 60/month`, `set concurrency 4`, `set compute vcpu 4 memory 8 disk 40` (GiB; any of them, merged over what is set — the account's own pool, lower than the plan's), `set deploy_block secrets` (`none`, `secrets` or `security` — what the scanner's findings do to a deploy), `set network_enforce on` (every workspace refuses a site off an agent's `network:` list; `off` reports only), `set owner <email or name>`, `set alerts <threshold> <value>` (merged into what is set; `off` removes one), `set judge model|effort <value>`. Any setting may be named by its job — `set governance.deploy_block secrets`, `set observability.alerts stale_days 30` — and one named under the wrong job is refused with the right one, `pause` (`--reason "…"`, `--stop` to also stop every run going now — asks, or `--yes`) and `resume`: the kill switch, no new run starts in any workspace while paused, `telemetry` — where each finished run goes as an OpenTelemetry trace: bare shows it, `set <url> --header authorization='${OTEL_TOKEN}'` (repeatable; a value is a vault secret's name; the headers already set are kept, as the dashboard's card keeps them, and `--header name=` drops one), `clear`, `test` (one made-up run, and what the collector answered; exit 1 when not delivered), and `clear <key>` to unset one. `set notify` merges against what is there, because the platform replaces the whole block. `providers` lists the model providers the account's files use and the last daily key check — `--check` asks now, and a dead key is a non-zero exit. `model` is what every step runs on unless a `provider:` block names another — the account's own model key, or foldrun's models: `foldrun account model` shows it (never a key, only its last four; on foldrun's models, the provider, its tier map and today's spend against the daily cap; exit 1 when runs are refused — no key, or foldrun's models refused for the account), `model set <provider> --key <api key>` sets the key — a preset name (anthropic, openrouter, openai, groq, …) or `custom --base-url https://… --format anthropic|openai`, `--key -` reads the key from stdin, and in a terminal it (or no `--key`) asks for it hidden — a pasted key works, `--use` also runs on it from now on in the same request (as `model use own`, which the dashboard's Save does) — and `model remove` removes it (the choice stays); a Claude login token is refused for any account not allowed the platform's own credential. `model use foldrun --provider <anthropic|openai|gemini|deepseek|moonshot>` runs every step on foldrun's models — the platform's keys, billed in credits at foldrun's price list, hosted only; a provider the platform cannot serve now is refused — and `model use own` goes back to the account's own key, which is kept. `model prices` (`--provider <p>`, `--json`) lists foldrun's price list as the account pays it, USD per million tokens. `export` downloads everything the platform holds about the account — workspaces, runs, members and the whole ledger — as one JSON file (owner only; `--file <path>`, `--force`). Singular — `accounts` below is the list of logins on this machine |
197
+ | `foldrun account` | the account's own defaults — the AGENTS.md frontmatter every workspace under it inherits: `timezone`, `notify`, `budget`, `concurrency`, `deploy_block`, `network_enforce`. `foldrun account set timezone Australia/Sydney`, `set notify email you@example.com` (`--events failed,awaiting-approval,completed`), `set notify url https://…`, `set budget 60/month`, `set concurrency 4`, `set compute vcpu 4 memory 8 disk 40` (GiB; any of them, merged over what is set — the account's own pool, lower than the plan's), `set deploy_block secrets` (`none`, `secrets` or `security` — what the scanner's findings do to a deploy), `set network_enforce on` (every workspace refuses a site off an agent's `network:` list; `off` reports only), `set owner <email or name>`, `set alerts <threshold> <value>` (merged into what is set; `off` removes one), `set judge model|effort <value>`. Any setting may be named by its job — `set governance.deploy_block secrets`, `set observability.alerts stale_days 30` — and one named under the wrong job is refused with the right one, `pause` (`--reason "…"`, `--stop` to also stop every run going now — asks, or `--yes`) and `resume`: the kill switch, no new run starts in any workspace while paused, `telemetry` — where each finished run goes as an OpenTelemetry trace: bare shows it, `set <url> --header authorization='${OTEL_TOKEN}'` (repeatable; a value is a vault secret's name; the headers already set are kept, as the dashboard's card keeps them, and `--header name=` drops one), `clear`, `test` (one made-up run, and what the collector answered; exit 1 when not delivered), and `clear <key>` to unset one. `set notify` merges against what is there, because the platform replaces the whole block. `providers` lists the model providers the account's files use and the last daily key check — `--check` asks now, and a dead key is a non-zero exit. `model` is what every step runs on unless a `provider:` block names another — the account's own model key, or foldrun's models: `foldrun account model` shows it (never a key, only its last four; on foldrun's models, the provider, its tier map and today's spend against the daily cap; exit 1 when runs are refused — no key, or foldrun's models refused for the account), `model set <provider> --key <api key>` sets the key — a preset name (anthropic, openrouter, openai, groq, …) or `custom --base-url https://… --format anthropic|openai`, `--key -` reads the key from stdin, and in a terminal it (or no `--key`) asks for it hidden — a pasted key works, `--use` also runs on it from now on in the same request (as `model use own`, which the dashboard's Save does) — and `model remove` removes it (the choice stays); a Claude login token is refused for any account not allowed the platform's own credential. `model use foldrun --provider <anthropic|openai|gemini|deepseek|moonshot>` runs every step on foldrun's models — the platform's keys, billed in credits at foldrun's price list, hosted only; a provider the platform cannot serve now is refused — and `model use own` goes back to the account's own key, which is kept. `model prices` (`--provider <p>`, `--json`) lists foldrun's price list as the account pays it, USD per million tokens. `export` downloads everything the platform holds about the account — workspaces, runs, members and the whole ledger — as one JSON file (owner only; `--file <path>`, `--force`). `beta` shows whether the account gets beta features first, and the beta flags as they stand for it; `beta on` joins the beta, `beta off` leaves it (an admin of every workspace; `--json`). Singular — `accounts` below is the list of logins on this machine |
198
198
  | `foldrun account clear compute <vcpu\|memory\|disk>…` | drops just those figures of the account's own pool and keeps the rest (`{ compute: { diskGiB: null } }`, as the Governance card's emptied field); bare `clear compute` drops all three. `clear notify email` or `clear notify url` drops one channel and keeps the other and the events; the last channel goes with `clear notify`, which turns notify off |
199
199
  | `foldrun workspace` | one deployed workspace's own settings (`--to <workspace>`): description, timezone, budget and notify, read from its `AGENTS.md` — unset means the account's. `set timezone <tz>`, `set budget 20/week`, `set compute vcpu 2 memory 4 disk 20` (this workspace's own pool, inside the account's; any of them), `set notify email <address>` / `set notify url <https://…>` (`--events`; merged with what the file says), `set network_enforce on` (refuse a site off an agent's `network:` list here; `off` or `clear` goes back to the account's), `set owner`, `set alerts <threshold> <value>`, `set judge model|effort <value>`, and `<job>.<field>` as on `account`, `pause` (`--reason`, `--stop`) and `resume` — this workspace's kill switch, `set description "…"`, `set name <new>` — a rename changes every webhook URL, so it asks first and names the flows whose URLs changed — and `clear <key>`. Singular — `workspaces` is the list |
200
200
  | `foldrun workspace clear compute <vcpu\|memory\|disk>…` | the same for one workspace (`--to`): just those figures of its own pool, and `clear notify email\|url` for one channel of its own `notify:`, the other and the events kept |
@@ -4,10 +4,10 @@ Some changes ship dark: the code is deployed, and whether an account gets
4
4
  the new behaviour is a decision made afterwards, by the platform team, one
5
5
  account or a share of accounts at a time. That decision is a feature flag.
6
6
 
7
- An account cannot change its flags. It can see them: **Settings → Feature
8
- flags** in the dashboard, `foldrun flags` in a terminal, or
9
- `GET /api/account/flags`. Each flag says whether it is on for this account
10
- and why.
7
+ An account cannot change its flags — with one exception, the
8
+ [beta](#beta-features). It can see them: **Settings → Feature flags** in the
9
+ dashboard, `foldrun flags` in a terminal, or `GET /api/account/flags`. Each
10
+ flag says whether it is on for this account and why.
11
11
 
12
12
  ## What decides a flag
13
13
 
@@ -21,12 +21,35 @@ answer wins:
21
21
  |---|---|---|
22
22
  | 1 | `account` | this account's own override — on or off whatever else says |
23
23
  | 2 | `global` | the install-wide setting — on or off for every account without an override |
24
- | 3 | `rollout` | a percentage of accounts. Each account falls in a fixed bucket from 0 to 99, a hash of the account and the flag's names, so the same account gets the same answer on every server and every day, and raising the percentage only adds accounts — nobody who had it loses it |
25
- | 4 | `default` | what the code says when nothing else does |
24
+ | 3 | `beta` | a flag marked beta, for an account [in the beta](#beta-features): on |
25
+ | 4 | `rollout` | a percentage of accounts. Each account falls in a fixed bucket from 0 to 99, a hash of the account and the flag's names, so the same account gets the same answer on every server and every day, and raising the percentage only adds accounts — nobody who had it loses it |
26
+ | 5 | `default` | what the code says when nothing else does |
26
27
 
27
28
  A change is seen at once on the server that made it, and on every other
28
29
  within ten seconds.
29
30
 
31
+ ## Beta features
32
+
33
+ An account may take new features before they reach everyone: it joins the
34
+ **beta**. New work ships dark as a flag marked beta; it is on for every
35
+ account in the beta first, then for a rollout, then for everyone. The
36
+ features are finished, but may still change.
37
+
38
+ Joining or leaving is the account's own choice, made by an admin of every
39
+ workspace, and it can be undone at any time:
40
+
41
+ - the dashboard: **Settings → General → Beta features**;
42
+ - `foldrun account beta on` (or `off`; bare `foldrun account beta` shows where
43
+ it stands and the beta flags);
44
+ - `PUT /api/account/beta` with `{ "beta": true }` (or `false`); `GET` answers
45
+ `{ beta, flags }`.
46
+
47
+ Each change is on the account's audit log as `account.beta_joined` or
48
+ `account.beta_left`. The operator may also put an account in the beta or take
49
+ it out (the flag `beta-program`), and an override for the account or for
50
+ everyone still decides a beta flag first. `example-beta` is the registered
51
+ example: on for accounts in the beta, and read by nothing.
52
+
30
53
  ## The example
31
54
 
32
55
  `example-flag` is registered, off by default, and read by nothing: turning
package/docs/status.md CHANGED
@@ -20,7 +20,7 @@ that read the same record:
20
20
 
21
21
  | Component | Operational when | Measured from |
22
22
  |---|---|---|
23
- | Dashboard and API | the web tier answers and its database does | the request itself; the worker also fetches `/api/healthz` through the public address every five minutes |
23
+ | Dashboard and API | the web tier answers and its database does | the request itself; the worker also fetches `/api/healthz` through the public address every five minutes (it needs only the `200`; the database it asks itself) |
24
24
  | Run workers | a worker holds the lease and nothing queued has waited over ten minutes | the worker lease and the queue's oldest job |
25
25
  | Scheduler | it has ticked in the last fifteen minutes | the samples themselves — they are written from inside the scheduler's tick, so a stale sample *is* a stopped scheduler |
26
26
  | Model providers | `api.anthropic.com` answers, and fewer than two step attempts in the last hour failed with a provider error (overloaded, rate limited, a 5xx; a refused credential only when two accounts saw one — one account's own expired key is that account's) | a reachability check, and the run records |
package/docs/versions.md CHANGED
@@ -94,7 +94,7 @@ ALTER TABLE "api_keys" DROP COLUMN "label";
94
94
  | The sidebar's foot | `foldrun v2026.10.01.3`, linking to What's new |
95
95
  | **What's new** (`/dashboard/whats-new`) | every recent release, newest first, with what changed in each — grouped Features, Fixes, Docs and Other |
96
96
  | **Settings → About** | the version, when it was released, the API version, and each component's commit |
97
- | `GET /api/version` | the same as JSON, no key needed — see the [API reference](api#versions) |
97
+ | `GET /api/version` | the same as JSON; without a key it names only the version and the API date, the rest needs a key or a session — see the [API reference](api#versions) |
98
98
  | `GET /api/changelog` | the release notes as JSON, with a key |
99
99
  | Any `/api` response | the `X-Foldrun-Version`, `X-Foldrun-Api` and `X-Foldrun-Cli` headers |
100
100
  | `foldrun version` | this CLI, its core, and the platform it talks to |
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "foldrun",
3
- "version": "26.0.0",
3
+ "version": "26.1.0",
4
4
  "description": "Agents are just folders. Write them, check them, run them — on your machine.",
5
5
  "license": "FSL-1.1-ALv2",
6
6
  "type": "module",
package/src/commands.mjs CHANGED
@@ -7846,8 +7846,9 @@ async function accountCmd(positional, flags) {
7846
7846
  }
7847
7847
  if (verb === "model") return accountModelCmd(url, positional.slice(1), flags);
7848
7848
  if (verb === "export") return accountExportCmd(url, flags);
7849
+ if (verb === "beta") return accountBetaCmd(url, positional.slice(1), flags);
7849
7850
  if (verb !== "set" && verb !== "clear") {
7850
- throw new Error(`unknown account verb "${verb}" — \`foldrun account\` shows them, \`set\` and \`clear\` change one, \`model\` is the account's own model key, \`providers\` checks the model keys, \`export\` downloads everything, \`pause\`/\`resume\` the kill switch`);
7851
+ throw new Error(`unknown account verb "${verb}" — \`foldrun account\` shows them, \`set\` and \`clear\` change one, \`model\` is the account's own model key, \`providers\` checks the model keys, \`export\` downloads everything, \`pause\`/\`resume\` the kill switch, \`beta on|off\` beta features first`);
7851
7852
  }
7852
7853
 
7853
7854
  // `governance.deploy_block` names the job; checked, then sent as the field.
@@ -13165,6 +13166,7 @@ async function notificationsCmd(positional, flags) {
13165
13166
  const FLAG_SOURCES = {
13166
13167
  account: "set for this account",
13167
13168
  global: "set for every account",
13169
+ beta: "the beta",
13168
13170
  rollout: "staged rollout",
13169
13171
  default: "default",
13170
13172
  };
@@ -13178,6 +13180,36 @@ const FLAG_SOURCES = {
13178
13180
  * self-hosted install runs every flag at its default. So the CLI has no
13179
13181
  * verb for it.
13180
13182
  */
13183
+ /**
13184
+ * `foldrun account beta [on|off]` — the account's beta (13 Nov 2026): in it,
13185
+ * every flag marked beta is on for the account before its rollout reaches
13186
+ * everyone. Bare: where it stands and the beta flags. on/off: join or leave
13187
+ * (an admin of every workspace; GET/PUT /api/account/beta).
13188
+ * @param {string} url
13189
+ * @param {string[]} rest
13190
+ * @param {Record<string, any>} flags
13191
+ */
13192
+ async function accountBetaCmd(url, rest, flags) {
13193
+ const want = rest[0];
13194
+ if (want !== undefined && want !== "on" && want !== "off") throw new Error("`foldrun account beta` shows it, `foldrun account beta on` joins the beta, `foldrun account beta off` leaves it");
13195
+ const r = want === undefined
13196
+ ? await remoteCall(url, flags, "/api/account/beta")
13197
+ : await remoteCall(url, flags, "/api/account/beta", { method: "PUT", body: JSON.stringify({ beta: want === "on" }) });
13198
+ if (flags.json === true) {
13199
+ console.log(JSON.stringify(r, null, 2));
13200
+ return 0;
13201
+ }
13202
+ console.log(`\n beta features ${r.beta ? c.green("on — this account gets them first") : c.dim("off")}${want !== undefined && r.changed === false ? c.dim(" (unchanged)") : ""}`);
13203
+ const list = r.flags ?? [];
13204
+ if (list.length) {
13205
+ const w = Math.max(...list.map((f) => f.name.length));
13206
+ console.log("");
13207
+ for (const f of list) console.log(` ${pad(f.name, w)} ${f.on ? c.green("on ") : c.dim("off")} ${f.description}`);
13208
+ }
13209
+ console.log(`\n ${c.dim(r.beta ? "foldrun account beta off — leave it" : "foldrun account beta on — get new features before everyone")}\n`);
13210
+ return 0;
13211
+ }
13212
+
13181
13213
  async function flagsCmd(positional, flags) {
13182
13214
  const url = platformFor(flags, "flags");
13183
13215
  if (positional[0]) throw new Error("`foldrun flags` lists this account's feature flags — only the platform's operator changes them, not from here");