@gurulu/cli 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const detect_1 = require("../frameworks/detect");
+const ui_1 = require("../utils/ui");
+async function statusCommand(args) {
+    let profile;
+    try {
+        profile = await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    }
+    catch {
+        profile = null;
+    }
+    const siteId = args.site;
+    const projectDir = process.cwd();
+    if (args.json) {
+        return statusJSON(siteId, profile, projectDir);
+    }
+    (0, ui_1.banner)();
+    console.log((0, ui_1.bold)('  Status Check'));
+    console.log('');
+    // 1. Framework detection
+    const framework = (0, detect_1.detectFramework)(projectDir);
+    console.log(`  ${(0, ui_1.dim)('Framework:')}     ${(0, detect_1.getFrameworkDisplayName)(framework)}`);
+    // 2. SDK installed check
+    const pkgPath = path_1.default.join(projectDir, 'package.json');
+    let sdkInstalled = false;
+    if (fs_1.default.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        sdkInstalled = !!allDeps['@gurulu/web-sdk'] || !!allDeps['@gurulu/node'] || !!allDeps['@gurulu/react-native'];
+    }
+    // Check for mobile SDKs (non-npm based)
+    let mobileSDKFound = false;
+    const pubspecPath = path_1.default.join(projectDir, 'pubspec.yaml');
+    if (fs_1.default.existsSync(pubspecPath) && fs_1.default.readFileSync(pubspecPath, 'utf-8').includes('gurulu_flutter')) {
+        mobileSDKFound = true;
+    }
+    const swiftPkgPath = path_1.default.join(projectDir, 'Package.swift');
+    if (!mobileSDKFound && fs_1.default.existsSync(swiftPkgPath) && fs_1.default.readFileSync(swiftPkgPath, 'utf-8').includes('gurulu-ios-sdk')) {
+        mobileSDKFound = true;
+    }
+    for (const gFile of ['build.gradle.kts', 'build.gradle']) {
+        const gPath = path_1.default.join(projectDir, gFile);
+        if (!mobileSDKFound && fs_1.default.existsSync(gPath)) {
+            const content = fs_1.default.readFileSync(gPath, 'utf-8');
+            if (content.includes('gurulu') || content.includes('jitpack')) {
+                mobileSDKFound = true;
+            }
+        }
+    }
+    // Also check for gurulu setup file
+    const hasSetupFile = checkSetupFile(projectDir);
+    const installed = sdkInstalled || hasSetupFile || mobileSDKFound;
+    console.log(`  ${(0, ui_1.dim)('SDK:')}           ${installed ? (0, ui_1.green)('Installed') : (0, ui_1.yellow)('Not detected')}`);
+    // 3. Auth check
+    const authed = !!profile;
+    console.log(`  ${(0, ui_1.dim)('Auth:')}          ${authed ? (0, ui_1.green)('Authenticated') : (0, ui_1.yellow)('Not authenticated')}`);
+    // 4. Site check
+    console.log(`  ${(0, ui_1.dim)('Site ID:')}       ${siteId ? siteId : (0, ui_1.yellow)('Not set')}`);
+    // 5. Connection check via /api/cli/sites/:id/health
+    if (siteId && profile) {
+        try {
+            const health = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${siteId}/health`, { preloadedProfile: profile });
+            if (health.healthy) {
+                console.log(`  ${(0, ui_1.dim)('Connection:')}    ${(0, ui_1.green)('All services healthy')}`);
+            }
+            else {
+                const failing = Object.entries(health.checks)
+                    .filter(([, s]) => s === 'fail')
+                    .map(([k]) => k)
+                    .join(', ');
+                console.log(`  ${(0, ui_1.dim)('Connection:')}    ${(0, ui_1.red)(`Unhealthy: ${failing}`)}`);
+            }
+        }
+        catch {
+            console.log(`  ${(0, ui_1.dim)('Connection:')}    ${(0, ui_1.yellow)('Could not reach health endpoint')}`);
+        }
+    }
+    else {
+        if (!siteId) {
+            console.log(`  ${(0, ui_1.dim)('Connection:')}    ${(0, ui_1.dim)('Skipped (no site)')}`);
+        }
+        else {
+            console.log(`  ${(0, ui_1.dim)('Connection:')}    ${(0, ui_1.dim)('Skipped (not authenticated)')}`);
+        }
+    }
+    console.log('');
+    if (!installed) {
+        (0, ui_1.info)(`Run ${(0, ui_1.cyan)('gurulu init')} to set up analytics`);
+    }
+    if (!authed) {
+        (0, ui_1.info)(`Run ${(0, ui_1.cyan)('gurulu login')} to authenticate`);
+    }
+    console.log('');
+}
+function checkSetupFile(projectDir) {
+    const candidates = [
+        'src/lib/gurulu.tsx',
+        'src/lib/gurulu.ts',
+        'src/gurulu.ts',
+        'src/plugins/gurulu.ts',
+        'plugins/gurulu.client.ts',
+        'src/components/Gurulu.astro',
+        'src/gurulu.middleware.ts',
+    ];
+    return candidates.some(f => fs_1.default.existsSync(path_1.default.join(projectDir, f)));
+}
+async function statusJSON(siteId, profile, projectDir) {
+    const framework = (0, detect_1.detectFramework)(projectDir);
+    const hasSetupFile = checkSetupFile(projectDir);
+    const result = {
+        framework,
+        frameworkName: (0, detect_1.getFrameworkDisplayName)(framework),
+        sdkDetected: hasSetupFile,
+        authenticated: !!profile,
+        siteId: siteId || null,
+        connection: null,
+    };
+    if (siteId && profile) {
+        try {
+            result.connection = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${siteId}/health`, { preloadedProfile: profile });
+        }
+        catch {
+            // leave as null
+        }
+    }
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/warehouse.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Phase 18 B1 — `gurulu warehouse export` — manually trigger a warehouse
+ * export run from the CLI. Uses the multi-profile config and Bearer auth
+ * via cliApi.
+ *
+ * Usage:
+ *   gurulu warehouse export --export <warehouseExportId>
+ *
+ * The `--tenant` flag is accepted for forward compatibility (Phase 18 B2
+ * will route to a tenant-aware endpoint) but is not required today —
+ * tenant scoping is derived server-side from the authenticated session.
+ */
+interface WarehouseArgs {
+    tenant?: string;
+    export?: string;
+    json?: boolean;
+    profile?: string;
+}
+export declare function warehouseExportCommand(args: WarehouseArgs): Promise<void>;
+export {};

package/dist/commands/warehouse.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Phase 18 B1 — `gurulu warehouse export` — manually trigger a warehouse
+ * export run from the CLI. Uses the multi-profile config and Bearer auth
+ * via cliApi.
+ *
+ * Usage:
+ *   gurulu warehouse export --export <warehouseExportId>
+ *
+ * The `--tenant` flag is accepted for forward compatibility (Phase 18 B2
+ * will route to a tenant-aware endpoint) but is not required today —
+ * tenant scoping is derived server-side from the authenticated session.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warehouseExportCommand = warehouseExportCommand;
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function warehouseExportCommand(args) {
+    let profile;
+    try {
+        profile = await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    }
+    catch {
+        if (args.json)
+            console.log(JSON.stringify({ error: 'not_authenticated' }));
+        else
+            (0, ui_1.error)('Not authenticated. Run "gurulu login" first.');
+        process.exit(1);
+    }
+    if (!args.export) {
+        if (args.json)
+            console.log(JSON.stringify({ error: 'export_id_required' }));
+        else
+            (0, ui_1.error)('--export <id> is required');
+        process.exit(1);
+    }
+    const url = `/api/warehouses/exports/${encodeURIComponent(args.export)}/trigger`;
+    try {
+        const res = await (0, api_client_1.cliApi)(url, {
+            method: 'POST',
+            preloadedProfile: profile,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`HTTP ${res.status}: ${text}`);
+        }
+        const body = await res.json();
+        if (args.json) {
+            console.log(JSON.stringify(body, null, 2));
+            return;
+        }
+        (0, ui_1.info)(`Warehouse export ${args.export} triggered`);
+        (0, ui_1.success)(`Status: ${body?.result?.status ?? 'ok'}`);
+    }
+    catch (err) {
+        if (args.json) {
+            console.log(JSON.stringify({ error: err.message }));
+        }
+        else {
+            (0, ui_1.error)(`Trigger failed: ${err.message}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/warehouses.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Phase 19.5 W2 B6 — `gurulu warehouses list|runs <id>`.
+ * Phase 20  W2 B5 — `create|update|delete|run`.
+ */
+export interface WarehousesArgs {
+    action?: string;
+    target?: string;
+    json?: boolean;
+    profile?: string;
+    fromFile?: string;
+    name?: string;
+    type?: string;
+    schedule?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+}
+export declare function warehousesCommand(args: WarehousesArgs): Promise<void>;

package/dist/commands/warehouses.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Phase 19.5 W2 B6 — `gurulu warehouses list|runs <id>`.
+ * Phase 20  W2 B5 — `create|update|delete|run`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warehousesCommand = warehousesCommand;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+const confirm_1 = require("../utils/confirm");
+const dry_run_1 = require("../utils/dry-run");
+const from_file_1 = require("../utils/from-file");
+async function warehousesCommand(args) {
+    const action = args.action || 'list';
+    switch (action) {
+        case 'list':
+            return listCmd(args);
+        case 'runs':
+            return runsCmd(args);
+        case 'create':
+            return createCmd(args);
+        case 'update':
+            return updateCmd(args);
+        case 'delete':
+            return deleteCmd(args);
+        case 'run':
+            return runManualCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown warehouses action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu warehouses [list|runs|create|update|delete|run]');
+            process.exit(1);
+    }
+}
+async function listCmd(args) {
+    const body = await (0, api_client_1.cliApiJson)('/api/cli/warehouses', {
+        profile: args.profile,
+    });
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    const rows = body.exports || [];
+    if (rows.length === 0) {
+        (0, ui_1.info)('No warehouse exports configured.');
+        return;
+    }
+    process.stdout.write(['ID', 'NAME', 'TYPE', 'SCHEDULE', 'LAST_RUN', 'STATUS'].join('\t') + '\n');
+    for (const e of rows) {
+        process.stdout.write([
+            e.id,
+            e.name,
+            e.type,
+            e.schedule,
+            String(e.lastRunAt || '-'),
+            e.lastRunStatus || '-',
+        ].join('\t') + '\n');
+    }
+}
+async function runsCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu warehouses runs <export-id>');
+        process.exit(1);
+    }
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/warehouses/${encodeURIComponent(args.target)}/runs`, { profile: args.profile });
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    const rows = body.runs || [];
+    if (rows.length === 0) {
+        (0, ui_1.info)('No runs yet.');
+        return;
+    }
+    process.stdout.write(['ID', 'STARTED', 'STATUS', 'TABLE', 'ROWS', 'BYTES'].join('\t') + '\n');
+    for (const r of rows) {
+        process.stdout.write([r.id, String(r.startedAt), r.status, r.tableName, r.rowsExported, r.bytesExported].join('\t') + '\n');
+    }
+}
+async function createCmd(args) {
+    let payload = {};
+    if (args.fromFile)
+        payload = (0, from_file_1.loadFromFile)(args.fromFile);
+    if (args.name)
+        payload.name = args.name;
+    if (args.type)
+        payload.type = args.type;
+    if (args.schedule)
+        payload.schedule = args.schedule;
+    if (!payload.name || !payload.type || !payload.credentialVaultId || !payload.config) {
+        (0, ui_1.error)('name, type, credentialVaultId, and config are all required.');
+        process.exit(1);
+    }
+    if (args.dryRun) {
+        const body = await (0, api_client_1.cliApiJson)('/api/cli/warehouses?dryRun=1', {
+            profile: args.profile,
+            method: 'POST',
+            json: payload,
+        });
+        (0, dry_run_1.printDryRun)(body, args.json);
+        return;
+    }
+    const ok = await (0, confirm_1.promptConfirm)(`Create warehouse export '${payload.name}'?`, {
+        yes: args.yes,
+        defaultYes: true,
+    });
+    if (!ok)
+        return (0, ui_1.info)('Aborted.');
+    const body = await (0, api_client_1.cliApiJson)('/api/cli/warehouses', {
+        profile: args.profile,
+        method: 'POST',
+        json: payload,
+    });
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    (0, ui_1.success)(`Created warehouse export ${body.export?.id ?? ''}`);
+}
+async function updateCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu warehouses update <id>');
+        process.exit(1);
+    }
+    let payload = {};
+    if (args.fromFile)
+        payload = (0, from_file_1.loadFromFile)(args.fromFile);
+    if (args.schedule)
+        payload.schedule = args.schedule;
+    if (args.dryRun) {
+        const body = await (0, api_client_1.cliApiJson)(`/api/cli/warehouses/${encodeURIComponent(args.target)}?dryRun=1`, { profile: args.profile, method: 'PATCH', json: payload });
+        (0, dry_run_1.printDryRun)(body, args.json);
+        return;
+    }
+    const ok = await (0, confirm_1.promptConfirm)(`Update warehouse export '${args.target}'?`, {
+        yes: args.yes,
+        defaultYes: true,
+    });
+    if (!ok)
+        return (0, ui_1.info)('Aborted.');
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/warehouses/${encodeURIComponent(args.target)}`, { profile: args.profile, method: 'PATCH', json: payload });
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    (0, ui_1.success)(`Updated warehouse export ${args.target}`);
+}
+async function deleteCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu warehouses delete <id>');
+        process.exit(1);
+    }
+    if (args.dryRun) {
+        const body = await (0, api_client_1.cliApiJson)(`/api/cli/warehouses/${encodeURIComponent(args.target)}?dryRun=1`, { profile: args.profile, method: 'DELETE' });
+        (0, dry_run_1.printDryRun)(body, args.json);
+        return;
+    }
+    const ok = await (0, confirm_1.promptConfirm)(`About to delete warehouse export '${args.target}'. Continue?`, { yes: args.yes, defaultYes: false });
+    if (!ok)
+        return (0, ui_1.info)('Aborted.');
+    await (0, api_client_1.cliApiJson)(`/api/cli/warehouses/${encodeURIComponent(args.target)}`, { profile: args.profile, method: 'DELETE' });
+    (0, ui_1.success)(`Deleted warehouse export ${args.target}`);
+}
+async function runManualCmd(args) {
+    if (!args.target) {
+        (0, ui_1.error)('Usage: gurulu warehouses run <id>');
+        process.exit(1);
+    }
+    const ok = await (0, confirm_1.promptConfirm)(`Trigger warehouse export '${args.target}' now?`, {
+        yes: args.yes,
+        defaultYes: true,
+    });
+    if (!ok)
+        return (0, ui_1.info)('Aborted.');
+    const body = await (0, api_client_1.cliApiJson)(`/api/cli/warehouses/${encodeURIComponent(args.target)}/run${args.dryRun ? '?dryRun=1' : ''}`, { profile: args.profile, method: 'POST', json: {} });
+    if (args.dryRun)
+        return (0, dry_run_1.printDryRun)(body, args.json);
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    (0, ui_1.success)(`Triggered run for ${args.target}`);
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Phase 18.5 W2 — `gurulu whoami`. Loads the active profile and hits
+ * `/api/cli/me` for a concise one-line summary. Supports --json.
+ */
+export interface WhoamiArgs {
+    profile?: string;
+    json?: boolean;
+}
+export declare function whoamiCommand(args: WhoamiArgs): Promise<void>;

package/dist/commands/whoami.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Phase 18.5 W2 — `gurulu whoami`. Loads the active profile and hits
+ * `/api/cli/me` for a concise one-line summary. Supports --json.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whoamiCommand = whoamiCommand;
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function whoamiCommand(args) {
+    let profile;
+    try {
+        profile = await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    }
+    catch {
+        if (args.json) {
+            process.stdout.write(JSON.stringify({ error: 'not_logged_in' }) + '\n');
+        }
+        else {
+            (0, ui_1.error)('Not logged in. Run `gurulu login` first.');
+        }
+        process.exit(1);
+    }
+    try {
+        const me = await (0, api_client_1.cliApiJson)('/api/cli/me', { preloadedProfile: profile });
+        if (args.json) {
+            process.stdout.write(JSON.stringify(me, null, 2) + '\n');
+            return;
+        }
+        const sites = (me.sites || []).length;
+        const keys = (me.apiKeys || []).length;
+        const installs = me.quota?.installsThisMonth ?? 0;
+        const limit = me.quota?.installsLimit ?? '∞';
+        process.stdout.write(`${me.user?.email} · ${me.tenant?.name} · ${me.tenant?.plan} plan · ${me.tenant?.id}\n`);
+        process.stdout.write(`Sites: ${sites} | API keys: ${keys} | Installs this month: ${installs}/${limit}\n`);
+    }
+    catch (err) {
+        if (args.json) {
+            process.stdout.write(JSON.stringify({ error: err.message }) + '\n');
+        }
+        else {
+            (0, ui_1.error)(`whoami failed: ${err.message}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Phase 18.5 W2 — Multi-profile CLI config.
+ *
+ * Replaces the single-profile `~/.gurulu/config.json` used by earlier phases
+ * with a profile-aware store, while keeping backward compatibility for
+ * commands that still call `utils/config.ts` (they now read from the
+ * currently-active profile).
+ *
+ * Resolution order for a live session:
+ *   1. GURULU_SECRET_KEY  (env-var override — bypasses the file entirely)
+ *   2. --profile <name>   (CLI flag)
+ *   3. GURULU_PROFILE     (env)
+ *   4. default_profile    (from file)
+ *   5. 'personal'         (final fallback)
+ *
+ * Optional macOS keychain integration: if `keytar` is available at runtime,
+ * secrets can be stored there under service 'io.gurulu.cli' account
+ * `<profile>`. If unavailable, secrets fall back to the plaintext file.
+ * Keytar is a **soft runtime require** — never a hard dependency, because
+ * it's a native module and we don't want to force its install.
+ */
+export interface ProfileConfig {
+    email: string;
+    secret_key: string;
+    api_base: string;
+}
+export interface StoredProfile {
+    email: string;
+    secret_key?: string;
+    api_base: string;
+    keychain?: boolean;
+}
+export interface ConfigFile {
+    default_profile: string;
+    profiles: Record<string, StoredProfile>;
+}
+export interface ActiveProfile extends ProfileConfig {
+    name: string;
+    source: 'env' | 'file' | 'keychain';
+}
+export interface CliFlags {
+    profile?: string;
+}
+export declare function configPath(): string;
+export declare function readKeychainSecret(profile: string): Promise<string | null>;
+export declare function writeKeychainSecret(profile: string, secret: string): Promise<boolean>;
+export declare function deleteKeychainSecret(profile: string): Promise<void>;
+export declare function isKeychainAvailable(): boolean;
+export declare function listProfiles(): Array<{
+    name: string;
+    email: string;
+    api_base: string;
+    isDefault: boolean;
+    keychain: boolean;
+}>;
+export declare function getStoredProfile(name: string): StoredProfile | null;
+export declare function getDefaultProfileName(): string;
+export declare function setDefaultProfile(name: string): void;
+export declare function saveProfile(name: string, profile: ProfileConfig, opts?: {
+    useKeychain?: boolean;
+}): Promise<{
+    storedInKeychain: boolean;
+}>;
+export declare function deleteProfile(name: string): Promise<boolean>;
+export declare function deleteAllProfiles(): Promise<string[]>;
+/**
+ * Resolve the active profile given CLI flags. Throws if no usable profile.
+ * Accepts the `GURULU_SECRET_KEY` env var as an override for CI.
+ */
+export declare function loadActiveProfile(flags?: CliFlags): Promise<ActiveProfile>;
+export declare function getActiveProfile(flags?: CliFlags): Promise<ActiveProfile | null>;
+export declare class ProfileNotFoundError extends Error {
+    constructor(name: string);
+}
+export declare function defaultApiBase(): string;