@nordsym/apiclaw 1.8.7 → 1.8.9

package/convex/teams.js

@@ -0,0 +1,215 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+// ============================================
+// HELPER FUNCTIONS
+// ============================================
+function generateToken() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < 32; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+// ============================================
+// TEAM QUERIES
+// ============================================
+/**
+ * Get team members for a workspace
+ */
+export const getMembers = query({
+    args: { token: v.string() },
+    handler: async (ctx, { token }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session)
+            return [];
+        const workspace = await ctx.db.get(session.workspaceId);
+        if (!workspace)
+            return [];
+        const members = await ctx.db
+            .query("workspaceMembers")
+            .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+            .collect();
+        // Add owner as first member
+        return [
+            {
+                email: workspace.email,
+                role: "owner",
+                status: "active",
+                isOwner: true,
+                createdAt: workspace.createdAt,
+            },
+            ...members.map((m) => ({
+                id: m._id,
+                email: m.email,
+                role: m.role,
+                status: m.status,
+                isOwner: false,
+                invitedBy: m.invitedBy,
+                createdAt: m.createdAt,
+                acceptedAt: m.acceptedAt,
+            })),
+        ];
+    },
+});
+// ============================================
+// TEAM MUTATIONS
+// ============================================
+/**
+ * Invite a member to the workspace (creates pending invite)
+ */
+export const inviteMember = mutation({
+    args: {
+        token: v.string(),
+        email: v.string(),
+        role: v.union(v.literal("admin"), v.literal("member")),
+    },
+    handler: async (ctx, { token, email, role }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session)
+            throw new Error("Invalid session");
+        const workspace = await ctx.db.get(session.workspaceId);
+        if (!workspace)
+            throw new Error("Workspace not found");
+        // Normalize email
+        const normalizedEmail = email.toLowerCase().trim();
+        // Can't invite yourself
+        if (normalizedEmail === workspace.email.toLowerCase()) {
+            throw new Error("Cannot invite yourself");
+        }
+        // Check if already member
+        const existing = await ctx.db
+            .query("workspaceMembers")
+            .withIndex("by_workspaceId_email", (q) => q.eq("workspaceId", session.workspaceId).eq("email", normalizedEmail))
+            .first();
+        if (existing) {
+            if (existing.status === "active") {
+                throw new Error("Already a team member");
+            }
+            if (existing.status === "pending") {
+                throw new Error("Invite already pending");
+            }
+            // If revoked, we can re-invite - update existing record
+            const inviteToken = generateToken();
+            await ctx.db.patch(existing._id, {
+                role,
+                invitedBy: workspace.email,
+                inviteToken,
+                status: "pending",
+                createdAt: Date.now(),
+                acceptedAt: undefined,
+            });
+            return { id: existing._id, inviteToken };
+        }
+        // Generate invite token
+        const inviteToken = generateToken();
+        const id = await ctx.db.insert("workspaceMembers", {
+            workspaceId: session.workspaceId,
+            email: normalizedEmail,
+            role,
+            invitedBy: workspace.email,
+            inviteToken,
+            status: "pending",
+            createdAt: Date.now(),
+        });
+        return { id, inviteToken };
+    },
+});
+/**
+ * Accept an invite
+ */
+export const acceptInvite = mutation({
+    args: { inviteToken: v.string() },
+    handler: async (ctx, { inviteToken }) => {
+        const member = await ctx.db
+            .query("workspaceMembers")
+            .withIndex("by_inviteToken", (q) => q.eq("inviteToken", inviteToken))
+            .first();
+        if (!member)
+            throw new Error("Invalid invite token");
+        if (member.status !== "pending")
+            throw new Error("Invite already used or revoked");
+        await ctx.db.patch(member._id, {
+            status: "active",
+            acceptedAt: Date.now(),
+            inviteToken: undefined, // Clear token after use
+        });
+        // Get workspace info for response
+        const workspace = await ctx.db.get(member.workspaceId);
+        return {
+            success: true,
+            workspaceId: member.workspaceId,
+            workspaceEmail: workspace?.email,
+            role: member.role,
+        };
+    },
+});
+/**
+ * Remove a member from the workspace
+ */
+export const removeMember = mutation({
+    args: {
+        token: v.string(),
+        memberEmail: v.string(),
+    },
+    handler: async (ctx, { token, memberEmail }) => {
+        const session = await ctx.db
+            .query("agentSessions")
+            .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+            .first();
+        if (!session)
+            throw new Error("Invalid session");
+        const workspace = await ctx.db.get(session.workspaceId);
+        if (!workspace)
+            throw new Error("Workspace not found");
+        const normalizedEmail = memberEmail.toLowerCase().trim();
+        // Cannot remove owner
+        if (normalizedEmail === workspace.email.toLowerCase()) {
+            throw new Error("Cannot remove workspace owner");
+        }
+        const member = await ctx.db
+            .query("workspaceMembers")
+            .withIndex("by_workspaceId_email", (q) => q.eq("workspaceId", session.workspaceId).eq("email", normalizedEmail))
+            .first();
+        if (!member)
+            throw new Error("Member not found");
+        // Set status to revoked instead of deleting
+        await ctx.db.patch(member._id, {
+            status: "revoked",
+            inviteToken: undefined,
+        });
+        return { success: true };
+    },
+});
+/**
+ * Get invite details (public, for invite acceptance page)
+ */
+export const getInviteDetails = query({
+    args: { inviteToken: v.string() },
+    handler: async (ctx, { inviteToken }) => {
+        const member = await ctx.db
+            .query("workspaceMembers")
+            .withIndex("by_inviteToken", (q) => q.eq("inviteToken", inviteToken))
+            .first();
+        if (!member)
+            return null;
+        if (member.status !== "pending")
+            return null;
+        const workspace = await ctx.db.get(member.workspaceId);
+        if (!workspace)
+            return null;
+        return {
+            email: member.email,
+            role: member.role,
+            invitedBy: member.invitedBy,
+            workspaceEmail: workspace.email,
+        };
+    },
+});
+//# sourceMappingURL=teams.js.map

package/convex/telemetry.d.ts

@@ -0,0 +1,4 @@
+export declare const track: any;
+export declare const getStats: any;
+export declare const getRecent: any;
+//# sourceMappingURL=telemetry.d.ts.map

package/convex/telemetry.js

@@ -0,0 +1,74 @@
+import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+export const track = mutation({
+    args: {
+        event: v.object({
+            type: v.string(),
+            query: v.optional(v.string()),
+            apiId: v.optional(v.string()),
+            resultCount: v.optional(v.number()),
+            responseTimeMs: v.optional(v.number()),
+            version: v.optional(v.string()),
+            platform: v.optional(v.string()),
+            nodeVersion: v.optional(v.string()),
+            timestamp: v.optional(v.number()),
+        }),
+    },
+    handler: async (ctx, { event }) => {
+        await ctx.db.insert("telemetry", {
+            type: event.type,
+            query: event.query,
+            apiId: event.apiId,
+            resultCount: event.resultCount,
+            responseTimeMs: event.responseTimeMs,
+            version: event.version || "unknown",
+            platform: event.platform || "unknown",
+            nodeVersion: event.nodeVersion || "unknown",
+            timestamp: event.timestamp || Date.now(),
+        });
+    },
+});
+export const getStats = query({
+    args: {},
+    handler: async (ctx) => {
+        const events = await ctx.db.query("telemetry").collect();
+        const startups = events.filter(e => e.type === "startup").length;
+        const searches = events.filter(e => e.type === "search").length;
+        const executes = events.filter(e => e.type === "execute").length;
+        const uniqueUsers = new Set(events.map(e => `${e.platform}-${e.nodeVersion}`)).size;
+        const topQueries = events
+            .filter(e => e.type === "search" && e.query)
+            .reduce((acc, e) => {
+            acc[e.query] = (acc[e.query] || 0) + 1;
+            return acc;
+        }, {});
+        const topAPIs = events
+            .filter(e => e.type === "execute" && e.apiId)
+            .reduce((acc, e) => {
+            acc[e.apiId] = (acc[e.apiId] || 0) + 1;
+            return acc;
+        }, {});
+        return {
+            totalStartups: startups,
+            totalSearches: searches,
+            totalExecutes: executes,
+            estimatedUniqueUsers: uniqueUsers,
+            topQueries: Object.entries(topQueries)
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, 10),
+            topAPIs: Object.entries(topAPIs)
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, 10),
+        };
+    },
+});
+export const getRecent = query({
+    args: { limit: v.optional(v.number()) },
+    handler: async (ctx, { limit = 50 }) => {
+        return await ctx.db
+            .query("telemetry")
+            .order("desc")
+            .take(limit);
+    },
+});
+//# sourceMappingURL=telemetry.js.map

package/convex/updateAPIStatus.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Update providerAPIs status to reflect actual Direct Call status
+ * Run: npx convex run updateAPIStatus:update
+ */
+export declare const update: any;
+//# sourceMappingURL=updateAPIStatus.d.ts.map

package/convex/updateAPIStatus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateAPIStatus.d.ts","sourceRoot":"","sources":["updateAPIStatus.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,MAAM,KAsCjB,CAAC"}
+{"version":3,"file":"updateAPIStatus.d.ts","sourceRoot":"","sources":["updateAPIStatus.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,MAAM,KAqCjB,CAAC"}

package/convex/updateAPIStatus.js

@@ -0,0 +1,39 @@
+import { mutation } from "./_generated/server";
+/**
+ * Update providerAPIs status to reflect actual Direct Call status
+ * Run: npx convex run updateAPIStatus:update
+ */
+export const update = mutation({
+    args: {},
+    handler: async (ctx) => {
+        const providerId = "k97cvcvadnyz8x8m4we7xqmh1s83p0ph"; // APILayer
+        const apis = await ctx.db
+            .query("providerAPIs")
+            .withIndex("by_providerId", (q) => q.eq("providerId", providerId))
+            .collect();
+        // APIs that are blocked by subscription tier
+        const blocked = ["Number Verification API", "World News API", "Image Crop API", "Form API"];
+        // PDF Layer is rate limited
+        const rateLimited = ["PDF Layer"];
+        let updated = 0;
+        for (const api of apis) {
+            let newStatus = "approved"; // default = live
+            let hasDirectCall = true;
+            if (blocked.includes(api.name)) {
+                newStatus = "blocked";
+                hasDirectCall = false;
+            }
+            else if (rateLimited.includes(api.name)) {
+                newStatus = "rate_limited";
+            }
+            if (api.status !== newStatus || api.hasDirectCall !== hasDirectCall) {
+                await ctx.db.patch(api._id, {
+                    status: newStatus,
+                });
+                updated++;
+            }
+        }
+        return { success: true, updated, total: apis.length };
+    },
+});
+//# sourceMappingURL=updateAPIStatus.js.map

package/convex/updateAPIStatus.js.map

@@ -1 +1 @@
-{"version":3,"file":"updateAPIStatus.js","sourceRoot":"","sources":["updateAPIStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C;;;GAGG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,QAAQ,CAAC;IAC7B,IAAI,EAAE,EAAE;IACR,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QACrB,MAAM,UAAU,GAAG,kCAAyC,CAAC,CAAC,WAAW;QAEzE,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,EAAE;aACtB,KAAK,CAAC,cAAc,CAAC;aACrB,SAAS,CAAC,eAAe,EAAE,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;aACtE,OAAO,EAAE,CAAC;QAEb,6CAA6C;QAC7C,MAAM,OAAO,GAAG,CAAC,yBAAyB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC;QAC5F,4BAA4B;QAC5B,MAAM,WAAW,GAAG,CAAC,WAAW,CAAC,CAAC;QAElC,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,SAAS,GAAG,UAAU,CAAC,CAAC,iBAAiB;YAC7C,IAAI,aAAa,GAAG,IAAI,CAAC;YAEzB,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC/B,SAAS,GAAG,SAAS,CAAC;gBACtB,aAAa,GAAG,KAAK,CAAC;YACxB,CAAC;iBAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1C,SAAS,GAAG,cAAc,CAAC;YAC7B,CAAC;YAED,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,GAAG,CAAC,aAAa,KAAK,aAAa,EAAE,CAAC;gBACpE,MAAM,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAC1B,MAAM,EAAE,SAAS;oBACjB,aAAa;iBACd,CAAC,CAAC;gBACH,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IACxD,CAAC;CACF,CAAC,CAAC"}
+{"version":3,"file":"updateAPIStatus.js","sourceRoot":"","sources":["updateAPIStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C;;;GAGG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,QAAQ,CAAC;IAC7B,IAAI,EAAE,EAAE;IACR,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QACrB,MAAM,UAAU,GAAG,kCAAyC,CAAC,CAAC,WAAW;QAEzE,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,EAAE;aACtB,KAAK,CAAC,cAAc,CAAC;aACrB,SAAS,CAAC,eAAe,EAAE,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;aACtE,OAAO,EAAE,CAAC;QAEb,6CAA6C;QAC7C,MAAM,OAAO,GAAG,CAAC,yBAAyB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC;QAC5F,4BAA4B;QAC5B,MAAM,WAAW,GAAG,CAAC,WAAW,CAAC,CAAC;QAElC,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,SAAS,GAAG,UAAU,CAAC,CAAC,iBAAiB;YAC7C,IAAI,aAAa,GAAG,IAAI,CAAC;YAEzB,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC/B,SAAS,GAAG,SAAS,CAAC;gBACtB,aAAa,GAAG,KAAK,CAAC;YACxB,CAAC;iBAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1C,SAAS,GAAG,cAAc,CAAC;YAC7B,CAAC;YAED,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,IAAK,GAAW,CAAC,aAAa,KAAK,aAAa,EAAE,CAAC;gBAC7E,MAAM,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;oBAC1B,MAAM,EAAE,SAAS;iBACX,CAAC,CAAC;gBACV,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IACxD,CAAC;CACF,CAAC,CAAC"}

package/convex/usage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Log an API call usage
+ */
+export declare const logUsage: any;
+/**
+ * Get user usage stats for rate limiting
+ * Returns counts for last minute and last day
+ */
+export declare const getUserUsage: any;
+/**
+ * Get provider usage stats for analytics
+ */
+export declare const getProviderUsage: any;
+/**
+ * Get Direct Call specific usage stats
+ */
+export declare const getDirectCallUsage: any;
+/**
+ * Get recent usage logs (for dashboard/debugging)
+ */
+export declare const getRecentLogs: any;
+/**
+ * Check if user is within rate limits
+ * Returns { allowed: boolean, reason?: string }
+ */
+export declare const checkRateLimit: any;
+//# sourceMappingURL=usage.d.ts.map

package/convex/usage.js

@@ -0,0 +1,229 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+// ============================================
+// MUTATIONS
+// ============================================
+/**
+ * Log an API call usage
+ */
+export const logUsage = mutation({
+    args: {
+        userId: v.string(),
+        providerId: v.id("providers"),
+        directCallId: v.id("providerDirectCall"),
+        actionName: v.string(),
+        success: v.boolean(),
+        latencyMs: v.number(),
+        creditsUsed: v.number(),
+        errorMessage: v.optional(v.string()),
+    },
+    handler: async (ctx, args) => {
+        return await ctx.db.insert("usageLog", {
+            userId: args.userId,
+            providerId: args.providerId,
+            directCallId: args.directCallId,
+            actionName: args.actionName,
+            timestamp: Date.now(),
+            success: args.success,
+            latencyMs: args.latencyMs,
+            creditsUsed: args.creditsUsed,
+            errorMessage: args.errorMessage,
+        });
+    },
+});
+// ============================================
+// QUERIES
+// ============================================
+/**
+ * Get user usage stats for rate limiting
+ * Returns counts for last minute and last day
+ */
+export const getUserUsage = query({
+    args: {
+        userId: v.string(),
+        providerId: v.id("providers"),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60 * 1000;
+        const oneDayAgo = now - 24 * 60 * 60 * 1000;
+        // Get all usage for this user + provider in the last 24h
+        const recentUsage = await ctx.db
+            .query("usageLog")
+            .withIndex("by_userId_providerId", (q) => q.eq("userId", args.userId).eq("providerId", args.providerId))
+            .filter((q) => q.gte(q.field("timestamp"), oneDayAgo))
+            .collect();
+        // Calculate counts
+        const minuteCount = recentUsage.filter((u) => u.timestamp >= oneMinuteAgo).length;
+        const dayCount = recentUsage.length;
+        const totalCredits = recentUsage.reduce((sum, u) => sum + u.creditsUsed, 0);
+        return {
+            minute: minuteCount,
+            day: dayCount,
+            totalCreditsUsed: totalCredits,
+        };
+    },
+});
+/**
+ * Get provider usage stats for analytics
+ */
+export const getProviderUsage = query({
+    args: {
+        providerId: v.id("providers"),
+        periodDays: v.optional(v.number()), // default 30
+    },
+    handler: async (ctx, args) => {
+        const periodDays = args.periodDays ?? 30;
+        const now = Date.now();
+        const periodStart = now - periodDays * 24 * 60 * 60 * 1000;
+        const usage = await ctx.db
+            .query("usageLog")
+            .withIndex("by_providerId", (q) => q.eq("providerId", args.providerId))
+            .filter((q) => q.gte(q.field("timestamp"), periodStart))
+            .collect();
+        // Aggregate stats
+        const totalCalls = usage.length;
+        const successfulCalls = usage.filter((u) => u.success).length;
+        const failedCalls = totalCalls - successfulCalls;
+        const totalCredits = usage.reduce((sum, u) => sum + u.creditsUsed, 0);
+        const totalLatency = usage.reduce((sum, u) => sum + u.latencyMs, 0);
+        const avgLatency = totalCalls > 0 ? Math.round(totalLatency / totalCalls) : 0;
+        // Group by action
+        const byAction = {};
+        for (const u of usage) {
+            if (!byAction[u.actionName]) {
+                byAction[u.actionName] = { calls: 0, credits: 0 };
+            }
+            byAction[u.actionName].calls++;
+            byAction[u.actionName].credits += u.creditsUsed;
+        }
+        // Group by day for chart
+        const byDay = {};
+        for (const u of usage) {
+            const day = new Date(u.timestamp).toISOString().split("T")[0];
+            if (!byDay[day]) {
+                byDay[day] = { calls: 0, credits: 0 };
+            }
+            byDay[day].calls++;
+            byDay[day].credits += u.creditsUsed;
+        }
+        // Unique users
+        const uniqueUsers = new Set(usage.map((u) => u.userId)).size;
+        return {
+            periodDays,
+            totalCalls,
+            successfulCalls,
+            failedCalls,
+            successRate: totalCalls > 0 ? (successfulCalls / totalCalls) * 100 : 0,
+            totalCredits,
+            avgLatencyMs: avgLatency,
+            uniqueUsers,
+            byAction,
+            byDay,
+        };
+    },
+});
+/**
+ * Get Direct Call specific usage stats
+ */
+export const getDirectCallUsage = query({
+    args: {
+        directCallId: v.id("providerDirectCall"),
+        periodDays: v.optional(v.number()),
+    },
+    handler: async (ctx, args) => {
+        const periodDays = args.periodDays ?? 30;
+        const now = Date.now();
+        const periodStart = now - periodDays * 24 * 60 * 60 * 1000;
+        const usage = await ctx.db
+            .query("usageLog")
+            .withIndex("by_directCallId", (q) => q.eq("directCallId", args.directCallId))
+            .filter((q) => q.gte(q.field("timestamp"), periodStart))
+            .collect();
+        const totalCalls = usage.length;
+        const successfulCalls = usage.filter((u) => u.success).length;
+        const totalCredits = usage.reduce((sum, u) => sum + u.creditsUsed, 0);
+        const totalLatency = usage.reduce((sum, u) => sum + u.latencyMs, 0);
+        return {
+            periodDays,
+            totalCalls,
+            successfulCalls,
+            failedCalls: totalCalls - successfulCalls,
+            successRate: totalCalls > 0 ? (successfulCalls / totalCalls) * 100 : 0,
+            totalCredits,
+            avgLatencyMs: totalCalls > 0 ? Math.round(totalLatency / totalCalls) : 0,
+            uniqueUsers: new Set(usage.map((u) => u.userId)).size,
+        };
+    },
+});
+/**
+ * Get recent usage logs (for dashboard/debugging)
+ */
+export const getRecentLogs = query({
+    args: {
+        providerId: v.optional(v.id("providers")),
+        directCallId: v.optional(v.id("providerDirectCall")),
+        limit: v.optional(v.number()),
+    },
+    handler: async (ctx, args) => {
+        const limit = args.limit ?? 50;
+        const { directCallId, providerId } = args;
+        if (directCallId !== undefined) {
+            return await ctx.db
+                .query("usageLog")
+                .withIndex("by_directCallId", (q) => q.eq("directCallId", directCallId))
+                .order("desc")
+                .take(limit);
+        }
+        if (providerId !== undefined) {
+            return await ctx.db
+                .query("usageLog")
+                .withIndex("by_providerId", (q) => q.eq("providerId", providerId))
+                .order("desc")
+                .take(limit);
+        }
+        return await ctx.db
+            .query("usageLog")
+            .withIndex("by_timestamp")
+            .order("desc")
+            .take(limit);
+    },
+});
+/**
+ * Check if user is within rate limits
+ * Returns { allowed: boolean, reason?: string }
+ */
+export const checkRateLimit = query({
+    args: {
+        userId: v.string(),
+        providerId: v.id("providers"),
+        rateLimitPerUser: v.number(),
+        rateLimitPerDay: v.number(),
+    },
+    handler: async (ctx, args) => {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60 * 1000;
+        const oneDayAgo = now - 24 * 60 * 60 * 1000;
+        const recentUsage = await ctx.db
+            .query("usageLog")
+            .withIndex("by_userId_providerId", (q) => q.eq("userId", args.userId).eq("providerId", args.providerId))
+            .filter((q) => q.gte(q.field("timestamp"), oneDayAgo))
+            .collect();
+        const minuteCount = recentUsage.filter((u) => u.timestamp >= oneMinuteAgo).length;
+        const dayCount = recentUsage.length;
+        if (minuteCount >= args.rateLimitPerUser) {
+            return {
+                allowed: false,
+                reason: `Rate limit exceeded: ${minuteCount}/${args.rateLimitPerUser} requests per minute`,
+            };
+        }
+        if (dayCount >= args.rateLimitPerDay) {
+            return {
+                allowed: false,
+                reason: `Daily limit exceeded: ${dayCount}/${args.rateLimitPerDay} requests per day`,
+            };
+        }
+        return { allowed: true };
+    },
+});
+//# sourceMappingURL=usage.js.map

package/convex/waitlist.d.ts

@@ -0,0 +1,4 @@
+export declare const join: any;
+export declare const count: any;
+export declare const list: any;
+//# sourceMappingURL=waitlist.d.ts.map

package/convex/waitlist.js

@@ -0,0 +1,49 @@
+import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+export const join = mutation({
+    args: {
+        email: v.string(),
+        type: v.optional(v.string()),
+        source: v.optional(v.string()),
+    },
+    handler: async (ctx, args) => {
+        const email = args.email.toLowerCase().trim();
+        // Check if already on waitlist
+        const existing = await ctx.db
+            .query("waitlist")
+            .withIndex("by_email", (q) => q.eq("email", email))
+            .first();
+        if (existing) {
+            return { success: true, alreadyExists: true };
+        }
+        await ctx.db.insert("waitlist", {
+            email,
+            type: args.type || "provider",
+            source: args.source || "landing",
+            createdAt: Date.now(),
+        });
+        return { success: true, alreadyExists: false };
+    },
+});
+export const count = query({
+    args: {},
+    handler: async (ctx) => {
+        const all = await ctx.db.query("waitlist").collect();
+        return all.length;
+    },
+});
+export const list = query({
+    args: {
+        type: v.optional(v.string()),
+    },
+    handler: async (ctx, args) => {
+        if (args.type) {
+            return await ctx.db
+                .query("waitlist")
+                .withIndex("by_type", (q) => q.eq("type", args.type))
+                .collect();
+        }
+        return await ctx.db.query("waitlist").collect();
+    },
+});
+//# sourceMappingURL=waitlist.js.map

package/convex/webhooks.d.ts

@@ -0,0 +1,12 @@
+export declare const WEBHOOK_EVENTS: readonly ["usage.threshold.80", "usage.threshold.100", "api.error", "agent.connected", "agent.revoked"];
+export declare const getWebhooks: any;
+export declare const createWebhook: any;
+export declare const updateWebhook: any;
+export declare const deleteWebhook: any;
+export declare const regenerateSecret: any;
+export declare const testWebhook: any;
+export declare const triggerWebhooks: any;
+export declare const getWebhookInternal: any;
+export declare const getWebhooksForEvent: any;
+export declare const updateWebhookStatus: any;
+//# sourceMappingURL=webhooks.d.ts.map