@nordsym/apiclaw 1.3.5 → 1.3.7

package/convex/logs.ts

@@ -0,0 +1,287 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// ============================================
+// MUTATIONS
+// ============================================
+
+/**
+ * Create a log entry for an API call
+ * Called after each Direct Call execution
+ */
+export const createLog = mutation({
+  args: {
+    token: v.string(),
+    provider: v.string(),
+    action: v.string(),
+    status: v.union(v.literal("success"), v.literal("error")),
+    latencyMs: v.number(),
+    errorMessage: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Verify session and get workspace
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      throw new Error("Invalid session token");
+    }
+
+    // Create log entry
+    return await ctx.db.insert("apiLogs", {
+      workspaceId: session.workspaceId,
+      sessionToken: args.token,
+      provider: args.provider,
+      action: args.action,
+      status: args.status,
+      latencyMs: args.latencyMs,
+      errorMessage: args.errorMessage,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+/**
+ * Internal log creation (when workspaceId is already known)
+ * Used by execute functions that have already verified the session
+ */
+export const createLogInternal = mutation({
+  args: {
+    workspaceId: v.id("workspaces"),
+    sessionToken: v.string(),
+    provider: v.string(),
+    action: v.string(),
+    status: v.union(v.literal("success"), v.literal("error")),
+    latencyMs: v.number(),
+    errorMessage: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.insert("apiLogs", {
+      workspaceId: args.workspaceId,
+      sessionToken: args.sessionToken,
+      provider: args.provider,
+      action: args.action,
+      status: args.status,
+      latencyMs: args.latencyMs,
+      errorMessage: args.errorMessage,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+// ============================================
+// QUERIES
+// ============================================
+
+/**
+ * Get logs for a workspace with pagination and filters
+ */
+export const getLogs = query({
+  args: {
+    token: v.string(),
+    limit: v.optional(v.number()),
+    cursor: v.optional(v.number()), // createdAt timestamp for pagination
+    status: v.optional(v.union(v.literal("success"), v.literal("error"), v.literal("all"))),
+    provider: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 50;
+    const status = args.status ?? "all";
+    const provider = args.provider;
+    const cursor = args.cursor;
+
+    // Verify session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      return { logs: [], hasMore: false };
+    }
+
+    // Get logs for workspace
+    let query = ctx.db
+      .query("apiLogs")
+      .withIndex("by_workspaceId_createdAt", (q) => q.eq("workspaceId", session.workspaceId))
+      .order("desc");
+
+    // Apply cursor (pagination)
+    if (cursor) {
+      query = query.filter((q) => q.lt(q.field("createdAt"), cursor));
+    }
+
+    // Collect more than limit to check hasMore
+    const allLogs = await query.take(limit + 1);
+
+    // Apply filters in-memory (Convex doesn't support complex compound filters)
+    let filteredLogs = allLogs;
+
+    if (status !== "all") {
+      filteredLogs = filteredLogs.filter((log) => log.status === status);
+    }
+
+    if (provider && provider !== "all") {
+      filteredLogs = filteredLogs.filter((log) => log.provider === provider);
+    }
+
+    const hasMore = filteredLogs.length > limit;
+    const logs = filteredLogs.slice(0, limit);
+
+    return {
+      logs: logs.map((log) => ({
+        id: log._id,
+        provider: log.provider,
+        action: log.action,
+        status: log.status,
+        latencyMs: log.latencyMs,
+        errorMessage: log.errorMessage,
+        createdAt: log.createdAt,
+      })),
+      hasMore,
+      nextCursor: logs.length > 0 ? logs[logs.length - 1].createdAt : undefined,
+    };
+  },
+});
+
+/**
+ * Get aggregated log stats for workspace
+ */
+export const getLogStats = query({
+  args: {
+    token: v.string(),
+    periodDays: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const periodDays = args.periodDays ?? 7;
+
+    // Verify session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      return {
+        totalCalls: 0,
+        successCount: 0,
+        errorCount: 0,
+        successRate: 0,
+        avgLatency: 0,
+        byProvider: [],
+        byDay: [],
+      };
+    }
+
+    const now = Date.now();
+    const periodStart = now - periodDays * 24 * 60 * 60 * 1000;
+
+    // Get all logs for this workspace in the period
+    const logs = await ctx.db
+      .query("apiLogs")
+      .withIndex("by_workspaceId_createdAt", (q) => q.eq("workspaceId", session.workspaceId))
+      .filter((q) => q.gte(q.field("createdAt"), periodStart))
+      .collect();
+
+    const totalCalls = logs.length;
+    const successCount = logs.filter((l) => l.status === "success").length;
+    const errorCount = logs.filter((l) => l.status === "error").length;
+    const successRate = totalCalls > 0 ? (successCount / totalCalls) * 100 : 0;
+    const totalLatency = logs.reduce((sum, l) => sum + l.latencyMs, 0);
+    const avgLatency = totalCalls > 0 ? Math.round(totalLatency / totalCalls) : 0;
+
+    // Group by provider
+    const byProviderMap: Record<string, { calls: number; success: number; error: number; latency: number }> = {};
+    for (const log of logs) {
+      if (!byProviderMap[log.provider]) {
+        byProviderMap[log.provider] = { calls: 0, success: 0, error: 0, latency: 0 };
+      }
+      byProviderMap[log.provider].calls++;
+      byProviderMap[log.provider].latency += log.latencyMs;
+      if (log.status === "success") {
+        byProviderMap[log.provider].success++;
+      } else {
+        byProviderMap[log.provider].error++;
+      }
+    }
+
+    const byProvider = Object.entries(byProviderMap)
+      .map(([provider, data]) => ({
+        provider,
+        calls: data.calls,
+        successRate: data.calls > 0 ? (data.success / data.calls) * 100 : 0,
+        avgLatency: data.calls > 0 ? Math.round(data.latency / data.calls) : 0,
+      }))
+      .sort((a, b) => b.calls - a.calls);
+
+    // Group by day
+    const byDayMap: Record<string, { calls: number; success: number; error: number }> = {};
+    for (const log of logs) {
+      const day = new Date(log.createdAt).toISOString().split("T")[0];
+      if (!byDayMap[day]) {
+        byDayMap[day] = { calls: 0, success: 0, error: 0 };
+      }
+      byDayMap[day].calls++;
+      if (log.status === "success") {
+        byDayMap[day].success++;
+      } else {
+        byDayMap[day].error++;
+      }
+    }
+
+    const byDay = Object.entries(byDayMap)
+      .map(([date, data]) => ({
+        date,
+        calls: data.calls,
+        success: data.success,
+        error: data.error,
+      }))
+      .sort((a, b) => a.date.localeCompare(b.date));
+
+    // Get unique providers for filter dropdown
+    const providers = [...new Set(logs.map((l) => l.provider))].sort();
+
+    return {
+      totalCalls,
+      successCount,
+      errorCount,
+      successRate: Math.round(successRate * 10) / 10,
+      avgLatency,
+      byProvider,
+      byDay,
+      providers,
+    };
+  },
+});
+
+/**
+ * Get unique providers for filter dropdown
+ */
+export const getProviders = query({
+  args: {
+    token: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Verify session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      return [];
+    }
+
+    // Get all logs for this workspace
+    const logs = await ctx.db
+      .query("apiLogs")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+      .collect();
+
+    // Get unique providers
+    const providers = [...new Set(logs.map((l) => l.provider))].sort();
+    return providers;
+  },
+});

package/convex/providerKeys.ts

@@ -0,0 +1,209 @@
+import { v } from "convex/values";
+import { mutation, query, internalQuery } from "./_generated/server";
+
+// ============================================
+// BYOK - Bring Your Own Key
+// ============================================
+
+// Supported providers for BYOK
+export const BYOK_PROVIDERS = [
+  { id: "brave_search", name: "Brave Search", icon: "🔍" },
+  { id: "openrouter", name: "OpenRouter", icon: "🤖" },
+  { id: "elevenlabs", name: "ElevenLabs", icon: "🎙️" },
+  { id: "twilio", name: "Twilio", icon: "📞" },
+  { id: "resend", name: "Resend", icon: "📧" },
+  { id: "e2b", name: "E2B", icon: "💻" },
+] as const;
+
+// Simple base64 encoding for MVP (proper encryption in production)
+function encryptKey(key: string): string {
+  return Buffer.from(key).toString("base64");
+}
+
+function decryptKey(encryptedKey: string): string {
+  return Buffer.from(encryptedKey, "base64").toString("utf-8");
+}
+
+function getKeyHint(key: string): string {
+  if (key.length <= 4) return "••••";
+  return key.slice(-4);
+}
+
+// ============================================
+// ADD KEY
+// ============================================
+
+export const addKey = mutation({
+  args: {
+    token: v.string(),
+    provider: v.string(),
+    apiKey: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Validate session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      throw new Error("Invalid session");
+    }
+
+    const workspaceId = session.workspaceId;
+
+    // Check if key already exists for this provider
+    const existingKey = await ctx.db
+      .query("providerKeys")
+      .withIndex("by_provider", (q) =>
+        q.eq("workspaceId", workspaceId).eq("provider", args.provider)
+      )
+      .first();
+
+    const now = Date.now();
+    const encryptedKey = encryptKey(args.apiKey);
+    const keyHint = getKeyHint(args.apiKey);
+
+    if (existingKey) {
+      // Update existing key
+      await ctx.db.patch(existingKey._id, {
+        encryptedKey,
+        keyHint,
+        updatedAt: now,
+      });
+      return { success: true, action: "updated" };
+    } else {
+      // Create new key
+      await ctx.db.insert("providerKeys", {
+        workspaceId,
+        provider: args.provider,
+        encryptedKey,
+        keyHint,
+        isCustom: false,
+        createdAt: now,
+        updatedAt: now,
+      });
+      return { success: true, action: "created" };
+    }
+  },
+});
+
+// ============================================
+// REMOVE KEY
+// ============================================
+
+export const removeKey = mutation({
+  args: {
+    token: v.string(),
+    provider: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Validate session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      throw new Error("Invalid session");
+    }
+
+    const workspaceId = session.workspaceId;
+
+    // Find and delete the key
+    const existingKey = await ctx.db
+      .query("providerKeys")
+      .withIndex("by_provider", (q) =>
+        q.eq("workspaceId", workspaceId).eq("provider", args.provider)
+      )
+      .first();
+
+    if (!existingKey) {
+      throw new Error("Key not found");
+    }
+
+    await ctx.db.delete(existingKey._id);
+    return { success: true };
+  },
+});
+
+// ============================================
+// GET KEYS (for display - no actual key values)
+// ============================================
+
+export const getKeys = query({
+  args: {
+    token: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Validate session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", args.token))
+      .first();
+
+    if (!session) {
+      return { keys: [] };
+    }
+
+    const workspaceId = session.workspaceId;
+
+    // Get all keys for this workspace
+    const keys = await ctx.db
+      .query("providerKeys")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", workspaceId))
+      .collect();
+
+    // Return without actual key values
+    return {
+      keys: keys.map((key) => ({
+        provider: key.provider,
+        keyHint: key.keyHint,
+        isCustom: key.isCustom,
+        customConfig: key.customConfig,
+        createdAt: key.createdAt,
+        updatedAt: key.updatedAt,
+      })),
+    };
+  },
+});
+
+// ============================================
+// GET KEY FOR EXECUTION (internal use only)
+// ============================================
+
+export const getKeyForExecution = internalQuery({
+  args: {
+    workspaceId: v.id("workspaces"),
+    provider: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const key = await ctx.db
+      .query("providerKeys")
+      .withIndex("by_provider", (q) =>
+        q.eq("workspaceId", args.workspaceId).eq("provider", args.provider)
+      )
+      .first();
+
+    if (!key) {
+      return null;
+    }
+
+    return {
+      apiKey: decryptKey(key.encryptedKey),
+      isCustom: key.isCustom,
+      customConfig: key.customConfig,
+    };
+  },
+});
+
+// ============================================
+// GET SUPPORTED PROVIDERS
+// ============================================
+
+export const getSupportedProviders = query({
+  args: {},
+  handler: async () => {
+    return BYOK_PROVIDERS;
+  },
+});

package/convex/providers.ts

@@ -829,3 +829,21 @@ function generateToken(): string {
   }
   return result;
 }
+
+// Debug: Update API name/description
+export const debugUpdateAPI = mutation({
+  args: { 
+    apiId: v.string(),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    category: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const updates: any = {};
+    if (args.name) updates.name = args.name;
+    if (args.description) updates.description = args.description;
+    if (args.category) updates.category = args.category;
+    await ctx.db.patch(args.apiId as any, updates);
+    return { updated: true };
+  },
+});

package/convex/schema.ts

@@ -49,19 +49,57 @@ export default defineSchema({
     tier: v.string(), // "free" | "pro" | "enterprise"
     usageCount: v.number(), // total API calls made
     usageLimit: v.number(), // max API calls for tier
+    // Stripe billing fields
     stripeCustomerId: v.optional(v.string()),
+    stripeSubscriptionId: v.optional(v.string()),
+    billingPlan: v.optional(v.string()), // "free" | "usage_based" | "starter" | "pro" | "scale"
+    creditBalance: v.optional(v.number()), // prepaid credits in cents
+    lastBillingDate: v.optional(v.number()),
     createdAt: v.number(),
     updatedAt: v.number(),
   })
     .index("by_email", ["email"])
     .index("by_stripeCustomerId", ["stripeCustomerId"])
+    .index("by_stripeSubscriptionId", ["stripeSubscriptionId"])
     .index("by_status", ["status"]),
 
+  // Invoices (Stripe invoice records)
+  invoices: defineTable({
+    workspaceId: v.id("workspaces"),
+    stripeInvoiceId: v.string(),
+    amount: v.number(), // in cents
+    status: v.string(), // "paid" | "pending" | "failed" | "void"
+    periodStart: v.number(),
+    periodEnd: v.number(),
+    callCount: v.number(),
+    pdfUrl: v.optional(v.string()),
+    createdAt: v.number(),
+  })
+    .index("by_workspaceId", ["workspaceId"])
+    .index("by_stripeInvoiceId", ["stripeInvoiceId"])
+    .index("by_workspaceId_createdAt", ["workspaceId", "createdAt"]),
+
+  // Usage records (daily aggregation for billing)
+  usageRecords: defineTable({
+    workspaceId: v.id("workspaces"),
+    date: v.string(), // "2026-02-28" format
+    callCount: v.number(),
+    reportedToStripe: v.boolean(),
+    stripeUsageRecordId: v.optional(v.string()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_workspaceId", ["workspaceId"])
+    .index("by_date", ["date"])
+    .index("by_workspaceId_date", ["workspaceId", "date"])
+    .index("by_reportedToStripe", ["reportedToStripe"]),
+
   // Agent sessions (for MCP server authentication)
   agentSessions: defineTable({
     workspaceId: v.id("workspaces"),
     sessionToken: v.string(),
     fingerprint: v.optional(v.string()), // machine fingerprint
+    customName: v.optional(v.string()), // user-defined name
     lastUsedAt: v.number(),
     createdAt: v.number(),
   })
@@ -338,6 +376,24 @@ export default defineSchema({
     .index("by_userId_providerId", ["userId", "providerId"])
     .index("by_userId_timestamp", ["userId", "timestamp"]),
 
+  // ============================================
+  // API LOGS (workspace/consumer view)
+  // ============================================
+
+  apiLogs: defineTable({
+    workspaceId: v.id("workspaces"),
+    sessionToken: v.string(),
+    provider: v.string(),
+    action: v.string(),
+    status: v.union(v.literal("success"), v.literal("error")),
+    latencyMs: v.number(),
+    errorMessage: v.optional(v.string()),
+    createdAt: v.number(),
+  })
+    .index("by_workspaceId", ["workspaceId"])
+    .index("by_createdAt", ["createdAt"])
+    .index("by_workspaceId_createdAt", ["workspaceId", "createdAt"]),
+
   // ============================================
   // WAITLIST (for Direct Call provider leads)
   // ============================================
@@ -413,4 +469,63 @@ export default defineSchema({
     .index("by_providerId", ["providerId"])
     .index("by_userId", ["userId"])
     .index("by_timestamp", ["timestamp"]),
+
+  // ============================================
+  // WEBHOOKS
+  // ============================================
+
+  webhooks: defineTable({
+    workspaceId: v.id("workspaces"),
+    url: v.string(),
+    events: v.array(v.string()),
+    secret: v.string(), // For signature verification
+    enabled: v.boolean(),
+    lastTriggeredAt: v.optional(v.number()),
+    lastStatus: v.optional(v.string()), // "success" | "failed"
+    failCount: v.number(),
+    createdAt: v.number(),
+  })
+    .index("by_workspaceId", ["workspaceId"]),
+
+  // ============================================
+  // BYOK - BRING YOUR OWN KEY
+  // ============================================
+
+  // User-provided API keys for providers
+  providerKeys: defineTable({
+    workspaceId: v.id("workspaces"),
+    provider: v.string(), // "brave_search", "openrouter", etc.
+    encryptedKey: v.string(), // Base64 encoded for MVP
+    keyHint: v.string(), // Last 4 chars for display
+    isCustom: v.boolean(), // true if custom provider (not built-in)
+    customConfig: v.optional(v.object({
+      baseUrl: v.string(),
+      authType: v.string(), // "bearer", "api_key", "basic"
+      authHeader: v.optional(v.string()), // e.g. "X-API-Key"
+    })),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_workspaceId", ["workspaceId"])
+    .index("by_provider", ["workspaceId", "provider"]),
+
+  // ============================================
+  // FEEDBACK SYSTEM
+  // ============================================
+
+  // User feedback with voting
+  feedback: defineTable({
+    workspaceId: v.id("workspaces"),
+    type: v.union(v.literal("bug"), v.literal("feature"), v.literal("general")),
+    content: v.string(),
+    votes: v.number(),
+    votedBy: v.array(v.string()), // workspace IDs that voted
+    status: v.union(v.literal("new"), v.literal("reviewing"), v.literal("planned"), v.literal("shipped")),
+    createdAt: v.number(),
+  })
+    .index("by_workspaceId", ["workspaceId"])
+    .index("by_type", ["type"])
+    .index("by_status", ["status"])
+    .index("by_votes", ["votes"])
+    .index("by_createdAt", ["createdAt"]),
 });