@nordsym/apiclaw 2.2.0 → 2.3.0

package/convex/teams.ts

@@ -1,243 +0,0 @@
-import { v } from "convex/values";
-import { mutation, query } from "./_generated/server";
-
-// ============================================
-// HELPER FUNCTIONS
-// ============================================
-
-function generateToken(): string {
-  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" as const,
-        status: "active" as const,
-        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,
-    };
-  },
-});

package/convex/telemetry.ts

@@ -1,81 +0,0 @@
-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;
-      }, {} as Record<string, number>);
-    
-    const topAPIs = events
-      .filter(e => e.type === "execute" && e.apiId)
-      .reduce((acc, e) => {
-        acc[e.apiId!] = (acc[e.apiId!] || 0) + 1;
-        return acc;
-      }, {} as Record<string, number>);
-    
-    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);
-  },
-});

package/convex/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  /* This TypeScript project config describes the environment that
-   * Convex functions run in and is used to typecheck them.
-   * You can modify it, but some settings are required to use Convex.
-   */
-  "compilerOptions": {
-    /* These settings are not required by Convex and can be modified. */
-    "allowJs": true,
-    "strict": true,
-    "moduleResolution": "Bundler",
-    "jsx": "react-jsx",
-    "skipLibCheck": true,
-    "allowSyntheticDefaultImports": true,
-
-    /* These compiler options are required by Convex */
-    "target": "ESNext",
-    "lib": ["ES2021", "dom"],
-    "forceConsistentCasingInFileNames": true,
-    "module": "ESNext",
-    "isolatedModules": true,
-    "noEmit": true
-  },
-  "include": ["./**/*"],
-  "exclude": ["./_generated"]
-}

package/convex/updateAPIStatus.ts

@@ -1,44 +0,0 @@
-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" as any; // APILayer
-
-    const apis = await ctx.db
-      .query("providerAPIs")
-      .withIndex("by_providerId", (q: any) => 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 as any).hasDirectCall !== hasDirectCall) {
-        await ctx.db.patch(api._id, {
-          status: newStatus,
-        } as any);
-        updated++;
-      }
-    }
-
-    return { success: true, updated, total: apis.length };
-  },
-});

package/convex/usage.ts

@@ -1,260 +0,0 @@
-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: Record<string, { calls: number; credits: number }> = {};
-    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: Record<string, { calls: number; credits: number }> = {};
-    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 };
-  },
-});