@nordsym/apiclaw 1.5.18 → 1.5.19

package/convex/purchases.d.ts

@@ -1,7 +0,0 @@
-export declare const purchaseAccess: any;
-export declare const getAgentPurchases: any;
-export declare const getActivePurchase: any;
-export declare const getUsage: any;
-export declare const recordUsage: any;
-export declare const getBalanceSummary: any;
-//# sourceMappingURL=purchases.d.ts.map

package/convex/purchases.js

@@ -1,157 +0,0 @@
-import { v } from "convex/values";
-import { mutation, query } from "./_generated/server";
-// Provider pricing (credits per dollar)
-const CREDITS_PER_DOLLAR = {
-    "46elks": 30, // ~30 SMS per dollar
-    twilio: 25, // ~25 SMS per dollar
-    resend: 1000, // ~1000 emails per dollar
-    brave_search: 200, // ~200 searches per dollar
-    openrouter: 100, // ~100k tokens per dollar
-    elevenlabs: 3333, // ~3333 characters per dollar
-};
-// Calculate credits for a provider purchase
-function calculateCredits(providerId, amountUsd) {
-    const rate = CREDITS_PER_DOLLAR[providerId] || 100;
-    return Math.floor(amountUsd * rate);
-}
-// Purchase API access
-export const purchaseAccess = mutation({
-    args: {
-        agentId: v.string(),
-        providerId: v.string(),
-        amountUsd: v.number(),
-        credentials: v.any(), // Credentials passed from server side
-    },
-    handler: async (ctx, args) => {
-        // Check balance
-        const credits = await ctx.db
-            .query("agentCredits")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .first();
-        if (!credits || credits.balanceUsd < args.amountUsd) {
-            throw new Error(`Insufficient balance: have $${(credits?.balanceUsd || 0).toFixed(2)}, need $${args.amountUsd.toFixed(2)}`);
-        }
-        // Deduct credits
-        await ctx.db.patch(credits._id, {
-            balanceUsd: credits.balanceUsd - args.amountUsd,
-            updatedAt: Date.now(),
-        });
-        // Calculate credits granted
-        const creditsGranted = calculateCredits(args.providerId, args.amountUsd);
-        // Create purchase record
-        const purchaseId = await ctx.db.insert("purchases", {
-            agentId: args.agentId,
-            providerId: args.providerId,
-            amountUsd: args.amountUsd,
-            creditsGranted,
-            status: "active",
-            credentials: args.credentials,
-            createdAt: Date.now(),
-        });
-        // Initialize usage tracking
-        await ctx.db.insert("usage", {
-            purchaseId,
-            providerId: args.providerId,
-            unitsUsed: 0,
-            unitsRemaining: creditsGranted,
-            costIncurredUsd: 0,
-            lastUsedAt: Date.now(),
-        });
-        return await ctx.db.get(purchaseId);
-    },
-});
-// Get all purchases for an agent
-export const getAgentPurchases = query({
-    args: { agentId: v.string() },
-    handler: async (ctx, args) => {
-        return await ctx.db
-            .query("purchases")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .collect();
-    },
-});
-// Get active purchase for a provider
-export const getActivePurchase = query({
-    args: {
-        agentId: v.string(),
-        providerId: v.string(),
-    },
-    handler: async (ctx, args) => {
-        const purchases = await ctx.db
-            .query("purchases")
-            .withIndex("by_agentId_providerId", (q) => q.eq("agentId", args.agentId).eq("providerId", args.providerId))
-            .collect();
-        return purchases.find((p) => p.status === "active") || null;
-    },
-});
-// Get usage for a purchase
-export const getUsage = query({
-    args: { purchaseId: v.id("purchases") },
-    handler: async (ctx, args) => {
-        return await ctx.db
-            .query("usage")
-            .withIndex("by_purchaseId", (q) => q.eq("purchaseId", args.purchaseId))
-            .first();
-    },
-});
-// Record usage
-export const recordUsage = mutation({
-    args: {
-        purchaseId: v.id("purchases"),
-        unitsUsed: v.number(),
-        costUsd: v.number(),
-    },
-    handler: async (ctx, args) => {
-        const usage = await ctx.db
-            .query("usage")
-            .withIndex("by_purchaseId", (q) => q.eq("purchaseId", args.purchaseId))
-            .first();
-        if (!usage) {
-            throw new Error("Usage record not found");
-        }
-        const newUnitsRemaining = Math.max(0, usage.unitsRemaining - args.unitsUsed);
-        await ctx.db.patch(usage._id, {
-            unitsUsed: usage.unitsUsed + args.unitsUsed,
-            unitsRemaining: newUnitsRemaining,
-            costIncurredUsd: usage.costIncurredUsd + args.costUsd,
-            lastUsedAt: Date.now(),
-        });
-        // Update purchase status if depleted
-        if (newUnitsRemaining === 0) {
-            const purchase = await ctx.db.get(args.purchaseId);
-            if (purchase) {
-                await ctx.db.patch(args.purchaseId, { status: "exhausted" });
-            }
-        }
-        return await ctx.db
-            .query("usage")
-            .withIndex("by_purchaseId", (q) => q.eq("purchaseId", args.purchaseId))
-            .first();
-    },
-});
-// Get balance summary for an agent
-export const getBalanceSummary = query({
-    args: { agentId: v.string() },
-    handler: async (ctx, args) => {
-        const credits = await ctx.db
-            .query("agentCredits")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .first();
-        const purchases = await ctx.db
-            .query("purchases")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .collect();
-        const activePurchases = purchases.filter((p) => p.status === "active");
-        const totalSpent = purchases.reduce((sum, p) => sum + p.amountUsd, 0);
-        return {
-            credits: credits || {
-                agentId: args.agentId,
-                balanceUsd: 0,
-                currency: "USD",
-            },
-            activePurchases,
-            totalSpentUsd: totalSpent,
-        };
-    },
-});
-//# sourceMappingURL=purchases.js.map

package/convex/ratelimit.d.ts

@@ -1,4 +0,0 @@
-export declare const checkLimit: any;
-export declare const getUsage: any;
-export declare const cleanup: any;
-//# sourceMappingURL=ratelimit.d.ts.map

package/convex/ratelimit.js

@@ -1,91 +0,0 @@
-import { mutation, query } from "./_generated/server";
-import { v } from "convex/values";
-// Rate limit config per tier
-const LIMITS = {
-    free: {
-        discovery: 100, // searches per hour
-        instant: 10, // API calls per hour
-    },
-    subscriber: {
-        discovery: 1000,
-        instant: 100,
-    },
-    provider: {
-        discovery: 10000,
-        instant: 1000,
-    },
-};
-// Check and increment rate limit
-export const checkLimit = mutation({
-    args: {
-        identifier: v.string(), // IP or agentId
-        action: v.union(v.literal("discovery"), v.literal("instant")),
-        tier: v.optional(v.union(v.literal("free"), v.literal("subscriber"), v.literal("provider"))),
-    },
-    handler: async (ctx, args) => {
-        const tier = args.tier || "free";
-        const limit = LIMITS[tier][args.action];
-        const hourKey = Math.floor(Date.now() / 3600000); // Hour bucket
-        const key = `${args.identifier}:${args.action}:${hourKey}`;
-        // Get current count
-        const existing = await ctx.db
-            .query("rateLimits")
-            .withIndex("by_key", (q) => q.eq("key", key))
-            .first();
-        if (existing) {
-            if (existing.count >= limit) {
-                return { allowed: false, remaining: 0, resetIn: 3600 - (Date.now() % 3600000) / 1000 };
-            }
-            await ctx.db.patch(existing._id, { count: existing.count + 1 });
-            return { allowed: true, remaining: limit - existing.count - 1 };
-        }
-        // Create new entry
-        await ctx.db.insert("rateLimits", {
-            key,
-            identifier: args.identifier,
-            action: args.action,
-            count: 1,
-            hourBucket: hourKey,
-            createdAt: Date.now(),
-        });
-        return { allowed: true, remaining: limit - 1 };
-    },
-});
-// Get current usage stats
-export const getUsage = query({
-    args: {
-        identifier: v.string(),
-    },
-    handler: async (ctx, args) => {
-        const hourKey = Math.floor(Date.now() / 3600000);
-        const discovery = await ctx.db
-            .query("rateLimits")
-            .withIndex("by_key", (q) => q.eq("key", `${args.identifier}:discovery:${hourKey}`))
-            .first();
-        const instant = await ctx.db
-            .query("rateLimits")
-            .withIndex("by_key", (q) => q.eq("key", `${args.identifier}:instant:${hourKey}`))
-            .first();
-        return {
-            discovery: discovery?.count || 0,
-            instant: instant?.count || 0,
-            limits: LIMITS.free,
-        };
-    },
-});
-// Cleanup old rate limit entries (run via cron)
-export const cleanup = mutation({
-    args: {},
-    handler: async (ctx) => {
-        const hourAgo = Math.floor(Date.now() / 3600000) - 2; // Keep 2 hours
-        const old = await ctx.db
-            .query("rateLimits")
-            .filter((q) => q.lt(q.field("hourBucket"), hourAgo))
-            .take(100);
-        for (const entry of old) {
-            await ctx.db.delete(entry._id);
-        }
-        return { deleted: old.length };
-    },
-});
-//# sourceMappingURL=ratelimit.js.map

package/convex/searchLogs.d.ts

@@ -1,4 +0,0 @@
-export declare const logSearch: any;
-export declare const getTopQueries: any;
-export declare const getZeroResultQueries: any;
-//# sourceMappingURL=searchLogs.d.ts.map

package/convex/searchLogs.js

@@ -1,129 +0,0 @@
-import { internalMutation, query } from "./_generated/server";
-import { v } from "convex/values";
-// Log a search query (uses existing searchLogs table schema)
-export const logSearch = internalMutation({
-    args: {
-        query: v.string(),
-        resultsCount: v.number(),
-        matchedProviders: v.optional(v.array(v.string())),
-        sessionToken: v.optional(v.string()),
-        userAgent: v.optional(v.string()),
-        responseTimeMs: v.optional(v.number()),
-    },
-    handler: async (ctx, args) => {
-        // Try to get workspaceId from session token
-        let workspaceId = undefined;
-        let subagentId = undefined;
-        if (args.sessionToken) {
-            try {
-                const token = args.sessionToken;
-                const session = await ctx.db
-                    .query("agentSessions")
-                    .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
-                    .first();
-                if (session) {
-                    workspaceId = session.workspaceId;
-                    // No agentId in agentSessions, subagentId stays undefined
-                }
-            }
-            catch (e) {
-                // Ignore - just skip workspace linking
-            }
-        }
-        // Only log if we have a workspace (existing schema requires it)
-        if (workspaceId) {
-            await ctx.db.insert("searchLogs", {
-                workspaceId,
-                subagentId,
-                query: args.query,
-                resultCount: args.resultsCount,
-                hasResults: args.resultsCount > 0,
-                matchedProviders: args.matchedProviders,
-                responseTimeMs: args.responseTimeMs || 0,
-                timestamp: Date.now(),
-            });
-        }
-        // TODO: Also log anonymous searches somewhere (for product insights)
-    },
-});
-// Get top search queries (for analytics)
-export const getTopQueries = query({
-    args: {
-        limit: v.optional(v.number()),
-        since: v.optional(v.number()), // timestamp
-    },
-    handler: async (ctx, args) => {
-        const limit = args.limit || 50;
-        const since = args.since || Date.now() - 7 * 24 * 60 * 60 * 1000; // Last 7 days
-        const logs = await ctx.db
-            .query("searchLogs")
-            .withIndex("by_timestamp")
-            .filter((q) => q.gte(q.field("timestamp"), since))
-            .collect();
-        // Aggregate by query
-        const queryCounts = {};
-        for (const log of logs) {
-            const q = log.query.toLowerCase().trim();
-            if (!q)
-                continue;
-            if (!queryCounts[q]) {
-                queryCounts[q] = { count: 0, avgResults: 0, totalResults: 0 };
-            }
-            queryCounts[q].count++;
-            queryCounts[q].totalResults += log.resultCount;
-        }
-        // Calculate averages and sort
-        const sorted = Object.entries(queryCounts)
-            .map(([query, data]) => ({
-            query,
-            count: data.count,
-            avgResults: Math.round(data.totalResults / data.count * 10) / 10,
-            noResults: data.totalResults === 0,
-        }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, limit);
-        return {
-            queries: sorted,
-            totalSearches: logs.length,
-            uniqueQueries: Object.keys(queryCounts).length,
-            period: {
-                since: new Date(since).toISOString(),
-                until: new Date().toISOString(),
-            },
-        };
-    },
-});
-// Get searches with no results (API gaps)
-export const getZeroResultQueries = query({
-    args: {
-        limit: v.optional(v.number()),
-        since: v.optional(v.number()),
-    },
-    handler: async (ctx, args) => {
-        const limit = args.limit || 20;
-        const since = args.since || Date.now() - 7 * 24 * 60 * 60 * 1000;
-        const logs = await ctx.db
-            .query("searchLogs")
-            .withIndex("by_hasResults")
-            .filter((q) => q.and(q.eq(q.field("hasResults"), false), q.gte(q.field("timestamp"), since)))
-            .collect();
-        // Aggregate
-        const queryCounts = {};
-        for (const log of logs) {
-            const q = log.query.toLowerCase().trim();
-            if (!q)
-                continue;
-            queryCounts[q] = (queryCounts[q] || 0) + 1;
-        }
-        const sorted = Object.entries(queryCounts)
-            .map(([query, count]) => ({ query, count }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, limit);
-        return {
-            gaps: sorted,
-            totalZeroResults: logs.length,
-            message: "These queries returned no results - potential APIs to add",
-        };
-    },
-});
-//# sourceMappingURL=searchLogs.js.map

package/convex/spendAlerts.d.ts

@@ -1,36 +0,0 @@
-/**
- * Update workspace budget settings
- */
-export declare const updateBudgetSettings: any;
-/**
- * Record spend and check budget alerts
- * Called after each successful API execution
- * Returns budget status for response
- */
-export declare const recordSpend: any;
-/**
- * Check budget before execution
- * Returns { allowed: boolean, reason?: string }
- */
-export declare const checkBudget: any;
-/**
- * Get budget status for workspace dashboard
- */
-export declare const getBudgetStatus: any;
-/**
- * Get budget status by session token (for dashboard)
- */
-export declare const getBudgetStatusByToken: any;
-/**
- * Send budget alert email (80% warning)
- */
-export declare const sendBudgetAlertEmail: any;
-/**
- * Send budget exceeded email
- */
-export declare const sendBudgetExceededEmail: any;
-/**
- * Reset monthly spend for all workspaces (called by cron on 1st of month)
- */
-export declare const resetMonthlySpend: any;
-//# sourceMappingURL=spendAlerts.d.ts.map