@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/server/pg-job-queue.js

@@ -0,0 +1,375 @@
+/**
+ * PostgreSQL-backed job queue for production deployments
+ * Uses same Pool pattern as pg-auth-store.ts
+ */
+import pg from 'pg';
+import { randomUUID } from 'crypto';
+const { Pool } = pg;
+export class PostgresJobQueue {
+    pool;
+    cleanupInterval;
+    constructor(connectionString) {
+        const dbUrl = connectionString || process.env.DATABASE_URL;
+        if (!dbUrl) {
+            throw new Error('DATABASE_URL environment variable is required for PostgresJobQueue');
+        }
+        this.pool = new Pool({
+            connectionString: dbUrl,
+            // TLS: enabled when DATABASE_URL contains sslmode=require.
+            // Secure by default (rejectUnauthorized: true); set PG_REJECT_UNAUTHORIZED=false
+            // only for managed DBs (Render/Neon/Supabase) that use self-signed certs.
+            ssl: process.env.DATABASE_URL?.includes('sslmode=require')
+                ? { rejectUnauthorized: process.env.PG_REJECT_UNAUTHORIZED !== 'false' }
+                : undefined,
+            max: 20,
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 10000,
+        });
+        // Initialize table
+        this.initTable().catch(err => {
+            console.error('Failed to initialize jobs table:', err);
+        });
+        // Clean up old completed/failed jobs every hour
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupOldJobs().catch(err => {
+                console.error('Failed to cleanup old jobs:', err);
+            });
+        }, 60 * 60 * 1000);
+    }
+    /**
+     * Create jobs table if it doesn't exist
+     */
+    async initTable() {
+        try {
+            await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS jobs (
+          id TEXT PRIMARY KEY,
+          type TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          progress INTEGER DEFAULT 0,
+          data JSONB,
+          error TEXT,
+          total INTEGER DEFAULT 0,
+          completed INTEGER DEFAULT 0,
+          credits_used INTEGER DEFAULT 0,
+          owner_id TEXT,
+          webhook_url TEXT,
+          webhook_events JSONB,
+          webhook_metadata JSONB,
+          webhook_secret TEXT,
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          updated_at TIMESTAMPTZ DEFAULT NOW(),
+          expires_at TIMESTAMPTZ
+        )
+      `);
+            // Add owner_id column if it doesn't exist (migration for existing tables)
+            await this.pool.query(`
+        DO $$ BEGIN
+          ALTER TABLE jobs ADD COLUMN IF NOT EXISTS owner_id TEXT;
+          ALTER TABLE jobs ADD COLUMN IF NOT EXISTS webhook_delivery JSONB;
+        EXCEPTION WHEN others THEN NULL;
+        END $$;
+      `);
+            // Add index on status and created_at for faster queries
+            await this.pool.query(`
+        CREATE INDEX IF NOT EXISTS idx_jobs_status_created 
+        ON jobs(status, created_at DESC)
+      `);
+            // Add index on type for filtering
+            await this.pool.query(`
+        CREATE INDEX IF NOT EXISTS idx_jobs_type 
+        ON jobs(type)
+      `);
+            // Add index on expires_at for cleanup
+            await this.pool.query(`
+        CREATE INDEX IF NOT EXISTS idx_jobs_expires 
+        ON jobs(expires_at)
+      `);
+            // Add index on owner_id for per-user job filtering
+            await this.pool.query(`
+        CREATE INDEX IF NOT EXISTS idx_jobs_owner 
+        ON jobs(owner_id)
+      `);
+        }
+        catch (error) {
+            console.error('Failed to create jobs table:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create a new job
+     */
+    async createJob(type, webhook, ownerId) {
+        const id = randomUUID();
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + 25 * 60 * 60 * 1000); // 25h from now
+        try {
+            await this.pool.query(`INSERT INTO jobs (
+          id, type, status, progress, data, total, completed, credits_used,
+          owner_id, webhook_url, webhook_events, webhook_metadata, webhook_secret,
+          created_at, updated_at, expires_at
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)`, [
+                id,
+                type,
+                'queued',
+                0,
+                JSON.stringify([]),
+                0,
+                0,
+                0,
+                ownerId || null,
+                webhook?.url || null,
+                webhook?.events ? JSON.stringify(webhook.events) : null,
+                webhook?.metadata ? JSON.stringify(webhook.metadata) : null,
+                webhook?.secret || null,
+                now,
+                now,
+                expiresAt,
+            ]);
+            return {
+                id,
+                type,
+                status: 'queued',
+                progress: 0,
+                total: 0,
+                completed: 0,
+                creditsUsed: 0,
+                data: [],
+                webhook,
+                ownerId,
+                createdAt: now.toISOString(),
+                updatedAt: now.toISOString(),
+                expiresAt: expiresAt.toISOString(),
+            };
+        }
+        catch (error) {
+            console.error('Failed to create job:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get a job by ID
+     */
+    async getJob(id) {
+        try {
+            const result = await this.pool.query(`SELECT * FROM jobs WHERE id = $1`, [id]);
+            if (result.rows.length === 0) {
+                return null;
+            }
+            return this.mapRowToJob(result.rows[0]);
+        }
+        catch (error) {
+            console.error('Failed to get job:', error);
+            return null;
+        }
+    }
+    /**
+     * Update a job
+     */
+    async updateJob(id, update) {
+        try {
+            const job = await this.getJob(id);
+            if (!job)
+                return;
+            const updates = [];
+            const values = [];
+            let paramIndex = 1;
+            // Map Job fields to database columns
+            if (update.status !== undefined) {
+                updates.push(`status = $${paramIndex++}`);
+                values.push(update.status);
+            }
+            if (update.progress !== undefined) {
+                updates.push(`progress = $${paramIndex++}`);
+                values.push(update.progress);
+            }
+            if (update.total !== undefined) {
+                updates.push(`total = $${paramIndex++}`);
+                values.push(update.total);
+            }
+            if (update.completed !== undefined) {
+                updates.push(`completed = $${paramIndex++}`);
+                values.push(update.completed);
+            }
+            if (update.creditsUsed !== undefined) {
+                updates.push(`credits_used = $${paramIndex++}`);
+                values.push(update.creditsUsed);
+            }
+            if (update.data !== undefined) {
+                updates.push(`data = $${paramIndex++}`);
+                values.push(JSON.stringify(update.data));
+            }
+            if (update.error !== undefined) {
+                updates.push(`error = $${paramIndex++}`);
+                values.push(update.error);
+            }
+            if (update.webhookDelivery !== undefined) {
+                updates.push(`webhook_delivery = $${paramIndex++}`);
+                values.push(JSON.stringify(update.webhookDelivery));
+            }
+            // Always update updated_at
+            updates.push(`updated_at = $${paramIndex++}`);
+            values.push(new Date());
+            // When job completes/fails, set expiration to 24h from now
+            if (update.status === 'completed' || update.status === 'failed' || update.status === 'cancelled') {
+                const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000);
+                updates.push(`expires_at = $${paramIndex++}`);
+                values.push(expiresAt);
+            }
+            // Calculate progress percentage if total and completed are provided
+            const newTotal = update.total ?? job.total;
+            const newCompleted = update.completed ?? job.completed;
+            if (newTotal > 0) {
+                const progress = Math.round((newCompleted / newTotal) * 100);
+                if (!updates.some(u => u.startsWith('progress'))) {
+                    updates.push(`progress = $${paramIndex++}`);
+                    values.push(progress);
+                }
+            }
+            if (updates.length === 0)
+                return;
+            // Add job ID as the last parameter
+            values.push(id);
+            const sql = `UPDATE jobs SET ${updates.join(', ')} WHERE id = $${paramIndex}`;
+            await this.pool.query(sql, values);
+        }
+        catch (error) {
+            console.error('Failed to update job:', error);
+            throw error;
+        }
+    }
+    /**
+     * Cancel a job
+     */
+    async cancelJob(id) {
+        try {
+            const job = await this.getJob(id);
+            if (!job)
+                return false;
+            // Can only cancel queued or processing jobs
+            if (job.status !== 'queued' && job.status !== 'processing') {
+                return false;
+            }
+            await this.updateJob(id, {
+                status: 'cancelled',
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to cancel job:', error);
+            return false;
+        }
+    }
+    /**
+     * List jobs with optional filters
+     */
+    async listJobs(options) {
+        try {
+            const conditions = [];
+            const values = [];
+            let paramIndex = 1;
+            if (options?.ownerId) {
+                conditions.push(`owner_id = $${paramIndex++}`);
+                values.push(options.ownerId);
+            }
+            if (options?.type) {
+                conditions.push(`type = $${paramIndex++}`);
+                values.push(options.type);
+            }
+            if (options?.status) {
+                conditions.push(`status = $${paramIndex++}`);
+                values.push(options.status);
+            }
+            const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+            const limit = options?.limit || 50;
+            const sql = `
+        SELECT * FROM jobs 
+        ${whereClause}
+        ORDER BY created_at DESC 
+        LIMIT $${paramIndex}
+      `;
+            values.push(limit);
+            const result = await this.pool.query(sql, values);
+            return result.rows.map(row => this.mapRowToJob(row));
+        }
+        catch (error) {
+            console.error('Failed to list jobs:', error);
+            return [];
+        }
+    }
+    /**
+     * Remove expired jobs (called periodically)
+     */
+    async cleanExpired() {
+        try {
+            await this.pool.query(`DELETE FROM jobs WHERE expires_at < NOW()`);
+        }
+        catch (error) {
+            console.error('Failed to clean expired jobs:', error);
+        }
+    }
+    /**
+     * Remove old completed/failed jobs (>7 days)
+     */
+    async cleanupOldJobs() {
+        try {
+            // Remove expired jobs
+            await this.cleanExpired();
+            // Remove completed/failed jobs older than 7 days
+            await this.pool.query(`DELETE FROM jobs 
+        WHERE (status = 'completed' OR status = 'failed' OR status = 'cancelled')
+        AND updated_at < NOW() - INTERVAL '7 days'`);
+        }
+        catch (error) {
+            console.error('Failed to cleanup old jobs:', error);
+        }
+    }
+    /**
+     * Map database row to Job object
+     */
+    mapRowToJob(row) {
+        const webhook = row.webhook_url
+            ? {
+                url: row.webhook_url,
+                events: row.webhook_events || [],
+                metadata: row.webhook_metadata || undefined,
+                secret: row.webhook_secret || undefined,
+            }
+            : undefined;
+        const webhookDelivery = row.webhook_delivery
+            ? (typeof row.webhook_delivery === 'string'
+                ? JSON.parse(row.webhook_delivery)
+                : row.webhook_delivery)
+            : undefined;
+        return {
+            id: row.id,
+            type: row.type,
+            status: row.status,
+            progress: row.progress || 0,
+            total: row.total || 0,
+            completed: row.completed || 0,
+            creditsUsed: row.credits_used || 0,
+            data: row.data || [],
+            error: row.error || undefined,
+            webhook,
+            webhookDelivery,
+            ownerId: row.owner_id || undefined,
+            createdAt: row.created_at.toISOString(),
+            updatedAt: row.updated_at.toISOString(),
+            expiresAt: row.expires_at.toISOString(),
+        };
+    }
+    /**
+     * Clean up interval on shutdown
+     */
+    destroy() {
+        clearInterval(this.cleanupInterval);
+    }
+    /**
+     * Close the database pool
+     */
+    async close() {
+        this.destroy();
+        await this.pool.end();
+    }
+}

package/dist/server/routes/activity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Activity endpoint - provides recent API request history
+ */
+import { Router } from 'express';
+import { AuthStore } from '../auth-store.js';
+export declare function createActivityRouter(authStore: AuthStore): Router;

package/dist/server/routes/activity.js

@@ -0,0 +1,79 @@
+/**
+ * Activity endpoint - provides recent API request history
+ */
+import { Router } from 'express';
+import { PostgresAuthStore } from '../pg-auth-store.js';
+export function createActivityRouter(authStore) {
+    const router = Router();
+    router.get('/v1/activity', async (req, res) => {
+        try {
+            // Require authentication (API key or JWT session token)
+            const userId = req.auth?.keyInfo?.accountId || req.user?.userId;
+            if (!userId) {
+                res.status(401).json({ success: false, error: { type: 'unauthorized', message: 'Authentication required', hint: 'Get a free API key at https://app.webpeel.dev/keys', docs: 'https://webpeel.dev/docs/errors#unauthorized' }, requestId: req.requestId });
+                return;
+            }
+            // Only works with PostgreSQL backend
+            if (!(authStore instanceof PostgresAuthStore)) {
+                res.status(501).json({
+                    success: false,
+                    error: {
+                        type: 'not_implemented',
+                        message: 'Activity endpoint requires PostgreSQL backend',
+                        docs: 'https://webpeel.dev/docs/errors#not_implemented',
+                    },
+                    requestId: req.requestId,
+                });
+                return;
+            }
+            // Access pool via any cast (pool is private but we need direct DB access)
+            const pgStore = authStore;
+            const limit = Math.min(parseInt(req.query.limit) || 50, 100);
+            // Get recent requests from usage_logs
+            const activityQuery = `
+        SELECT 
+          id,
+          url,
+          endpoint,
+          method,
+          status_code,
+          processing_time_ms,
+          tokens_used,
+          ip_address,
+          created_at
+        FROM usage_logs
+        WHERE user_id = $1
+        ORDER BY created_at DESC
+        LIMIT $2
+      `;
+            const result = await pgStore.pool.query(activityQuery, [userId, limit]);
+            // Transform to frontend format
+            const requests = result.rows.map((row) => ({
+                id: row.id,
+                url: row.url || 'N/A',
+                endpoint: row.endpoint || null,
+                status: (row.status_code >= 200 && row.status_code < 300) ? 'success' : 'error',
+                responseTime: row.processing_time_ms || 0,
+                mode: row.method || 'basic',
+                timestamp: row.created_at,
+                tokensUsed: row.tokens_used || null,
+                ipAddress: row.ip_address || null,
+                statusCode: row.status_code || null,
+            }));
+            res.json({ requests });
+        }
+        catch (error) {
+            console.error('Activity error:', error);
+            res.status(500).json({
+                success: false,
+                error: {
+                    type: 'internal_error',
+                    message: 'Failed to retrieve activity',
+                    docs: 'https://webpeel.dev/docs/errors#internal_error',
+                },
+                requestId: req.requestId,
+            });
+        }
+    });
+    return router;
+}

package/dist/server/routes/admin-active.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Admin active-users endpoint — admin tier only
+ *
+ * GET /v1/admin/active — currently active API users (24h + 7d windows)
+ */
+import { Router } from 'express';
+export declare function createAdminActiveRouter(): Router;

package/dist/server/routes/admin-active.js

@@ -0,0 +1,120 @@
+/**
+ * Admin active-users endpoint — admin tier only
+ *
+ * GET /v1/admin/active — currently active API users (24h + 7d windows)
+ */
+import { Router } from 'express';
+import pg from 'pg';
+const { Pool } = pg;
+function noDB(req, res) {
+    res.status(501).json({
+        success: false,
+        error: {
+            type: 'not_configured',
+            message: 'Admin endpoints require PostgreSQL backend',
+            docs: 'https://webpeel.dev/docs/errors#not_configured',
+        },
+        requestId: req.requestId,
+    });
+}
+function adminOnly(req, res) {
+    if (req.auth?.tier !== 'admin') {
+        res.status(403).json({
+            success: false,
+            error: { type: 'forbidden', message: 'Admin access required', docs: 'https://webpeel.dev/docs/authentication' },
+            requestId: req.requestId,
+        });
+        return false;
+    }
+    return true;
+}
+export function createAdminActiveRouter() {
+    const router = Router();
+    const dbUrl = process.env.DATABASE_URL;
+    if (!dbUrl) {
+        router.get('/v1/admin/active', noDB);
+        return router;
+    }
+    const pool = new Pool({
+        connectionString: dbUrl,
+        ssl: dbUrl.includes('sslmode=require')
+            ? { rejectUnauthorized: process.env.PG_REJECT_UNAUTHORIZED !== 'false' }
+            : undefined,
+        max: 5,
+    });
+    router.get('/v1/admin/active', async (req, res) => {
+        if (!adminOnly(req, res))
+            return;
+        try {
+            // Total registered users
+            const totalResult = await pool.query('SELECT COUNT(*) AS count FROM users');
+            const totalRegistered = parseInt(totalResult.rows[0].count) || 0;
+            // Active 24h — users whose API key was used in the last 24h
+            // Join with usage_logs to get today's request count per user
+            const active24hResult = await pool.query(`
+        SELECT
+          u.id        AS user_id,
+          u.email,
+          u.tier,
+          MAX(ak.last_used_at) AS last_seen,
+          COUNT(ul.id)         AS requests_today
+        FROM users u
+        JOIN api_keys ak ON ak.user_id = u.id AND ak.is_active = true
+        LEFT JOIN usage_logs ul
+          ON ul.user_id::text = u.id::text
+          AND ul.created_at >= NOW() - INTERVAL '24 hours'
+        WHERE ak.last_used_at > NOW() - INTERVAL '24 hours'
+        GROUP BY u.id, u.email, u.tier
+        ORDER BY last_seen DESC
+      `);
+            const active24h = active24hResult.rows.map((r) => ({
+                userId: r.user_id,
+                email: r.email,
+                tier: r.tier,
+                lastSeen: r.last_seen instanceof Date ? r.last_seen.toISOString() : String(r.last_seen),
+                requestsToday: parseInt(r.requests_today) || 0,
+            }));
+            // Active 7d — users whose API key was used in the last 7 days
+            const active7dResult = await pool.query(`
+        SELECT
+          u.id        AS user_id,
+          u.email,
+          u.tier,
+          MAX(ak.last_used_at) AS last_seen,
+          COUNT(ul.id)         AS requests_7d
+        FROM users u
+        JOIN api_keys ak ON ak.user_id = u.id AND ak.is_active = true
+        LEFT JOIN usage_logs ul
+          ON ul.user_id::text = u.id::text
+          AND ul.created_at >= NOW() - INTERVAL '7 days'
+        WHERE ak.last_used_at > NOW() - INTERVAL '7 days'
+        GROUP BY u.id, u.email, u.tier
+        ORDER BY last_seen DESC
+      `);
+            const active7d = active7dResult.rows.map((r) => ({
+                userId: r.user_id,
+                email: r.email,
+                tier: r.tier,
+                lastSeen: r.last_seen instanceof Date ? r.last_seen.toISOString() : String(r.last_seen),
+                requestsLast7d: parseInt(r.requests_7d) || 0,
+            }));
+            res.json({
+                success: true,
+                data: {
+                    active24h,
+                    active7d,
+                    totalRegistered,
+                },
+            });
+        }
+        catch (err) {
+            console.error('[admin-active] error:', err);
+            res.status(500).json({
+                success: false,
+                error: { type: 'internal_error', message: 'Failed to retrieve active users', docs: 'https://webpeel.dev/docs/errors#internal_error' },
+                requestId: req.requestId,
+            });
+        }
+    });
+    return router;
+}

package/dist/server/routes/admin-stats.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Admin analytics endpoint — admin tier only
+ *
+ * GET /v1/admin/stats — platform-wide usage and user metrics
+ */
+import { Router } from 'express';
+export declare function createAdminStatsRouter(): Router;