@gurulu/cli 0.4.2 → 0.4.4

package/dist/commands/releases.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Sprint E SE-B — `gurulu releases list`.
+ *
+ * Mirror of MCP `gurulu.releases.list`. Returns recent releases with
+ * crash-free session %, adoption, and regression deltas.
+ */
+export interface ReleasesArgs {
+    action?: string;
+    site?: string;
+    range?: string;
+    environment?: string;
+    limit?: number;
+    format?: string;
+    json?: boolean;
+    profile?: string;
+}
+export declare function releasesCommand(args: ReleasesArgs): Promise<void>;

package/dist/commands/releases.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Sprint E SE-B — `gurulu releases list`.
+ *
+ * Mirror of MCP `gurulu.releases.list`. Returns recent releases with
+ * crash-free session %, adoption, and regression deltas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasesCommand = releasesCommand;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function releasesCommand(args) {
+    const action = args.action || 'list';
+    switch (action) {
+        case 'list':
+            return listCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown releases action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu releases list --site=<id> [--limit=20] [--range=7d|30d]');
+            process.exit(1);
+    }
+}
+async function listCmd(args) {
+    if (!args.site) {
+        (0, ui_1.error)('Usage: gurulu releases list --site=<id> [--limit=20]');
+        process.exit(1);
+    }
+    const usp = new URLSearchParams();
+    usp.set('site', args.site);
+    if (args.range)
+        usp.set('range', args.range);
+    if (args.environment)
+        usp.set('environment', args.environment);
+    if (args.limit)
+        usp.set('limit', String(args.limit));
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/releases?${usp.toString()}`, {
+        profile: args.profile,
+    });
+    if (args.format === 'table') {
+        const rows = body.releases || [];
+        process.stdout.write(['VERSION', 'SESSIONS', 'CRASH_FREE_%', 'USERS', 'ERRORS'].join('\t') + '\n');
+        for (const r of rows) {
+            process.stdout.write([
+                r.version ?? '-',
+                r.totalSessions ?? 0,
+                r.crashFreeSessionRate?.toFixed?.(2) ?? r.crashFreeSessionRate ?? '-',
+                r.totalUsers ?? 0,
+                r.errorCount ?? 0,
+            ].join('\t') + '\n');
+        }
+        return;
+    }
+    process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+}

package/dist/commands/replay.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sprint E SE-B — `gurulu replay list|get`.
+ *
+ * Mirror of MCP `gurulu.replay.list` / `.get`. Hits new `/api/cli/replay/*`
+ * proxy endpoints with CLI-auth.
+ */
+export interface ReplayArgs {
+    action?: string;
+    site?: string;
+    sessionId?: string;
+    range?: string;
+    hasError?: boolean;
+    limit?: number;
+    format?: string;
+    json?: boolean;
+    profile?: string;
+}
+export declare function replayCommand(args: ReplayArgs): Promise<void>;

package/dist/commands/replay.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Sprint E SE-B — `gurulu replay list|get`.
+ *
+ * Mirror of MCP `gurulu.replay.list` / `.get`. Hits new `/api/cli/replay/*`
+ * proxy endpoints with CLI-auth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayCommand = replayCommand;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function replayCommand(args) {
+    const action = args.action || 'list';
+    switch (action) {
+        case 'list':
+            return listCmd(args);
+        case 'get':
+            return getCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown replay action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu replay [list|get] --site=<id> [--session-id=<id>]');
+            process.exit(1);
+    }
+}
+async function listCmd(args) {
+    if (!args.site) {
+        (0, ui_1.error)('Usage: gurulu replay list --site=<id> [--range=7d|30d] [--limit=20]');
+        process.exit(1);
+    }
+    const usp = new URLSearchParams();
+    usp.set('site', args.site);
+    if (args.range)
+        usp.set('range', args.range);
+    if (args.hasError !== undefined)
+        usp.set('hasError', String(args.hasError));
+    if (args.limit)
+        usp.set('limit', String(args.limit));
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/replay?${usp.toString()}`, {
+        profile: args.profile,
+    });
+    if (args.format === 'table') {
+        const rows = body.sessions || [];
+        process.stdout.write(['SESSION', 'STARTED', 'DURATION', 'ERRORS', 'SEGMENTS'].join('\t') + '\n');
+        for (const s of rows) {
+            process.stdout.write([
+                s.sessionId ?? s.id ?? '-',
+                String(s.startedAt ?? '-'),
+                String(s.duration ?? 0),
+                s.hasError ? 'yes' : 'no',
+                String(s.segments ?? 0),
+            ].join('\t') + '\n');
+        }
+        return;
+    }
+    process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+}
+async function getCmd(args) {
+    if (!args.site || !args.sessionId) {
+        (0, ui_1.error)('Usage: gurulu replay get --site=<id> --session-id=<id>');
+        process.exit(1);
+    }
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/replay/${encodeURIComponent(args.sessionId)}?site=${encodeURIComponent(args.site)}`, { profile: args.profile });
+    process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+}

package/dist/commands/secrets.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CLI@0.4.4 — `gurulu secrets` — list & rotate keys in the tenant credential vault.
+ *
+ * Subcommands:
+ *   gurulu secrets list                       (key names only — never values)
+ *   gurulu secrets rotate --key API_TOKEN     (issues new value, keeps old in 24h grace window)
+ *
+ * TODO(Sprint K): backend endpoints below are not yet live. The CLI command
+ * surface is implemented now so customers can wire automation.
+ *   - GET   /api/cli/secrets/list                     -> { secrets: [{ key, lastRotatedAt, rotationStatus }] }
+ *   - POST  /api/cli/secrets/rotate { key }           -> { key, newRevealedOnce: string, graceUntil: ISO }
+ */
+export interface SecretsArgs {
+    action?: string;
+    key?: string;
+    json?: boolean;
+    profile?: string;
+}
+export declare function secretsCommand(args: SecretsArgs): Promise<void>;

package/dist/commands/secrets.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * CLI@0.4.4 — `gurulu secrets` — list & rotate keys in the tenant credential vault.
+ *
+ * Subcommands:
+ *   gurulu secrets list                       (key names only — never values)
+ *   gurulu secrets rotate --key API_TOKEN     (issues new value, keeps old in 24h grace window)
+ *
+ * TODO(Sprint K): backend endpoints below are not yet live. The CLI command
+ * surface is implemented now so customers can wire automation.
+ *   - GET   /api/cli/secrets/list                     -> { secrets: [{ key, lastRotatedAt, rotationStatus }] }
+ *   - POST  /api/cli/secrets/rotate { key }           -> { key, newRevealedOnce: string, graceUntil: ISO }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretsCommand = secretsCommand;
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+const redact_1 = require("../utils/redact");
+async function secretsCommand(args) {
+    // Defensive — never echo args wholesale in any future debug path.
+    if (process.env.GURULU_DEBUG === '1') {
+        console.log(`[debug] secrets args: ${JSON.stringify((0, redact_1.redactSensitiveArgs)({ ...args }))}`);
+    }
+    switch (args.action) {
+        case 'list':
+            return secretsList(args);
+        case 'rotate':
+            return secretsRotate(args);
+        default:
+            (0, ui_1.error)(`Unknown action: ${args.action}. Use: list, rotate`);
+            process.exit(1);
+    }
+}
+async function loadProfileOrExit(args) {
+    try {
+        return await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    }
+    catch {
+        (0, ui_1.error)('Not authenticated. Run "gurulu login" first.');
+        process.exit(1);
+    }
+}
+function emitFallbackNotice(json) {
+    if (json)
+        return;
+    (0, ui_1.info)((0, ui_1.dim)('Note: backend endpoint not yet live (Sprint K candidate). Command-shape is stable.'));
+}
+// ── list ───────────────────────────────────────────────────────────────────
+async function secretsList(args) {
+    const profile = await loadProfileOrExit(args);
+    try {
+        const res = await (0, api_client_1.cliApi)('/api/cli/secrets/list', { preloadedProfile: profile });
+        const data = await res.json().catch(() => ({}));
+        if (res.status === 404) {
+            emitFallbackNotice(args.json);
+            if (args.json)
+                console.log(JSON.stringify({ ok: false, pending: true, secrets: [] }));
+            else
+                (0, ui_1.info)('Pending: would list tenant secrets (key names only).');
+            return;
+        }
+        if (!res.ok) {
+            const msg = data.message || data.error || `HTTP ${res.status}`;
+            if (args.json)
+                console.log(JSON.stringify({ ok: false, error: msg }));
+            else
+                (0, ui_1.error)(msg);
+            process.exit(1);
+        }
+        if (args.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const secrets = data.secrets || [];
+        if (secrets.length === 0) {
+            (0, ui_1.info)('No secrets in this tenant vault.');
+            return;
+        }
+        console.log((0, ui_1.bold)('Secrets (values are never exposed):'));
+        for (const s of secrets) {
+            const rotated = s.lastRotatedAt ? (0, ui_1.dim)(`  rotated ${s.lastRotatedAt}`) : '';
+            const status = s.rotationStatus ? (0, ui_1.dim)(`  [${s.rotationStatus}]`) : '';
+            (0, ui_1.step)(`${s.key}${rotated}${status}`);
+        }
+    }
+    catch (err) {
+        if (args.json)
+            console.log(JSON.stringify({ ok: false, error: err.message }));
+        else
+            (0, ui_1.error)(`Failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+// ── rotate ─────────────────────────────────────────────────────────────────
+async function secretsRotate(args) {
+    if (!args.key) {
+        (0, ui_1.error)('Usage: gurulu secrets rotate --key <KEY_NAME>');
+        process.exit(1);
+    }
+    const profile = await loadProfileOrExit(args);
+    try {
+        const res = await (0, api_client_1.cliApi)('/api/cli/secrets/rotate', {
+            method: 'POST',
+            body: JSON.stringify({ key: args.key }),
+            preloadedProfile: profile,
+        });
+        const data = await res.json().catch(() => ({}));
+        if (res.status === 404) {
+            emitFallbackNotice(args.json);
+            if (args.json)
+                console.log(JSON.stringify({ ok: false, pending: true, key: args.key }));
+            else
+                (0, ui_1.info)(`Pending: would rotate ${args.key} (24h grace window).`);
+            return;
+        }
+        if (!res.ok) {
+            const msg = data.message || data.error || `HTTP ${res.status}`;
+            if (args.json)
+                console.log(JSON.stringify({ ok: false, error: msg }));
+            else
+                (0, ui_1.error)(msg);
+            process.exit(1);
+        }
+        if (args.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        (0, ui_1.success)(`Rotated ${args.key}`);
+        if (data.newRevealedOnce) {
+            (0, ui_1.warn)('New value (shown ONCE — store it now, you cannot retrieve it again):');
+            console.log(`  ${(0, ui_1.bold)(data.newRevealedOnce)}`);
+        }
+        if (data.graceUntil) {
+            (0, ui_1.info)(`Old value remains valid until: ${data.graceUntil}`);
+        }
+    }
+    catch (err) {
+        if (args.json)
+            console.log(JSON.stringify({ ok: false, error: err.message }));
+        else
+            (0, ui_1.error)(`Failed: ${err.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/skad.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sprint E SE-B — `gurulu skad postbacks`.
+ *
+ * Mirror of MCP `gurulu.skad.list_postbacks`. Backend already exists at
+ * `/api/cli/skad` (Sprint C C9).
+ */
+export interface SkadArgs {
+    action?: string;
+    site?: string;
+    from?: string;
+    to?: string;
+    goal?: string;
+    limit?: number;
+    format?: string;
+    json?: boolean;
+    profile?: string;
+}
+export declare function skadCommand(args: SkadArgs): Promise<void>;

package/dist/commands/skad.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Sprint E SE-B — `gurulu skad postbacks`.
+ *
+ * Mirror of MCP `gurulu.skad.list_postbacks`. Backend already exists at
+ * `/api/cli/skad` (Sprint C C9).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skadCommand = skadCommand;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function skadCommand(args) {
+    const action = args.action || '';
+    switch (action) {
+        case 'postbacks':
+            return postbacksCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown skad action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu skad postbacks --site=<id> [--from=...] [--goal=$purchase] [--limit=50]');
+            process.exit(1);
+    }
+}
+async function postbacksCmd(args) {
+    const usp = new URLSearchParams();
+    if (args.site)
+        usp.set('site', args.site);
+    if (args.from)
+        usp.set('from', args.from);
+    if (args.to)
+        usp.set('to', args.to);
+    if (args.goal)
+        usp.set('goal', args.goal);
+    if (args.limit)
+        usp.set('limit', String(args.limit));
+    const path = `/api/cli/skad${usp.toString() ? `?${usp.toString()}` : ''}`;
+    const body = await (0, api_client_1.cliApiJson)(path, { profile: args.profile });
+    if (args.format === 'table') {
+        const rows = body.postbacks || [];
+        process.stdout.write(['RECEIVED', 'NETWORK', 'GOAL', 'CV', 'WIN', 'VERIFIED'].join('\t') + '\n');
+        for (const p of rows) {
+            process.stdout.write([
+                String(p.received_at ?? '-'),
+                p.ad_network_id ?? '-',
+                p.resolved_goal ?? '-',
+                String(p.conversion_value ?? '-'),
+                p.did_win ? 'yes' : 'no',
+                p.signature_verified ? 'yes' : 'no',
+            ].join('\t') + '\n');
+        }
+        return;
+    }
+    process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+}

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,21 @@
+/**
+ * FA-1 P1-4 — `gurulu upgrade` command.
+ *
+ * Bumps installed @gurulu/* packages to the latest version published on npm.
+ * Reads current versions from `npm ls --depth=0 --json` so it works regardless
+ * of which package manager is in use, then dispatches to the same `pm`
+ * detection install.ts uses (npm/pnpm/yarn/bun) for the actual upgrade.
+ *
+ * Usage:
+ *   gurulu upgrade                    # default: bump @gurulu/web
+ *   gurulu upgrade --package=@gurulu/cli
+ *   gurulu upgrade --all              # bump @gurulu/cli + @gurulu/node + @gurulu/web
+ *   gurulu upgrade --dry-run          # show plan without executing
+ */
+export interface UpgradeArgs {
+    package?: string;
+    all?: boolean;
+    dryRun?: boolean;
+    path?: string;
+}
+export declare function upgradeCommand(args: UpgradeArgs): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * FA-1 P1-4 — `gurulu upgrade` command.
+ *
+ * Bumps installed @gurulu/* packages to the latest version published on npm.
+ * Reads current versions from `npm ls --depth=0 --json` so it works regardless
+ * of which package manager is in use, then dispatches to the same `pm`
+ * detection install.ts uses (npm/pnpm/yarn/bun) for the actual upgrade.
+ *
+ * Usage:
+ *   gurulu upgrade                    # default: bump @gurulu/web
+ *   gurulu upgrade --package=@gurulu/cli
+ *   gurulu upgrade --all              # bump @gurulu/cli + @gurulu/node + @gurulu/web
+ *   gurulu upgrade --dry-run          # show plan without executing
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgradeCommand = upgradeCommand;
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ui_1 = require("../utils/ui");
+const install_1 = require("./install");
+const DEFAULT_PACKAGES = ['@gurulu/cli', '@gurulu/node', '@gurulu/web'];
+function runCmd(cmd, args, opts = {}) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            cwd: opts.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => (stdout += c.toString()));
+        child.stderr.on('data', (c) => (stderr += c.toString()));
+        child.on('close', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+        child.on('error', (err) => resolve({ code: 1, stdout, stderr: String(err) }));
+    });
+}
+async function getCurrentVersion(repoRoot, pkg) {
+    // `npm ls --depth=0 --json` works in any project regardless of which PM
+    // wrote the lockfile (npm reads node_modules directly). When the package
+    // is missing from node_modules the JSON is still valid; we just see no
+    // entry under `dependencies`.
+    const res = await runCmd('npm', ['ls', pkg, '--depth=0', '--json'], { cwd: repoRoot });
+    if (!res.stdout)
+        return null;
+    try {
+        const parsed = JSON.parse(res.stdout);
+        const dep = parsed.dependencies && parsed.dependencies[pkg];
+        if (dep && typeof dep.version === 'string')
+            return dep.version;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getLatestVersion(pkg) {
+    const res = await runCmd('npm', ['view', pkg, 'version']);
+    if (res.code !== 0)
+        return null;
+    const v = res.stdout.trim();
+    return v || null;
+}
+function pmUpgradeArgs(pm, pkg) {
+    if (pm === 'pnpm')
+        return ['update', '--latest', pkg];
+    if (pm === 'yarn')
+        return ['upgrade', `${pkg}@latest`];
+    if (pm === 'bun')
+        return ['update', pkg];
+    return ['install', `${pkg}@latest`];
+}
+function compareSemver(a, b) {
+    // Returns -1 if a < b, 0 if equal, 1 if a > b. Strips any leading `v` and
+    // pre-release suffixes ("1.2.3-rc.1" → ["1","2","3"]).
+    const norm = (s) => s
+        .replace(/^v/, '')
+        .split('-')[0]
+        .split('.')
+        .map((n) => parseInt(n, 10) || 0);
+    const aa = norm(a);
+    const bb = norm(b);
+    for (let i = 0; i < Math.max(aa.length, bb.length); i++) {
+        const x = aa[i] || 0;
+        const y = bb[i] || 0;
+        if (x < y)
+            return -1;
+        if (x > y)
+            return 1;
+    }
+    return 0;
+}
+async function upgradeCommand(args) {
+    const repoRoot = path.resolve(args.path || process.cwd());
+    const targets = args.all
+        ? DEFAULT_PACKAGES
+        : [args.package || '@gurulu/web'];
+    (0, ui_1.info)(`${(0, ui_1.bold)('gurulu upgrade')} — checking ${targets.length} package(s) in ${(0, ui_1.cyan)(repoRoot)}`);
+    const pm = (0, install_1.detectPackageManager)(repoRoot);
+    (0, ui_1.step)(`Package manager: ${(0, ui_1.bold)(pm)}`);
+    const plans = [];
+    for (const pkg of targets) {
+        const [current, latest] = await Promise.all([
+            getCurrentVersion(repoRoot, pkg),
+            getLatestVersion(pkg),
+        ]);
+        plans.push({ pkg, current, latest });
+    }
+    const toBump = [];
+    for (const p of plans) {
+        if (!p.latest) {
+            (0, ui_1.warn)(`${p.pkg}: could not resolve latest version (npm view failed).`);
+            continue;
+        }
+        if (!p.current) {
+            (0, ui_1.info)(`${p.pkg}: not installed — skipping (run \`gurulu install\` first).`);
+            continue;
+        }
+        const cmp = compareSemver(p.current, p.latest);
+        if (cmp >= 0) {
+            (0, ui_1.success)(`${p.pkg}: up-to-date (${p.current})`);
+            continue;
+        }
+        (0, ui_1.info)(`${p.pkg}: ${(0, ui_1.dim)(p.current)} → ${(0, ui_1.cyan)(p.latest)}`);
+        toBump.push(p);
+    }
+    if (toBump.length === 0) {
+        (0, ui_1.success)('All packages up-to-date.');
+        return;
+    }
+    if (args.dryRun) {
+        (0, ui_1.info)(`Dry-run: would upgrade ${toBump.length} package(s).`);
+        return;
+    }
+    let failures = 0;
+    for (const p of toBump) {
+        (0, ui_1.step)(`Upgrading ${p.pkg} via ${pm}...`);
+        const res = await runCmd(pm, pmUpgradeArgs(pm, p.pkg), { cwd: repoRoot });
+        if (res.code !== 0) {
+            failures++;
+            (0, ui_1.error)(`${pm} upgrade failed for ${p.pkg} (exit ${res.code}): ${res.stderr.trim()}`);
+        }
+        else {
+            (0, ui_1.success)(`${p.pkg} upgraded.`);
+        }
+    }
+    if (failures > 0) {
+        process.exit(1);
+    }
+}

package/dist/frameworks/detect.d.ts

@@ -1,4 +1,4 @@
-export type Framework = 'nextjs-app' | 'nextjs-pages' | 'react-vite' | 'react-cra' | 'vue3' | 'nuxt3' | 'svelte' | 'sveltekit' | 'astro' | 'express' | 'nestjs' | 'html' | 'react-native' | 'ios-swift' | 'android-kotlin' | 'flutter' | 'unknown';
+export type Framework = 'nextjs-app' | 'nextjs-pages' | 'react-vite' | 'react-cra' | 'vue3' | 'nuxt3' | 'svelte' | 'sveltekit' | 'astro' | 'express' | 'fastify' | 'hono' | 'nestjs' | 'html' | 'react-native' | 'ios-swift' | 'android-kotlin' | 'flutter' | 'unknown';
 export declare function detectFramework(projectDir: string): Framework;
 export declare function getSetupSnippet(framework: Framework, siteId: string, token: string): {
     file: string;