@gurulu/cli 0.4.0 → 0.4.1

package/dist/commands/sourcemap.js

@@ -2,12 +2,16 @@
 /**
  * `gurulu sourcemap upload` — Upload source maps for error deobfuscation.
  *
- * Reads all `.map` files from the specified directory and POSTs them to
- * `/api/errors/sourcemaps` with Bearer auth. The server stores them on
- * disk for later stack trace deobfuscation (follow-up task).
- *
- * Usage:
+ * Web (default):
  *   gurulu sourcemap upload --release v1.0.0 --dir .next/static/
+ *
+ * Native (C3 — iOS dSYM / Android ProGuard):
+ *   gurulu sourcemap upload --platform=ios     --version=1.4.2 --bundle-id=com.example.app --file=app.xcarchive/dSYMs/MyApp.dSYM.zip
+ *   gurulu sourcemap upload --platform=android --version=1.4.2 --bundle-id=com.example.app --file=app/build/outputs/mapping/release/mapping.txt
+ *
+ * The native variant POSTs a single `file` to `/api/sourcemap/native`, which
+ * persists it under {SOURCEMAP_STORAGE_PATH}/native/{siteId}/{platform}/{release}/
+ * and registers a `NativeSymbolFile` row.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,10 +59,71 @@ async function sourcemapCommand(args) {
     if (action !== 'upload') {
         (0, ui_1.error)(`Unknown sourcemap action: ${action}`);
         (0, ui_1.info)('Usage: gurulu sourcemap upload --release <version> --dir <path>');
+        (0, ui_1.info)('       gurulu sourcemap upload --platform=ios|android --version=<v> --bundle-id=<id> --file=<path>');
         process.exit(1);
     }
+    if (args.platform === 'ios' || args.platform === 'android') {
+        return uploadNativeCmd(args);
+    }
     return uploadCmd(args);
 }
+async function uploadNativeCmd(args) {
+    const version = args.version || args.release;
+    if (!version) {
+        (0, ui_1.error)('Missing --version flag. Example: --version=1.4.2');
+        process.exit(1);
+    }
+    if (!args.file) {
+        (0, ui_1.error)('Missing --file flag. For iOS pass the dSYM zip; for Android pass mapping.txt');
+        process.exit(1);
+    }
+    const bundleId = args.bundleId || args.appId;
+    if (!bundleId) {
+        (0, ui_1.error)('Missing --bundle-id flag (iOS bundleId or Android applicationId)');
+        process.exit(1);
+    }
+    const filePath = path.resolve(args.file);
+    if (!fs.existsSync(filePath)) {
+        (0, ui_1.error)(`File not found: ${filePath}`);
+        process.exit(1);
+    }
+    const profile = await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    const siteId = args.site || profile.site_id;
+    if (!siteId) {
+        (0, ui_1.error)('Missing --site flag or default site in profile.');
+        process.exit(1);
+    }
+    const fileName = path.basename(filePath);
+    const content = fs.readFileSync(filePath);
+    const blob = new Blob([content], { type: 'application/octet-stream' });
+    const formData = new FormData();
+    formData.append('platform', args.platform);
+    formData.append('version', version);
+    formData.append('bundleId', bundleId);
+    formData.append('siteId', siteId);
+    formData.append('file', blob, fileName);
+    (0, ui_1.info)(`Uploading ${fileName} (${args.platform}) for ${bundleId}@${version}...`);
+    const res = await (0, api_client_1.cliApi)('/api/sourcemap/native', {
+        method: 'POST',
+        body: formData,
+        profile: args.profile,
+        headers: {},
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: 'Unknown error' }));
+        (0, ui_1.error)(`Upload failed (${res.status}): ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const result = await res.json();
+    if (args.json) {
+        process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+        return;
+    }
+    (0, ui_1.success)(`Native symbols uploaded for ${args.platform} ${version}`);
+    process.stdout.write((0, ui_1.dim)(`  File: ${result.fileName}\n`));
+    process.stdout.write((0, ui_1.dim)(`  Path: ${result.storagePath}\n`));
+    process.stdout.write((0, ui_1.dim)(`  Size: ${result.sizeBytes} bytes\n`));
+}
 function findMapFiles(dir) {
     const results = [];
     function walk(d) {
@@ -103,17 +168,19 @@ async function uploadCmd(args) {
         (0, ui_1.error)('Missing --site flag or default site in profile. Use: gurulu sourcemap upload --site <site-id> ...');
         process.exit(1);
     }
+    const platform = args.platform || 'web';
     // Build FormData
     const formData = new FormData();
     formData.append('release', args.release);
     formData.append('siteId', siteId);
+    formData.append('platform', platform);
     for (const filePath of mapFiles) {
         const content = fs.readFileSync(filePath);
         const fileName = path.basename(filePath);
         const blob = new Blob([content], { type: 'application/json' });
         formData.append(fileName, blob, fileName);
     }
-    const res = await (0, api_client_1.cliApi)('/api/errors/sourcemaps', {
+    const res = await (0, api_client_1.cliApi)('/api/tracker-config/sourcemaps', {
         method: 'POST',
         body: formData,
         profile: args.profile,

package/dist/commands/watch.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sprint B Group VII B14 — `gurulu watch` live event stream.
+ *
+ * Tail every event for the active tenant in near-real time, with optional
+ * filtering by site / event types. Uses the existing CLI SSE endpoint
+ * (/api/cli/events/tail) so we don't duplicate poll/heartbeat plumbing.
+ *
+ *   gurulu watch                              # all sites, all events
+ *   gurulu watch --site=site_123              # one site
+ *   gurulu watch --types=$purchase,page_view  # filter by event names (CSV)
+ *   gurulu watch --tail=50                    # show last N before streaming
+ *   gurulu watch --json                       # one JSON line per event
+ *
+ * Auth: bearer token from active profile (`loadActiveProfile` via cliApi).
+ * Graceful shutdown: SIGINT cancels the fetch via AbortController.
+ */
+export interface WatchArgs {
+    site?: string;
+    types?: string;
+    tail?: number;
+    json?: boolean;
+    profile?: string;
+    /** Override the upstream SSE path — for tests/proxies. Defaults to the CLI
+     *  bearer-auth tail route. */
+    endpoint?: string;
+}
+interface RealtimeEventRow {
+    event_id?: string;
+    event_ts?: string;
+    event_name?: string;
+    site_id?: string;
+    site_name?: string;
+    url?: string;
+    page_url?: string;
+    anonymous_id?: string;
+    user_id?: string;
+    selector?: string;
+    revenue_value?: number | string;
+    revenue_currency?: string;
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare function watchCommand(args: WatchArgs): Promise<void>;
+export declare function formatEventLine(row: RealtimeEventRow, json: boolean): string;
+export {};

package/dist/commands/watch.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Sprint B Group VII B14 — `gurulu watch` live event stream.
+ *
+ * Tail every event for the active tenant in near-real time, with optional
+ * filtering by site / event types. Uses the existing CLI SSE endpoint
+ * (/api/cli/events/tail) so we don't duplicate poll/heartbeat plumbing.
+ *
+ *   gurulu watch                              # all sites, all events
+ *   gurulu watch --site=site_123              # one site
+ *   gurulu watch --types=$purchase,page_view  # filter by event names (CSV)
+ *   gurulu watch --tail=50                    # show last N before streaming
+ *   gurulu watch --json                       # one JSON line per event
+ *
+ * Auth: bearer token from active profile (`loadActiveProfile` via cliApi).
+ * Graceful shutdown: SIGINT cancels the fetch via AbortController.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchCommand = watchCommand;
+exports.formatEventLine = formatEventLine;
+const api_client_1 = require("../api-client");
+const ui_1 = require("../utils/ui");
+async function watchCommand(args) {
+    const types = parseTypes(args.types);
+    const tailCount = Math.max(0, Number(args.tail) || 0);
+    // 1. Optional tail of recent events before streaming.
+    if (tailCount > 0) {
+        await printTail(args, types, tailCount);
+    }
+    // 2. Open the SSE stream and forward events until SIGINT.
+    await streamEvents(args, types);
+}
+function parseTypes(raw) {
+    if (!raw)
+        return null;
+    const list = raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    if (list.length === 0)
+        return null;
+    return new Set(list);
+}
+async function printTail(args, types, tailCount) {
+    const qs = new URLSearchParams();
+    if (args.site)
+        qs.set('site', args.site);
+    // The tail-history endpoint accepts a single event_name. When the user
+    // requested multiple, fetch the union and filter client-side.
+    if (types && types.size === 1) {
+        qs.set('event_name', Array.from(types)[0]);
+    }
+    qs.set('limit', String(Math.min(tailCount * (types ? 5 : 1), 500)));
+    qs.set('since', '24h');
+    const path = `/api/cli/events?${qs.toString()}`;
+    let body;
+    try {
+        body = await (0, api_client_1.cliApiJson)(path, {
+            profile: args.profile,
+        });
+    }
+    catch (err) {
+        (0, ui_1.error)(`Failed to fetch tail history: ${err.message}`);
+        return;
+    }
+    const all = body.events || [];
+    const filtered = (types ? all.filter((e) => e.event_name && types.has(e.event_name)) : all)
+        .slice(-tailCount) // keep the newest N (events arrive newest-first)
+        .reverse();
+    if (filtered.length === 0) {
+        if (!args.json)
+            (0, ui_1.info)('No prior events in the last 24h.');
+    }
+    for (const ev of filtered) {
+        process.stdout.write(formatEventLine(ev, !!args.json));
+    }
+    if (!args.json && filtered.length > 0) {
+        process.stdout.write((0, ui_1.dim)('  --- live stream ---\n'));
+    }
+}
+async function streamEvents(args, types) {
+    const qs = new URLSearchParams();
+    if (args.site)
+        qs.set('site', args.site);
+    // SSE backend accepts a single eventName. Multi-type filter is applied on
+    // the client. (Forwarded as a hint when only one is set so the server can
+    // skip irrelevant rows entirely.)
+    if (types && types.size === 1)
+        qs.set('event_name', Array.from(types)[0]);
+    const path = args.endpoint ||
+        `/api/cli/events/tail${qs.toString() ? `?${qs.toString()}` : ''}`;
+    // SIGINT → abort the fetch so the SSE socket is released cleanly.
+    const controller = new AbortController();
+    const onSigint = () => {
+        if (!args.json)
+            process.stderr.write((0, ui_1.dim)('\n[watch] disconnected\n'));
+        controller.abort();
+        // Give the abort path a tick to drain, then exit normally.
+        setTimeout(() => process.exit(0), 25);
+    };
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigint);
+    if (!args.json) {
+        (0, ui_1.info)(`Streaming events${args.site ? ` for site=${args.site}` : ''}${types ? ` types=[${Array.from(types).join(',')}]` : ''} — Ctrl+C to stop`);
+    }
+    // Reconnect loop — SSE streams cap at 10 minutes server-side. Honour the
+    // `reconnect` frame and any transient network drop.
+    let attempt = 0;
+    while (!controller.signal.aborted) {
+        try {
+            const res = await (0, api_client_1.cliApi)(path, {
+                profile: args.profile,
+                headers: { accept: 'text/event-stream' },
+                signal: controller.signal,
+            });
+            if (!res.body) {
+                (0, ui_1.error)('Watch stream returned no body.');
+                return;
+            }
+            attempt = 0; // reset backoff on successful connect
+            await consumeSseBody(res.body, types, !!args.json);
+            // Stream ended cleanly (max_lifetime). Re-open immediately.
+        }
+        catch (err) {
+            if (controller.signal.aborted)
+                return;
+            attempt += 1;
+            const wait = Math.min(15_000, 500 * 2 ** attempt);
+            if (!args.json) {
+                process.stderr.write((0, ui_1.dim)(`[watch] connection lost (${err.message}); reconnecting in ${wait}ms\n`));
+            }
+            await sleep(wait);
+        }
+    }
+}
+async function consumeSseBody(body, types, json) {
+    // Browser-style ReadableStream
+    const reader = body.getReader?.();
+    if (reader) {
+        const decoder = new TextDecoder();
+        let buffer = '';
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            buffer += decoder.decode(value, { stream: true });
+            const flushed = drainSseBuffer(buffer);
+            buffer = flushed.tail;
+            for (const frame of flushed.frames)
+                emitFrame(frame, types, json);
+        }
+    }
+    // Node Readable fallback
+    let buffer = '';
+    for await (const chunk of body) {
+        buffer += Buffer.from(chunk).toString('utf8');
+        const flushed = drainSseBuffer(buffer);
+        buffer = flushed.tail;
+        for (const frame of flushed.frames)
+            emitFrame(frame, types, json);
+    }
+}
+function drainSseBuffer(buffer) {
+    const frames = [];
+    let idx = buffer.indexOf('\n\n');
+    while (idx !== -1) {
+        const block = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        let event = 'message';
+        let data = '';
+        for (const line of block.split('\n')) {
+            if (line.startsWith('event: '))
+                event = line.slice(7).trim();
+            else if (line.startsWith('data: '))
+                data += line.slice(6);
+        }
+        if (data)
+            frames.push({ event, data });
+        idx = buffer.indexOf('\n\n');
+    }
+    return { frames, tail: buffer };
+}
+function emitFrame(frame, types, json) {
+    if (frame.event !== 'realtime_event')
+        return;
+    let row;
+    try {
+        row = JSON.parse(frame.data);
+    }
+    catch {
+        return;
+    }
+    if (types && row.event_name && !types.has(row.event_name))
+        return;
+    process.stdout.write(formatEventLine(row, json));
+}
+function formatEventLine(row, json) {
+    if (json)
+        return JSON.stringify(row) + '\n';
+    const ts = formatTimestamp(row.event_ts);
+    const name = String(row.event_name || '-').padEnd(14);
+    const namePainted = paintEvent(name, String(row.event_name || ''));
+    const who = formatActor(row);
+    const site = row.site_name || row.site_id ? `site=${row.site_name || row.site_id}` : '';
+    const tail = formatTail(row);
+    return `${(0, ui_1.dim)(ts)}  ${namePainted}  ${who}${site ? ' ' + (0, ui_1.dim)(site) : ''}${tail ? '  ' + tail : ''}\n`;
+}
+function formatTimestamp(ts) {
+    if (!ts)
+        return '----------------'.padEnd(19);
+    // ClickHouse format: '2026-04-27 14:23:01' (UTC) or ISO. Take the first 19.
+    const cleaned = ts.replace('T', ' ').slice(0, 19);
+    return cleaned.padEnd(19);
+}
+function paintEvent(padded, raw) {
+    if (!raw)
+        return padded;
+    if (raw.startsWith('$'))
+        return (0, ui_1.cyan)(padded); // system events
+    if (raw.startsWith('error'))
+        return (0, ui_1.yellow)(padded);
+    if (raw === 'page_view' || raw === 'pageview')
+        return (0, ui_1.dim)(padded);
+    return (0, ui_1.green)(padded);
+}
+function formatActor(row) {
+    if (row.user_id)
+        return `${(0, ui_1.bold)('user')}=${String(row.user_id).slice(0, 8)}`;
+    if (row.anonymous_id)
+        return `anon=${String(row.anonymous_id).slice(0, 6)}`;
+    return (0, ui_1.dim)('anon=?');
+}
+function formatTail(row) {
+    const parts = [];
+    const url = row.url || row.page_url;
+    if (url)
+        parts.push(stripHost(String(url)));
+    if (row.selector)
+        parts.push(`selector=${row.selector}`);
+    if (row.revenue_value != null && Number(row.revenue_value) > 0) {
+        const cur = row.revenue_currency || 'USD';
+        parts.push(`value=${row.revenue_value} ${cur}`);
+    }
+    return parts.join(' ');
+}
+function stripHost(url) {
+    try {
+        const u = new URL(url);
+        return u.pathname + (u.search || '');
+    }
+    catch {
+        return url;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/frameworks/detect.js

@@ -11,25 +11,47 @@ const path_1 = __importDefault(require("path"));
 function detectFramework(projectDir) {
     const pkgPath = path_1.default.join(projectDir, 'package.json');
     const hasPkgJson = fs_1.default.existsSync(pkgPath);
+    // Read package.json early so we can dedupe iOS-vs-React-Native (RN repos
+    // commonly host an `ios/MyApp.xcodeproj` and a top-level Package.swift in
+    // monorepos — without the RN check first we'd return `ios-swift` and ship
+    // the wrong SDK snippet).
+    let deps = {};
+    if (hasPkgJson) {
+        try {
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+            deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        }
+        catch {
+            /* malformed package.json — fall through to filesystem detection */
+        }
+        if (deps['react-native'])
+            return 'react-native';
+    }
     // Mobile framework detection (non-package.json based)
     if (fs_1.default.existsSync(path_1.default.join(projectDir, 'pubspec.yaml')))
         return 'flutter';
     const hasSwiftPkg = fs_1.default.existsSync(path_1.default.join(projectDir, 'Package.swift'));
-    const hasXcodeProj = fs_1.default.readdirSync(projectDir).some(f => f.endsWith('.xcodeproj'));
+    let hasXcodeProj = false;
+    try {
+        hasXcodeProj = fs_1.default
+            .readdirSync(projectDir)
+            .some((f) => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'));
+    }
+    catch {
+        /* unreadable dir — treat as no Xcode project */
+    }
     if (hasSwiftPkg || hasXcodeProj)
         return 'ios-swift';
     if (!hasPkgJson) {
         // Android detection (no package.json means no RN false positive)
-        if (fs_1.default.existsSync(path_1.default.join(projectDir, 'build.gradle.kts')) || fs_1.default.existsSync(path_1.default.join(projectDir, 'build.gradle'))) {
+        if (fs_1.default.existsSync(path_1.default.join(projectDir, 'build.gradle.kts')) ||
+            fs_1.default.existsSync(path_1.default.join(projectDir, 'build.gradle')) ||
+            fs_1.default.existsSync(path_1.default.join(projectDir, 'app', 'build.gradle')) ||
+            fs_1.default.existsSync(path_1.default.join(projectDir, 'app', 'build.gradle.kts'))) {
             return 'android-kotlin';
         }
         return 'html';
     }
-    const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    // React Native (must check before other React frameworks)
-    if (deps['react-native'])
-        return 'react-native';
     if (deps['next']) {
         // Check for app router
         if (fs_1.default.existsSync(path_1.default.join(projectDir, 'src', 'app')) || fs_1.default.existsSync(path_1.default.join(projectDir, 'app'))) {