@sandboxsonny/ace-kit 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @sandboxsonny/ace-kit
 
+## 0.5.0
+
+### Minor Changes
+
+- 88e17be: CMS Ace is a hosted platform, so a site no longer has to say where it is.
+  
+  - `ACE_API_URL` now defaults to `https://api.ace-cms.co.uk` and `ACE_PREVIEW_ADMIN_ORIGIN` to `https://app.ace-cms.co.uk` (the Astro integration, the React Router adapter and the command line). **If you develop against a CMS on your own machine, set `ACE_API_URL=http://localhost:8080` and `ACE_PREVIEW_ADMIN_ORIGIN=http://localhost:5173` in `.env`**, where before they were the defaults.
+  - A site names itself with Astro's own `site` setting (`site: "https://www.example.com"`, or `astro dev --site https://www.example.com`). `ACE_SITE_DOMAIN`, when set, still wins.
+  - `ace-kit sync` and `ace-kit generate` take `--site example.com` (a domain or a web address); `--domain` still works.
+  - `ace-kit login` and `whoami` need no flags: with no address given they use the hosted CMS Ace.
+
 ## 0.4.0
 
 ### Minor Changes

package/README.md

@@ -24,7 +24,7 @@ const page = await loadPage(cms, { slug: "pages/about", url: new URL(request.url
 if (page.kind === "entry") console.log(page.entry.title, page.entry.values);
 ```
 
-On Astro there is nothing to wire up by hand: add the integration to `astro.config.mjs` (`integrations: [ace()]`), set `ACE_API_URL` and `ACE_SITE_DOMAIN`, and read the CMS straight from a page:
+On Astro there is nothing to wire up by hand: add the integration to `astro.config.mjs` (`integrations: [ace()]`), set your site's domain (`site: "https://www.example.com"` in the Astro config, or `ACE_SITE_DOMAIN`), and read the CMS straight from a page:
 
 ```astro
 ---

package/dist/astro-integration.d.ts

@@ -13,9 +13,9 @@ import { AstroIntegration } from 'astro';
  *
  * | Setting                    | Default                 | Meaning                                                  |
  * | -------------------------- | ----------------------- | -------------------------------------------------------- |
- * | `ACE_API_URL`              | `http://localhost:8080` | where the CMS Ace API lives                              |
- * | `ACE_SITE_DOMAIN`          | `localhost`             | the domain this site has in the CMS                      |
- * | `ACE_PREVIEW_ADMIN_ORIGIN` | `http://localhost:5173` | where the CMS admin app runs (may frame the site)        |
+ * | `ACE_API_URL`              | `https://api.ace-cms.co.uk` | where the CMS Ace API lives (set it for a CMS on your machine) |
+ * | `ACE_SITE_DOMAIN`          | the host of Astro's `site` setting, else `localhost` | the domain this site has in the CMS |
+ * | `ACE_PREVIEW_ADMIN_ORIGIN` | `https://app.ace-cms.co.uk` | where the CMS admin app runs (may frame the site)  |
  */
 declare function ace(): AstroIntegration;
 

package/dist/astro-integration.js

@@ -1,4 +1,5 @@
-import { startDevSite, sectionSync } from './chunk-O3NAJNUN.js';
+import { startDevSite, sectionSync } from './chunk-WM5NOQE3.js';
+import { domainFromSite, hostedAdminOrigin, hostedApiUrl } from './chunk-N5DIMG3X.js';
 import { envField } from 'astro/config';
 import { fileURLToPath } from 'url';
 
@@ -8,10 +9,12 @@ function ace() {
     name: "ace-kit",
     hooks: {
       "astro:config:setup": async ({ command, config, logger, updateConfig, addMiddleware }) => {
+        const siteDomain = config.site ? domainFromSite(config.site) : "localhost";
         if (command === "dev") {
           devSite = await startDevSite({
             root: fileURLToPath(config.root),
             mode: "development",
+            siteDomain,
             log: { info: (text) => logger.info(text), warn: (text) => logger.warn(text) }
           });
         }
@@ -19,12 +22,12 @@ function ace() {
           env: {
             schema: {
               // "secret" only because Astro reads secrets when the server starts, while "public" values are baked into the build.
-              ACE_API_URL: envField.string({ context: "server", access: "secret", default: "http://localhost:8080" }),
-              ACE_SITE_DOMAIN: envField.string({ context: "server", access: "secret", default: "localhost" }),
+              ACE_API_URL: envField.string({ context: "server", access: "secret", default: hostedApiUrl }),
+              ACE_SITE_DOMAIN: envField.string({ context: "server", access: "secret", default: siteDomain }),
               ACE_PREVIEW_ADMIN_ORIGIN: envField.string({
                 context: "server",
                 access: "secret",
-                default: "http://localhost:5173"
+                default: hostedAdminOrigin
               })
             }
           },

package/dist/chunk-N5DIMG3X.js

@@ -0,0 +1,16 @@
+// src/helpers/platform.ts
+var hostedApiUrl = "https://api.ace-cms.co.uk";
+var hostedAdminOrigin = "https://app.ace-cms.co.uk";
+function domainFromSite(site) {
+  const trimmed = site.trim();
+  if (trimmed.includes("://")) {
+    try {
+      return new URL(trimmed).hostname.toLowerCase();
+    } catch {
+      return trimmed.toLowerCase();
+    }
+  }
+  return trimmed.replace(/\/.*$/, "").replace(/:\d+$/, "").toLowerCase();
+}
+
+export { domainFromSite, hostedAdminOrigin, hostedApiUrl };

package/dist/{chunk-O3NAJNUN.js → chunk-WM5NOQE3.js}

@@ -1,3 +1,4 @@
+import { hostedApiUrl } from './chunk-N5DIMG3X.js';
 import { loadEnv } from 'vite';
 import { readdir, readFile, mkdir, writeFile, rename } from 'fs/promises';
 import { homedir } from 'os';
@@ -5,8 +6,6 @@ import { join, relative, dirname } from 'path';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 
-// src/dev-site/start-dev-site.ts
-
 // src/auth/login-store.ts
 function normaliseApiUrl(address) {
   let parsed;
@@ -282,18 +281,19 @@ async function prepareDevSite(options) {
 }
 
 // src/dev-site/start-dev-site.ts
-var defaultApiUrl = "http://localhost:8080";
 async function startDevSite(options) {
   const { root, mode, log } = options;
   if (mode === "test" || process.env.VITEST) return null;
-  const variables = options.environment?.variables ?? { ...loadEnv(mode, root, "ACE_"), ...process.env };
+  const base = options.environment?.variables ?? { ...loadEnv(mode, root, "ACE_"), ...process.env };
+  const realDomain = base.ACE_SITE_DOMAIN?.trim() || options.siteDomain?.trim() || "localhost";
+  const variables = { ...base, ACE_SITE_DOMAIN: realDomain };
   let apiUrl;
   try {
-    apiUrl = normaliseApiUrl(variables.ACE_API_URL ?? defaultApiUrl);
+    apiUrl = normaliseApiUrl(variables.ACE_API_URL ?? hostedApiUrl);
   } catch {
     return null;
   }
-  const environment = options.environment ?? {
+  const environment = options.environment ? { ...options.environment, variables } : {
     variables,
     store: await chooseLoginStore({ platform: process.platform, variables, run: runCommand }),
     now: Date.now,
@@ -317,7 +317,7 @@ async function startDevSite(options) {
       log.info(
         outcome.created ? `Made you a dev site, "${outcome.site.name}", as a copy of the live site (${outcome.site.domain}). This dev server reads and syncs to it; the live site is not touched.` : `Using your dev site, "${outcome.site.name}" (${outcome.site.domain}). The live site is not touched.`
       );
-      const siteDomain = variables.ACE_SITE_DOMAIN?.trim() || "localhost";
+      const siteDomain = realDomain;
       return {
         domain: outcome.site.domain,
         setPreviewUrl: async (previewUrl) => {

package/dist/cli.js

@@ -171,7 +171,7 @@ function createLastApiUrl(path) {
 }
 
 // src/cli/version.ts
-var aceKitVersion = true ? "0.4.0" : "development";
+var aceKitVersion = true ? "0.5.0" : "development";
 
 // src/cli/environment.ts
 var runCommand = (command, commandArguments, input) => new Promise((resolve2, reject) => {
@@ -403,15 +403,29 @@ export {};
 // src/helpers/package-name.ts
 var packageName = "@sandboxsonny/ace-kit";
 
+// src/helpers/platform.ts
+var hostedApiUrl = "https://api.ace-cms.co.uk";
+function domainFromSite(site) {
+  const trimmed = site.trim();
+  if (trimmed.includes("://")) {
+    try {
+      return new URL(trimmed).hostname.toLowerCase();
+    } catch {
+      return trimmed.toLowerCase();
+    }
+  }
+  return trimmed.replace(/\/.*$/, "").replace(/:\d+$/, "").toLowerCase();
+}
+
 // src/cli/generate-command.ts
 var generateUsage = `ace-kit generate: write TypeScript types for your CMS Ace content types.
 
 Usage:
-  ace-kit generate [--api-url <address>] [--domain <domain>] [--out <file>]
+  ace-kit generate [--site <domain>] [--api-url <address>] [--out <file>]
 
 Options:
-  --api-url   Where the CMS Ace API lives (or set ACE_API_URL, in the environment or a .env file).
-  --domain    The domain your site has in the CMS (or set ACE_SITE_DOMAIN).
+  --site      The domain your site has in the CMS, e.g. example.com (or set ACE_SITE_DOMAIN). --domain means the same.
+  --api-url   Where the CMS Ace API lives (or set ACE_API_URL). Only for a CMS on your own machine.
   --out       Where to write the types (default: src/ace-kit.generated.d.ts).
   --help      Show this message.
 `;
@@ -421,6 +435,7 @@ async function generateCommand(commandArguments, environment) {
     args: commandArguments,
     options: {
       "api-url": { type: "string" },
+      site: { type: "string" },
       domain: { type: "string" },
       out: { type: "string" },
       help: { type: "boolean" }
@@ -430,14 +445,13 @@ async function generateCommand(commandArguments, environment) {
     environment.out(generateUsage);
     return 0;
   }
-  const apiUrl = values["api-url"] ?? environment.variables.ACE_API_URL;
-  const siteDomain = values.domain ?? environment.variables.ACE_SITE_DOMAIN;
-  if (!apiUrl || !siteDomain) {
-    environment.error(
-      "Give the API address and the site's domain: --api-url and --domain, or ACE_API_URL and ACE_SITE_DOMAIN."
-    );
+  const apiUrl = values["api-url"] ?? environment.variables.ACE_API_URL ?? hostedApiUrl;
+  const given = values.site ?? values.domain ?? environment.variables.ACE_SITE_DOMAIN;
+  if (!given) {
+    environment.error("Give the site's domain: --site, or ACE_SITE_DOMAIN.");
     return 1;
   }
+  const siteDomain = domainFromSite(given);
   const client = createAceClient({
     apiUrl,
     siteDomain,
@@ -586,13 +600,7 @@ async function resolveLogin(options) {
 
 // src/cli/api-url.ts
 async function resolveApiUrl(fromOption, environment) {
-  const address = fromOption ?? environment.variables.ACE_API_URL ?? await environment.lastApiUrl.read();
-  if (!address) {
-    environment.error(
-      "Give the API address: --api-url, or ACE_API_URL in the environment or a .env file. (Once you have signed in, that address is remembered.)"
-    );
-    return null;
-  }
+  const address = fromOption ?? environment.variables.ACE_API_URL ?? await environment.lastApiUrl.read() ?? hostedApiUrl;
   try {
     return normaliseApiUrl(address);
   } catch (error) {
@@ -1013,7 +1021,7 @@ async function syncSectionTypes(options) {
 var syncUsage = `ace-kit sync: send the section types your code defines to CMS Ace.
 
 Usage:
-  ace-kit sync [--api-url <address>] [--domain <domain>] [--dir <folder>]
+  ace-kit sync [--site <domain>] [--api-url <address>] [--dir <folder>]
 
 It finds every *.schema.ts file in the folder (src by default), checks them, and makes the CMS's section types for your
 site match. The dev server does this for you whenever a schema file is saved; run it yourself for a one-off sync, or on a
@@ -1023,12 +1031,12 @@ Nothing is deleted: a section type, block or field you take out of your code is
 written in it survives. If any schema file can't be loaded, nothing is synced.
 
 Options:
-  --api-url   Where the CMS Ace API lives (default: ACE_API_URL, else http://localhost:8080).
-  --domain    The domain your site has in the CMS (default: ACE_SITE_DOMAIN, else localhost).
+  --site      The domain your site has in the CMS, e.g. example.com (default: ACE_SITE_DOMAIN, else localhost).
+              (--domain means the same.)
+  --api-url   Where the CMS Ace API lives (default: ACE_API_URL, else the hosted CMS Ace). Only for a CMS on your own machine.
   --dir       The folder to look in (default: src).
   --help      Show this message.
 `;
-var defaultApiUrl = "http://localhost:8080";
 var isSwitchedOff = (value) => ["false", "off", "no", "0"].includes((value ?? "").trim().toLowerCase());
 async function syncCommand(commandArguments, environment) {
   const { values } = parseArgs3({
@@ -1036,6 +1044,7 @@ async function syncCommand(commandArguments, environment) {
     args: commandArguments,
     options: {
       "api-url": { type: "string" },
+      site: { type: "string" },
       domain: { type: "string" },
       dir: { type: "string" },
       // Set by the dev server, which syncs on its own: it stays quiet when there is nothing to do, and keeps to a
@@ -1052,12 +1061,13 @@ async function syncCommand(commandArguments, environment) {
   if (automatic && isSwitchedOff(environment.variables.ACE_SYNC_SECTIONS)) return 0;
   let apiUrl;
   try {
-    apiUrl = normaliseApiUrl(values["api-url"] ?? environment.variables.ACE_API_URL ?? defaultApiUrl);
+    apiUrl = normaliseApiUrl(values["api-url"] ?? environment.variables.ACE_API_URL ?? hostedApiUrl);
   } catch (error) {
     environment.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
-  const siteDomain = values.domain ?? environment.variables.ACE_SITE_DOMAIN ?? "localhost";
+  const given = values.site ?? values.domain ?? environment.variables.ACE_SITE_DOMAIN;
+  const siteDomain = given ? domainFromSite(given) : "localhost";
   const aimedAtDevSite = environment.variables.ACE_DEV_SITE_ACTIVE === "1";
   if (automatic && !aimedAtDevSite && !isLocalApiUrl(apiUrl) && environment.variables.ACE_SYNC_SECTIONS?.trim().toLowerCase() !== "remote") {
     environment.out(
@@ -1112,7 +1122,7 @@ async function syncCommand(commandArguments, environment) {
       return automatic ? 0 : 1;
     case "site-not-found":
       environment.error(
-        `The CMS at ${apiUrl} has no site with the domain "${outcome.domain}" that you can see` + (outcome.available.length > 0 ? ` (your sites: ${outcome.available.join(", ")})` : "") + ". Set ACE_SITE_DOMAIN or pass --domain."
+        `The CMS at ${apiUrl} has no site with the domain "${outcome.domain}" that you can see` + (outcome.available.length > 0 ? ` (your sites: ${outcome.available.join(", ")})` : "") + ". Set ACE_SITE_DOMAIN or pass --site."
       );
       return 1;
     case "forbidden":

package/dist/react-router-server.js

@@ -1,5 +1,6 @@
 import { createAceClient, loadMenuLinks, loadPage } from './chunk-XYOW63V6.js';
 import './chunk-M5WR5TCR.js';
+import { hostedAdminOrigin, hostedApiUrl } from './chunk-N5DIMG3X.js';
 import { previewTokenFrom, addFramingPolicy } from './chunk-YLO6IAXF.js';
 import { createReadableStreamFromReadable } from '@react-router/node';
 import { PassThrough } from 'stream';
@@ -10,9 +11,9 @@ import { jsx } from 'react/jsx-runtime';
 // src/react-router/settings.ts
 function getAceSettings() {
   return {
-    apiUrl: process.env.ACE_API_URL ?? "http://localhost:8080",
+    apiUrl: process.env.ACE_API_URL ?? hostedApiUrl,
     siteDomain: process.env.ACE_SITE_DOMAIN ?? "localhost",
-    previewAdminOrigin: process.env.ACE_PREVIEW_ADMIN_ORIGIN ?? "http://localhost:5173"
+    previewAdminOrigin: process.env.ACE_PREVIEW_ADMIN_ORIGIN ?? hostedAdminOrigin
   };
 }
 if (typeof window !== "undefined" && typeof process === "undefined") {

package/dist/vite.js

@@ -1,4 +1,5 @@
-import { startDevSite, startSectionSync } from './chunk-O3NAJNUN.js';
+import { startDevSite, startSectionSync } from './chunk-WM5NOQE3.js';
+import './chunk-N5DIMG3X.js';
 import { resolve } from 'path';
 import { loadEnv } from 'vite';
 

package/docs/astro.md

@@ -17,13 +17,19 @@ export default defineConfig({
 
 The integration declares three settings, adds the middleware that lets the CMS's admin app (and only it) frame the site for [live preview](./live-preview.md), and makes Vite process the kit. The settings are read when the server starts, not baked into the build, so one build runs anywhere:
 
-| Setting                    | Default                 | Meaning                                                   |
-| -------------------------- | ----------------------- | --------------------------------------------------------- |
-| `ACE_API_URL`              | `http://localhost:8080` | where the CMS Ace API lives                               |
-| `ACE_SITE_DOMAIN`          | `localhost`             | the domain this site has in the CMS (the port is ignored) |
-| `ACE_PREVIEW_ADMIN_ORIGIN` | `http://localhost:5173` | where the CMS admin app runs                              |
+| Setting                    | Default                                              | Meaning                                                   |
+| -------------------------- | ---------------------------------------------------- | --------------------------------------------------------- |
+| `ACE_API_URL`              | `https://api.ace-cms.co.uk`                          | where the CMS Ace API lives                               |
+| `ACE_SITE_DOMAIN`          | the host of Astro's `site` setting, else `localhost` | the domain this site has in the CMS (the port is ignored) |
+| `ACE_PREVIEW_ADMIN_ORIGIN` | `https://app.ace-cms.co.uk`                          | where the CMS admin app runs                              |
 
-Put them in `.env` for development and in the environment for production.
+CMS Ace is a hosted platform, so a site normally sets none of these except its domain, and it does that with Astro's own `site` setting, which Astro needs for canonical addresses anyway:
+
+```js
+export default defineConfig({ site: "https://www.example.com", integrations: [ace()] });
+```
+
+To try a site without editing the config, `npm run dev -- --site https://www.example.com` does the same. `ACE_SITE_DOMAIN`, when set, wins. Set `ACE_API_URL` and `ACE_PREVIEW_ADMIN_ORIGIN` (in `.env`) only to use a CMS running on your own machine, for example `http://localhost:8080` and `http://localhost:5173`.
 
 ## Pages
 

package/docs/command-line.md

@@ -10,18 +10,18 @@ npx ace-kit generate   # write TypeScript types (see Typed content)
 npx ace-kit sync       # send your section types to the CMS (see Sections)
 ```
 
-Every command takes `--api-url`, or reads `ACE_API_URL` from the environment or a `.env` file in the folder you run it in. Failing both, it uses the address you last signed in to (kept in a small file beside your logins), so after `ace-kit login --api-url …` you can simply run `ace-kit whoami` from anywhere.
+Commands talk to the hosted CMS Ace unless told otherwise. Only for a CMS on your own machine, give `--api-url`, or set `ACE_API_URL` in the environment or a `.env` file in the folder you run it in. Failing both, a command uses the address you last signed in to (kept in a small file beside your logins), and failing that the hosted one, so `ace-kit login` and `ace-kit whoami` need no flags at all. Commands about a site (`sync`, `generate`) take `--site example.com`, or read `ACE_SITE_DOMAIN`.
 
 ## Signing in
 
 ```sh
-npx ace-kit login --api-url http://localhost:8080
+npx ace-kit login
 ```
 
 ```
-Signing in to http://localhost:8080
+Signing in to https://api.ace-cms.co.uk
 
-  1. Go to   http://localhost:5173/device
+  1. Go to   https://app.ace-cms.co.uk/device
   2. Type    BCDF-GHJK
 
 Check the code on that page matches. Waiting for you to approve it (Ctrl-C to cancel)...

package/docs/dev-sites.md

@@ -6,7 +6,7 @@ When your site's dev server works against a hosted CMS, it doesn't touch the liv
 
 On start, the dev server (the Astro integration, or the `ace()` Vite plugin on React Router):
 
-1. checks you are signed in (`npx ace-kit login`), and finds the site `ACE_SITE_DOMAIN` names;
+1. checks you are signed in (`npx ace-kit login`), and finds the site you are working on (Astro's `site` setting, or `ACE_SITE_DOMAIN`);
 2. asks the CMS for your dev site of it, which the CMS makes the first time as a copy of the live site: its content types, section types, menus and the **text** of its entries, with every link between entries pointing at the copy. Images are not copied yet, so image fields start empty;
 3. points the site at it: `ACE_SITE_DOMAIN` becomes the dev site's domain for as long as the dev server runs (your `.env` is not changed), so the site reads its content from the dev site, and section sync goes there;
 4. tells the CMS where the dev server is running, so the live preview in the admin app shows your dev server.
@@ -23,7 +23,7 @@ Partner accounts and super admins, for sites they own. Ask for a partner account
 
 ## Going to the live site
 
-A dev site is never merged into the live site. When your change is ready, deploy your site, then run `npx ace-kit sync` against the live site (`ACE_SITE_DOMAIN` set to the live domain, as in your `.env`). Deploy first: the live CMS then has the section types the deployed code expects.
+A dev site is never merged into the live site. When your change is ready, deploy your site, then run `npx ace-kit sync` against the live site (`--site www.example.com`, or `ACE_SITE_DOMAIN`). Deploy first: the live CMS then has the section types the deployed code expects.
 
 ## Settings
 

package/docs/react-router.md

@@ -26,11 +26,13 @@ export default defineConfig({ plugins: [ace(), reactRouter()] });
 
 The settings are environment variables, read when the server starts, so one build runs anywhere. Put them in `.env` for development and in the host's environment for production:
 
-| Variable                   | Default                 | Meaning                                                   |
-| -------------------------- | ----------------------- | --------------------------------------------------------- |
-| `ACE_API_URL`              | `http://localhost:8080` | where the CMS Ace API lives                               |
-| `ACE_SITE_DOMAIN`          | `localhost`             | the domain this site has in the CMS (the port is ignored) |
-| `ACE_PREVIEW_ADMIN_ORIGIN` | `http://localhost:5173` | where the CMS admin app runs                              |
+| Variable                   | Default                     | Meaning                                                   |
+| -------------------------- | --------------------------- | --------------------------------------------------------- |
+| `ACE_API_URL`              | `https://api.ace-cms.co.uk` | where the CMS Ace API lives                               |
+| `ACE_SITE_DOMAIN`          | `localhost`                 | the domain this site has in the CMS (the port is ignored) |
+| `ACE_PREVIEW_ADMIN_ORIGIN` | `https://app.ace-cms.co.uk` | where the CMS admin app runs                              |
+
+CMS Ace is a hosted platform, so a site normally sets only `ACE_SITE_DOMAIN`. Set the other two only to use a CMS on your own machine (`http://localhost:8080` and `http://localhost:5173`).
 
 **2. The server entry**, which renders pages and lets the CMS's admin app (and only it) frame the site for [live preview](./live-preview.md):
 

package/docs/sections.md

@@ -87,7 +87,7 @@ While the dev server runs, Ace Kit watches for `*.schema.ts` files (in `src`) an
 10:41:07 [ace-kit] Synced 3 section types (faq, gallery, hero) to localhost (http://localhost:8080).
 ```
 
-You don't run anything. You do need to be signed in once: `npx ace-kit login` (see [the command line](./command-line.md)). The sync goes to the site named by `ACE_SITE_DOMAIN` at `ACE_API_URL`, the same settings the site reads its content with, and only an owner of that site (or a super admin) can sync to it.
+You don't run anything. You do need to be signed in once: `npx ace-kit login` (see [the command line](./command-line.md)). The sync goes to the site the dev server is working on, the same one it reads its content from, and only an owner of that site (or a super admin) can sync to it.
 
 **Your dev site, not the live one.** Against a _hosted_ CMS the dev server works on a [dev site](./dev-sites.md): your own private copy of the site, made for you the first time, so a half-written field never reaches editors or visitors of the live site. The sync goes there. Against a CMS on your own machine there is no need for one, and the sync goes to the site itself.
 

package/docs/typed-content.md

@@ -3,16 +3,16 @@
 The kit can write TypeScript types for your site's content types, so `getEntry` and `getEntries` return the right shape and a change in the CMS shows up as a type error in your site.
 
 ```sh
-npx ace-kit generate --api-url http://localhost:8080 --domain localhost
+npx ace-kit generate --site www.example.com
 ```
 
 or with the settings in the environment:
 
 ```sh
-ACE_API_URL=http://localhost:8080 ACE_SITE_DOMAIN=localhost npx ace-kit generate
+ACE_SITE_DOMAIN=www.example.com npx ace-kit generate
 ```
 
-It reads `GET /public/content-types` (no login: it describes field names and kinds, never entries) and writes `src/ace-kit.generated.d.ts` (change it with `--out`). Make sure the file is inside your `tsconfig` `include`. Commit it, and run the command again whenever content types change (a good moment is a CI step, or a `generate` script next to `dev`).
+Add `--api-url http://localhost:8080` (or `ACE_API_URL`) only for a CMS on your own machine. It reads `GET /public/content-types` (no login: it describes field names and kinds, never entries) and writes `src/ace-kit.generated.d.ts` (change it with `--out`). Make sure the file is inside your `tsconfig` `include`. Commit it, and run the command again whenever content types change (a good moment is a CI step, or a `generate` script next to `dev`).
 
 ```ts
 // ace-kit.generated.d.ts (generated)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sandboxsonny/ace-kit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Everything a website needs to use CMS Ace: a typed client, addressing, images, menus, rich text, live preview, and Astro and React adapters.",
   "keywords": [
     "cms",