@lukoweb/apitogo 0.2.59 → 0.2.61

package/docs/cli/commands.md

@@ -62,7 +62,7 @@ Env: `APITOGO_API_KEY_ID`, `APITOGO_API_SECRET`. Optional: `APITOGO_API_URL`.
 ## Config version 2: add a service
 
 ```bash
-npx apitogo add gateway
+apitogo add gateway
 ```
 
 `add` puts one service (`portal`, `gateway`, `identity` or `plans`) into `apitogo.config.json`. In a
@@ -81,8 +81,8 @@ the flag to pass, and `--dry-run` shows the change without writing it.
 ## Config version 2: create the project, then deploy
 
 ```bash
-npx apitogo project create
-npx apitogo deploy
+apitogo project create
+apitogo deploy
 ```
 
 `project create` makes the platform project, selects the **Free** plan (or the plan from `--plan`),
@@ -115,7 +115,7 @@ A project on the **Free** platform plan can only publish free plans, and its lim
 charge your customers, create the project on a paid platform plan:
 
 ```bash
-npx apitogo project create --plan starter
+apitogo project create --plan starter
 ```
 
 The command makes the project, then prints a link to the platform's own checkout (and opens it in
@@ -136,8 +136,8 @@ See [Walkthrough: from an empty folder to a customer's first call](./walkthrough
 ### Move a folder to another project
 
 ```bash
-npx apitogo project use fe3a12b0-fbaf-4315-b37f-b731d930ee57
-npx apitogo deploy
+apitogo project use fe3a12b0-fbaf-4315-b37f-b731d930ee57
+apitogo deploy
 ```
 
 `project use <id>` points the folder at another project you own, for good. It checks that the

package/docs/cli/go-live.md

@@ -1,7 +1,7 @@
 ---
 title: Go live with CLI
 description: >-
-  Deploy your project with npx apitogo deploy: the hosting plan, the secrets deploy asks for, one
+  Deploy your project with apitogo deploy: the hosting plan, the secrets deploy asks for, one
   service at a time, and checking the result.
 sidebar_icon: rocket
 ---
@@ -14,7 +14,7 @@ and plans.
 1. Sign in to APItoGo once on this computer:
 
    ```bash
-   npx apitogo login
+   apitogo login
    ```
 
    In CI, set `APITOGO_API_KEY_ID` and `APITOGO_API_SECRET` (an API key from the dashboard) instead.
@@ -22,19 +22,19 @@ and plans.
 2. Check the config:
 
    ```bash
-   npx apitogo check
+   apitogo check
    ```
 
 ## Deploy
 
 ```bash
-npx apitogo deploy
+apitogo deploy
 ```
 
 On the first run, deploy creates the project: it asks for the hosting plan (**Free**, **Starter** or
 **Professional**) and writes the project's id into `apitogo.config.json`. Starter and Professional
 open the platform's checkout. To create the project without deploying, run
-`npx apitogo project create --plan <plan>`.
+`apitogo project create --plan <plan>`.
 
 Then it sets up each service and prints what it did:
 
@@ -58,8 +58,8 @@ Deploy asks, hidden, for the secrets the config needs and stores them as project
 | `identity.connections` has a provider | That provider's client secret, under the name the config gives |
 
 [Set up Stripe for paid plans](../guides/stripe-setup.mdx) shows where the Stripe values are. Set or
-change a secret yourself with `npx apitogo secrets set <NAME>`, and list them with
-`npx apitogo secrets list`.
+change a secret yourself with `apitogo secrets set <NAME>`, and list them with
+`apitogo secrets list`.
 
 Selling paid plans and using a custom domain need **Starter** or **Professional**. On **Free**,
 deploy stops at a paid plan and says so.
@@ -67,8 +67,8 @@ deploy stops at a paid plan and says so.
 ## One service at a time
 
 ```bash
-npx apitogo deploy --only portal
-npx apitogo deploy --only gateway,plans
+apitogo deploy --only portal
+apitogo deploy --only gateway,plans
 ```
 
 `--only` takes `portal`, `gateway`, `identity` and `plans`.
@@ -83,14 +83,14 @@ npx apitogo deploy --only gateway,plans
 | `--json`       | Print the result as JSON only                                            |
 | `--project-id` | Deploy to this project for this run only                                 |
 
-To move the folder to another project for good, use `npx apitogo project use <id>` (see
+To move the folder to another project for good, use `apitogo project use <id>` (see
 [Commands](./commands.md#move-a-folder-to-another-project)).
 
 ## After deploy
 
 ```bash
-npx apitogo status              # account, project and live checks
-npx apitogo teardown --yes      # delete the project and everything in it
+apitogo status              # account, project and live checks
+apitogo teardown --yes      # delete the project and everything in it
 ```
 
 ## Your plans and APItoGo's

package/docs/cli/overview.md

@@ -6,20 +6,19 @@ sidebar_icon: terminal
 ---
 
 The **`apitogo`** CLI lets you manage developer portals from the terminal. You scaffold and shape
-local files, preview with `npx apitogo run`, and publish to APItoGo hosting with
-`npx apitogo deploy`.
+local files, preview with `apitogo run`, and publish to APItoGo hosting with `apitogo deploy`.
 
 **First time?** Install and wire credentials → **[Install the CLI](./setup.md)**. Then follow
 [Shape](./shape.md) and [Go live](./go-live.md).
 
 ## What you get
 
-- Scaffold a local portal site (`npx @lukoweb/apitogo@latest init`)
-- Shape backend, OpenAPI, plans, and docs pages via `npx apitogo config` and file edits
-- Preview locally (`npx apitogo run`)
-- Publish to APItoGo hosting (`npx apitogo deploy`) with platform plans **Free**, **Starter**, or
+- Scaffold a local portal site (`apitogo init`)
+- Shape backend, OpenAPI, plans, and docs pages via `apitogo config` and file edits
+- Preview locally (`apitogo run`)
+- Publish to APItoGo hosting (`apitogo deploy`) with platform plans **Free**, **Starter**, or
   **Professional**
-- Check live status (`npx apitogo status`) and tear down (`npx apitogo teardown --yes`)
+- Check live status (`apitogo status`) and tear down (`apitogo teardown --yes`)
 
 ## Prerequisites
 
@@ -39,21 +38,21 @@ local files, preview with `npx apitogo run`, and publish to APItoGo hosting with
 
 ## Changing your site
 
-| Approach                 | When it helps                                                                                                                     |
-| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
-| **`npx apitogo config`** | Wire OpenAPI, custom pages, gateway plans, and site title from the terminal. See [Make config](../configuration/make-config.mdx). |
-| **Edit files directly**  | Full control — `apitogo.config.json`, `pages/**`, `landing/LandingPage.tsx`, etc.                                                 |
+| Approach                | When it helps                                                                                                                     |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| **`apitogo config`**    | Wire OpenAPI, custom pages, gateway plans, and site title from the terminal. See [Make config](../configuration/make-config.mdx). |
+| **Edit files directly** | Full control — `apitogo.config.json`, `pages/**`, `landing/LandingPage.tsx`, etc.                                                 |
 
 Common CLI shape tasks:
 
-| Change                          | How                                                              |
-| ------------------------------- | ---------------------------------------------------------------- |
-| Backend runtime                 | `npx apitogo config` (backend)                                   |
-| OpenAPI files (`gateway.specs`) | `npx apitogo config` (openapi)                                   |
-| Custom docs pages               | `npx apitogo config` (page) or add under `apitogo/portal/pages/` |
-| Gateway / API plans             | `npx apitogo config` (plan) or edit `apitogo/plans.json`         |
-| Site title                      | `--title` or edit `apitogo.config.json`                          |
-| Theme and fonts                 | Edit `apitogo/portal/theme.json`                                 |
+| Change                          | How                                                          |
+| ------------------------------- | ------------------------------------------------------------ |
+| Backend runtime                 | `apitogo config` (backend)                                   |
+| OpenAPI files (`gateway.specs`) | `apitogo config` (openapi)                                   |
+| Custom docs pages               | `apitogo config` (page) or add under `apitogo/portal/pages/` |
+| Gateway / API plans             | `apitogo config` (plan) or edit `apitogo/plans.json`         |
+| Site title                      | `--title` or edit `apitogo.config.json`                      |
+| Theme and fonts                 | Edit `apitogo/portal/theme.json`                             |
 
 The home page is `apitogo/portal/landing/LandingPage.tsx` and the footer
 `apitogo/portal/footer/Footer.tsx`, named by `portal.landing` and `portal.footer`.
@@ -65,20 +64,20 @@ The home page is `apitogo/portal/landing/LandingPage.tsx` and the footer
 | `apitogo.config.json` | The services: portal, gateway, identity, plans |
 | `apitogo/`            | Pages, plans, theme, OpenAPI files             |
 
-Secrets are project secrets (`npx apitogo secrets set`), never files. Details:
+Secrets are project secrets (`apitogo secrets set`), never files. Details:
 [Configuration overview](../configuration/overview.md).
 
 ## CLI vs MCP
 
 Each MCP tool runs one CLI command in the project folder, so both give the same result.
 
-| Task              | CLI                                           | MCP (agent)                           |
-| ----------------- | --------------------------------------------- | ------------------------------------- |
-| Create            | `npx @lukoweb/apitogo@latest create`          | `apitogo_create`                      |
-| Shape config      | `npx apitogo config` + file edits             | `apitogo_config` + file edits         |
-| Preview           | `npx apitogo run`                             | `npx apitogo run` (you start it)      |
-| Deploy            | `npx apitogo plan` / `npx apitogo deploy`     | `apitogo_plan` / `apitogo_deploy`     |
-| Status / teardown | `npx apitogo status` / `npx apitogo teardown` | `apitogo_status` / `apitogo_teardown` |
+| Task              | CLI                                   | MCP (agent)                           |
+| ----------------- | ------------------------------------- | ------------------------------------- |
+| Create            | `apitogo create`                      | `apitogo_create`                      |
+| Shape config      | `apitogo config` + file edits         | `apitogo_config` + file edits         |
+| Preview           | `apitogo run`                         | `apitogo run` (you start it)          |
+| Deploy            | `apitogo plan` / `apitogo deploy`     | `apitogo_plan` / `apitogo_deploy`     |
+| Status / teardown | `apitogo status` / `apitogo teardown` | `apitogo_status` / `apitogo_teardown` |
 
 Prefer MCP when an agent should drive changes. Prefer CLI for CI, scripts, or terminal-only
 workflows.

package/docs/cli/setup.md

@@ -6,35 +6,47 @@ sidebar_icon: terminal
 ---
 
 Use the **`apitogo`** CLI (`@lukoweb/apitogo`) to scaffold a local portal, shape
-`apitogo.config.json`, preview with `npx apitogo run`, and publish with `npx apitogo deploy`. The
+`apitogo.config.json`, preview with `apitogo run`, and publish with `apitogo deploy`. The
 [MCP tools](../mcp/tools.md) run these same commands for an agent.
 
-Examples in these docs use **`npx apitogo`** so they run the project-local CLI. A global install is
-optional and not required.
+Examples in these docs run **`apitogo`** directly, so they assume you have installed the CLI
+globally (see [Install](#install)).
 
 ## Prerequisites
 
 - **Node.js 20+**
-- Platform API credentials from [apitogo.com](https://apitogo.com) when you run `npx apitogo deploy`
+- Platform API credentials from [apitogo.com](https://apitogo.com) when you run `apitogo deploy`
   (API key id + secret)
 
 ## Install
 
-The CLI is the npm package **`@lukoweb/apitogo`**. It exposes the **`apitogo`** binary. Scaffold
-commands add it to your project and `npm install` puts it on `node_modules/.bin`. Invoke it with
-`npx apitogo`.
+The CLI is the npm package **`@lukoweb/apitogo`**. It exposes the **`apitogo`** binary. Install it
+globally once:
+
+```bash
+npm install -g @lukoweb/apitogo
+```
+
+Then check that it works from any folder:
+
+```bash
+apitogo --help
+```
+
+Upgrade later with `npm install -g @lukoweb/apitogo@latest`. Uninstall with
+`npm uninstall -g @lukoweb/apitogo`.
 
 ### New project (recommended)
 
-`npx @lukoweb/apitogo@latest init` creates a config version 2 project in the current folder. It
-shows what it will create and asks first (pass `--yes` to skip the question), writes
-`apitogo.config.json`, uses an existing `docs/` folder in place, and, in a new folder, creates
-`package.json` and installs `@lukoweb/apitogo`, `react` and `react-dom`:
+`apitogo init` creates a config version 2 project in the current folder. It shows what it will
+create and asks first (pass `--yes` to skip the question), writes `apitogo.config.json`, uses an
+existing `docs/` folder in place, and, in a new folder, creates `package.json` and installs
+`@lukoweb/apitogo`, `react` and `react-dom`:
 
 ```bash
 mkdir my-portal && cd my-portal
-npx @lukoweb/apitogo@latest init --name "Books API"
-npx apitogo run
+apitogo init --name "Books API"
+apitogo run
 ```
 
 In an existing project the tool never edits your `package.json`. It prints the install command to
@@ -43,9 +55,9 @@ run instead.
 Named folder or site name:
 
 ```bash
-npx @lukoweb/apitogo@latest init ./my-portal --name "Books API"
+apitogo init ./my-portal --name "Books API"
 cd ./my-portal
-npx apitogo run
+apitogo run
 ```
 
 #### Scaffold options
@@ -59,39 +71,19 @@ npx apitogo run
 | `--force`         | Replace an existing `apitogo.config.json`     |
 | `--json`          | Print a JSON result payload on stdout         |
 
-`npx @lukoweb/apitogo init` is local only — it does not call the platform. After `config`, run
-`npx apitogo run` to preview, then `npx apitogo deploy` when ready to go live.
-
-### How to run `apitogo`
+`apitogo init` is local only — it does not call the platform. After `config`, run `apitogo run` to
+preview, then `apitogo deploy` when ready to go live.
 
-| Situation                                                 | Command                                             |
-| --------------------------------------------------------- | --------------------------------------------------- |
-| After `init` or `npm install` in the project              | `npx apitogo <command>` (e.g. `npx apitogo config`) |
-| One-off, no project yet                                   | `npx @lukoweb/apitogo <command>`                    |
-| After [optional global install](#optional-global-install) | `apitogo <command>` anywhere                        |
+### Global CLI and project scripts
 
-`npm run dev` / `npm run build` use the project-local CLI via `package.json` scripts — no global
-install required.
+With the global install, run `apitogo <command>` from any folder (for example `apitogo config`).
 
-### Optional global install
-
-```bash
-npm install -g @lukoweb/apitogo
-```
-
-Then run `apitogo` from any directory:
-
-```bash
-apitogo --help
-```
-
-Upgrade later with `npm install -g @lukoweb/apitogo@latest`. Uninstall with
-`npm uninstall -g @lukoweb/apitogo`. Prefer `npx apitogo` in projects so each site uses the version
-in its `package.json`.
+Projects made by `init` or `create` also list `@lukoweb/apitogo` in their `package.json`, so
+`npm run dev` and `npm run build` use the version pinned in that project.
 
 ## Platform credentials
 
-Export these before `npx apitogo deploy`, `npx apitogo status`, or `npx apitogo teardown`:
+Export these before `apitogo deploy`, `apitogo status`, or `apitogo teardown`:
 
 | Variable             | Required | Purpose           |
 | -------------------- | -------- | ----------------- |
@@ -106,12 +98,12 @@ Optional:
 | `APITOGO_CLI_PATH` | Local `@lukoweb/apitogo` / doc-tool checkout for MCP spawn |
 
 Never commit secrets. Secrets such as the Stripe key are project secrets: deploy asks for them, and
-`npx apitogo secrets set <NAME>` changes them. See [Go live](./go-live.md).
+`apitogo secrets set <NAME>` changes them. See [Go live](./go-live.md).
 
 ## Verify
 
 ```bash
-npx apitogo --help
+apitogo --help
 ```
 
 You should see `init`, `config`, `run`, `build`, `deploy`, `status`, and `teardown`.
@@ -119,12 +111,12 @@ You should see `init`, `config`, `run`, `build`, `deploy`, `status`, and `teardo
 With credentials set:
 
 ```bash
-npx apitogo status
+apitogo status
 ```
 
 ## Next
 
 - [CLI overview](./overview.md)
 - [Shape](./shape.md) — scaffold and local preview
-- [Go live](./go-live.md) — `npx apitogo deploy`
+- [Go live](./go-live.md) — `apitogo deploy`
 - [Commands](./commands.md) — full catalog

package/docs/cli/shape.md

@@ -1,43 +1,40 @@
 ---
 title: Shape with CLI
-description:
-  Scaffold and customize a developer portal locally with npx apitogo init, config, and run.
+description: Scaffold and customize a developer portal locally with apitogo init, config, and run.
 sidebar_icon: pencil-ruler
 ---
 
 **Shape** means: create or update a local portal site (OpenAPI, plans, docs pages, auth) without
-publishing. You preview with `npx apitogo run`.
+publishing. You preview with `apitogo run`.
 
 Requires the **`apitogo`** CLI (`@lukoweb/apitogo`). If you have not installed it yet, see
 [Install the CLI](./setup.md).
 
 ## Happy path
 
-`npx @lukoweb/apitogo@latest init` creates a project in the current folder: it writes
-`apitogo.config.json`, uses an existing `docs/` folder, and installs the CLI. Then shape it with
-`npx apitogo config`:
+`apitogo init` creates a project in the current folder: it writes `apitogo.config.json`, uses an
+existing `docs/` folder, and installs the CLI. Then shape it with `apitogo config`:
 
 ```bash
-npx @lukoweb/apitogo@latest init
-npx apitogo config         # backend, OpenAPI, pages, plans (apply each immediately)
-npx apitogo run            # http://localhost:3000
+apitogo init
+apitogo config         # backend, OpenAPI, pages, plans (apply each immediately)
+apitogo run            # http://localhost:3000
 ```
 
 Named folder:
 
 ```bash
-npx @lukoweb/apitogo@latest init ./my-portal --name "Books API"
+apitogo init ./my-portal --name "Books API"
 cd ./my-portal
-npx apitogo config
-npx apitogo run
+apitogo config
+apitogo run
 ```
 
-`npx @lukoweb/apitogo init` does **not** call the platform. Run `npx apitogo deploy` when you are
-ready to go live.
+`apitogo init` does **not** call the platform. Run `apitogo deploy` when you are ready to go live.
 
-## Interactive config (`npx apitogo config`)
+## Interactive config (`apitogo config`)
 
-On a TTY, bare `npx apitogo config` opens the wizard. Each choice is written immediately; the loop
+On a TTY, bare `apitogo config` opens the wizard. Each choice is written immediately; the loop
 continues until you type `done`:
 
 | Choice    | What it does                                                                            |
@@ -49,8 +46,8 @@ continues until you type `done`:
 
 Fonts and colors are **not** prompted. See [Colors & theme](../customization/colors-theme.mdx).
 
-**Paid plans:** payments go through Stripe. Once a plan has a price, `npx apitogo deploy` asks for
-your Stripe secret key (if the project has none yet) and stores it as a project secret. Free and
+**Paid plans:** payments go through Stripe. Once a plan has a price, `apitogo deploy` asks for your
+Stripe secret key (if the project has none yet) and stores it as a project secret. Free and
 contact-us plans need no key. [Set up Stripe for paid plans](../guides/stripe-setup.mdx) shows where
 to find the key and how to add the webhook, with pictures. Paid plans also need **Starter** or
 **Professional** platform hosting; **Free** cannot publish paid gateway plans or custom domains.
@@ -64,10 +61,10 @@ Changes a config version 2 project. Every change to `apitogo.config.json` is che
 written. The command does not create a project: use `init` or `create` for that.
 
 ```bash
-npx apitogo config --title "Books API"
-npx apitogo config --page-slug guides/quickstart --page-title "Quickstart"
-npx apitogo config --plan '{"sku":"free","displayName":"Free"}'
-npx apitogo config --no-interactive
+apitogo config --title "Books API"
+apitogo config --page-slug guides/quickstart --page-title "Quickstart"
+apitogo config --plan '{"sku":"free","displayName":"Free"}'
+apitogo config --no-interactive
 ```
 
 Common flags:
@@ -84,7 +81,7 @@ Common flags:
 
 ## Shape by editing files
 
-After `npx apitogo config`, edit the manifest and site files directly:
+After `apitogo config`, edit the manifest and site files directly:
 
 - **Services, backend, OpenAPI files** — `apitogo.config.json`
 - **Plans** — `apitogo/plans.json`
@@ -160,14 +157,14 @@ Each card in `apitogo/plans.json` lists, in this order:
 }
 ```
 
-`npx apitogo run` shows the same cards as the deployed portal.
+`apitogo run` shows the same cards as the deployed portal.
 
 ## Add a portal from scratch
 
 In a project that has no portal yet:
 
 ```bash
-npx apitogo add portal
+apitogo add portal
 ```
 
 It adds `portal` to `apitogo.config.json` and writes the files above: `introduction.mdx` (the
@@ -176,20 +173,20 @@ footer. Docs you already have (a `docs/` folder, for example) are used instead o
 `--docs <path>` to name them. Files that exist are never overwritten.
 
 Never put secrets in `apitogo.config.json`: the config names a project secret (`secret:NAME`), and
-`npx apitogo secrets set NAME` stores the value.
+`apitogo secrets set NAME` stores the value.
 
 ## Preview locally
 
 ```bash
-npx apitogo run
-npx apitogo run --port 4000 --open
+apitogo run
+apitogo run --port 4000 --open
 ```
 
 Production build check:
 
 ```bash
-npx apitogo build
-npx apitogo build --preview
+apitogo build
+apitogo build --preview
 ```
 
 Shape-phase edits hot-reload when the dev server is running.
@@ -197,14 +194,14 @@ Shape-phase edits hot-reload when the dev server is running.
 ## Existing docs + OpenAPI folder
 
 In a folder that already has docs and an OpenAPI file, run `init` there: it uses the `docs/` folder
-in place, and `npx apitogo config` (openapi) adds the OpenAPI file:
+in place, and `apitogo config` (openapi) adds the OpenAPI file:
 
 ```bash
-npx @lukoweb/apitogo@latest init
-npx apitogo config
-npx apitogo run
+apitogo init
+apitogo config
+apitogo run
 ```
 
 ## Next
 
-When the site looks right, [go live](./go-live.md) with `npx apitogo deploy`.
+When the site looks right, [go live](./go-live.md) with `apitogo deploy`.

package/docs/cli/walkthrough.md

@@ -25,19 +25,19 @@ their own key. Every step is a command you run, or something your customer does
 ## 1. Create the project folder
 
 ```bash
-npx @lukoweb/apitogo@latest init my-portal --yes --name my-portal
+apitogo init my-portal --yes --name my-portal
 cd my-portal
 ```
 
 `init` creates a config version 2 project with a portal, and installs the CLI into it. The commands
-below use the installed CLI through `npx apitogo`.
+below use the installed CLI through `apitogo`.
 
 ## 2. Add the services
 
 ```bash
-npx apitogo add identity
-npx apitogo add gateway --origin proxy --url https://httpbin.org --auth identity --create-spec
-npx apitogo add plans --template free
+apitogo add identity
+apitogo add gateway --origin proxy --url https://httpbin.org --auth identity --create-spec
+apitogo add plans --template free
 ```
 
 | Service  | What it gives you                                                                               |
@@ -59,8 +59,8 @@ replaced.
 ## 3. Create the platform project and deploy
 
 ```bash
-npx apitogo project create
-npx apitogo deploy
+apitogo project create
+apitogo deploy
 ```
 
 `deploy` runs the services in a fixed order and prints what it did:
@@ -77,8 +77,8 @@ The portal's address is only known once the portal is published. The gateway onl
 calls from addresses it knows, so `deploy` sends the gateway its list again after the portal. One
 `deploy` is enough: you do not need to run it twice.
 
-Running `deploy` again changes only what changed. Use `npx apitogo status` to see each service and
-`npx apitogo plan` to see what the next deploy would do.
+Running `deploy` again changes only what changed. Use `apitogo status` to see each service and
+`apitogo plan` to see what the next deploy would do.
 
 ## 4. The customer's side
 
@@ -113,22 +113,22 @@ The customer sees their calls on the **Usage** page. See
 Free plans need no payment. To charge your customers, the project needs two things: a Starter or
 Professional plan with APItoGo, and your own Stripe account. Your customers pay you, not APItoGo.
 
-1. Create the project on a paid platform plan: `npx apitogo project create --plan starter`. This
-   opens the platform's checkout for the hosting fee. A project that already exists on the Free plan
+1. Create the project on a paid platform plan: `apitogo project create --plan starter`. This opens
+   the platform's checkout for the hosting fee. A project that already exists on the Free plan
    cannot be moved: create a new one. See
    [Selling paid plans needs Starter or Professional](./commands.md#selling-paid-plans-needs-starter-or-professional).
 2. Give a plan a price in `plans.json`: `"priceAmount": 49`, `"priceCurrency": "usd"` and
    `"billingInterval": "month"`. Its limits cannot be higher than your platform plan allows.
    Payments go through Stripe; nothing else in the config changes.
-3. Deploy: `npx apitogo deploy`. Because a plan now has a price, deploy asks for your Stripe secret
-   key (it starts with `sk_test_` while you test) and stores it as the project secret
-   `STRIPE_API_KEY`, so it stays out of your files. You can also store it beforehand with
-   `npx apitogo secrets set STRIPE_API_KEY`. The output says whether Stripe is in test or live mode
-   and prints your portal's webhook address.
+3. Deploy: `apitogo deploy`. Because a plan now has a price, deploy asks for your Stripe secret key
+   (it starts with `sk_test_` while you test) and stores it as the project secret `STRIPE_API_KEY`,
+   so it stays out of your files. You can also store it beforehand with
+   `apitogo secrets set STRIPE_API_KEY`. The output says whether Stripe is in test or live mode and
+   prints your portal's webhook address.
 4. In Stripe, add that address as a webhook endpoint with the events `checkout.session.completed`,
    `customer.subscription.updated`, `customer.subscription.deleted` and `invoice.payment_failed`.
    Copy the signing secret (it starts with `whsec_`), store it with
-   `npx apitogo secrets set STRIPE_WEBHOOK`, add
+   `apitogo secrets set STRIPE_WEBHOOK`, add
    `"plans": { "billing": { "webhookSecret": "secret:STRIPE_WEBHOOK" } }` to `apitogo.config.json`,
    and deploy again. Until then a payment does not activate the plan, because the portal cannot
    confirm it came from Stripe.
@@ -139,7 +139,7 @@ money moves. Never type a live key until you have tested the whole path.
 ## 6. Remove a test project
 
 ```bash
-npx apitogo teardown --yes
+apitogo teardown --yes
 ```
 
 This deletes the platform project: the gateway, the identity and its users, the portal, its address
@@ -151,7 +151,7 @@ and certificate, and the project's email domain. Your local files stay.
 - **Sign-up needs a real email address.** Confirmation and password-reset emails are sent to it. For
   tests, an address with a suffix such as `you+test1@example.com` usually reaches your own mailbox.
 - **Secrets stay out of the config.** A value such as an origin key is written as `secret:NAME` and
-  set with `npx apitogo secrets`.
+  set with `apitogo secrets`.
 
 ## Related