@dokebi/cli 0.2.5 → 0.4.1

package/dist/verify.d.ts

@@ -0,0 +1,62 @@
+export interface VerifyCheck {
+    readonly name: 'doctor' | 'check' | 'typecheck' | 'build' | 'preflight' | 'start' | 'http' | 'stop';
+    readonly ok: boolean;
+    readonly skipped?: string;
+    readonly ms: number;
+    /** Why it failed, a code to look up in AI.md. */
+    readonly code?: string;
+    readonly message?: string;
+    readonly details?: unknown;
+}
+export interface VerifyResult {
+    readonly ok: boolean;
+    readonly checks: VerifyCheck[];
+    /**
+     * Where the app answers (AI-M03): with @dokebi/app, `<scheme>://<domain>:<port>` for each
+     * configured loopback domain (`localhost`, `*.localhost`, `127.x.x.x`); without it, `listen`.
+     */
+    readonly urls: string[];
+    /** The listening addresses (the web listening line, else dokebi.yaml); HTTP checks connect here. */
+    readonly listen: string[];
+    /**
+     * Only when ok and a recipe was applied (`.dokebi/recipe.json`): lines the agent's final
+     * message to the user must include — each choice and who made it (a default with its reason)
+     * and the notices, such as no CSRF protection for HTML forms (AI-M03).
+     */
+    readonly tellUser?: string[];
+}
+/**
+ * Runs an npm script of the project; resolves with its exit code and the bounded, redacted end
+ * of its output (stdout and stderr in arrival order, `OutputTail` of npm-client).
+ */
+export declare function npmScript(root: string, script: string, timeoutMs: number): Promise<{
+    code: number | null;
+    output: string;
+    timedOut: boolean;
+}>;
+/** The environment variable verify sets on the app it starts; @dokebi/web reads it. */
+export declare const VERIFY_TOKEN_ENV = "DOKEBI_VERIFY_TOKEN";
+/** The response header @dokebi/web answers with when that variable is set. */
+export declare const VERIFY_HEADER = "x-dokebi-verify";
+/** One HTTP request of the verify check. */
+export interface HttpProbe {
+    readonly url: string;
+    readonly host?: string;
+    readonly status: number;
+    readonly ok: boolean;
+    /** `other`: an answer without this run's token header — another server on the port. */
+    readonly instance?: 'ours' | 'other';
+    readonly error?: string;
+}
+/**
+ * The HTTP check of verify: GET the readiness path, then `/` of each app domain, at `base`. An
+ * answer counts only when it carries `token` in the x-dokebi-verify header (the instance verify
+ * started); anything else is retried like a failed request and then reported FOREIGN_SERVER.
+ */
+export declare function httpChecks(base: string, paths: {
+    ready: string | null;
+    domains: readonly string[];
+}, token: string, delayMs?: number): Promise<Omit<VerifyCheck, 'name' | 'ms'>>;
+export declare function verify(root: string, options?: {
+    waitMs?: number;
+}): Promise<VerifyResult>;

package/dist/verify.js

@@ -0,0 +1,380 @@
+// `dokebi verify` (D-0065): the one check an AI runs before it says "done". doctor → check
+// (D-0072, user-code conventions) → typecheck → build (Vite projects) → preflight → start →
+// HTTP checks → stop; `ok` only when every check that ran passed. The app it starts is always
+// stopped again.
+//
+// D-0065 §11 (AI-M02): the HTTP checks count only answers from the instance verify started. The
+// app gets a random token in DOKEBI_VERIFY_TOKEN and @dokebi/web echoes it in the
+// `x-dokebi-verify` response header (only when that variable is set: nothing in production). An
+// answer without it is another server on the port (FOREIGN_SERVER). When the app did not start,
+// the HTTP check is skipped and failed. The stop uses the pids `start` returned (no `ps`).
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { request } from 'node:http';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { appUrls } from './app-urls.js';
+import { check } from './check/index.js';
+import { CONFIG_FILE, parseProjectConfig } from './configuration.js';
+import { portInUse, URL_PLACEHOLDER_PREFIX } from './dev-infra.js';
+import { debug, describeError } from './diagnostics.js';
+import { CliError } from './errors.js';
+import { exists, parseObject, securePath } from './filesystem.js';
+import { findHost } from './manifest.js';
+import { OutputTail } from './npm-client.js';
+import { ProjectInspector } from './project-inspector.js';
+import { readState } from './project-state.js';
+import { readAppliedRecipes, tellUserLines } from './recipe-record.js';
+import * as server from './server.js';
+/**
+ * Runs an npm script of the project; resolves with its exit code and the bounded, redacted end
+ * of its output (stdout and stderr in arrival order, `OutputTail` of npm-client).
+ */
+export async function npmScript(root, script, timeoutMs) {
+    const npmPath = process.env.npm_execpath;
+    const command = npmPath?.endsWith('npm-cli.js') ? process.execPath : 'npm';
+    const args = [...(npmPath?.endsWith('npm-cli.js') ? [npmPath] : []), 'run', script];
+    debug('verify: running npm script', { script, root });
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+        const output = new OutputTail();
+        const keep = (chunk) => output.push(chunk);
+        child.stdout.on('data', keep);
+        child.stderr.on('data', keep);
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.once('error', (cause) => {
+            clearTimeout(timer);
+            reject(new CliError('NPM_FAILED', `Could not run npm run ${script}`, { cause }));
+        });
+        child.once('close', (code) => {
+            clearTimeout(timer);
+            resolve({ code, output: output.text(), timedOut });
+        });
+    });
+}
+/** The environment variable verify sets on the app it starts; @dokebi/web reads it. */
+export const VERIFY_TOKEN_ENV = 'DOKEBI_VERIFY_TOKEN';
+/** The response header @dokebi/web answers with when that variable is set. */
+export const VERIFY_HEADER = 'x-dokebi-verify';
+/** GET with a Host header (fetch cannot set one). */
+function get(url, host, timeoutMs = 5000) {
+    return new Promise((resolve, reject) => {
+        const target = new URL(url);
+        const req = request({
+            host: target.hostname.replace(/^\[|\]$/g, ''),
+            port: target.port,
+            path: `${target.pathname}${target.search}`,
+            headers: host ? { host } : {},
+            timeout: timeoutMs,
+        }, (response) => {
+            response.resume();
+            response.once('end', () => resolve({
+                status: response.statusCode ?? 0,
+                type: String(response.headers['content-type'] ?? ''),
+                instance: response.headers[VERIFY_HEADER],
+            }));
+        });
+        req.once('timeout', () => req.destroy(new Error(`No answer within ${timeoutMs} ms`)));
+        req.once('error', reject);
+        req.end();
+    });
+}
+async function settings(root) {
+    const pkg = parseObject(await readFile(join(root, 'package.json'), 'utf8'), 'package.json');
+    let vite = false;
+    for (const file of ['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs'])
+        vite ||= await exists(await securePath(root, file));
+    const state = readState(parseObject(await readFile(join(root, '.dokebi/state.json'), 'utf8'), 'state'));
+    const ids = new Set(state.plugins.map((plugin) => plugin.id));
+    // The domains to check belong to the plugin that hosts apps (D-0070), whatever its id.
+    const host = findHost(state.plugins, 'apps');
+    const options = parseProjectConfig(await readFile(join(root, CONFIG_FILE), 'utf8')).options;
+    const web = (options['dokebi-web'] ?? {});
+    const app = ((host ? options[host.id] : undefined) ?? {});
+    const db = (options['dokebi-db'] ?? {});
+    return {
+        scripts: (pkg.scripts ?? {}),
+        vite,
+        web: {
+            installed: ids.has('dokebi-web'),
+            port: typeof web.port === 'number' ? web.port : 0,
+            host: typeof web.host === 'string' ? web.host : '127.0.0.1',
+            ready: web.healthRoutes === false ? null : (web.healthRoutes?.ready ?? '/health/ready'),
+        },
+        domains: host ? Object.keys(app.domains ?? {}) : [],
+        dbUrls: ids.has('dokebi-db')
+            ? Object.entries(db.connections ?? {}).map(([name, connection]) => {
+                const url = connection?.options?.url;
+                return {
+                    name,
+                    missing: url !== undefined &&
+                        (typeof url !== 'string' || url.startsWith(URL_PLACEHOLDER_PREFIX)),
+                };
+            })
+            : [],
+    };
+}
+/**
+ * The HTTP check of verify: GET the readiness path, then `/` of each app domain, at `base`. An
+ * answer counts only when it carries `token` in the x-dokebi-verify header (the instance verify
+ * started); anything else is retried like a failed request and then reported FOREIGN_SERVER.
+ */
+export async function httpChecks(base, paths, token, delayMs = 250) {
+    const requests = [];
+    const probe = async (path, host, attempts) => {
+        const url = `${base}${path}`;
+        for (let attempt = 1;; attempt++) {
+            try {
+                const answer = await get(url, host);
+                const instance = answer.instance === token ? 'ours' : 'other';
+                const ok = answer.status >= 200 && answer.status < 400 && instance === 'ours';
+                if (ok || attempt >= attempts) {
+                    requests.push({ url, ...(host ? { host } : {}), status: answer.status, ok, instance });
+                    return;
+                }
+                if (instance === 'other')
+                    debug('verify: an answer without the token of this run; retrying', {
+                        url,
+                        status: answer.status,
+                    });
+            }
+            catch (error) {
+                if (attempt >= attempts) {
+                    requests.push({
+                        url,
+                        ...(host ? { host } : {}),
+                        status: 0,
+                        ok: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    return;
+                }
+                debug('verify: request failed, retrying', { url, error: describeError(error) });
+            }
+            await delay(delayMs);
+        }
+    };
+    if (paths.ready)
+        await probe(paths.ready, undefined, 20);
+    for (const domain of paths.domains)
+        await probe('/', domain, 4);
+    const failed = requests.filter((item) => !item.ok);
+    const foreign = failed.filter((item) => item.instance === 'other');
+    return {
+        ok: failed.length === 0,
+        ...(foreign.length
+            ? {
+                code: 'FOREIGN_SERVER',
+                message: `Another server answered on ${base} (no ${VERIFY_HEADER} header of this run): the app verify started is not the one listening there; stop the other app or choose another port (npx dokebi config set dokebi-web.port=<free port>)`,
+            }
+            : failed.length
+                ? {
+                    code: 'HTTP_FAILED',
+                    message: failed
+                        .map((item) => `${item.host ?? ''}${item.url} → ${item.status || item.error}`)
+                        .join('; '),
+                }
+                : {}),
+        details: { requests },
+    };
+}
+export async function verify(root, options = {}) {
+    const checks = [];
+    const run = async (name, body) => {
+        const began = performance.now();
+        let check;
+        try {
+            check = { name, ...(await body()), ms: Math.round(performance.now() - began) };
+        }
+        catch (error) {
+            // A check that throws is a failed check with its code; the others still report.
+            check = {
+                name,
+                ok: false,
+                ms: Math.round(performance.now() - began),
+                code: error instanceof CliError ? error.code : 'CHECK_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+                ...(error instanceof CliError && error.details !== undefined
+                    ? { details: error.details }
+                    : { details: { error: describeError(error) } }),
+            };
+        }
+        debug('verify: check finished', { name, ok: check.ok, skipped: check.skipped ?? null });
+        checks.push(check);
+        return check;
+    };
+    const skip = (reason) => async () => ({ ok: true, skipped: reason });
+    const project = await settings(root);
+    let inspection;
+    const doctor = await run('doctor', async () => {
+        const result = await new ProjectInspector().inspect(root, { runChecks: true });
+        inspection = result;
+        const errors = result.diagnostics.filter((item) => item.severity === 'error');
+        return {
+            ok: result.healthy,
+            ...(result.healthy ? {} : { code: 'DOCTOR_FAILED', message: 'npx dokebi doctor --json' }),
+            details: {
+                errors,
+                warnings: result.diagnostics.filter((item) => item.severity === 'warning').length,
+            },
+        };
+    });
+    // D-0072: user-code conventions, on doctor's inspection (doctor is not run twice).
+    await run('check', async () => {
+        const result = await check(root, inspection ? { inspection } : {});
+        return {
+            ok: result.ok,
+            ...(result.ok
+                ? {}
+                : {
+                    code: 'CHECK_FAILED',
+                    message: `${result.problems.length} convention problem(s): npx dokebi check`,
+                }),
+            details: { problems: result.problems, files: result.files, ms: result.ms },
+        };
+    });
+    const script = async (name, timeoutMs) => {
+        const result = await npmScript(root, name, timeoutMs);
+        const ok = result.code === 0 && !result.timedOut;
+        return {
+            ok,
+            ...(ok
+                ? {}
+                : {
+                    code: name === 'build' ? 'BUILD_FAILED' : 'TYPECHECK_FAILED',
+                    message: result.timedOut ? `npm run ${name} timed out` : `npm run ${name} failed`,
+                    details: { exitCode: result.code, output: result.output },
+                }),
+        };
+    };
+    await run('typecheck', typeof project.scripts.typecheck === 'string'
+        ? () => script('typecheck', 300_000)
+        : skip('package.json has no typecheck script'));
+    await run('build', typeof project.scripts.build === 'string' && project.vite
+        ? () => script('build', 300_000)
+        : skip('no Vite build in this project'));
+    const preflight = await run('preflight', async () => {
+        const problems = [];
+        const running = await server.status(root);
+        if (running.running)
+            problems.push({
+                code: 'ALREADY_RUNNING',
+                message: `The app already runs (pid ${running.pid}); verify does not stop it`,
+                fix: 'npx dokebi stop',
+            });
+        else if (project.web.installed && project.web.port > 0 && (await portInUse(project.web.port)))
+            problems.push({
+                code: 'PORT_IN_USE',
+                message: `Port ${project.web.port} (options.dokebi-web.port) is in use`,
+                fix: 'stop what uses it, or npx dokebi config set dokebi-web.port=<free port>',
+            });
+        for (const db of project.dbUrls)
+            if (db.missing)
+                problems.push({
+                    code: 'DB_URL_MISSING',
+                    message: `options.dokebi-db.connections.${db.name}.options.url is not set`,
+                    fix: 'npx dokebi dev-infra (Docker) or write the URL in dokebi.yaml',
+                });
+        return problems.length
+            ? {
+                ok: false,
+                code: problems[0]?.code,
+                message: problems.map((item) => item.message).join('; '),
+                details: { problems },
+            }
+            : { ok: true };
+    });
+    let started;
+    // Only the instance started here echoes this token (x-dokebi-verify, @dokebi/web).
+    const token = randomBytes(16).toString('hex');
+    const reason = !doctor.ok ? 'doctor failed' : !preflight.ok ? 'preflight failed' : undefined;
+    await run('start', reason
+        ? skip(reason)
+        : async () => {
+            started = await server.start(root, {
+                waitMs: options.waitMs ?? 30_000,
+                env: { [VERIFY_TOKEN_ENV]: token },
+            });
+            return {
+                ok: started.ready,
+                ...(started.ready ? {} : { code: 'NOT_READY', message: started.warnings.join('; ') }),
+                details: {
+                    pid: started.pid,
+                    urls: started.urls,
+                    listen: started.listen,
+                    log: started.log,
+                },
+            };
+        });
+    const host = ['0.0.0.0', '::', '[::]'].includes(project.web.host)
+        ? '127.0.0.1'
+        : project.web.host;
+    const listen = started?.listen.length
+        ? started.listen
+        : project.web.installed && project.web.port > 0
+            ? [`http://${host.includes(':') ? `[${host}]` : host}:${project.web.port}`]
+            : [];
+    try {
+        await run('http', !project.web.installed
+            ? skip('no web plugin')
+            : !started?.ready
+                ? // Nothing of ours answers: whatever is on the port proves nothing (AI-M02).
+                    async () => ({
+                        ok: false,
+                        skipped: 'the app did not start',
+                        code: 'NOT_STARTED',
+                        message: 'No HTTP check ran: the app verify starts did not start (see the start check)',
+                    })
+                : async () => {
+                    // Connect to the listening address; the Host header of each app domain picks the
+                    // app (the readiness route answers every host).
+                    const base = listen.find((url) => url.includes('127.0.0.1')) ?? listen[0];
+                    if (!base)
+                        return {
+                            ok: false,
+                            code: 'URL_UNKNOWN',
+                            message: 'No address: the web listening line is missing and options.dokebi-web.port is 0',
+                        };
+                    return httpChecks(base, { ready: project.web.ready, domains: project.domains }, token);
+                });
+    }
+    finally {
+        await run('stop', started
+            ? async () => {
+                // The process this run started, by its pids: no `ps` needed (server.ts, D-0065 §11).
+                const stopped = await server.stopStarted(root, started, 15_000, true);
+                return {
+                    ok: stopped.stopped && !stopped.forced,
+                    ...(stopped.forced
+                        ? { code: 'STOP_FORCED', message: 'The app did not drain in 15 s and was killed' }
+                        : stopped.stale
+                            ? {
+                                code: 'APP_EXITED',
+                                message: 'The app exited by itself before verify stopped it: npx dokebi logs',
+                            }
+                            : {}),
+                    details: {
+                        ms: stopped.ms ?? null,
+                        forced: stopped.forced ?? false,
+                        ...(stopped.warnings ? { warnings: stopped.warnings } : {}),
+                    },
+                };
+            }
+            : skip('nothing was started'));
+    }
+    const ok = checks.every((check) => check.ok);
+    const tellUser = ok ? tellUserLines(await readAppliedRecipes(root)) : [];
+    const shown = started ? listen : [];
+    return {
+        ok,
+        checks,
+        urls: shown.length ? appUrls(shown, await server.appHostsOrNone(root)) : [],
+        listen: shown,
+        ...(tellUser.length ? { tellUser } : {}),
+    };
+}

package/dist/vite-host-process.d.ts

@@ -0,0 +1,20 @@
+import type { ChildProcess } from 'node:child_process';
+/** The host script of the installed template-inertia, or undefined when it has none (< 0.4.0). */
+export declare function viteHostScript(root: string): string | undefined;
+export interface ViteHostAddress {
+    readonly url: string;
+    readonly key: string;
+}
+/**
+ * The host process: `ensure` starts it when it is not running and resolves with its address, or
+ * with undefined when it failed (said on the terminal; the next change tries again).
+ */
+export declare class ViteHostProcess {
+    #private;
+    constructor(spawn: () => ChildProcess, say: (line: string) => void, readyMs?: number);
+    /** A host process is starting or running. */
+    get running(): boolean;
+    ensure(): Promise<ViteHostAddress | undefined>;
+    /** Stops the host (SIGTERM, then SIGKILL after `limitMs`); `force` kills at once. */
+    stop(limitMs?: number, force?: boolean): Promise<void>;
+}

package/dist/vite-host-process.js

@@ -0,0 +1,117 @@
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { debug, reportError } from './diagnostics.js';
+/** The host script of the installed template-inertia, or undefined when it has none (< 0.4.0). */
+export function viteHostScript(root) {
+    try {
+        return createRequire(join(root, 'package.json')).resolve('@dokebi/template-inertia/vite-host');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'MODULE_NOT_FOUND' || code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            debug('template-inertia has no Vite dev host; Vite runs inside the app', { code });
+            return undefined;
+        }
+        reportError('DEV_VITE_HOST_LOOKUP_FAILED', 'Unable to find the Vite dev host script', error);
+        return undefined;
+    }
+}
+/**
+ * The host process: `ensure` starts it when it is not running and resolves with its address, or
+ * with undefined when it failed (said on the terminal; the next change tries again).
+ */
+export class ViteHostProcess {
+    #spawn;
+    #say;
+    #readyMs;
+    #child;
+    #address;
+    #stopping = false;
+    constructor(spawn, say, readyMs = 60_000) {
+        this.#spawn = spawn;
+        this.#say = say;
+        this.#readyMs = readyMs;
+    }
+    /** A host process is starting or running. */
+    get running() {
+        return this.#child !== undefined;
+    }
+    ensure() {
+        this.#address ??= this.#start();
+        return this.#address;
+    }
+    #start() {
+        const begin = performance.now();
+        const child = this.#spawn();
+        this.#child = child;
+        debug('Vite dev host spawned', { pid: child.pid });
+        return new Promise((resolve) => {
+            let settled = false;
+            let ready = false;
+            const settle = (address) => {
+                if (settled)
+                    return;
+                settled = true;
+                ready = address !== undefined;
+                clearTimeout(timer);
+                child.off('message', onMessage);
+                resolve(address);
+            };
+            const timer = setTimeout(() => {
+                this.#say(`vite dev server did not start in ${this.#readyMs / 1000} s; stopping it`);
+                child.kill('SIGKILL');
+            }, this.#readyMs);
+            const onMessage = (message) => {
+                if (message?.type !== 'dokebi-vite-host')
+                    return;
+                if (message.state === 'ready' &&
+                    typeof message.url === 'string' &&
+                    typeof message.key === 'string') {
+                    debug('Vite dev host ready', {
+                        pid: child.pid,
+                        url: message.url,
+                        ms: Math.round(performance.now() - begin),
+                    });
+                    this.#say(`vite dev server: ${message.url} (one for every worker)`);
+                    settle({ url: message.url, key: message.key });
+                }
+                else if (message.state === 'failed') {
+                    this.#say(`vite dev server failed to start: ${String(message.message ?? '')}; waiting for a change to retry`);
+                    settle(undefined);
+                    // It exits by itself; this only makes sure it does not linger.
+                    child.kill('SIGTERM');
+                }
+            };
+            child.on('message', onMessage);
+            child.once('exit', (code, signal) => {
+                if (this.#child === child) {
+                    this.#child = undefined;
+                    this.#address = undefined;
+                }
+                if (!settled) {
+                    this.#say(`vite dev server exited (${signal ?? code}); waiting for a change to retry`);
+                    settle(undefined);
+                }
+                else if (ready && !this.#stopping)
+                    this.#say(`vite dev server exited (${signal ?? code}); it starts again with the next change`);
+            });
+        });
+    }
+    /** Stops the host (SIGTERM, then SIGKILL after `limitMs`); `force` kills at once. */
+    async stop(limitMs = 5000, force = false) {
+        this.#stopping = true;
+        const child = this.#child;
+        if (!child || child.exitCode !== null || child.signalCode !== null)
+            return;
+        const exited = new Promise((resolve) => child.once('exit', resolve));
+        child.kill(force ? 'SIGKILL' : 'SIGTERM');
+        const timer = setTimeout(() => child.kill('SIGKILL'), limitMs);
+        await exited;
+        clearTimeout(timer);
+        debug('Vite dev host stopped', {
+            pid: child.pid,
+            code: child.exitCode,
+            signal: child.signalCode,
+        });
+    }
+}

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "@dokebi/cli",
-  "version": "0.2.5",
+  "version": "0.4.1",
+  "description": "Project scaffolding, plugin catalog, recipes, install and verification CLI for Dokebi.",
+  "keywords": [
+    "dokebi",
+    "cli",
+    "scaffold",
+    "plugins",
+    "catalog"
+  ],
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -15,17 +23,18 @@
   },
   "files": [
     "dist",
-    "AI.md"
+    "AI.md",
+    "catalog.json"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.test.json --noEmit",
-    "test": "tsc -p tsconfig.test.json && node --test \".tmp/tests/tests/*.test.js\""
+    "test": "node -e \"require('node:fs').rmSync('.tmp/tests',{recursive:true,force:true})\" && tsc -p tsconfig.test.json && node --test \".tmp/tests/tests/*.test.js\""
   },
   "dependencies": {
     "semver": "7.8.5",
-    "@dokebi/core": "^0.2.2",
-    "@dokebi/config": "^0.2.2",
+    "@dokebi/core": "^0.4.0",
+    "@dokebi/config": "^0.4.0",
     "yaml": "2.9.1"
   },
   "devDependencies": {
@@ -37,5 +46,20 @@
     "directory": "packages/cli"
   },
   "license": "MIT",
-  "description": "Project scaffolding, plugin management and diagnostics for Dokebi."
+  "dokebiCatalog": {
+    "kind": "cli",
+    "summary": "Commands to create a project, browse the plugin catalog, run recipes, install plugins and verify (dokebi)",
+    "maturity": "preview",
+    "provides": [
+      "cli.project"
+    ],
+    "doesNot": [
+      "It is not the npm package named dokebi (never npx -y dokebi)",
+      "It does not write app code for you"
+    ],
+    "recipes": [
+      "api",
+      "blog"
+    ]
+  }
 }