Toolaby

A plan buyers can buy: a Price on the workspace's Stripe account (on Test, its test account). "one_time" is a lifetime licence (by default on the tool's devices, sold per seat); "subscription" bills monthly or yearly (any devices, one person). Answers the plan's id (the first is "default") — what openPaymentPage(id) and data-toolaby-plan take — then say what it unlocks with toolaby_set_features. Two plans with one name are one tier. The answer says when the tool key changed: then `npx -y toolaby@latest upgrade <id>`.

Registers the developer's server to receive Toolaby's events on Test, and writes its signing secret into an env file as TOOLABY_WEBHOOK_SECRET, never shown. A server that mirrors buyers gets no event until its endpoint is registered: on Test, this is yours to do as part of the job, not a step to leave to the person; toolaby_remove_webhook undoes it. The url is the server's public address and the handler's path (a tunnel's while developing, like https://…trycloudflare.com/webhooks/toolaby).

Ends a buyer's subscription: at the end of the period they paid for (they keep access until then), or now. Nothing is refunded. By the buyer's address (when they have one running) or a subscription id from toolaby_get_customer.

Checks an extension folder's Toolaby wiring and answers findings with stable codes ({ code, level, message, file, line, fix, docs }); ok is false when any is an error. Run it before saying the work is done. `built`: a build folder (like ".output/chrome-mv3" or "dist") to check as the build. `browser`: also load the extension in Chromium and ask its background (downloads Playwright and Chromium once, about 180 MB). `as`: with browser, enter the test licence `toolaby_test_unlock` made for this plan and confirm its features unlock.

Copies a tool from Test to Live — its Free plan, features, plans (as prices on the Live Stripe account), extension identity and versions — and answers the Live tool key. Done again later, it updates what changed. Needs the command line signed in on both sides (`npx -y toolaby@latest login` and `login --live`) as the same person, and Stripe taking payments on Live for the plans: copied before, the plans stay on Test until it is copied again. The answer's dashboard is the tool's page on Live, which lists what is left. Then `npx -y toolaby@latest upgrade <id> --live` writes the Live key into the extension before the store build.

A secret API key for the developer's own server (Toolaby's REST API, Test), written into an env file as TOOLABY_API_KEY, with the API's base for this side as TOOLABY_API_URL, and never shown: the answer says where it went, not what it is. The file is created if missing; a TOOLABY_API_KEY line already there is replaced. Make sure the file is in .gitignore.

A coupon code buyers type on the checkout page, on the workspace's Stripe account (Test). The Chrome Web Store reviewer's way in: percentOff 100, maxRedemptions 1, a few days, and the code in the item's test instructions. percentOff or amountOff (with currency); once, for some months ("repeating" + months), or for ever on a subscription.

A new tool on Toolaby (Test): one more thing the workspace sells. Its Free plan holds everything until access is set. Then wire an extension to it: `npx -y toolaby@latest wire <id>` in an existing extension's folder, `npx -y toolaby@latest create <id>` for a new one.

Toolaby's docs as Markdown. Without a page: the index, every page with what it covers. With a page (like "gating", "pricing", "agents", "reference/client"): that page.

One buyer of the tool on Toolaby (Test): whether they hold it now and how (entitledVia, plan, features), their licences, subscriptions (status, renews, endsAt, trialEnd) and grants, each with the id refund, cancel and revoke take, and how many devices they use. Answers 404 when the address holds nothing of the tool.

One tool on Toolaby (Test). Read it before changing it. freePlan says what the Free plan holds (freePlan.holds, in a sentence); features are the keys gate({ feature }) takes; plans say what each unlocks (plans[].features), with the id openPaymentPage(id) and data-toolaby-plan take; toolKey is what toolaby.config.js must hold (else `npx -y toolaby@latest upgrade <id>`); extension.checkedInAt says whether a copy has checked in; sale says whether anything can be bought, as the dashboard says it (label, and fix: stripe or price); pages.buyer is the checkout page, pages.webScript the <script src> of toolaby-web.js for a website, pages.api the REST API's base on this side.

Access to the tool's paid features without paying, for an address: a friend, a beta tester, a refund made good. It applies once that person signs in to the extension with that address (a sign-in link by email). For a store reviewer, who cannot receive a sign-in link, make a coupon instead (toolaby_create_coupon). For a number of days, or until revoked; answers the grant id toolaby_revoke_grant takes. On Hobby a workspace holds 100 grants and other passes live at once.

The tool's customers on Toolaby (Test): everyone who holds or held it, with how (licence, subscription, trial, grant) and whether they are entitled now. `query` filters by an address or a name, in part.

Every tool in the developer's workspaces on Toolaby (Test), with the id the other tools take.

The events Toolaby sends a registered endpoint — purchases, subscriptions started and cancelled, refunds, disputes — each with a description and an example of what it carries, for the handler that reads them.

The endpoints registered on Test: id, address, the events each listens for, and whether it is paused.

Refunds a buyer's lifetime licence in full on their card and revokes it at once; Stripe keeps its fee and Toolaby keeps its own. By the buyer's address (when they have one paid licence) or a licence id from toolaby_get_customer. A subscription's payment is refunded in the Stripe Dashboard; end the subscription with toolaby_cancel_subscription.

Removes an endpoint: deliveries to it stop at once.

Takes a plan off sale: its Stripe price is archived and nobody can buy it any more. Everyone who bought it keeps what they bought.

Takes back access given without paying: the person loses it at their next check. The id comes from toolaby_grant's answer or toolaby_get_customer.

Searches Toolaby's docs. Call this before writing Toolaby code or answering how something works, even when you think you know: it gives the pages and sections that match, with the page name toolaby_docs reads.

Sends an event's example to every endpoint registered on Test that listens for it, as a real, signed delivery: the way to see a handler answer 2xx. 100 a day per workspace.

What a buyer gets before paying, on Test: "open" (the tool's use, unlimited), "free_uses" (a number of uses per device, or per account with signInRequired, counted by gate() without a feature: for good, or each day, week or month with freeUsesPer, counted by Toolaby in UTC), or "paid" (nothing before a plan). Whichever it is, a feature a plan sells (not marked free) is refused until bought. signInRequired asks for an account first. Takes effect on every device at its next check, with no release — so moving from "free_uses" to "open" would let copies already installed that gate with a bare gate() run everything free until they update: while copies are installed it is refused. Keep "free_uses": opening it is the person's step, once the build that gates by feature is live on the store — tell them, with the command the refusal names. The answer says when the tool key changed: then `npx -y toolaby@latest upgrade <id>`.

The tool's whole feature list — send the features it keeps too: one left out is archived, never deleted (off the checkout, still held by the plans that held it, still answered for code that asks; sent again, it is listed again) — and which plans unlock which. Add the plans first (toolaby_add_plan), then this. A feature's key is what the extension passes to gate({ feature }) and has(). A feature marked free is on the Free plan too; one not free that no plan unlocks is refused to everyone. Naming one plan of a tier (plans that share a name, like "Pro" monthly and yearly) sets the whole tier. The answer lists what each plan unlocks now.

Signs the command line and this server in to Toolaby (Test). Answers a link and a code for the person to approve in their browser — show them both — and keeps waiting in the background: once they approve, every other tool works. Already signed in: says who.

Whether a workspace sells through Stripe yet on Test, and where a person connects it. Connecting is Stripe's own onboarding (identity, bank, terms): only a person can do it, in a browser. On Test every workspace has a test account already.

Test only. A licence for one of the tool's plans, for the developer's own +toolaby-test address, with no payment: then toolaby_check with browser and as: <plan> enters it in the loaded extension and confirms the plan's features unlock. Proves the paid path with no person and no card. Each call makes a new one (a pass on Hobby).

A plan's name (its tier), free trial, devices or per seat. Only what is sent changes. The price never changes: a new price is a new plan (toolaby_add_plan), and the old one is retired (toolaby_retire_plan).

The tool's name, its line, its description, or its Chrome Web Store listing (the store link or the 32-letter id), on Test. Only what is sent changes. The store listing makes the store's copy one the tool key opens for: set it once the item exists.

The developer signed in to Toolaby (Test) and their workspaces, each with its role and the address its buyers use.