fraim 2.0.179 → 2.0.182

package/dist/src/services/session-service.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+class SessionManager {
+    constructor(dbService) {
+        this.sessions = new Map();
+        this.dbService = dbService;
+        // Default 1m, configurable for testing
+        this.FLUSH_INTERVAL_MS = process.env.FRAIM_TELEMETRY_FLUSH_INTERVAL
+            ? parseInt(process.env.FRAIM_TELEMETRY_FLUSH_INTERVAL)
+            : 60 * 1000;
+        // Flush on shutdown
+        const cleanup = async () => {
+            console.log('Flushing telemetry sessions before shutdown...');
+            // Race flush with a 2s timeout to guarantee exit
+            const timeout = new Promise(resolve => setTimeout(resolve, 2000));
+            await Promise.race([this.flushAll(), timeout]);
+            console.log('Shutdown flush complete (or timed out). Exiting.');
+            process.exit(0);
+        };
+        process.on('SIGTERM', cleanup);
+        process.on('SIGINT', cleanup);
+    }
+    registerSession(apiKey, sessionId) {
+        const now = Date.now();
+        this.sessions.set(this.getSessionKey(apiKey, sessionId), {
+            sessionId,
+            lastWrite: now,
+            lastActive: now
+        });
+    }
+    async updateActivity(apiKey, sessionId) {
+        let sessionKey = sessionId ? this.getSessionKey(apiKey, sessionId) : null;
+        let session = sessionKey ? this.sessions.get(sessionKey) : null;
+        const now = Date.now();
+        if (!session) {
+            // Re-hydration: find the exact session when sessionId is provided.
+            // Legacy fallback (no sessionId) resolves latest active session for API key.
+            try {
+                const dbSession = sessionId
+                    ? await this.dbService.getSessionByApiKeyAndSessionId(apiKey, sessionId)
+                    : await this.dbService.getActiveSessionByApiKey(apiKey);
+                if (dbSession) {
+                    sessionKey = this.getSessionKey(apiKey, dbSession.sessionId);
+                    console.log(`Re-hydrating session for API Key: ${apiKey}, sessionId: ${dbSession.sessionId}`);
+                    session = {
+                        sessionId: dbSession.sessionId,
+                        lastWrite: now,
+                        lastActive: now
+                    };
+                    this.sessions.set(sessionKey, session);
+                }
+                else {
+                    return false;
+                }
+            }
+            catch (e) {
+                console.error('Failed to re-hydrate session from DB:', e);
+                return false;
+            }
+        }
+        session.lastActive = now;
+        const shouldFlushByInterval = now - session.lastWrite > this.FLUSH_INTERVAL_MS;
+        // Write-behind with deterministic fallback persistence:
+        // - Flush asynchronously on interval.
+        if (shouldFlushByInterval) {
+            const flushPromise = this.dbService.updateSessionActivity(session.sessionId, new Date(now));
+            flushPromise.catch((e) => {
+                console.error('Failed to flush session activity:', e);
+            });
+            session.lastWrite = now;
+        }
+        return true;
+    }
+    async flushAll() {
+        const promises = [];
+        for (const [_, data] of this.sessions) {
+            promises.push(this.dbService.updateSessionActivity(data.sessionId, new Date(data.lastActive)));
+        }
+        await Promise.allSettled(promises);
+    }
+    getSessionKey(apiKey, sessionId) {
+        return `${apiKey}::${sessionId}`;
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/src/services/trial-reminder-service.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrialReminderService = void 0;
+const email_service_1 = require("./email-service");
+/**
+ * Trial Reminder Service
+ *
+ * Sends automated emails to trial users:
+ * - Day 7: Mid-trial check-in (7 days remaining)
+ * - Day 12: Trial expiring soon (2 days remaining)
+ * - Day 14: Trial expired
+ *
+ * This service should be run as a cron job once per day
+ */
+class TrialReminderService {
+    constructor(dbService) {
+        this.dbService = dbService;
+        this.emailService = new email_service_1.EmailService();
+    }
+    /**
+     * Main cron job entry point
+     * Run this once per day (e.g., at 10:00 AM UTC)
+     */
+    async runDailyReminders() {
+        console.log('[TRIAL-REMINDER] Starting daily trial reminder check...');
+        try {
+            const now = new Date();
+            const oneDayMs = 24 * 60 * 60 * 1000;
+            // Get all active trial keys
+            const allKeys = await this.dbService.listApiKeys();
+            const trialKeys = allKeys.filter(key => key.tier === 'trial' &&
+                key.status === 'active' &&
+                key.expiresAt !== null);
+            console.log(`[TRIAL-REMINDER] Found ${trialKeys.length} active trial users`);
+            let day7Count = 0;
+            let day12Count = 0;
+            let expiredCount = 0;
+            for (const key of trialKeys) {
+                const expiresAt = key.expiresAt;
+                const msUntilExpiry = expiresAt.getTime() - now.getTime();
+                const daysUntilExpiry = Math.ceil(msUntilExpiry / oneDayMs);
+                try {
+                    // Trial expired
+                    if (daysUntilExpiry <= 0) {
+                        await this.handleExpiredTrial(key);
+                        expiredCount++;
+                    }
+                    // 2 days remaining (day 12 of trial)
+                    else if (daysUntilExpiry === 2) {
+                        await this.handleTrialExpiringSoon(key, daysUntilExpiry);
+                        day12Count++;
+                    }
+                    // 7 days remaining (day 7 of trial)
+                    else if (daysUntilExpiry === 7) {
+                        await this.handleMidTrialCheckIn(key);
+                        day7Count++;
+                    }
+                }
+                catch (error) {
+                    console.error(`[TRIAL-REMINDER] Error processing trial for ${key.userId}:`, error);
+                    // Continue processing other users
+                }
+            }
+            console.log(`[TRIAL-REMINDER] Completed daily reminders:`, {
+                day7CheckIns: day7Count,
+                day12Warnings: day12Count,
+                expired: expiredCount,
+                total: trialKeys.length
+            });
+        }
+        catch (error) {
+            console.error('[TRIAL-REMINDER] Error in daily reminder job:', error);
+            throw error;
+        }
+    }
+    /**
+     * Send mid-trial check-in (day 7 - 7 days remaining)
+     */
+    async handleMidTrialCheckIn(key) {
+        console.log(`[TRIAL-REMINDER] Sending day 7 check-in to ${key.userId}`);
+        await this.emailService.sendTrialCheckIn(key.userId, key.expiresAt);
+    }
+    /**
+     * Send trial expiring soon warning (day 12 - 2 days remaining)
+     */
+    async handleTrialExpiringSoon(key, daysRemaining) {
+        console.log(`[TRIAL-REMINDER] Sending expiring warning to ${key.userId} (${daysRemaining} days left)`);
+        await this.emailService.sendTrialExpiring(key.userId, key.expiresAt, daysRemaining);
+    }
+    /**
+     * Handle expired trial (mark as expired, send notification)
+     */
+    async handleExpiredTrial(key) {
+        console.log(`[TRIAL-REMINDER] Processing expired trial for ${key.userId}`);
+        // Update key status to expired
+        await this.dbService.updateApiKey(key.key, {
+            status: 'expired'
+        });
+        // Send expired notification
+        await this.emailService.sendTrialExpired(key.userId, key.expiresAt);
+        console.log(`[TRIAL-REMINDER] Trial expired and notification sent to ${key.userId}`);
+    }
+    /**
+     * Manual trigger for testing (processes all trials regardless of timing)
+     */
+    async runTestMode() {
+        console.log('[TRIAL-REMINDER] Running in TEST MODE...');
+        const allKeys = await this.dbService.listApiKeys();
+        const trialKeys = allKeys.filter(key => key.tier === 'trial' &&
+            key.expiresAt !== null);
+        console.log(`[TRIAL-REMINDER] Found ${trialKeys.length} trial users (all statuses)`);
+        for (const key of trialKeys) {
+            const now = new Date();
+            const msUntilExpiry = key.expiresAt.getTime() - now.getTime();
+            const daysUntilExpiry = Math.ceil(msUntilExpiry / (24 * 60 * 60 * 1000));
+            console.log(`[TRIAL-REMINDER] ${key.userId}: ${daysUntilExpiry} days remaining, status: ${key.status}`);
+        }
+    }
+}
+exports.TrialReminderService = TrialReminderService;

package/dist/src/services/usage-analytics-service.js

@@ -0,0 +1,419 @@
+"use strict";
+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.UsageAnalyticsService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Service for handling usage analytics operations
+ * Provides high-level interface for tracking and analyzing usage patterns
+ */
+class UsageAnalyticsService {
+    constructor(dbService) {
+        this.eventQueue = [];
+        this.flushInterval = null;
+        this.BATCH_SIZE = 100;
+        this.FLUSH_INTERVAL_MS = 5000; // 5 seconds
+        this.jobMap = null;
+        this.registryPath = null;
+        this.dbService = dbService;
+        this.startBatchProcessor();
+    }
+    /**
+     * Log a usage event (queued for batch processing)
+     */
+    async logUsage(input) {
+        // Add to queue for batch processing
+        this.eventQueue.push(input);
+        // Flush immediately if queue is full
+        if (this.eventQueue.length >= this.BATCH_SIZE) {
+            await this.flushQueue();
+        }
+    }
+    /**
+     * Log a usage event immediately (bypasses queue)
+     */
+    async logUsageImmediate(input) {
+        try {
+            // Enrich with category if missing and type is job
+            if (input.type === 'job' && (!input.category || input.category === 'uncategorized')) {
+                input.category = await this.resolveCategory(input.name);
+            }
+            await this.dbService.logUsageEvent(input);
+        }
+        catch (error) {
+            console.error('Failed to log usage event:', error);
+            // Don't throw - analytics failures shouldn't break main functionality
+        }
+    }
+    /**
+     * Resolve category for a job name
+     */
+    async resolveCategory(jobName) {
+        if (!this.jobMap) {
+            await this.loadJobMap();
+        }
+        return this.jobMap?.get(jobName) || 'uncategorized';
+    }
+    async resolveCanonicalCategory(name, type, fallbackCategory) {
+        if (type === 'job') {
+            const resolved = await this.resolveCategory(name);
+            if (resolved && resolved !== 'uncategorized') {
+                return resolved;
+            }
+        }
+        return fallbackCategory || undefined;
+    }
+    async loadJobMap() {
+        try {
+            this.jobMap = new Map();
+            // Find registry root - using process.cwd() for server-side resolution
+            const registryRoot = path.join(process.cwd(), 'registry', 'jobs');
+            if (!fs.existsSync(registryRoot)) {
+                console.warn(`[UsageAnalyticsService] Could not find registry/jobs directory at ${registryRoot}`);
+                return;
+            }
+            this.scanRegistryDir(registryRoot);
+            console.log(`[UsageAnalyticsService] Loaded ${this.jobMap.size} jobs from registry`);
+        }
+        catch (error) {
+            console.error('[UsageAnalyticsService] Failed to load job registry:', error);
+        }
+    }
+    scanRegistryDir(dir, base = '') {
+        if (!this.jobMap)
+            return;
+        try {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+            for (const item of items) {
+                const fullPath = path.join(dir, item.name);
+                const relPath = path.relative(path.join(process.cwd(), 'registry', 'jobs'), fullPath);
+                const parts = relPath.split(path.sep);
+                if (item.isDirectory()) {
+                    this.scanRegistryDir(fullPath, path.join(base, item.name));
+                }
+                else if (item.name.endsWith('.md')) {
+                    const jobName = item.name.replace('.md', '');
+                    // Group ai-manager jobs into ai-management
+                    // We check if "ai-manager" is in the path OR the name includes "manager" or "analyze-why"
+                    const lowerName = jobName.toLowerCase();
+                    if (parts.includes('ai-manager') || lowerName.includes('manager') || lowerName.includes('coaching') || lowerName.includes('analyze-why')) {
+                        this.jobMap.set(jobName, 'ai-management');
+                    }
+                    else {
+                        // Find category (one level up from filename)
+                        const category = parts[parts.length - 2] || 'uncategorized';
+                        this.jobMap.set(jobName, category);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[UsageAnalyticsService] Error scanning directory ${dir}:`, error);
+        }
+    }
+    /**
+     * Get usage statistics for a time period
+     */
+    async getUsageStats(query) {
+        const timeWindow = this.resolveTimeWindow(query.period || '30d', query.startDate, query.endDate);
+        return await this.dbService.getUsageStats(timeWindow, query.types, query.userId, query.repoIdentifier);
+    }
+    /**
+     * Get top components by usage
+     */
+    async getTopComponents(limit = 10, period = '30d', types, userId, repoIdentifier, startDate, endDate) {
+        const timeWindow = this.resolveTimeWindow(period, startDate, endDate);
+        const components = await this.dbService.getTopComponents(limit, timeWindow, types, userId, repoIdentifier);
+        return await Promise.all(components.map(async (component) => ({
+            ...component,
+            category: await this.resolveCanonicalCategory(component.name, component.type, component.category)
+        })));
+    }
+    /**
+     * Get usage pattern for a specific user
+     */
+    async getUserUsagePattern(userId) {
+        return await this.dbService.getUserUsagePattern(userId);
+    }
+    /**
+     * Get trend data for a component
+     */
+    async getComponentTrend(componentName, componentType, period = '30d', userId, dateUnit, repoIdentifier, startDate, endDate) {
+        const timeWindow = this.resolveTimeWindow(period, startDate, endDate);
+        return await this.dbService.getComponentTrend(componentName, componentType, timeWindow, userId, dateUnit, repoIdentifier);
+    }
+    /**
+     * Get job timeline data for bubble chart
+     */
+    async getJobRunsOverTime(period = '30d', userId, dateUnit, repoIdentifier, startDate, endDate) {
+        const timeWindow = this.resolveTimeWindow(period, startDate, endDate);
+        const timeline = await this.dbService.getJobRunsOverTime(timeWindow, userId, dateUnit, repoIdentifier);
+        return await Promise.all(timeline.map(async (item) => ({
+            ...item,
+            category: await this.resolveCanonicalCategory(item.name, 'job', item.category)
+        })));
+    }
+    async getDominantJobCategory(period = '30d', userId, repoIdentifier, startDate, endDate) {
+        const components = await this.getTopComponents(10000, period, ['job'], userId, repoIdentifier, startDate, endDate);
+        if (components.length === 0)
+            return null;
+        const totals = new Map();
+        for (const component of components) {
+            const category = component.category || 'uncategorized';
+            totals.set(category, (totals.get(category) || 0) + component.count);
+        }
+        let dominant = null;
+        for (const [category, count] of totals.entries()) {
+            if (!dominant || count > dominant.count) {
+                dominant = { category, count };
+            }
+        }
+        return dominant;
+    }
+    /**
+     * Export usage data as CSV
+     */
+    async exportUsageData(query) {
+        const stats = await this.getUsageStats(query);
+        const topComponents = await this.getTopComponents(query.limit || 50, query.period || '30d', query.types, query.userId, query.repoIdentifier, query.startDate, query.endDate);
+        // Create CSV content
+        let csv = 'Component Name,Type,Category,Usage Count,Success Rate,Last Used\n';
+        topComponents.forEach(component => {
+            csv += `"${component.name}","${component.type}","${component.category || 'N/A'}",${component.count},${(component.successRate || 0).toFixed(2)}%,"${component.lastUsed ? component.lastUsed.toISOString() : 'N/A'}"\n`;
+        });
+        return csv;
+    }
+    /**
+     * Clean up old usage events
+     */
+    async cleanupOldEvents(retentionDays = 90) {
+        return await this.dbService.cleanupOldUsageEvents(retentionDays);
+    }
+    /**
+     * Initialize the analytics system
+     */
+    async initialize() {
+        await this.dbService.initializeUsageEventsCollection();
+    }
+    /**
+     * Get unique repositories that have generated telemetry for a user
+     */
+    async getUniqueRepos(userId) {
+        return await this.dbService.getUniqueRepos(userId);
+    }
+    /**
+     * Gracefully shutdown the service
+     */
+    async shutdown() {
+        if (this.flushInterval) {
+            clearInterval(this.flushInterval);
+            this.flushInterval = null;
+        }
+        // Flush any remaining events
+        await this.flushQueue();
+    }
+    /**
+     * Create a usage event for job start (when get_fraim_job is called)
+     */
+    async logJobStart(jobId, jobName, userId, sessionId, issueNumber) {
+        const jobStartEvent = UsageAnalyticsService.createUsageEvent('job', jobName, userId, sessionId, true, {
+            action: 'start',
+            issueNumber,
+            jobId
+        }, await this.resolveCategory(jobName), jobId);
+        await this.logUsage(jobStartEvent);
+    }
+    /**
+     * Create a usage event for job completion (when seekMentoring returns nextPhase=null)
+     */
+    async logJobComplete(jobId, jobName, userId, sessionId, finalPhase) {
+        const jobCompleteEvent = UsageAnalyticsService.createUsageEvent('job', jobName, userId, sessionId, true, {
+            action: 'complete',
+            finalPhase,
+            jobId
+        }, await this.resolveCategory(jobName), jobId, finalPhase);
+        await this.logUsage(jobCompleteEvent);
+    }
+    /**
+     * Log a quality score for a job that produces quality assessments (e.g., process-interview-notes, triage-customer-needs).
+     * Writes to the dedicated fraim_quality_scores collection (no TTL — retained indefinitely).
+     */
+    async logQualityScore(userId, jobName, jobId, sessionId, scores, artifactPath, repoIdentifier, reviewContext) {
+        try {
+            await this.dbService.insertQualityScore({
+                userId,
+                jobName,
+                jobId,
+                sessionId,
+                scores,
+                reviewContext,
+                artifactPath,
+                repoIdentifier,
+                createdAt: new Date()
+            });
+        }
+        catch (error) {
+            console.error(`[UsageAnalyticsService] Failed to log quality score for ${jobName}:`, error);
+        }
+    }
+    /**
+     * Create a usage event for mentoring calls with job tracking
+     */
+    async logMentoringCall(jobId, jobName, userId, sessionId, currentPhase, status, nextPhase, success = true) {
+        const mentoringEvent = UsageAnalyticsService.createUsageEvent('mentoring', jobName, userId, sessionId, success, {
+            currentPhase,
+            status,
+            nextPhase,
+            jobId
+        }, await this.resolveCategory(jobName), jobId, currentPhase);
+        await this.logUsage(mentoringEvent);
+    }
+    /**
+     * Validate that a jobId exists for the user (check recent usage events)
+     */
+    async validateJobId(jobId, userId) {
+        try {
+            // Check if there's a recent job start event for this jobId and user
+            const recentEvents = await this.dbService.getDb();
+            const collection = recentEvents.collection('fraim_usage_events');
+            const jobStartEvent = await collection.findOne({
+                jobId,
+                userId,
+                type: 'job',
+                'args.action': 'start',
+                createdAt: { $gte: new Date(Date.now() - 24 * 60 * 60 * 1000) } // Within last 24 hours
+            });
+            return jobStartEvent !== null;
+        }
+        catch (error) {
+            console.error('Error validating jobId:', error);
+            return false;
+        }
+    }
+    /**
+     * Get job completion metrics using usage events
+     */
+    async getJobCompletionMetrics(period = '30d', jobName, userId, repoIdentifier, startDate, endDate) {
+        const timeWindow = this.resolveTimeWindow(period, startDate, endDate);
+        return await this.dbService.getJobCompletionMetrics(timeWindow.startDate, jobName, userId, repoIdentifier, timeWindow.endDate);
+    }
+    /**
+     * Start the batch processor for queued events
+     */
+    startBatchProcessor() {
+        this.flushInterval = setInterval(async () => {
+            if (this.eventQueue.length > 0) {
+                await this.flushQueue();
+            }
+        }, this.FLUSH_INTERVAL_MS);
+        this.flushInterval.unref?.();
+    }
+    /**
+     * Flush queued events to database
+     */
+    async flushQueue() {
+        if (this.eventQueue.length === 0)
+            return;
+        // Skip flush if DB is not connected (e.g., during server shutdown)
+        if (!this.dbService.getClient())
+            return;
+        const eventsToFlush = this.eventQueue.splice(0, this.BATCH_SIZE);
+        try {
+            // Process events in parallel for better performance
+            await Promise.all(eventsToFlush.map(event => this.dbService.logUsageEvent(event)));
+        }
+        catch (error) {
+            // Only re-queue if the error is transient (not a disconnection)
+            if (error instanceof Error && error.message.includes('not connected')) {
+                return; // DB shut down — drop events
+            }
+            console.error('Failed to flush usage events:', error);
+            // Re-queue failed events (up to a limit to prevent infinite growth)
+            if (this.eventQueue.length < this.BATCH_SIZE * 2) {
+                this.eventQueue.unshift(...eventsToFlush);
+            }
+        }
+    }
+    /**
+     * Parse period string to days
+     */
+    parsePeriodToDays(period) {
+        const match = period.match(/^(\d+)([dwmy])$/);
+        if (!match)
+            return 30; // default to 30 days
+        const [, num, unit] = match;
+        const value = parseInt(num, 10);
+        switch (unit) {
+            case 'd': return value;
+            case 'w': return value * 7;
+            case 'm': return value * 30;
+            case 'y': return value * 365;
+            default: return 30;
+        }
+    }
+    resolveTimeWindow(period, startDateInput, endDateInput) {
+        const now = new Date();
+        if (startDateInput || endDateInput) {
+            const startDate = startDateInput ? new Date(startDateInput) : new Date(now);
+            const endDate = endDateInput ? new Date(endDateInput) : now;
+            const days = Math.max(1, Math.ceil((endDate.getTime() - startDate.getTime()) / (24 * 60 * 60 * 1000)) + 1);
+            return { startDate, endDate, days };
+        }
+        const days = this.parsePeriodToDays(period);
+        return {
+            startDate: new Date(now.getTime() - days * 24 * 60 * 60 * 1000),
+            endDate: now,
+            days
+        };
+    }
+    /**
+     * Create a usage event input from parameters
+     */
+    static createUsageEvent(type, name, userId, sessionId, success = true, args, category, jobId, jobPhase) {
+        return {
+            type,
+            name,
+            userId,
+            sessionId,
+            success,
+            args,
+            category,
+            jobId,
+            jobPhase
+        };
+    }
+}
+exports.UsageAnalyticsService = UsageAnalyticsService;

package/dist/src/services/workspace-identity.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeWorkspaceEmail = normalizeWorkspaceEmail;
+exports.resolveWorkspaceId = resolveWorkspaceId;
+function normalizeWorkspaceEmail(email) {
+    if (!email)
+        return null;
+    const trimmed = email.trim().toLowerCase();
+    return trimmed || null;
+}
+function resolveWorkspaceId(input) {
+    if (input.workspaceId)
+        return input.workspaceId;
+    if (input.stripeCustomerId)
+        return `cust:${input.stripeCustomerId}`;
+    const normalizedEmail = normalizeWorkspaceEmail(input.email);
+    if (normalizedEmail) {
+        return `user:${normalizedEmail}`;
+    }
+    return null;
+}

package/dist/src/types/analytics.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });