@openluxeco/cli 0.1.0 → 0.5.1

package/README.md

@@ -38,6 +38,46 @@ openluxe auth logout      # forget the local token
 
 Revoke a CLI token anytime from **Settings → Integrations** on the web.
 
+## Terms of Service
+
+Use of the API and this CLI is governed by a binding agreement. Before any
+request will succeed you must read and accept the **OpenLuxe API & CLI Terms
+of Service** and every referenced policy (Terms of Service, Privacy, Acceptable
+Use, Data, Cookie). This is a one-time, in-browser step — authorizing the
+device during `openluxe auth login` records your acceptance. You are
+re-prompted only if the terms materially change (e.g. pricing, rate limits,
+discontinued endpoints).
+
+If a token predates the current terms (or they changed), every call returns
+`403` and the CLI tells you exactly where to accept. Review anytime:
+
+```bash
+openluxe terms
+```
+
+Key points: the API and CLI are provided "as is" with no uptime guarantee;
+endpoints, pricing, credits, and rate limits may change or be discontinued at
+any time without liability; AI-generated output may be inaccurate and must be
+independently verified. Full text: `https://openluxe.co/api-terms`.
+
+## Pro access
+
+The OpenLuxe API, this CLI, and the MCP server are part of the **Pro suite** —
+using them requires unlocking Pro access on your account (the same one-time
+platform access that gates the Pro apps in the web app). Until you unlock it,
+commands return:
+
+```
+✗ Pro access required
+  The OpenLuxe API, CLI, and MCP server are part of the Pro suite.
+  Unlock Pro access ($99 today) to use them.
+
+  Unlock here:  https://openluxe.co/onboarding/access
+```
+
+Authorizing the CLI (`openluxe auth login`) is also blocked in the browser until
+you unlock access. Admins and grandfathered accounts are exempt.
+
 ## Use it
 
 Typed resource commands:
@@ -51,8 +91,20 @@ openluxe webhooks events
 openluxe me show
 ```
 
-Run `openluxe <resource>` to see its commands, or `openluxe help` for the
-full list.
+AI generation is async — start a job, then poll the returned handle:
+
+```bash
+# start (returns { data: { id, status, status_url } } with HTTP 202)
+openluxe generate start image -d '{"prompt":"a marble villa at golden hour"}'
+openluxe generate start agent_odysseus -d '{"message":"brief me before the meeting"}'
+
+# poll until status is succeeded | failed
+openluxe generations get <id>
+```
+
+Generations are charged the same credits as the equivalent in-app action; a
+shortfall returns `402` with a `topup_url`. Run `openluxe <resource>` to see
+its commands, or `openluxe help` for the full list.
 
 Raw passthrough to any v1 endpoint:
 
@@ -73,6 +125,41 @@ scripts and tool-use loops.
 export OPENLUXE_API_URL=https://openluxe.co   # default; override for staging/local
 ```
 
+## MCP (Model Context Protocol)
+
+`openluxe mcp` runs an MCP server over stdio, so any MCP-aware client
+(Claude Code, Claude Desktop, Cursor, …) can drive OpenLuxe in a chat. It
+authenticates with your stored CLI token and proxies to the v1 API — the agent
+gets the same scoped, ToS-gated, billed surface you do.
+
+Sign in once (`openluxe auth login`), then register the server with your client.
+Example MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "openluxe": { "command": "openluxe", "args": ["mcp"] }
+  }
+}
+```
+
+It exposes a lean tool set — `openluxe_list_endpoints` to discover the full v1
+surface and `openluxe_api_request` to call any of it, plus typed helpers
+(`openluxe_me`, `openluxe_search`, `openluxe_contacts_list`,
+`openluxe_create_contact`, `openluxe_credits_balance`). OpenLuxe also hosts a
+remote MCP server at `https://openluxe.co/api/v1/mcp` (Bearer-authed with a
+`ol_itk_` token) for clients that speak Streamable HTTP directly.
+
+## Credits
+
+AI-generating calls (`openluxe generate …`) cost credits at web-app parity. A
+shortfall returns `402` with a top-up link; you can also open it anytime:
+
+```bash
+openluxe credits balance
+openluxe credits buy
+```
+
 ## Environment
 
 | Var | Purpose |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openluxeco/cli",
-  "version": "0.1.0",
+  "version": "0.5.1",
   "description": "Official OpenLuxe command-line client — drive the OpenLuxe v1 API from your terminal or an AI agent.",
   "type": "module",
   "bin": {

package/src/api.js

@@ -8,6 +8,28 @@ export class ApiError extends Error {
     }
 }
 
+/**
+ * Node's fetch buries the real failure (TLS, DNS, refused) in `error.cause` and
+ * reports only "fetch failed" — surface the cause plus an actionable hint.
+ */
+function networkErrorMessage(e, url) {
+    const cause = e.cause || {};
+    const code = cause.code || '';
+    const causeMsg = cause.message || '';
+    let origin = '';
+    try { origin = ' (' + new URL(url).origin + ')'; } catch { /* keep plain */ }
+
+    let msg = `Network error: ${causeMsg || e.message}${origin}`;
+    if (/CERT|certificate|SSL|TLS/i.test(code + ' ' + causeMsg)) {
+        msg += '\n  Untrusted/self-signed certificate — for a local dev server, retry with OPENLUXE_INSECURE=1';
+    } else if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
+        msg += '\n  Host not found — check the API base (OPENLUXE_API_URL, or `openluxe auth status` for the stored base)';
+    } else if (code === 'ECONNREFUSED') {
+        msg += '\n  Connection refused — is the server running at that base URL?';
+    }
+    return msg;
+}
+
 /**
  * Perform an authenticated v1 API request. `path` is everything after
  * /api/v1 (e.g. "/contacts"). `query` is an object, `body` is JSON-able.
@@ -36,7 +58,7 @@ export async function request(method, path, { query, body, token, base } = {}) {
     try {
         res = await fetch(url, init);
     } catch (e) {
-        throw new ApiError(0, `Network error: ${e.message}`);
+        throw new ApiError(0, networkErrorMessage(e, url));
     }
 
     const text = await res.text();
@@ -55,11 +77,16 @@ export async function request(method, path, { query, body, token, base } = {}) {
 /** Unauthenticated POST used only by the device-auth handshake. */
 export async function postPublic(base, path, body) {
     const url = base.replace(/\/$/, '') + '/api/v1' + path;
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
-        body: JSON.stringify(body || {}),
-    });
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify(body || {}),
+        });
+    } catch (e) {
+        throw new ApiError(0, networkErrorMessage(e, url));
+    }
     const text = await res.text();
     let parsed;
     try { parsed = text ? JSON.parse(text) : null; } catch { parsed = text; }

package/src/auth.js

@@ -54,6 +54,11 @@ export async function login({ base } = {}) {
             const who = poll.data.user?.email || poll.data.user?.name || 'your account';
             console.log(`\x1b[32m✓ Signed in as ${who}\x1b[0m`);
             console.log(`  Token stored at ${credentialsPath}`);
+            console.log('');
+            console.log('  Your API use is governed by the OpenLuxe API & CLI Terms');
+            console.log(`  and all referenced policies — see \x1b[36m${apiBase}/api-terms\x1b[0m`);
+            console.log("  (run `openluxe terms`). Authorizing this device recorded");
+            console.log("  your acceptance; you'll be re-prompted only if they change.");
             return;
         }
         if (poll.ok && poll.data?.status === 'pending') {

package/src/cli.js

@@ -1,7 +1,8 @@
 import { request, ApiError } from './api.js';
 import { RESOURCES } from './resources.js';
 import * as auth from './auth.js';
-import { load } from './config.js';
+import { load, VERSION } from './config.js';
+import { serve as mcpServe } from './mcp.js';
 
 const C = {
     dim: (s) => `\x1b[2m${s}\x1b[0m`,
@@ -53,6 +54,100 @@ function out(data) {
     process.stdout.write(typeof data === 'string' ? data + '\n' : JSON.stringify(data, null, 2) + '\n');
 }
 
+/** The server hard-blocks every call until the API & CLI Terms are accepted. */
+function isTermsBlock(e) {
+    return e?.status === 403
+        && typeof e?.body?.type === 'string'
+        && e.body.type.endsWith('/api_terms_required');
+}
+
+/** The API/CLI/MCP are Pro surfaces — blocked until the user unlocks Pro access. */
+function isPlatformAccessBlock(e) {
+    return e?.status === 402
+        && ((typeof e?.body?.type === 'string' && e.body.type.endsWith('/platform_access_required'))
+            || e?.body?.error === 'platform_access_required');
+}
+
+function printPlatformAccessBlock(body = {}) {
+    const url = body.upgrade_url || body.landing_url || `${load().base}/pro`;
+    const price = typeof body.price_cents === 'number' ? `$${(body.price_cents / 100).toLocaleString()}` : null;
+    console.error(C.red('✗ Pro access required'));
+    console.error('');
+    console.error('  The OpenLuxe API, CLI, and MCP server are part of the Pro suite.');
+    console.error(`  Unlock Pro access${price ? ` (${price} today)` : ''} to use them.`);
+    console.error('');
+    console.error(`  Unlock here:  ${C.cyan(url)}`);
+    console.error(C.dim('  Then re-run your command.'));
+}
+
+function printTermsBlock(body = {}) {
+    const acceptUrl = body.accept_url || `${load().base}/developers`;
+    console.error(C.red('✗ API & CLI Terms acceptance required'));
+    console.error('');
+    console.error('  Before using the API you must read and accept the current');
+    console.error('  OpenLuxe API & CLI Terms of Service and every referenced policy.');
+    console.error('  This is a one-time, in-browser step (it re-prompts only when');
+    console.error('  the terms change).');
+    console.error('');
+    console.error(`  Sign in and accept here:  ${C.cyan(acceptUrl)}`);
+    if (Array.isArray(body.required_policies) && body.required_policies.length) {
+        console.error('');
+        console.error('  You will be asked to accept:');
+        for (const p of body.required_policies) {
+            console.error(`    • ${p.title}${p.url ? C.dim('  ' + p.url) : ''}`);
+        }
+    }
+    console.error('');
+    console.error(C.dim('  Then re-run your command.'));
+}
+
+/** A billable call hit a credit shortfall — surface the top-up path (no in-app modal here). */
+function printInsufficientCredits(body = {}) {
+    const { base } = load();
+    const topup = body.topup_url || `${base}/credits/buy`;
+    console.error(C.red('✗ 402 Insufficient credits'));
+    if (body.message) console.error(`  ${body.message}`);
+    if (body.required_credits !== undefined) {
+        console.error(C.dim(`  required: ${body.required_credits}  available: ${body.available_credits ?? 0}  type: ${body.credit_type ?? 'credits'}`));
+    }
+    console.error('');
+    console.error(`  Top up here:  ${C.cyan(topup)}`);
+    console.error(C.dim('  Then re-run your command.'));
+}
+
+/** `openluxe credits buy` — open / print the credit top-up page. */
+function creditsBuy(flags = {}) {
+    const { base } = load();
+    const url = new URL(`${base.replace(/\/$/, '')}/credits/buy`);
+    if (flags.topup) url.searchParams.set('topup', flags.topup);
+    if (flags.required) url.searchParams.set('required', flags.required);
+    url.searchParams.set('label', flags.label || 'API credit top-up');
+    console.log(`Open this page to buy OpenLuxe credits:\n\n  ${C.cyan(url.toString())}\n`);
+    console.log(C.dim('Credits fund AI-generating API calls (openluxe generate ...) at the same cost as the web app.'));
+}
+
+function termsHelp() {
+    const { base } = load();
+    console.log(`
+${C.bold('openluxe terms')} — API & CLI Terms of Service
+
+  Using the OpenLuxe API or CLI is governed by a binding agreement.
+  You must read and accept it (and every referenced policy) once, in
+  your browser while signed in, before any request will work. You'll
+  be re-prompted only if the terms materially change.
+
+  Accept / review:
+    API & CLI Terms     ${C.cyan(base + '/api-terms')}
+    Terms of Service    ${C.cyan(base + '/terms-of-service')}
+    Privacy Policy      ${C.cyan(base + '/privacy-policy')}
+    Acceptable Use      ${C.cyan(base + '/acceptable-use')}
+    Data Policy         ${C.cyan(base + '/data-policy')}
+    Cookie Policy       ${C.cyan(base + '/cookie-policy')}
+
+  Accept from:          ${C.cyan(base + '/developers')}
+`);
+}
+
 async function callApi(method, path, { positionals = [], flags = {}, body }) {
     // Fill :placeholders from --flag of the same name, else positionals in order.
     const used = new Set();
@@ -80,7 +175,19 @@ async function callApi(method, path, { positionals = [], flags = {}, body }) {
         out(res);
     } catch (e) {
         if (e instanceof ApiError) {
-            console.error(C.red(`✗ ${e.status} ${e.message}`));
+            if (isTermsBlock(e)) {
+                printTermsBlock(e.body);
+                process.exit(1);
+            }
+            if (isPlatformAccessBlock(e)) {
+                printPlatformAccessBlock(e.body || {});
+                process.exit(1);
+            }
+            if (e.status === 402) {
+                printInsufficientCredits(e.body || {});
+                process.exit(1);
+            }
+            console.error(C.red('✗ ' + (e.status ? e.status + ' ' : '') + e.message));
             if (e.body && typeof e.body === 'object') console.error(C.dim(JSON.stringify(e.body, null, 2)));
             if (e.status === 401) console.error(C.dim('  Run: openluxe auth login'));
             process.exit(1);
@@ -101,12 +208,19 @@ ${C.bold('AUTH')}
   auth login                Sign in via your browser (device flow)
   auth logout               Forget the local token
   auth status               Show who you're signed in as
+  terms                     Review / accept the API & CLI Terms
 
 ${C.bold('RAW')}
   api <METHOD> <path>       Call any v1 endpoint directly
                             e.g. openluxe api GET /contacts --per_page 5
                                  openluxe api POST /notes -d '{"contact_id":1,"body":"hi"}'
 
+${C.bold('AI / MCP')}
+  mcp                       Run an MCP server over stdio (point Claude Code,
+                            Cursor, etc. at this to drive OpenLuxe in chat)
+  credits buy               Open the credit top-up page (funds AI calls)
+  manifest                  Print the typed-command surface as JSON
+
 ${C.bold('RESOURCES')}
 ${Object.entries(RESOURCES).map(([g, r]) => `  ${g.padEnd(16)} ${C.dim(r.summary)}`).join('\n')}
 
@@ -131,7 +245,22 @@ export async function run(argv) {
     const [cmd, ...rest] = argv;
 
     if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') return topHelp();
-    if (cmd === '--version' || cmd === '-v') return out('openluxe 0.1.0');
+    if (cmd === '--version' || cmd === '-v') return out('openluxe ' + VERSION);
+    if (cmd === 'terms') return termsHelp();
+
+    // MCP server over stdio — point Claude Code / Cursor at `openluxe mcp`.
+    if (cmd === 'mcp') return mcpServe();
+
+    // Emit the typed-command surface as JSON (feeds the coverage tooling).
+    if (cmd === 'manifest') {
+        const commands = [];
+        for (const [resource, def] of Object.entries(RESOURCES)) {
+            for (const [command, spec] of Object.entries(def.commands)) {
+                commands.push({ resource, command, method: spec.method, path: spec.path, summary: spec.summary || null });
+            }
+        }
+        return out({ version: VERSION, count: commands.length, commands });
+    }
 
     if (cmd === 'auth') {
         const sub = rest[0];
@@ -150,6 +279,12 @@ export async function run(argv) {
         return callApi(method, path, { flags, body });
     }
 
+    // `credits buy` opens the top-up page (not an API call).
+    if (cmd === 'credits' && rest[0] === 'buy') {
+        const { flags } = parseArgs(rest.slice(1));
+        return creditsBuy(flags);
+    }
+
     const group = RESOURCES[cmd];
     if (!group) return die(`Unknown command: ${cmd}. Run 'openluxe help'.`);
 

package/src/config.js

@@ -5,6 +5,11 @@ import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync, rmSync }
 const DIR = join(homedir(), '.openluxe');
 const FILE = join(DIR, 'credentials.json');
 
+/** Single source of truth for the CLI version — read from package.json. */
+export const VERSION = JSON.parse(
+    readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
+).version;
+
 const DEFAULT_BASE = process.env.OPENLUXE_API_URL || 'https://openluxe.co';
 
 export function load() {

package/src/mcp.js

@@ -0,0 +1,188 @@
+/**
+ * `openluxe mcp` — a zero-dependency MCP (Model Context Protocol) server over
+ * stdio that exposes the OpenLuxe v1 API to local AI clients (Claude Code,
+ * Cursor, etc.). It authenticates with the token stored by `openluxe auth login`
+ * and proxies every call to https://<base>/api/v1, so an agent gets the same
+ * scoped, ToS-gated, billed surface a human gets from the CLI.
+ *
+ * Transport: newline-delimited JSON-RPC 2.0 on stdin/stdout (the MCP stdio
+ * transport). We implement just enough of the protocol — initialize, tools/list,
+ * tools/call, ping — to be a useful client target.
+ *
+ * Tools are intentionally lean (a generic passthrough + endpoint discovery +
+ * a few high-value typed tools) rather than one-per-endpoint, so the agent's
+ * tool list stays small; `openluxe_api_request` covers the full ~300-endpoint
+ * surface. This mirrors the hosted /api/v1/mcp server.
+ */
+import { createInterface } from 'node:readline';
+import { request, ApiError } from './api.js';
+import { RESOURCES } from './resources.js';
+import { load, VERSION } from './config.js';
+
+const PROTOCOL_VERSION = '2025-06-18';
+
+function send(msg) {
+    process.stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function result(id, result) {
+    send({ jsonrpc: '2.0', id, result });
+}
+
+function error(id, code, message) {
+    send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+/** A flat catalog of every typed CLI command, for the discovery tool. */
+function endpointCatalog() {
+    const rows = [];
+    for (const [resource, def] of Object.entries(RESOURCES)) {
+        for (const [command, spec] of Object.entries(def.commands)) {
+            rows.push({ resource, command, method: spec.method, path: spec.path, summary: spec.summary || null });
+        }
+    }
+    return rows;
+}
+
+const TOOLS = [
+    {
+        name: 'openluxe_api_request',
+        description:
+            'Call any OpenLuxe v1 API endpoint. Use openluxe_list_endpoints first to discover paths. '
+            + 'GET/DELETE use `query`; POST/PATCH/PUT use `body`. Paths are relative to /api/v1 (e.g. "/contacts").',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                method: { type: 'string', enum: ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'], description: 'HTTP method' },
+                path: { type: 'string', description: 'Path after /api/v1, e.g. /contacts or /contacts/42' },
+                query: { type: 'object', description: 'Query parameters (GET/DELETE)', additionalProperties: true },
+                body: { type: 'object', description: 'JSON body (POST/PATCH/PUT)', additionalProperties: true },
+            },
+            required: ['method', 'path'],
+        },
+        run: (args) => request(args.method, args.path, { query: args.query, body: args.body }),
+    },
+    {
+        name: 'openluxe_list_endpoints',
+        description: 'List every available OpenLuxe v1 endpoint (method, path, summary) grouped by resource, so you know what to pass to openluxe_api_request.',
+        inputSchema: {
+            type: 'object',
+            properties: { resource: { type: 'string', description: 'Optional: filter to one resource (e.g. "contacts")' } },
+        },
+        run: async (args) => {
+            const rows = endpointCatalog();
+            return args?.resource ? rows.filter((r) => r.resource === args.resource) : rows;
+        },
+    },
+    {
+        name: 'openluxe_me',
+        description: 'Show the authenticated user and the abilities (scopes) of the presenting token.',
+        inputSchema: { type: 'object', properties: {} },
+        run: () => request('GET', '/me'),
+    },
+    {
+        name: 'openluxe_search',
+        description: 'Universal search across the user\'s OpenLuxe records (contacts, listings, deals, etc.).',
+        inputSchema: { type: 'object', properties: { q: { type: 'string', description: 'Search query' } }, required: ['q'] },
+        run: (args) => request('GET', '/search', { query: { q: args.q } }),
+    },
+    {
+        name: 'openluxe_contacts_list',
+        description: 'List the user\'s CRM contacts. Optional filters: industry, email, phone, search, updated_since, created_via, per_page.',
+        inputSchema: { type: 'object', properties: { search: { type: 'string' }, industry: { type: 'string' }, per_page: { type: 'number' } } },
+        run: (args) => request('GET', '/contacts', { query: args || {} }),
+    },
+    {
+        name: 'openluxe_create_contact',
+        description: 'Create a CRM contact. Fields: email, first_name, last_name, phone, company, position, industry, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                first_name: { type: 'string' }, last_name: { type: 'string' }, email: { type: 'string' },
+                phone: { type: 'string' }, company: { type: 'string' }, industry: { type: 'string' },
+            },
+        },
+        run: (args) => request('POST', '/contacts', { body: args || {} }),
+    },
+    {
+        name: 'openluxe_credits_balance',
+        description: 'Show the user\'s credit balance (what API generation calls are billed against).',
+        inputSchema: { type: 'object', properties: {} },
+        run: () => request('GET', '/credits/balance'),
+    },
+];
+
+const TOOL_INDEX = Object.fromEntries(TOOLS.map((t) => [t.name, t]));
+
+async function handle(msg) {
+    const { id, method, params } = msg;
+    const isRequest = id !== undefined && id !== null;
+
+    switch (method) {
+        case 'initialize':
+            return result(id, {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: { name: 'openluxe', version: VERSION },
+                instructions: 'Drive the OpenLuxe v1 API (CRM, listings, business, generation, …). '
+                    + 'Start with openluxe_list_endpoints, then openluxe_api_request for anything not covered by a typed tool.',
+            });
+
+        case 'notifications/initialized':
+        case 'notifications/cancelled':
+            return; // notifications get no response
+
+        case 'ping':
+            return isRequest && result(id, {});
+
+        case 'tools/list':
+            return result(id, {
+                tools: TOOLS.map(({ name, description, inputSchema }) => ({ name, description, inputSchema })),
+            });
+
+        case 'tools/call': {
+            const tool = TOOL_INDEX[params?.name];
+            if (!tool) return error(id, -32602, `Unknown tool: ${params?.name}`);
+            try {
+                const data = await tool.run(params.arguments || {});
+                return result(id, { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+            } catch (e) {
+                // Surface API errors to the model as tool errors (isError), not protocol errors.
+                const text = e instanceof ApiError
+                    ? `API error ${e.status}: ${e.message}\n${JSON.stringify(e.body ?? {}, null, 2)}`
+                    : `Error: ${e.message}`;
+                return result(id, { content: [{ type: 'text', text }], isError: true });
+            }
+        }
+
+        default:
+            return isRequest && error(id, -32601, `Method not found: ${method}`);
+    }
+}
+
+export async function serve() {
+    const { token, base } = load();
+    if (!token) {
+        process.stderr.write('openluxe mcp: not signed in — run `openluxe auth login` first.\n');
+        process.exit(1);
+    }
+    process.stderr.write(`openluxe mcp server ready (${base}) — ${TOOLS.length} tools.\n`);
+
+    const rl = createInterface({ input: process.stdin });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        } catch {
+            error(null, -32700, 'Parse error');
+            continue;
+        }
+        try {
+            await handle(msg);
+        } catch (e) {
+            if (msg?.id !== undefined && msg?.id !== null) error(msg.id, -32603, `Internal error: ${e.message}`);
+        }
+    }
+}

package/src/resources.js

@@ -8,7 +8,9 @@
  *   - For POST/PATCH: --flags + `-d '<json>'` merge into the JSON body.
  *
  * This is intentionally data-driven so the CLI mirrors the API surface
- * without 100+ hand-written command files.
+ * without 100+ hand-written command files. Curated resources are kept
+ * verbatim; the rest are generated for full parity with the v1 route table
+ * (regenerate via the main repo's scripts + `openluxe manifest`).
  */
 export const RESOURCES = {
     contacts: {
@@ -19,6 +21,46 @@ export const RESOURCES = {
             create: { method: 'POST', path: '/contacts', summary: 'Create a contact' },
             update: { method: 'PATCH', path: '/contacts/:contact', summary: 'Update a contact' },
             delete: { method: 'DELETE', path: '/contacts/:contact', summary: 'Delete a contact' },
+            problems: { method: 'GET', path: '/contacts/:contact/problems', summary: 'GET /contacts/{contact}/problems  [scope: crm:contacts:read]' },
+            'cultural-briefing': { method: 'GET', path: '/contacts/:contact/cultural-briefing', summary: 'GET /contacts/{contact}/cultural-briefing  [scope: crm:cultural:read]' },
+            personality: { method: 'GET', path: '/contacts/:contact/personality', summary: 'GET /contacts/{contact}/personality  [scope: crm:contacts:read]' },
+            favors: { method: 'GET', path: '/contacts/:contact/favors', summary: 'GET /contacts/{contact}/favors  [scope: crm:contacts:read]' },
+            'compliance-limits': { method: 'GET', path: '/contacts/:contact/compliance-limits', summary: 'GET /contacts/{contact}/compliance-limits  [scope: crm:contacts:read]' },
+            status: { method: 'GET', path: '/contacts/:contact/compliance-limits/status', summary: 'GET /contacts/{contact}/compliance-limits/status  [scope: crm:contacts:read]' },
+            value: { method: 'GET', path: '/contacts/:contact/value', summary: 'GET /contacts/{contact}/value  [scope: crm:contacts:read]' },
+            economics: { method: 'GET', path: '/contacts/:contact/economics', summary: 'GET /contacts/{contact}/economics  [scope: crm:contacts:read]' },
+            'buyer-profile': { method: 'GET', path: '/contacts/:contact/buyer-profile', summary: 'GET /contacts/{contact}/buyer-profile  [scope: crm:contacts:read]' },
+            'user-links': { method: 'GET', path: '/contacts/:contact/user-links', summary: 'GET /contacts/{contact}/user-links  [scope: crm:contacts:read]' },
+            'update-personality': { method: 'PUT', path: '/contacts/:contact/personality', summary: 'PUT /contacts/{contact}/personality  [scope: crm:contacts:write]' },
+            'create-favors': { method: 'POST', path: '/contacts/:contact/favors', summary: 'POST /contacts/{contact}/favors  [scope: crm:contacts:write]' },
+            'update-favors': { method: 'PUT', path: '/contacts/:contact/favors/:favor', summary: 'PUT /contacts/{contact}/favors/{favor}  [scope: crm:contacts:write]' },
+            'delete-favors': { method: 'DELETE', path: '/contacts/:contact/favors/:favor', summary: 'DELETE /contacts/{contact}/favors/{favor}  [scope: crm:contacts:write]' },
+            reciprocate: { method: 'POST', path: '/contacts/:contact/favors/:favor/reciprocate', summary: 'POST /contacts/{contact}/favors/{favor}/reciprocate  [scope: crm:contacts:write]' },
+            'create-compliance-limits': { method: 'POST', path: '/contacts/:contact/compliance-limits', summary: 'POST /contacts/{contact}/compliance-limits  [scope: crm:contacts:write]' },
+            'update-compliance-limits': { method: 'PUT', path: '/contacts/:contact/compliance-limits/:limit', summary: 'PUT /contacts/{contact}/compliance-limits/{limit}  [scope: crm:contacts:write]' },
+            'delete-compliance-limits': { method: 'DELETE', path: '/contacts/:contact/compliance-limits/:limit', summary: 'DELETE /contacts/{contact}/compliance-limits/{limit}  [scope: crm:contacts:write]' },
+            issue: { method: 'POST', path: '/contacts/:contact/compliance-override/issue', summary: 'POST /contacts/{contact}/compliance-override/issue  [scope: crm:contacts:write]' },
+            'create-value-manual-entry': { method: 'POST', path: '/contacts/:contact/value/manual-entry', summary: 'POST /contacts/{contact}/value/manual-entry  [scope: crm:contacts:write]' },
+            'update-value-expected-ltv': { method: 'PUT', path: '/contacts/:contact/value/expected-ltv', summary: 'PUT /contacts/{contact}/value/expected-ltv  [scope: crm:contacts:write]' },
+            'create-user-links': { method: 'POST', path: '/contacts/:contact/user-links', summary: 'POST /contacts/{contact}/user-links  [scope: crm:contacts:write]' },
+            discover: { method: 'POST', path: '/contacts/:contact/user-links/discover', summary: 'POST /contacts/{contact}/user-links/discover  [scope: crm:contacts:write]' },
+            confirm: { method: 'POST', path: '/contacts/:contact/user-links/:link/confirm', summary: 'POST /contacts/{contact}/user-links/{link}/confirm  [scope: crm:contacts:write]' },
+            reject: { method: 'POST', path: '/contacts/:contact/user-links/:link/reject', summary: 'POST /contacts/{contact}/user-links/{link}/reject  [scope: crm:contacts:write]' },
+            overview: { method: 'GET', path: '/contacts/:contact/owned-assets/:asset/overview', summary: 'GET /contacts/{contact}/owned-assets/{asset}/overview  [scope: crm:assets:read]' },
+            'owned-assets-service-events': { method: 'GET', path: '/contacts/:contact/owned-assets/:asset/service-events', summary: 'GET /contacts/{contact}/owned-assets/{asset}/service-events  [scope: crm:assets:read]' },
+            'owned-assets-locations': { method: 'GET', path: '/contacts/:contact/owned-assets/:asset/locations', summary: 'GET /contacts/{contact}/owned-assets/{asset}/locations  [scope: crm:assets:read]' },
+            'owned-assets-upgrades': { method: 'GET', path: '/contacts/:contact/owned-assets/:asset/upgrades', summary: 'GET /contacts/{contact}/owned-assets/{asset}/upgrades  [scope: crm:assets:read]' },
+            'create-owned-assets-service-events': { method: 'POST', path: '/contacts/:contact/owned-assets/:asset/service-events', summary: 'POST /contacts/{contact}/owned-assets/{asset}/service-events  [scope: crm:assets:write]' },
+            'update-owned-assets-service-events': { method: 'PUT', path: '/contacts/:contact/owned-assets/:asset/service-events/:event', summary: 'PUT /contacts/{contact}/owned-assets/{asset}/service-events/{event}  [scope: crm:assets:write]' },
+            'delete-owned-assets-service-events': { method: 'DELETE', path: '/contacts/:contact/owned-assets/:asset/service-events/:event', summary: 'DELETE /contacts/{contact}/owned-assets/{asset}/service-events/{event}  [scope: crm:assets:write]' },
+            'create-owned-assets-locations': { method: 'POST', path: '/contacts/:contact/owned-assets/:asset/locations', summary: 'POST /contacts/{contact}/owned-assets/{asset}/locations  [scope: crm:assets:write]' },
+            'create-owned-assets-upgrades': { method: 'POST', path: '/contacts/:contact/owned-assets/:asset/upgrades', summary: 'POST /contacts/{contact}/owned-assets/{asset}/upgrades  [scope: crm:assets:write]' },
+            'commission-partnerships': { method: 'GET', path: '/contacts/:contact/commission-partnerships', summary: 'GET /contacts/{contact}/commission-partnerships  [scope: crm:commission:read]' },
+            earnings: { method: 'GET', path: '/contacts/:contact/commission-partnerships/:partnership/earnings', summary: 'GET /contacts/{contact}/commission-partnerships/{partnership}/earnings  [scope: crm:commission:read]' },
+            'create-commission-partnerships': { method: 'POST', path: '/contacts/:contact/commission-partnerships', summary: 'POST /contacts/{contact}/commission-partnerships  [scope: crm:commission:write]' },
+            'create-earnings': { method: 'POST', path: '/contacts/:contact/commission-partnerships/:partnership/earnings', summary: 'POST /contacts/{contact}/commission-partnerships/{partnership}/earnings  [scope: crm:commission:write]' },
+            'update-commission-partnerships': { method: 'PUT', path: '/contacts/:contact/commission-partnerships/:partnership', summary: 'PUT /contacts/{contact}/commission-partnerships/{partnership}  [scope: crm:commission:write]' },
+            'delete-commission-partnerships': { method: 'DELETE', path: '/contacts/:contact/commission-partnerships/:partnership', summary: 'DELETE /contacts/{contact}/commission-partnerships/{partnership}  [scope: crm:commission:write]' },
         },
     },
     notes: {
@@ -66,6 +108,8 @@ export const RESOURCES = {
             create: { method: 'POST', path: '/contact-lists' },
             update: { method: 'PATCH', path: '/contact-lists/:list' },
             delete: { method: 'DELETE', path: '/contact-lists/:list' },
+            'create-contacts': { method: 'POST', path: '/contact-lists/:list/contacts', summary: 'POST /contact-lists/{list}/contacts  [scope: crm:lists:write]' },
+            'delete-contacts': { method: 'DELETE', path: '/contact-lists/:list/contacts', summary: 'DELETE /contact-lists/{list}/contacts  [scope: crm:lists:write]' },
         },
     },
     listings: {
@@ -134,11 +178,20 @@ export const RESOURCES = {
             enrollments: { method: 'GET', path: '/course-enrollments' },
         },
     },
+    smartboards: {
+        summary: 'Smartboards / collaborative diagrams (read-only in v1)',
+        commands: {
+            list: { method: 'GET', path: '/smartboards' },
+            get: { method: 'GET', path: '/smartboards/:smartboard', summary: 'One board with its elements' },
+        },
+    },
     credits: {
         summary: 'Credit balance & ledger',
         commands: {
             balance: { method: 'GET', path: '/credits/balance' },
             ledger: { method: 'GET', path: '/credits/ledger' },
+            pricing: { method: 'GET', path: '/credits/pricing', summary: 'GET /credits/pricing  [scope: credits:balance:read]' },
+            usage: { method: 'GET', path: '/credits/usage', summary: 'GET /credits/usage  [scope: credits:balance:read]' },
         },
     },
     webhooks: {
@@ -178,4 +231,544 @@ export const RESOURCES = {
             show: { method: 'GET', path: '/me', summary: 'Who am I + token scopes' },
         },
     },
+    generate: {
+        summary: 'AI generation (async): start a job, then poll with `generations get <id>`',
+        commands: {
+            start: { method: 'POST', path: '/generate/:feature', summary: 'Start a generation. feature ∈ image, video, sound_effect, email_template, sales_presentation, blog_article, podcast, sticker, brand_colors, dossier, agent_odysseus, agent_apollo, agent_atticus, agent_eva, agent_alfred. Inputs via -d \'<json>\'. Returns a 202 handle.' },
+        },
+    },
+    generations: {
+        summary: 'Poll an async AI generation handle',
+        commands: {
+            get: { method: 'GET', path: '/generations/:id', summary: 'Poll a generation by id — status (queued|processing|succeeded|failed) + result' },
+        },
+    },
+    cli: {
+        summary: 'cli (v1)',
+        commands: {
+            'create-auth-start': { method: 'POST', path: '/cli/auth/start', summary: 'POST /cli/auth/start' },
+            'create-auth-poll': { method: 'POST', path: '/cli/auth/poll', summary: 'POST /cli/auth/poll' },
+        },
+    },
+    industries: {
+        summary: 'industries (v1)',
+        commands: {
+            list: { method: 'GET', path: '/industries', summary: 'GET /industries' },
+            schema: { method: 'GET', path: '/industries/:industry/schema', summary: 'GET /industries/{industry}/schema' },
+        },
+    },
+    'live-shop': {
+        summary: 'live shop (v1)',
+        commands: {
+            list: { method: 'GET', path: '/live-shop', summary: 'GET /live-shop  [scope: livestreams:read]' },
+        },
+    },
+    kanbans: {
+        summary: 'kanbans (v1)',
+        commands: {
+            get: { method: 'GET', path: '/kanbans/:kanban', summary: 'GET /kanbans/{kanban}  [scope: crm:kanban:read]' },
+            list: { method: 'GET', path: '/kanbans', summary: 'GET /kanbans  [scope: crm:kanban:read]' },
+            lists: { method: 'GET', path: '/kanbans/:kanban/lists', summary: 'GET /kanbans/{kanban}/lists  [scope: crm:kanban:read]' },
+        },
+    },
+    'business-org-chart': {
+        summary: 'business org chart (v1)',
+        commands: {
+            list: { method: 'GET', path: '/business/org-chart', summary: 'GET /business/org-chart  [scope: business:org:read]' },
+        },
+    },
+    'business-departments': {
+        summary: 'business departments (v1)',
+        commands: {
+            list: { method: 'GET', path: '/business/departments', summary: 'GET /business/departments  [scope: business:org:read]' },
+        },
+    },
+    'crm-cultural-library': {
+        summary: 'crm cultural library (v1)',
+        commands: {
+            list: { method: 'GET', path: '/crm/cultural-library', summary: 'GET /crm/cultural-library  [scope: crm:cultural:read]' },
+            get: { method: 'GET', path: '/crm/cultural-library/:profile', summary: 'GET /crm/cultural-library/{profile}  [scope: crm:cultural:read]' },
+        },
+    },
+    'crm-portfolio': {
+        summary: 'crm portfolio (v1)',
+        commands: {
+            get: { method: 'GET', path: '/crm/portfolio/:section', summary: 'GET /crm/portfolio/{section}  [scope: crm:portfolio:read]' },
+        },
+    },
+    'client-deals': {
+        summary: 'client deals (v1)',
+        commands: {
+            list: { method: 'GET', path: '/client-deals', summary: 'GET /client-deals  [scope: crm:client_deals:read]' },
+            get: { method: 'GET', path: '/client-deals/:uuid', summary: 'GET /client-deals/{uuid}  [scope: crm:client_deals:read]' },
+        },
+    },
+    invoices: {
+        summary: 'invoices (v1)',
+        commands: {
+            list: { method: 'GET', path: '/invoices', summary: 'GET /invoices  [scope: crm:invoices:read]' },
+            get: { method: 'GET', path: '/invoices/:invoice', summary: 'GET /invoices/{invoice}  [scope: crm:invoices:read]' },
+        },
+    },
+    reviews: {
+        summary: 'reviews (v1)',
+        commands: {
+            list: { method: 'GET', path: '/reviews', summary: 'GET /reviews  [scope: crm:reviews:read]' },
+            get: { method: 'GET', path: '/reviews/:review', summary: 'GET /reviews/{review}  [scope: crm:reviews:read]' },
+        },
+    },
+    'message-campaigns': {
+        summary: 'message campaigns (v1)',
+        commands: {
+            list: { method: 'GET', path: '/message-campaigns', summary: 'GET /message-campaigns  [scope: crm:campaigns:read]' },
+            get: { method: 'GET', path: '/message-campaigns/:uuid', summary: 'GET /message-campaigns/{uuid}  [scope: crm:campaigns:read]' },
+            create: { method: 'POST', path: '/message-campaigns', summary: 'POST /message-campaigns  [scope: crm:campaigns:write]' },
+            enroll: { method: 'POST', path: '/message-campaigns/:uuid/enroll', summary: 'POST /message-campaigns/{uuid}/enroll  [scope: crm:campaigns:write]' },
+        },
+    },
+    'phone-numbers': {
+        summary: 'phone numbers (v1)',
+        commands: {
+            list: { method: 'GET', path: '/phone-numbers', summary: 'GET /phone-numbers  [scope: comms:numbers:read]' },
+            'list-2': { method: 'GET', path: '/phone-numbers/:uuid', summary: 'GET /phone-numbers/{uuid}  [scope: comms:numbers:read]' },
+            create: { method: 'POST', path: '/phone-numbers', summary: 'POST /phone-numbers  [scope: comms:numbers:write]' },
+        },
+    },
+    'command-centers': {
+        summary: 'command centers (v1)',
+        commands: {
+            overview: { method: 'GET', path: '/command-centers/:slug/overview', summary: 'GET /command-centers/{slug}/overview  [scope: business:command-center:read]' },
+            missions: { method: 'GET', path: '/command-centers/:slug/missions', summary: 'GET /command-centers/{slug}/missions  [scope: business:command-center:read]' },
+            'missions-2': { method: 'GET', path: '/command-centers/:slug/missions/:mission', summary: 'GET /command-centers/{slug}/missions/{mission}  [scope: business:command-center:read]' },
+            'work-feed': { method: 'GET', path: '/command-centers/:slug/work-feed', summary: 'GET /command-centers/{slug}/work-feed  [scope: business:command-center:read]' },
+            'performance-competencies': { method: 'GET', path: '/command-centers/:slug/performance/competencies', summary: 'GET /command-centers/{slug}/performance/competencies  [scope: business:performance:read]' },
+            'performance-templates': { method: 'GET', path: '/command-centers/:slug/performance/templates', summary: 'GET /command-centers/{slug}/performance/templates  [scope: business:performance:read]' },
+            reviews: { method: 'GET', path: '/command-centers/:slug/performance/reviews', summary: 'GET /command-centers/{slug}/performance/reviews  [scope: business:performance:read]' },
+            'reviews-2': { method: 'GET', path: '/command-centers/:slug/performance/reviews/:review', summary: 'GET /command-centers/{slug}/performance/reviews/{review}  [scope: business:performance:read]' },
+            'performance-subjects-rollup': { method: 'GET', path: '/command-centers/:slug/performance/subjects/:subject/rollup', summary: 'GET /command-centers/{slug}/performance/subjects/{subject}/rollup  [scope: business:performance:read]' },
+            'performance-plans': { method: 'GET', path: '/command-centers/:slug/performance/plans', summary: 'GET /command-centers/{slug}/performance/plans  [scope: business:performance:read]' },
+        },
+    },
+    'email-messages': {
+        summary: 'email messages (v1)',
+        commands: {
+            list: { method: 'GET', path: '/email-messages', summary: 'GET /email-messages  [scope: comms:email:read]' },
+            get: { method: 'GET', path: '/email-messages/:emailMessage', summary: 'GET /email-messages/{emailMessage}  [scope: comms:email:read]' },
+            send: { method: 'POST', path: '/email-messages/send', summary: 'POST /email-messages/send  [scope: comms:email:send]' },
+        },
+    },
+    'email-deliverability-contact-lists': {
+        summary: 'email deliverability contact lists (v1)',
+        commands: {
+            status: { method: 'GET', path: '/email-deliverability/contact-lists/:contactList/status', summary: 'GET /email-deliverability/contact-lists/{contactList}/status  [scope: comms:email:deliverability:read]' },
+            validate: { method: 'POST', path: '/email-deliverability/contact-lists/:contactList/validate', summary: 'POST /email-deliverability/contact-lists/{contactList}/validate  [scope: comms:email:deliverability:write]' },
+        },
+    },
+    'email-suppression': {
+        summary: 'email suppression (v1)',
+        commands: {
+            list: { method: 'GET', path: '/email-suppression', summary: 'GET /email-suppression  [scope: comms:email:suppression:read]' },
+        },
+    },
+    'sms-messages': {
+        summary: 'sms messages (v1)',
+        commands: {
+            list: { method: 'GET', path: '/sms-messages', summary: 'GET /sms-messages  [scope: comms:sms:read]' },
+            get: { method: 'GET', path: '/sms-messages/:smsMessage', summary: 'GET /sms-messages/{smsMessage}  [scope: comms:sms:read]' },
+            send: { method: 'POST', path: '/sms-messages/send', summary: 'POST /sms-messages/send  [scope: comms:sms:write]' },
+        },
+    },
+    calls: {
+        summary: 'calls (v1)',
+        commands: {
+            list: { method: 'GET', path: '/calls', summary: 'GET /calls  [scope: comms:phone:read]' },
+            get: { method: 'GET', path: '/calls/:call', summary: 'GET /calls/{call}  [scope: comms:phone:read]' },
+        },
+    },
+    'kanban-cards': {
+        summary: 'kanban cards (v1)',
+        commands: {
+            list: { method: 'GET', path: '/kanban-cards', summary: 'GET /kanban-cards  [scope: crm:kanban:read]' },
+        },
+    },
+    'email-templates': {
+        summary: 'email templates (v1)',
+        commands: {
+            list: { method: 'GET', path: '/email-templates', summary: 'GET /email-templates  [scope: comms:email-templates:read]' },
+            get: { method: 'GET', path: '/email-templates/:slug', summary: 'GET /email-templates/{slug}  [scope: comms:email-templates:read]' },
+        },
+    },
+    'mini-games': {
+        summary: 'mini games (v1)',
+        commands: {
+            plays: { method: 'GET', path: '/mini-games/plays', summary: 'GET /mini-games/plays  [scope: games:mini-games:read]' },
+        },
+    },
+    arena: {
+        summary: 'arena (v1)',
+        commands: {
+            matches: { method: 'GET', path: '/arena/matches', summary: 'GET /arena/matches  [scope: games:arena:read]' },
+        },
+    },
+    nft: {
+        summary: 'nft (v1)',
+        commands: {
+            collections: { method: 'GET', path: '/nft/collections', summary: 'GET /nft/collections  [scope: nft:collections:read]' },
+            assets: { method: 'GET', path: '/nft/assets', summary: 'GET /nft/assets  [scope: nft:assets:read]' },
+            'collections-2': { method: 'GET', path: '/nft/collections/:collection', summary: 'GET /nft/collections/{collection}  [scope: nft:collections:read]' },
+            'assets-2': { method: 'GET', path: '/nft/assets/:asset', summary: 'GET /nft/assets/{asset}  [scope: nft:assets:read]' },
+        },
+    },
+    openflix: {
+        summary: 'openflix (v1)',
+        commands: {
+            movies: { method: 'GET', path: '/openflix/movies', summary: 'GET /openflix/movies  [scope: media:openflix:read]' },
+            series: { method: 'GET', path: '/openflix/series', summary: 'GET /openflix/series  [scope: media:openflix:read]' },
+            'movies-2': { method: 'GET', path: '/openflix/movies/:movie', summary: 'GET /openflix/movies/{movie}  [scope: media:openflix:read]' },
+            'series-2': { method: 'GET', path: '/openflix/series/:series', summary: 'GET /openflix/series/{series}  [scope: media:openflix:read]' },
+        },
+    },
+    livestreams: {
+        summary: 'livestreams (v1)',
+        commands: {
+            list: { method: 'GET', path: '/livestreams', summary: 'GET /livestreams  [scope: media:livestreams:read]' },
+            get: { method: 'GET', path: '/livestreams/:room', summary: 'GET /livestreams/{room}  [scope: media:livestreams:read]' },
+        },
+    },
+    profile: {
+        summary: 'profile (v1)',
+        commands: {
+            list: { method: 'GET', path: '/profile', summary: 'GET /profile  [scope: profile:read]' },
+        },
+    },
+    affiliate: {
+        summary: 'affiliate (v1)',
+        commands: {
+            program: { method: 'GET', path: '/affiliate/program', summary: 'GET /affiliate/program  [scope: affiliate:program:read]' },
+            commissions: { method: 'GET', path: '/affiliate/commissions', summary: 'GET /affiliate/commissions  [scope: affiliate:program:read]' },
+            payouts: { method: 'GET', path: '/affiliate/payouts', summary: 'GET /affiliate/payouts  [scope: affiliate:payouts:read]' },
+        },
+    },
+    print: {
+        summary: 'print (v1)',
+        commands: {
+            'minimum-quantities': { method: 'GET', path: '/print/minimum-quantities', summary: 'GET /print/minimum-quantities  [scope: print:fulfillment:read]' },
+            'minimum-quantities-2': { method: 'GET', path: '/print/minimum-quantities/:productTypeId', summary: 'GET /print/minimum-quantities/{productTypeId}  [scope: print:fulfillment:read]' },
+        },
+    },
+    fulfillment: {
+        summary: 'fulfillment (v1)',
+        commands: {
+            queue: { method: 'GET', path: '/fulfillment/queue', summary: 'GET /fulfillment/queue  [scope: fulfillment:read]' },
+            analytics: { method: 'GET', path: '/fulfillment/analytics', summary: 'GET /fulfillment/analytics  [scope: fulfillment:read]' },
+        },
+    },
+    'branding-projects': {
+        summary: 'branding projects (v1)',
+        commands: {
+            list: { method: 'GET', path: '/branding-projects', summary: 'GET /branding-projects  [scope: brand:projects:read]' },
+            get: { method: 'GET', path: '/branding-projects/:project', summary: 'GET /branding-projects/{project}  [scope: brand:projects:read]' },
+        },
+    },
+    brands: {
+        summary: 'brands (v1)',
+        commands: {
+            list: { method: 'GET', path: '/brands', summary: 'GET /brands  [scope: brand:assets:read]' },
+            get: { method: 'GET', path: '/brands/:brand', summary: 'GET /brands/{brand}  [scope: brand:assets:read]' },
+        },
+    },
+    associations: {
+        summary: 'associations (v1)',
+        commands: {
+            list: { method: 'GET', path: '/associations', summary: 'GET /associations  [scope: community:associations:read]' },
+            get: { method: 'GET', path: '/associations/:association', summary: 'GET /associations/{association}  [scope: community:associations:read]' },
+            posts: { method: 'GET', path: '/associations/:association/posts', summary: 'GET /associations/{association}/posts  [scope: community:associations:read]' },
+        },
+    },
+    policies: {
+        summary: 'policies (v1)',
+        commands: {
+            list: { method: 'GET', path: '/policies', summary: 'GET /policies  [scope: business:policies:read]' },
+        },
+    },
+    meetups: {
+        summary: 'meetups (v1)',
+        commands: {
+            list: { method: 'GET', path: '/meetups', summary: 'GET /meetups  [scope: community:meetups:read]' },
+            get: { method: 'GET', path: '/meetups/:meetup', summary: 'GET /meetups/{meetup}  [scope: community:meetups:read]' },
+        },
+    },
+    clones: {
+        summary: 'clones (v1)',
+        commands: {
+            list: { method: 'GET', path: '/clones', summary: 'GET /clones  [scope: profile:clones:read]' },
+            get: { method: 'GET', path: '/clones/:clone', summary: 'GET /clones/{clone}  [scope: profile:clones:read]' },
+            create: { method: 'POST', path: '/clones', summary: 'POST /clones  [scope: profile:clones:write]' },
+            samples: { method: 'POST', path: '/clones/:clone/samples', summary: 'POST /clones/{clone}/samples  [scope: profile:clones:write]' },
+            iterate: { method: 'POST', path: '/clones/:clone/iterate', summary: 'POST /clones/{clone}/iterate  [scope: profile:clones:write]' },
+            tts: { method: 'POST', path: '/clones/:clone/tts', summary: 'POST /clones/{clone}/tts  [scope: profile:clones:tts]' },
+        },
+    },
+    'vms-communities': {
+        summary: 'vms communities (v1)',
+        commands: {
+            passes: { method: 'GET', path: '/vms/communities/:communitySlug/passes', summary: 'GET /vms/communities/{communitySlug}/passes  [scope: vms:passes:read]' },
+            'passes-2': { method: 'GET', path: '/vms/communities/:communitySlug/passes/:pass', summary: 'GET /vms/communities/{communitySlug}/passes/{pass}  [scope: vms:passes:read]' },
+            'create-passes': { method: 'POST', path: '/vms/communities/:communitySlug/passes', summary: 'POST /vms/communities/{communitySlug}/passes  [scope: vms:passes:write]' },
+            'delete-passes': { method: 'DELETE', path: '/vms/communities/:communitySlug/passes/:pass', summary: 'DELETE /vms/communities/{communitySlug}/passes/{pass}  [scope: vms:passes:write]' },
+            'gate-events': { method: 'GET', path: '/vms/communities/:communitySlug/gate-events', summary: 'GET /vms/communities/{communitySlug}/gate-events  [scope: vms:events:read]' },
+            'create-gate-events': { method: 'POST', path: '/vms/communities/:communitySlug/gate-events', summary: 'POST /vms/communities/{communitySlug}/gate-events  [scope: vms:events:write]' },
+            residents: { method: 'GET', path: '/vms/communities/:communitySlug/residents', summary: 'GET /vms/communities/{communitySlug}/residents  [scope: vms:residents:read]' },
+            'create-broadcasts': { method: 'POST', path: '/vms/communities/:communitySlug/broadcasts', summary: 'POST /vms/communities/{communitySlug}/broadcasts  [scope: vms:broadcasts:write]' },
+            gates: { method: 'GET', path: '/vms/communities/:communitySlug/gates', summary: 'GET /vms/communities/{communitySlug}/gates  [scope: vms:gates:read]' },
+            'gates-2': { method: 'GET', path: '/vms/communities/:communitySlug/gates/:gate', summary: 'GET /vms/communities/{communitySlug}/gates/{gate}  [scope: vms:gates:read]' },
+            relays: { method: 'GET', path: '/vms/communities/:communitySlug/relays', summary: 'GET /vms/communities/{communitySlug}/relays  [scope: vms:relays:read]' },
+            'relays-2': { method: 'GET', path: '/vms/communities/:communitySlug/relays/:relay', summary: 'GET /vms/communities/{communitySlug}/relays/{relay}  [scope: vms:relays:read]' },
+            fire: { method: 'POST', path: '/vms/communities/:communitySlug/relays/:relay/fire', summary: 'POST /vms/communities/{communitySlug}/relays/{relay}/fire  [scope: vms:relays:fire]' },
+            'parking-permits': { method: 'GET', path: '/vms/communities/:communitySlug/parking/permits', summary: 'GET /vms/communities/{communitySlug}/parking/permits  [scope: vms:permits:read]' },
+            'parking-allocations': { method: 'GET', path: '/vms/communities/:communitySlug/parking/allocations', summary: 'GET /vms/communities/{communitySlug}/parking/allocations  [scope: vms:permits:read]' },
+            'create-trafficlogix-event': { method: 'POST', path: '/vms/communities/:communitySlug/trafficlogix/event', summary: 'POST /vms/communities/{communitySlug}/trafficlogix/event  [scope: vms:events:write]' },
+            'create-telephone-entry-lookup': { method: 'POST', path: '/vms/communities/:communitySlug/telephone-entry/lookup', summary: 'POST /vms/communities/{communitySlug}/telephone-entry/lookup  [scope: vms:events:write]' },
+            'create-telephone-entry-pin': { method: 'POST', path: '/vms/communities/:communitySlug/telephone-entry/pin', summary: 'POST /vms/communities/{communitySlug}/telephone-entry/pin  [scope: vms:events:write]' },
+            'create-camera-ai-event': { method: 'POST', path: '/vms/communities/:communitySlug/camera-ai/:vendor/event', summary: 'POST /vms/communities/{communitySlug}/camera-ai/{vendor}/event  [scope: vms:events:write]' },
+            'predictive-pulse': { method: 'POST', path: '/vms/communities/:communitySlug/gates/:gate/predictive-pulse', summary: 'POST /vms/communities/{communitySlug}/gates/{gate}/predictive-pulse  [scope: vms:gates:predictive_pulse]' },
+            'create-backup-heartbeat': { method: 'POST', path: '/vms/communities/:communitySlug/backup/heartbeat', summary: 'POST /vms/communities/{communitySlug}/backup/heartbeat  [scope: vms:failsafe:sync]' },
+            'create-backup-mode': { method: 'POST', path: '/vms/communities/:communitySlug/backup/mode', summary: 'POST /vms/communities/{communitySlug}/backup/mode  [scope: vms:failsafe:sync]' },
+            'backup-snapshot': { method: 'GET', path: '/vms/communities/:communitySlug/backup/snapshot', summary: 'GET /vms/communities/{communitySlug}/backup/snapshot  [scope: vms:failsafe:sync]' },
+            'create-backup-relay-fire': { method: 'POST', path: '/vms/communities/:communitySlug/backup/relay-fire', summary: 'POST /vms/communities/{communitySlug}/backup/relay-fire  [scope: vms:failsafe:sync]' },
+            'create-backup-visitor-verification': { method: 'POST', path: '/vms/communities/:communitySlug/backup/visitor-verification', summary: 'POST /vms/communities/{communitySlug}/backup/visitor-verification  [scope: vms:failsafe:sync]' },
+            'residents-2': { method: 'GET', path: '/vms/communities/:communitySlug/residents/:resident', summary: 'GET /vms/communities/{communitySlug}/residents/{resident}  [scope: vms:residents:read]' },
+        },
+    },
+    goals: {
+        summary: 'goals (v1)',
+        commands: {
+            list: { method: 'GET', path: '/goals', summary: 'GET /goals  [scope: goals:read]' },
+        },
+    },
+    epics: {
+        summary: 'epics (v1)',
+        commands: {
+            list: { method: 'GET', path: '/epics', summary: 'GET /epics  [scope: goals:read]' },
+        },
+    },
+    'professional-profile': {
+        summary: 'professional profile (v1)',
+        commands: {
+            list: { method: 'GET', path: '/professional-profile', summary: 'GET /professional-profile  [scope: professional_profile:read]' },
+            portfolio: { method: 'GET', path: '/professional-profile/portfolio', summary: 'GET /professional-profile/portfolio  [scope: professional_profile:read]' },
+        },
+    },
+    'professional-profiles': {
+        summary: 'professional profiles (v1)',
+        commands: {
+            get: { method: 'GET', path: '/professional-profiles/:handle', summary: 'GET /professional-profiles/{handle}  [scope: professional_profile:read]' },
+        },
+    },
+    accounting: {
+        summary: 'accounting (v1)',
+        commands: {
+            'chart-of-accounts': { method: 'GET', path: '/accounting/chart-of-accounts', summary: 'GET /accounting/chart-of-accounts  [scope: accounting:read]' },
+            'journal-entries': { method: 'GET', path: '/accounting/journal-entries', summary: 'GET /accounting/journal-entries  [scope: accounting:read]' },
+            'trial-balance': { method: 'GET', path: '/accounting/trial-balance', summary: 'GET /accounting/trial-balance  [scope: accounting:read]' },
+            'statements-income': { method: 'GET', path: '/accounting/statements/income', summary: 'GET /accounting/statements/income  [scope: accounting:read]' },
+            'statements-balance-sheet': { method: 'GET', path: '/accounting/statements/balance-sheet', summary: 'GET /accounting/statements/balance-sheet  [scope: accounting:read]' },
+            'consolidated-trial-balance': { method: 'GET', path: '/accounting/consolidated/trial-balance', summary: 'GET /accounting/consolidated/trial-balance  [scope: accounting:read]' },
+            'consolidated-income': { method: 'GET', path: '/accounting/consolidated/income', summary: 'GET /accounting/consolidated/income  [scope: accounting:read]' },
+            'consolidated-balance-sheet': { method: 'GET', path: '/accounting/consolidated/balance-sheet', summary: 'GET /accounting/consolidated/balance-sheet  [scope: accounting:read]' },
+            'tax-liability': { method: 'GET', path: '/accounting/tax-liability', summary: 'GET /accounting/tax-liability  [scope: accounting:read]' },
+            'segregation-of-duties': { method: 'GET', path: '/accounting/segregation-of-duties', summary: 'GET /accounting/segregation-of-duties  [scope: accounting:read]' },
+            'audit-trail': { method: 'GET', path: '/accounting/audit-trail', summary: 'GET /accounting/audit-trail  [scope: accounting:read]' },
+            'e-invoices': { method: 'GET', path: '/accounting/e-invoices', summary: 'GET /accounting/e-invoices  [scope: accounting:read]' },
+            'bank-reconciliations': { method: 'GET', path: '/accounting/bank-reconciliations', summary: 'GET /accounting/bank-reconciliations  [scope: accounting:read]' },
+        },
+    },
+    receivables: {
+        summary: 'receivables (v1)',
+        commands: {
+            dunning: { method: 'GET', path: '/receivables/dunning', summary: 'GET /receivables/dunning  [scope: receivables:read]' },
+            subscriptions: { method: 'GET', path: '/receivables/subscriptions', summary: 'GET /receivables/subscriptions  [scope: receivables:read]' },
+        },
+    },
+    payables: {
+        summary: 'payables (v1)',
+        commands: {
+            'discount-opportunities': { method: 'GET', path: '/payables/discount-opportunities', summary: 'GET /payables/discount-opportunities  [scope: payables:read]' },
+        },
+    },
+    procurement: {
+        summary: 'procurement (v1)',
+        commands: {
+            suppliers: { method: 'GET', path: '/procurement/suppliers', summary: 'GET /procurement/suppliers  [scope: procurement:read]' },
+            'purchase-orders': { method: 'GET', path: '/procurement/purchase-orders', summary: 'GET /procurement/purchase-orders  [scope: procurement:read]' },
+            requisitions: { method: 'GET', path: '/procurement/requisitions', summary: 'GET /procurement/requisitions  [scope: procurement:read]' },
+        },
+    },
+    inventory: {
+        summary: 'inventory (v1)',
+        commands: {
+            'stock-levels': { method: 'GET', path: '/inventory/stock-levels', summary: 'GET /inventory/stock-levels  [scope: inventory:read]' },
+            valuation: { method: 'GET', path: '/inventory/valuation', summary: 'GET /inventory/valuation  [scope: inventory:read]' },
+            warehouses: { method: 'GET', path: '/inventory/warehouses', summary: 'GET /inventory/warehouses  [scope: inventory:read]' },
+        },
+    },
+    hr: {
+        summary: 'hr (v1)',
+        commands: {
+            employees: { method: 'GET', path: '/hr/employees', summary: 'GET /hr/employees  [scope: hr:read]' },
+            headcount: { method: 'GET', path: '/hr/headcount', summary: 'GET /hr/headcount  [scope: hr:read]' },
+        },
+    },
+    'fixed-assets': {
+        summary: 'fixed assets (v1)',
+        commands: {
+            list: { method: 'GET', path: '/fixed-assets', summary: 'GET /fixed-assets  [scope: fixed_assets:read]' },
+            overview: { method: 'GET', path: '/fixed-assets/overview', summary: 'GET /fixed-assets/overview  [scope: fixed_assets:read]' },
+        },
+    },
+    manufacturing: {
+        summary: 'manufacturing (v1)',
+        commands: {
+            'work-orders': { method: 'GET', path: '/manufacturing/work-orders', summary: 'GET /manufacturing/work-orders  [scope: manufacturing:read]' },
+            'bills-of-materials': { method: 'GET', path: '/manufacturing/bills-of-materials', summary: 'GET /manufacturing/bills-of-materials  [scope: manufacturing:read]' },
+        },
+    },
+    'tech-tree': {
+        summary: 'tech tree (v1)',
+        commands: {
+            nodes: { method: 'GET', path: '/tech-tree/nodes', summary: 'GET /tech-tree/nodes  [scope: tech_tree:read]' },
+            graph: { method: 'GET', path: '/tech-tree/graph', summary: 'GET /tech-tree/graph  [scope: tech_tree:read]' },
+        },
+    },
+    influence: {
+        summary: 'influence (v1)',
+        commands: {
+            layers: { method: 'GET', path: '/influence/layers', summary: 'GET /influence/layers  [scope: business:influence:read]' },
+            'missions-context': { method: 'GET', path: '/influence/missions/:mission/context', summary: 'GET /influence/missions/{mission}/context  [scope: business:influence:read]' },
+        },
+    },
+    qms: {
+        summary: 'qms (v1)',
+        commands: {
+            readiness: { method: 'GET', path: '/qms/readiness', summary: 'GET /qms/readiness  [scope: business:qms:read]' },
+            objectives: { method: 'GET', path: '/qms/objectives', summary: 'GET /qms/objectives  [scope: business:qms:read]' },
+            risks: { method: 'GET', path: '/qms/risks', summary: 'GET /qms/risks  [scope: business:qms:read]' },
+            capas: { method: 'GET', path: '/qms/capas', summary: 'GET /qms/capas  [scope: business:qms:read]' },
+            audits: { method: 'GET', path: '/qms/audits', summary: 'GET /qms/audits  [scope: business:qms:read]' },
+            competence: { method: 'GET', path: '/qms/competence', summary: 'GET /qms/competence  [scope: business:qms:read]' },
+            documents: { method: 'GET', path: '/qms/documents', summary: 'GET /qms/documents  [scope: business:qms:read]' },
+            certification: { method: 'GET', path: '/qms/certification', summary: 'GET /qms/certification  [scope: business:qms:read]' },
+            obligations: { method: 'GET', path: '/qms/obligations', summary: 'GET /qms/obligations  [scope: business:qms:read]' },
+        },
+    },
+    'data-objects': {
+        summary: 'data objects (v1)',
+        commands: {
+            list: { method: 'GET', path: '/data/objects', summary: 'GET /data/objects  [scope: data:objects:read]' },
+            schema: { method: 'GET', path: '/data/objects/:object/schema', summary: 'GET /data/objects/{object}/schema  [scope: data:objects:read]' },
+            create: { method: 'POST', path: '/data/objects', summary: 'POST /data/objects  [scope: data:objects:write]' },
+            records: { method: 'GET', path: '/data/objects/:object/records', summary: 'GET /data/objects/{object}/records  [scope: data:records:read]' },
+            'create-records': { method: 'POST', path: '/data/objects/:object/records', summary: 'POST /data/objects/{object}/records  [scope: data:records:write]' },
+            upsert: { method: 'POST', path: '/data/objects/:object/records/upsert', summary: 'POST /data/objects/{object}/records/upsert  [scope: data:records:write]' },
+        },
+    },
+    'data-records': {
+        summary: 'data records (v1)',
+        commands: {
+            get: { method: 'GET', path: '/data/records/:uuid', summary: 'GET /data/records/{uuid}  [scope: data:records:read]' },
+            update: { method: 'PATCH', path: '/data/records/:uuid', summary: 'PATCH /data/records/{uuid}  [scope: data:records:write]' },
+            delete: { method: 'DELETE', path: '/data/records/:uuid', summary: 'DELETE /data/records/{uuid}  [scope: data:records:write]' },
+        },
+    },
+    kits: {
+        summary: 'kits (v1)',
+        commands: {
+            list: { method: 'GET', path: '/kits', summary: 'GET /kits  [scope: kits:read]' },
+        },
+    },
+    'business-dna': {
+        summary: 'business dna (v1)',
+        commands: {
+            list: { method: 'GET', path: '/business/dna', summary: 'GET /business/dna  [scope: business:dna:read]' },
+        },
+    },
+    'business-plan': {
+        summary: 'business plan (v1)',
+        commands: {
+            list: { method: 'GET', path: '/business/plan', summary: 'GET /business/plan  [scope: business:plan:read]' },
+        },
+    },
+    iot: {
+        summary: 'iot (v1)',
+        commands: {
+            devices: { method: 'GET', path: '/iot/devices', summary: 'GET /iot/devices  [scope: iot:read]' },
+            'create-devices': { method: 'POST', path: '/iot/devices', summary: 'POST /iot/devices  [scope: iot:write]' },
+            'create-readings': { method: 'POST', path: '/iot/readings', summary: 'POST /iot/readings  [scope: iot:write]' },
+            'create-alarms': { method: 'POST', path: '/iot/alarms', summary: 'POST /iot/alarms  [scope: iot:write]' },
+        },
+    },
+    property: {
+        summary: 'property (v1)',
+        commands: {
+            locations: { method: 'GET', path: '/property/locations', summary: 'GET /property/locations  [scope: property:read]' },
+            'work-orders': { method: 'GET', path: '/property/work-orders', summary: 'GET /property/work-orders  [scope: property:read]' },
+            assets: { method: 'GET', path: '/property/assets', summary: 'GET /property/assets  [scope: property:read]' },
+        },
+    },
+    funnels: {
+        summary: 'funnels (v1)',
+        commands: {
+            list: { method: 'GET', path: '/funnels', summary: 'GET /funnels  [scope: funnels:read]' },
+        },
+    },
+    'ad-simulations': {
+        summary: 'ad simulations (v1)',
+        commands: {
+            list: { method: 'GET', path: '/ad-simulations', summary: 'GET /ad-simulations  [scope: business:ad-simulations:read]' },
+        },
+    },
+    sites: {
+        summary: 'sites (v1)',
+        commands: {
+            'store-locations': { method: 'GET', path: '/sites/:token/store-locations', summary: 'GET /sites/{token}/store-locations' },
+            products: { method: 'GET', path: '/sites/:token/products', summary: 'GET /sites/{token}/products' },
+            search: { method: 'GET', path: '/sites/:token/products/search', summary: 'GET /sites/{token}/products/search' },
+            'products-2': { method: 'GET', path: '/sites/:token/products/:slug', summary: 'GET /sites/{token}/products/{slug}' },
+            related: { method: 'GET', path: '/sites/:token/products/:slug/related', summary: 'GET /sites/{token}/products/{slug}/related' },
+            reviews: { method: 'GET', path: '/sites/:token/products/:slug/reviews', summary: 'GET /sites/{token}/products/{slug}/reviews' },
+            collections: { method: 'GET', path: '/sites/:token/collections', summary: 'GET /sites/{token}/collections' },
+            'collections-products': { method: 'GET', path: '/sites/:token/collections/:slug/products', summary: 'GET /sites/{token}/collections/{slug}/products' },
+            cart: { method: 'GET', path: '/sites/:token/cart', summary: 'GET /sites/{token}/cart' },
+            'cart-count': { method: 'GET', path: '/sites/:token/cart/count', summary: 'GET /sites/{token}/cart/count' },
+            'create-cart-items': { method: 'POST', path: '/sites/:token/cart/items', summary: 'POST /sites/{token}/cart/items' },
+            'update-cart-items': { method: 'PUT', path: '/sites/:token/cart/items/:itemId', summary: 'PUT /sites/{token}/cart/items/{itemId}' },
+            'delete-cart-items': { method: 'DELETE', path: '/sites/:token/cart/items/:itemId', summary: 'DELETE /sites/{token}/cart/items/{itemId}' },
+            'delete-cart': { method: 'DELETE', path: '/sites/:token/cart', summary: 'DELETE /sites/{token}/cart' },
+            'create-cart-apply-code': { method: 'POST', path: '/sites/:token/cart/apply-code', summary: 'POST /sites/{token}/cart/apply-code' },
+            'delete-cart-apply-code': { method: 'DELETE', path: '/sites/:token/cart/apply-code/:applicationId', summary: 'DELETE /sites/{token}/cart/apply-code/{applicationId}' },
+            'create-checkout-payment-intent': { method: 'POST', path: '/sites/:token/checkout/payment-intent', summary: 'POST /sites/{token}/checkout/payment-intent' },
+            'create-checkout-process': { method: 'POST', path: '/sites/:token/checkout/process', summary: 'POST /sites/{token}/checkout/process' },
+            orders: { method: 'GET', path: '/sites/:token/orders/:number', summary: 'GET /sites/{token}/orders/{number}' },
+            'blog-articles': { method: 'GET', path: '/sites/:token/blog-articles', summary: 'GET /sites/{token}/blog-articles' },
+            'create-contact-submissions': { method: 'POST', path: '/sites/:token/contact-submissions', summary: 'POST /sites/{token}/contact-submissions' },
+        },
+    },
+    'travel-flights': {
+        summary: 'travel flights (v1)',
+        commands: {
+            get: { method: 'GET', path: '/travel/flights/:flight', summary: 'GET /travel/flights/{flight}  [scope: travel:flights:read]' },
+        },
+    },
+    'travel-stays': {
+        summary: 'travel stays (v1)',
+        commands: {
+            get: { method: 'GET', path: '/travel/stays/:stay', summary: 'GET /travel/stays/{stay}  [scope: travel:stays:read]' },
+        },
+    },
+    'travel-cars': {
+        summary: 'travel cars (v1)',
+        commands: {
+            get: { method: 'GET', path: '/travel/cars/:car', summary: 'GET /travel/cars/{car}  [scope: travel:cars:read]' },
+        },
+    },
 };