@cookiecrumbs-eu/mcp 0.7.0

package/dist/cli/src/commands/usage.js

@@ -0,0 +1,41 @@
+import { usage as usageError } from "../errors.js";
+import { human, bold, dim, red, yellow } from "../output.js";
+import { table } from "../util.js";
+import { api, finish } from "./_shared.js";
+const pct = (m) => {
+    if (typeof m.pct === 'number')
+        return m.pct;
+    if (m.limit == null || m.limit <= 0)
+        return null;
+    return (m.used / m.limit) * 100;
+};
+/** 20 blocks; unlimited meters print a dash rather than a fake full bar. */
+function bar(p) {
+    if (p == null)
+        return dim('unlimited');
+    const filled = Math.max(0, Math.min(20, Math.round((p / 100) * 20)));
+    const s = '█'.repeat(filled) + '·'.repeat(20 - filled);
+    return p >= 100 ? red(s) : p >= 80 ? yellow(s) : s;
+}
+export function register(program) {
+    program
+        .command('usage')
+        .description('Usage meters of the workspace this token belongs to')
+        .option('--period <YYYY-MM>', 'billing period (default: the current one)')
+        .action(async (opts) => {
+        if (opts.period && !/^\d{4}-\d{2}(-\d{2})?$/.test(opts.period))
+            throw usageError('--period must be YYYY-MM');
+        const u = await api().usage(opts.period);
+        const meters = Array.isArray(u.meters) ? u.meters : [];
+        finish({ usage: u }, () => {
+            human.print(`${bold('Workspace')}  ${u.org_id ?? dim('—')}   ${bold('Plan')} ${u.plan ?? dim('—')}   ${bold('Period')} ${u.period ?? opts.period ?? dim('current')}`);
+            if (!meters.length)
+                return human.print(dim('No meters reported for this period.'));
+            human.print(table(meters.map((m) => {
+                const p = pct(m);
+                return [m.metric, String(m.used ?? 0), m.limit == null || m.limit < 0 ? '∞' : String(m.limit), p == null ? '—' : `${p.toFixed(1)}%`, bar(p)];
+            }), ['metric', 'used', 'limit', 'pct', '']));
+            human.print(dim('Meters are informational: exceeding a visitor meter never blocks the banner, /config or /consent.'));
+        });
+    });
+}

package/dist/cli/src/commands/versions.js

@@ -0,0 +1,95 @@
+import { CliError, usage } from "../errors.js";
+import { ctx, human, bold, dim } from "../output.js";
+import { findProjectRoot, requireState } from "../project.js";
+import { formatDate, table } from "../util.js";
+import { api, envOf, finish } from "./_shared.js";
+function parseNumber(n) {
+    const v = Number.parseInt(n.replace(/^v/i, ''), 10);
+    if (!Number.isFinite(v) || v < 1)
+        throw usage(`Version number expected (got "${n}")`);
+    return v;
+}
+async function findVersion(siteId, number) {
+    const rows = await api().versions(siteId);
+    const v = rows.find((r) => r.number === number);
+    if (!v)
+        throw new CliError('version_not_found', `No version ${number} on this site.`, 1);
+    return v;
+}
+/** config_versions has no environment column (publications carry it); show what the row offers. */
+const envOfRow = (v) => String(v.environment ?? v.env ?? v.published_to ?? '—');
+const actor = (v) => {
+    const who = v.actor_label ?? (typeof v.created_by === 'string' ? v.created_by : '');
+    const via = v.channel ? `via ${String(v.channel).toUpperCase() === 'CLI' ? 'CLI' : v.channel}` : '';
+    return [via, who].filter(Boolean).join(' · ');
+};
+export function register(program) {
+    const versions = program.command('versions').description('List, inspect, roll back or promote published versions');
+    versions
+        .command('list', { isDefault: true })
+        .description('List versions of the linked site')
+        .option('--env <env>', 'only this environment')
+        .action(async (opts) => {
+        const { site_id } = requireState(findProjectRoot(ctx().cwd));
+        let rows = await api().versions(site_id);
+        if (opts.env) {
+            const env = envOf(opts.env);
+            rows = rows.filter((r) => r.environment === env);
+        }
+        rows.sort((a, b) => b.number - a.number);
+        finish({ versions: rows.map((r) => ({ ...r, config: undefined, texts: undefined })) }, () => {
+            if (!rows.length)
+                return human.print(dim('No versions yet. Run `cookiecrumbs push`.'));
+            human.print(table(rows.map((r) => [`v${r.number}`, envOfRow(r), formatDate(r.created_at ?? r.published_at), actor(r), r.note ?? '']), ['version', 'env', 'published', 'by', 'note']));
+        });
+    });
+    versions
+        .command('show <n>')
+        .description('Show one version (full row with --json)')
+        .action(async (n) => {
+        const { site_id } = requireState(findProjectRoot(ctx().cwd));
+        const found = await findVersion(site_id, parseNumber(n));
+        const v = await api().version(found.id).catch(() => found);
+        finish({ version: v }, () => {
+            const c = v.config;
+            human.message([
+                `${bold(`v${v.number}`)} · ${envOfRow(v)} · ${formatDate(v.created_at ?? v.published_at)}`,
+                `${bold('Id')}        ${v.id}`,
+                `${bold('Note')}      ${v.note ?? dim('—')}${v.material || v.material_change ? ' (material)' : ''}`,
+                `${bold('By')}        ${actor(v) || dim('—')}`,
+                `${bold('Hash')}      ${v.config_hash ?? dim('—')}`,
+                c ? `${bold('Config')}    layout ${c.layout} · ${c.languages.join(', ')} · ${c.categories.map((x) => x.key).join(', ')}` : '',
+            ]
+                .filter(Boolean)
+                .join('\n'));
+        });
+    });
+    versions
+        .command('rollback <n>')
+        .description('Publish a new version copied from version n')
+        .option('--env <env>', 'target environment (default: the linked environment)')
+        .action(async (n, opts) => {
+        human.intro('versions rollback');
+        const state = requireState(findProjectRoot(ctx().cwd));
+        const env = envOf(opts.env, state.env);
+        const found = await findVersion(state.site_id, parseNumber(n));
+        const v = await api().rollback(found.id, env);
+        finish({ env, from: found.number, version: { ...v, config: undefined, texts: undefined } }, () => {
+            human.success(`Restored v${found.number} as ${bold(`v${v.number}`)} on ${env}`);
+            human.outro('Run `cookiecrumbs pull` to refresh the local config.');
+        });
+    });
+    versions
+        .command('promote <n>')
+        .description('Publish an existing preview version to production (no new version row)')
+        .action(async (n) => {
+        human.intro('versions promote');
+        const state = requireState(findProjectRoot(ctx().cwd));
+        const found = await findVersion(state.site_id, parseNumber(n));
+        const r = await api().promote(found.id);
+        finish({ version: found.number, result: r }, () => {
+            human.success(`Promoted ${bold(`v${found.number}`)} to production`);
+            human.outro('Done');
+        });
+    });
+}

package/dist/cli/src/commands/webhooks.js

@@ -0,0 +1,164 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { CliError, usage } from "../errors.js";
+import { askConfirm, ctx, human, bold, dim, green, red, yellow } from "../output.js";
+import { formatDate, parseCsvList, parseIntOpt, table } from "../util.js";
+import { verifyWebhook, WEBHOOK_EVENT_TYPES } from "../configpkg.js";
+import { api, finish } from "./_shared.js";
+const STORE_IT_NOW = 'Store it now — the secret is shown once and cannot be read back.';
+const statusColour = (s) => s === 'delivered' ? green(s) : s === 'dead' || s === 'failed' ? red(String(s)) : s === 'pending' ? yellow(s) : dim(String(s ?? '—'));
+function checkEvents(list) {
+    const events = list && list.length ? list : ['*'];
+    const unknown = events.filter((e) => e !== '*' && !WEBHOOK_EVENT_TYPES.includes(e));
+    if (unknown.length)
+        throw usage(`Unknown event type(s): ${unknown.join(', ')}. Known types: ${WEBHOOK_EVENT_TYPES.join(', ')} (or * for all).`);
+    return events;
+}
+/** create/rotate answer {id, secret, endpoint:{…}} — take the row from wherever it is. */
+const endpointOf = (r) => (r.endpoint ?? r);
+function describeEndpoint(e) {
+    return [
+        `${bold('Endpoint')}  ${e.id}`,
+        `${bold('URL')}       ${e.url}`,
+        `${bold('Events')}    ${(e.events ?? []).join(', ') || dim('—')}`,
+        `${bold('Scope')}     ${e.site_id ? `site ${e.site_id}` : 'whole workspace'}${e.enabled === false ? ' ' + yellow('(disabled)') : ''}`,
+    ].join('\n');
+}
+/** Secrets are printed only from the two responses that carry one, and never under --json without the flag. */
+function printSecret(secret, what) {
+    if (!secret) {
+        human.warn(`${what} did not return a secret — nothing to store.`);
+        return;
+    }
+    human.note(`${secret}\n\n${STORE_IT_NOW}`, what);
+}
+export function register(program) {
+    const webhooks = program.command('webhooks').description('Webhook endpoints and their deliveries');
+    webhooks
+        .command('list', { isDefault: true })
+        .description('List endpoints (never their secrets)')
+        .option('--site <id>', 'only endpoints of this site')
+        .action(async (opts) => {
+        const items = await api().webhooks(opts.site);
+        finish({ webhooks: items }, () => {
+            if (!items.length)
+                return human.print(dim('No webhook endpoints.'));
+            human.print(table(items.map((e) => [
+                e.id,
+                e.url,
+                (e.events ?? []).join(','),
+                e.site_id ? e.site_id.slice(0, 8) + '…' : 'workspace',
+                e.enabled === false ? 'disabled' : 'enabled',
+                formatDate(e.last_delivery_at),
+                statusColour(e.last_status),
+            ]), ['id', 'url', 'events', 'scope', 'state', 'last delivery', 'last status']));
+        });
+    });
+    webhooks
+        .command('create <url>')
+        .description('Create an endpoint; the signing secret is printed once')
+        .option('--events <list>', `comma-separated event types (default: * = all). Known: ${WEBHOOK_EVENT_TYPES.join(', ')}`)
+        .option('--site <id>', 'restrict the endpoint to one site')
+        .option('--description <text>', 'what this endpoint is for')
+        .action(async (url, opts) => {
+        const events = checkEvents(parseCsvList(opts.events));
+        const created = await api().createWebhook({ url, events, site_id: opts.site ?? null, description: opts.description ?? null });
+        const endpoint = endpointOf(created);
+        finish({ webhook: { ...created }, endpoint_id: endpoint.id ?? created.id ?? null, secret_shown_once: Boolean(created.secret) }, () => {
+            human.success(`Created endpoint ${endpoint.id ?? created.id ?? ''}`.trim());
+            human.message(describeEndpoint(endpoint));
+            printSecret(created.secret, 'Signing secret');
+        });
+    });
+    webhooks
+        .command('rotate <id>')
+        .description('Replace the signing secret; the new one is printed once')
+        .action(async (id) => {
+        const rotated = await api().rotateWebhook(id);
+        finish({ webhook_id: id, secret: rotated.secret ?? null, secret_shown_once: Boolean(rotated.secret) }, () => {
+            human.success(`Rotated the secret of ${id}`);
+            printSecret(rotated.secret, 'New signing secret');
+            human.warn('Deliveries signed with the previous secret stop verifying as soon as the worker picks the new one up.');
+        });
+    });
+    webhooks
+        .command('delete <id>')
+        .description('Delete an endpoint and its delivery history')
+        .option('-y, --yes', 'do not ask for confirmation')
+        .action(async (id, opts) => {
+        if (!opts.yes && !ctx().json) {
+            const ok = await askConfirm(`Delete endpoint ${id} and its deliveries?`, '--yes', false);
+            if (!ok)
+                throw new CliError('cancelled', 'Cancelled.', 2);
+        }
+        await api().deleteWebhook(id);
+        finish({ deleted: id }, () => human.success(`Deleted endpoint ${id}`));
+    });
+    webhooks
+        .command('deliveries <id>')
+        .description('Recent deliveries of an endpoint with status, attempt and next retry')
+        .option('--limit <n>', 'maximum rows (1..500)', parseIntOpt('--limit'), 20)
+        .action(async (id, opts) => {
+        const items = await api().webhookDeliveries(id, opts.limit);
+        finish({ endpoint_id: id, deliveries: items }, () => {
+            if (!items.length)
+                return human.print(dim('No deliveries yet.'));
+            human.print(table(items.map((d) => [
+                d.id,
+                d.event_type ?? '',
+                statusColour(d.status),
+                String(d.attempt ?? 0),
+                d.response_code == null ? '—' : String(d.response_code),
+                d.response_ms == null ? '—' : `${d.response_ms}ms`,
+                formatDate(d.created_at),
+                formatDate(d.next_retry_at),
+                String(d.error ?? '').slice(0, 40),
+            ]), ['id', 'event', 'status', 'try', 'code', 'time', 'created', 'next retry', 'error']));
+        });
+    });
+    webhooks
+        .command('redeliver <id> <delivery>')
+        .description('Queue the same event again as a new delivery')
+        .action(async (id, delivery) => {
+        const created = await api().redeliverWebhook(id, delivery);
+        finish({ delivery: created }, () => {
+            human.success(`Queued a redelivery of ${delivery}`);
+            human.message(`${bold('New delivery')}  ${created.id ?? dim('—')}  ${statusColour(created.status)}`);
+        });
+    });
+    // ---- verify-webhook (offline; no API call) --------------------------------------------------
+    program
+        .command('verify-webhook')
+        .description('Verify a Standard Webhooks request against a signing secret (offline)')
+        .requiredOption('--secret <whsec>', 'the endpoint signing secret (whsec_…)')
+        .requiredOption('--file <path>', 'file with the RAW request body exactly as received ("-" for stdin)')
+        .requiredOption('--headers <json>', 'the request headers as a JSON object, or @file with that JSON')
+        .option('--tolerance <seconds>', 'clock tolerance; 0 disables the timestamp check', parseIntOpt('--tolerance'), 300)
+        .action(async (opts) => {
+        const body = opts.file === '-' ? readFileSync(0, 'utf8') : readFileSync(resolve(ctx().cwd, opts.file), 'utf8');
+        const rawHeaders = opts.headers.startsWith('@') ? readFileSync(resolve(ctx().cwd, opts.headers.slice(1)), 'utf8') : opts.headers;
+        let headers;
+        try {
+            const parsed = JSON.parse(rawHeaders);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error('not an object');
+            headers = parsed;
+        }
+        catch (e) {
+            throw usage(`--headers must be a JSON object (or @file containing one): ${e.message}`);
+        }
+        const result = verifyWebhook({ headers, body, secret: opts.secret, toleranceSeconds: opts.tolerance });
+        // Never print "verified" for something that did not verify; the reporter renders this once.
+        if (!result.ok)
+            throw new CliError(result.reason, `Not verified (${result.reason}): ${result.message}`, 1, { extra: { verified: false, reason: result.reason } });
+        finish({ verified: true, id: result.id, timestamp: result.timestamp, signature: result.signature, bytes: Buffer.byteLength(body) }, () => {
+            human.success('Signature verified');
+            human.message([
+                `${bold('webhook-id')}         ${result.id}`,
+                `${bold('webhook-timestamp')}  ${result.timestamp} ${dim(new Date(result.timestamp * 1000).toISOString())}`,
+                `${bold('signature')}          ${result.signature}`,
+                `${bold('body')}               ${Buffer.byteLength(body)} bytes`,
+            ].join('\n'));
+        });
+    });
+}

package/dist/cli/src/configpkg.js

@@ -0,0 +1,10 @@
+/**
+ * Single import point for @cookiecrumbs/config. The package ships TypeScript
+ * sources (its `exports` map points at src/*.ts), so the CLI compiles it into
+ * its own dist/ through a relative import; tsc rewrites the extension.
+ * Only exports that exist today are used here — the config package is being
+ * extended in parallel and anything newer is treated as optional.
+ */
+export { BannerConfigSchema, defaultConfig, lintConfig, defineConfig, TEXT_KEYS } from "../../config/src/index.js";
+/** Standard Webhooks verifier (phase 5) — one implementation, shared with the worker and the sample receiver. */
+export { verifyWebhook, WEBHOOK_EVENT_TYPES, WEBHOOK_ID_HEADER, WEBHOOK_TIMESTAMP_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TOLERANCE_SECONDS } from "../../config/src/webhooks.js";

package/dist/cli/src/diff.js

@@ -0,0 +1,63 @@
+import pc from 'picocolors';
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** Flatten to dotted paths; arrays become `path.0`, `path.1`, … */
+export function flatten(value, prefix = '', out = new Map()) {
+    if (isPlainObject(value)) {
+        const keys = Object.keys(value).sort();
+        if (keys.length === 0 && prefix)
+            out.set(prefix, {});
+        for (const k of keys)
+            flatten(value[k], prefix ? `${prefix}.${k}` : k, out);
+    }
+    else if (Array.isArray(value)) {
+        if (value.length === 0 && prefix)
+            out.set(prefix, []);
+        value.forEach((v, i) => flatten(v, prefix ? `${prefix}.${i}` : String(i), out));
+    }
+    else {
+        out.set(prefix, value);
+    }
+    return out;
+}
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function diffConfigs(from, to) {
+    const a = flatten(from);
+    const b = flatten(to);
+    const paths = new Set([...a.keys(), ...b.keys()]);
+    const entries = [];
+    for (const path of [...paths].sort()) {
+        const inA = a.has(path);
+        const inB = b.has(path);
+        if (inA && !inB)
+            entries.push({ op: 'remove', path, from: a.get(path) });
+        else if (!inA && inB)
+            entries.push({ op: 'add', path, to: b.get(path) });
+        else if (!same(a.get(path), b.get(path)))
+            entries.push({ op: 'change', path, from: a.get(path), to: b.get(path) });
+    }
+    return entries;
+}
+const show = (v) => {
+    const s = JSON.stringify(v);
+    return s.length > 80 ? s.slice(0, 77) + '…' : s;
+};
+export function formatDiff(entries, colour = true) {
+    if (entries.length === 0)
+        return '';
+    const c = colour ? pc : { green: (s) => s, red: (s) => s, yellow: (s) => s };
+    return entries
+        .map((e) => {
+        if (e.op === 'add')
+            return c.green(`+ ${e.path}: ${show(e.to)}`);
+        if (e.op === 'remove')
+            return c.red(`- ${e.path}: ${show(e.from)}`);
+        return c.yellow(`~ ${e.path}: ${show(e.from)} → ${show(e.to)}`);
+    })
+        .join('\n');
+}
+export function summariseDiff(entries) {
+    const n = (op) => entries.filter((e) => e.op === op).length;
+    return `${n('change')} changed, ${n('add')} added, ${n('remove')} removed`;
+}

package/dist/cli/src/errors.js

@@ -0,0 +1,20 @@
+export class CliError extends Error {
+    code;
+    detail;
+    exit;
+    status;
+    extra;
+    constructor(code, detail, exit = 1, opts = {}) {
+        super(detail);
+        this.name = 'CliError';
+        this.code = code;
+        this.detail = detail;
+        this.exit = exit;
+        this.status = opts.status;
+        this.extra = opts.extra;
+    }
+    toJSON() {
+        return { code: this.code, detail: this.detail, exit: this.exit, ...(this.status ? { status: this.status } : {}), ...(this.extra ?? {}) };
+    }
+}
+export const usage = (detail, code = 'usage') => new CliError(code, detail, 2);

package/dist/cli/src/frameworks.js

@@ -0,0 +1,141 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const FILE_HINTS = [
+    ['next', ['next.config.js', 'next.config.mjs', 'next.config.ts', 'app/layout.tsx', 'app/layout.jsx', 'pages/_app.tsx', 'pages/_app.jsx']],
+    ['nuxt', ['nuxt.config.ts', 'nuxt.config.js', 'app.vue']],
+    ['sveltekit', ['svelte.config.js', 'src/app.html']],
+    ['astro', ['astro.config.mjs', 'astro.config.ts', 'astro.config.js']],
+    ['react', ['src/main.tsx', 'src/main.jsx', 'src/App.tsx', 'src/App.jsx']],
+];
+/** Framework from package.json dependencies first, then file hints, else plain. */
+export function detectFramework(root) {
+    const pkgPath = join(root, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+            const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+            if (deps.next)
+                return { framework: 'next', reason: 'package.json depends on next' };
+            if (deps.nuxt || deps.nuxt3)
+                return { framework: 'nuxt', reason: 'package.json depends on nuxt' };
+            if (deps['@sveltejs/kit'])
+                return { framework: 'sveltekit', reason: 'package.json depends on @sveltejs/kit' };
+            if (deps.astro)
+                return { framework: 'astro', reason: 'package.json depends on astro' };
+            if (deps.react || deps['react-dom'])
+                return { framework: 'react', reason: 'package.json depends on react' };
+        }
+        catch {
+            /* fall through to file hints */
+        }
+    }
+    for (const [framework, files] of FILE_HINTS) {
+        const hit = files.find((f) => existsSync(join(root, f)));
+        if (hit)
+            return { framework, reason: `found ${hit}` };
+    }
+    return { framework: 'plain', reason: 'no framework markers found' };
+}
+export const FRAMEWORK_LABEL = {
+    next: 'Next.js',
+    react: 'React',
+    astro: 'Astro',
+    nuxt: 'Nuxt',
+    sveltekit: 'SvelteKit',
+    plain: 'plain HTML',
+};
+function tag(i) {
+    return `<script src="${i.runtimeUrl}" data-cc-site="${i.siteKey}" data-cc-env="${i.env}" data-cc-api="${i.apiBase}"></script>`;
+}
+/** Install snippet text per framework (plain text; the CLI prints it as a note). */
+export function installSnippet(framework, i) {
+    const declaration = `<div data-cc-declaration${i.lang ? ` data-cc-lang="${i.lang}"` : ''}></div>`;
+    switch (framework) {
+        case 'next':
+            return [
+                '// npm i @cookiecrumbs/next',
+                '// app/layout.tsx — loads the banner with next/script beforeInteractive, so blocking works on first paint',
+                "import { CookieCrumbs } from '@cookiecrumbs/next';",
+                '',
+                'export default function RootLayout({ children }: { children: React.ReactNode }) {',
+                '  return (',
+                '    <html lang="en">',
+                '      <head>',
+                `        <CookieCrumbs site="${i.siteKey}" env="${i.env}" api="${i.apiBase}" runtimeUrl="${i.runtimeUrl}" />`,
+                '      </head>',
+                '      <body>{children}</body>',
+                '    </html>',
+                '  );',
+                '}',
+                '',
+                "// Server components can gate a script before it is ever rendered: import { getConsent } from '@cookiecrumbs/next/server'",
+                "// Route handlers: createMyConsentRoute() at app/cookiecrumbs/my-consent/route.ts, createGpcRoute() at app/.well-known/gpc.json/route.ts",
+                "// Client hooks (useConsent, ConsentGate) come from '@cookiecrumbs/next/client'.",
+                '',
+                '// Optional, anywhere in a page: the cookie declaration and a reopen control',
+                `// ${declaration}`,
+                '// <button data-cc-open>Cookie settings</button>',
+            ].join('\n');
+        case 'react':
+            return [
+                '<!-- index.html — before any other script so blocking applies to every tag -->',
+                '<head>',
+                `  ${tag(i)}`,
+                '</head>',
+                '',
+                '<!-- Optional, anywhere in the app: -->',
+                declaration,
+                '<button data-cc-open>Cookie settings</button>',
+                '<!-- Or install @cookiecrumbs/react and render <CookieCrumbs site="…" env="…" /> at the root. -->',
+            ].join('\n');
+        case 'astro':
+            return [
+                '// npm i @cookiecrumbs/astro',
+                '// astro.config.mjs — the integration inserts the tag first in <head> on every route',
+                "import cookiecrumbs from '@cookiecrumbs/astro';",
+                '',
+                'export default defineConfig({',
+                `  integrations: [cookiecrumbs({ site: '${i.siteKey}', env: '${i.env}', api: '${i.apiBase}' })],`,
+                '});',
+                '',
+                "<!-- Optional, in any page: <ConsentGate category=\"marketing\">, <CookieDeclaration />, <ManageCookiesLink /> from '@cookiecrumbs/astro/components' -->",
+                declaration,
+            ].join('\n');
+        case 'nuxt':
+            return [
+                '// npm i @cookiecrumbs/nuxt',
+                '// nuxt.config.ts — the module injects the tag into <head> of every page',
+                'export default defineNuxtConfig({',
+                "  modules: ['@cookiecrumbs/nuxt'],",
+                `  cookiecrumbs: { site: '${i.siteKey}', env: '${i.env}', api: '${i.apiBase}' },`,
+                '});',
+                '',
+                '// useConsent() is auto-imported; <ConsentGate category="marketing"> and <CookieDeclaration /> are global components.',
+                '',
+                '<!-- Optional, in any page: -->',
+                declaration,
+            ].join('\n');
+        case 'sveltekit':
+            return [
+                '// npm i @cookiecrumbs/sveltekit',
+                '// src/hooks.server.ts — inserts the tag into <head> and puts the visitor’s state on locals.consent',
+                "import { cookiecrumbsHandle } from '@cookiecrumbs/sveltekit';",
+                '',
+                `export const handle = cookiecrumbsHandle({ site: '${i.siteKey}', env: '${i.env}', api: '${i.apiBase}' });`,
+                '',
+                "// In a component: import { consent, granted } from '@cookiecrumbs/sveltekit' — both are stores.",
+                '',
+                '<!-- Optional, in any route: -->',
+                declaration,
+            ].join('\n');
+        default:
+            return [
+                '<!-- Add to <head>, before any analytics or marketing tag -->',
+                tag(i),
+                '',
+                '<!-- Optional, anywhere in the page: -->',
+                declaration,
+                '<button data-cc-open>Cookie settings</button>',
+            ].join('\n');
+    }
+}

package/dist/cli/src/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { Command, CommanderError } from 'commander';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { CliError } from "./errors.js";
+import { ctx, printJson, setCtx } from "./output.js";
+import { cliVersion, normaliseApi, DEFAULT_API } from "./util.js";
+import * as auth from "./commands/auth.js";
+import * as init from "./commands/init.js";
+import * as link from "./commands/link.js";
+import * as push from "./commands/push.js";
+import * as pull from "./commands/pull.js";
+import * as diff from "./commands/diff.js";
+import * as status from "./commands/status.js";
+import * as open from "./commands/open.js";
+import * as versions from "./commands/versions.js";
+import * as scan from "./commands/scan.js";
+import * as logs from "./commands/logs.js";
+import * as exportAll from "./commands/export.js";
+import * as declaration from "./commands/declaration.js";
+import * as tokens from "./commands/tokens.js";
+import * as alerts from "./commands/alerts.js";
+import * as webhooks from "./commands/webhooks.js";
+import * as usageCmd from "./commands/usage.js";
+import * as templates from "./commands/templates.js";
+import * as sites from "./commands/sites.js";
+import * as services from "./commands/services.js";
+import * as schedule from "./commands/schedule.js";
+import * as issues from "./commands/issues.js";
+import * as install from "./commands/install.js";
+import * as domains from "./commands/domains.js";
+const version = cliVersion();
+export function buildProgram() {
+    const program = new Command('cookiecrumbs')
+        .description('CookieCrumbs: push and pull banner config, publish versions, run scans, manage sites, services, schedules, issues, domains and templates, export consent logs, watch alerts and webhooks')
+        .version(version, '-v, --version')
+        .option('--json', 'print a single JSON object to stdout and nothing else')
+        .option('--api <url>', 'API base URL (env COOKIECRUMBS_API)', process.env.COOKIECRUMBS_API || DEFAULT_API)
+        .option('--cwd <dir>', 'run as if started in this folder')
+        .showSuggestionAfterError(true)
+        .configureOutput({
+        writeErr: (s) => {
+            if (!ctx().json)
+                process.stderr.write(s);
+        },
+    })
+        .exitOverride();
+    program.hook('preAction', (thisCommand) => {
+        const o = thisCommand.opts();
+        setCtx({ json: Boolean(o.json), api: normaliseApi(o.api), cwd: o.cwd ? o.cwd : process.cwd() });
+    });
+    for (const m of [auth, init, link, push, pull, diff, status, open, versions, scan, schedule, logs, exportAll, declaration, tokens, alerts, webhooks, usageCmd, templates, sites, services, issues, install, domains])
+        m.register(program);
+    return program;
+}
+function report(err) {
+    if (err instanceof CommanderError) {
+        if (err.code === 'commander.helpDisplayed' || err.code === 'commander.version' || err.code === 'commander.help')
+            return 0;
+        if (ctx().json || process.argv.includes('--json'))
+            printJson({ ok: false, error: { code: 'usage', detail: err.message.trim(), exit: 2 } });
+        return 2;
+    }
+    if (err instanceof CliError) {
+        if (ctx().json) {
+            printJson({ ok: false, error: err.toJSON() });
+        }
+        else {
+            p.log.error(pc.red(err.detail));
+            const lint = (err.extra?.lint ?? null);
+            if (lint?.issues?.length)
+                p.log.message(lint.issues.map((i) => `${i.severity === 'error' ? pc.red('error') : pc.yellow('warn ')} ${i.code} ${pc.dim(i.path)} ${i.message}`).join('\n'));
+            if (err.status)
+                p.log.message(pc.dim(`HTTP ${err.status} · ${err.code}`));
+        }
+        return err.exit;
+    }
+    const e = err;
+    if (ctx().json)
+        printJson({ ok: false, error: { code: 'internal', detail: e?.message ?? String(err), exit: 1 } });
+    else {
+        p.log.error(pc.red(e?.message ?? String(err)));
+        if (process.env.DEBUG && e?.stack)
+            process.stderr.write(e.stack + '\n');
+    }
+    return 1;
+}
+export async function main(argv = process.argv) {
+    const program = buildProgram();
+    try {
+        await program.parseAsync(argv);
+        return 0;
+    }
+    catch (err) {
+        return report(err);
+    }
+}
+main().then((code) => {
+    process.exitCode = code;
+});