@nordsym/apiclaw 1.7.3 → 1.7.5

package/convex/logs.ts

@@ -0,0 +1,662 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+import { api } from "./_generated/api";
+
+// ============================================
+// 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()),
+    subagentId: v.optional(v.string()), // from X-APIClaw-Subagent header
+  },
+  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,
+      subagentId: args.subagentId,
+      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()),
+    subagentId: v.optional(v.string()), // from X-APIClaw-Subagent header
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.insert("apiLogs", {
+      workspaceId: args.workspaceId,
+      sessionToken: args.sessionToken,
+      subagentId: args.subagentId,
+      provider: args.provider,
+      action: args.action,
+      status: args.status,
+      latencyMs: args.latencyMs,
+      errorMessage: args.errorMessage,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+/**
+ * Log an inbound call to a provider's workspace
+ * Called when someone uses an API that belongs to another workspace
+ */
+export const logProviderCall = mutation({
+  args: {
+    provider: v.string(),
+    action: v.string(),
+    status: v.union(v.literal("success"), v.literal("error")),
+    latencyMs: v.number(),
+    callerWorkspaceId: v.string(),
+    subagentId: v.optional(v.string()),
+    errorMessage: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Map provider to workspace email
+    const providerEmailMap: Record<string, string> = {
+      apilayer: "gustav_hemmingsson@hotmail.com",
+    };
+
+    const providerEmail = providerEmailMap[args.provider];
+    if (!providerEmail) return null; // no workspace for this provider
+
+    const workspace = await ctx.db
+      .query("workspaces")
+      .withIndex("by_email", (q) => q.eq("email", providerEmail))
+      .first();
+    if (!workspace) return null;
+
+    return await ctx.db.insert("apiLogs", {
+      workspaceId: workspace._id,
+      sessionToken: "",
+      provider: args.provider,
+      action: args.action,
+      status: args.status,
+      latencyMs: args.latencyMs,
+      direction: "inbound",
+      callerWorkspaceId: args.callerWorkspaceId,
+      subagentId: args.subagentId,
+      errorMessage: args.errorMessage,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+/**
+ * Get analytics for a provider workspace (inbound calls to their APIs)
+ * Used by API Analytics tab in workspace dashboard
+ */
+export const getProviderAnalytics = query({
+  args: {
+    token: v.string(),
+    hoursBack: v.optional(v.number()),
+  },
+  handler: async (ctx, { token, hoursBack = 168 }) => {
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+      .first();
+    if (!session) return null;
+
+    const since = Date.now() - hoursBack * 60 * 60 * 1000;
+
+    // Get all logs for this workspace
+    const allLogs = await ctx.db
+      .query("apiLogs")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+      .collect();
+
+    const periodLogs = allLogs.filter((l) => l.createdAt >= since);
+    const inboundLogs = periodLogs.filter((l) => l.direction === "inbound");
+    const outboundLogs = periodLogs.filter((l) => l.direction !== "inbound");
+
+    // Daily buckets
+    const byDay: Record<string, number> = {};
+    periodLogs.forEach((l) => {
+      const day = new Date(l.createdAt).toISOString().split("T")[0];
+      byDay[day] = (byDay[day] || 0) + 1;
+    });
+
+    // By provider
+    const byProvider: Record<string, { calls: number; success: number }> = {};
+    periodLogs.forEach((l) => {
+      if (!byProvider[l.provider]) byProvider[l.provider] = { calls: 0, success: 0 };
+      byProvider[l.provider].calls++;
+      if (l.status === "success") byProvider[l.provider].success++;
+    });
+
+    // Unique callers (for inbound)
+    const uniqueCallers = new Set(inboundLogs.map((l) => l.callerWorkspaceId).filter(Boolean)).size;
+
+    return {
+      totalCalls: periodLogs.length,
+      inboundCalls: inboundLogs.length,
+      outboundCalls: outboundLogs.length,
+      uniqueCallers,
+      byDay: Object.entries(byDay)
+        .map(([date, calls]) => ({ date, calls }))
+        .sort((a, b) => a.date.localeCompare(b.date)),
+      byProvider: Object.entries(byProvider)
+        .map(([provider, stats]) => ({ provider, ...stats }))
+        .sort((a, b) => b.calls - a.calls),
+      successRate: periodLogs.length > 0
+        ? (periodLogs.filter((l) => l.status === "success").length / periodLogs.length) * 100
+        : 100,
+      avgLatency: periodLogs.length > 0
+        ? periodLogs.reduce((sum, l) => sum + l.latencyMs, 0) / periodLogs.length
+        : 0,
+    };
+  },
+});
+
+// ============================================
+// HELPER: Get month start
+// ============================================
+
+function getMonthStart(): number {
+  const now = new Date();
+  return new Date(now.getUTCFullYear(), now.getUTCMonth(), 1, 0, 0, 0, 0).getTime();
+}
+
+/**
+ * Combined log creation + spend tracking (PRD 2.6)
+ * Creates log entry, tracks spend, returns budget status
+ * Returns shouldSendAlert: true if 80% threshold crossed (caller should send email)
+ */
+export const createLogWithSpend = 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(),
+    costCents: v.number(), // Cost in USD cents
+    errorMessage: v.optional(v.string()),
+    subagentId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const monthStart = getMonthStart();
+    
+    // 1. Create log entry
+    const logId = await ctx.db.insert("apiLogs", {
+      workspaceId: args.workspaceId,
+      sessionToken: args.sessionToken,
+      subagentId: args.subagentId,
+      provider: args.provider,
+      action: args.action,
+      status: args.status,
+      latencyMs: args.latencyMs,
+      errorMessage: args.errorMessage,
+      createdAt: now,
+    });
+
+    // 2. Track spend if successful call with cost
+    if (args.status === "success" && args.costCents > 0) {
+      const workspace = await ctx.db.get(args.workspaceId);
+      if (!workspace) {
+        return { logId, spendTracked: false };
+      }
+
+      // Reset monthly spend if new month
+      let currentSpend = workspace.monthlySpendCents || 0;
+      if (!workspace.lastSpendResetAt || workspace.lastSpendResetAt < monthStart) {
+        currentSpend = 0;
+      }
+
+      // Add new spend
+      const newSpend = currentSpend + args.costCents;
+      const budgetCap = workspace.budgetCap;
+
+      // Update workspace
+      await ctx.db.patch(args.workspaceId, {
+        monthlySpendCents: newSpend,
+        lastSpendResetAt: monthStart,
+        updatedAt: now,
+      });
+
+      // Check if we need to send alert (80% threshold)
+      let shouldSendAlert = false;
+      let budgetExceeded = false;
+
+      if (budgetCap && budgetCap > 0) {
+        const threshold = budgetCap * 0.8;
+        const alertAlreadySentThisMonth = workspace.budgetAlertSentAt &&
+          workspace.budgetAlertSentAt >= monthStart;
+
+        // Check if at 80% and alert not yet sent
+        if (newSpend >= threshold && !alertAlreadySentThisMonth) {
+          shouldSendAlert = true;
+          await ctx.db.patch(args.workspaceId, {
+            budgetAlertSentAt: now,
+          });
+        }
+
+        // Check if budget exceeded
+        if (newSpend >= budgetCap) {
+          budgetExceeded = true;
+        }
+      }
+
+      return {
+        logId,
+        spendTracked: true,
+        currentSpendCents: newSpend,
+        budgetCapCents: budgetCap || null,
+        budgetPercentage: budgetCap ? Math.round((newSpend / budgetCap) * 100) : null,
+        shouldSendAlert,
+        budgetExceeded,
+        email: workspace.email,
+      };
+    }
+
+    return { logId, spendTracked: false };
+  },
+});
+
+// ============================================
+// 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()),
+    subagentId: v.optional(v.string()), // filter by subagent
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 50;
+    const status = args.status ?? "all";
+    const provider = args.provider;
+    const subagentId = args.subagentId;
+    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);
+    }
+
+    // Filter by subagent
+    if (subagentId) {
+      if (subagentId === "main") {
+        // Main agent calls (no subagentId)
+        filteredLogs = filteredLogs.filter((log) => !log.subagentId);
+      } else {
+        filteredLogs = filteredLogs.filter((log) => log.subagentId === subagentId);
+      }
+    }
+
+    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,
+        subagentId: log.subagentId || null,
+        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 and agents for filter dropdowns
+    const providers = [...new Set(logs.map((l) => l.provider))].sort();
+    const agents = [...new Set(logs.map((l) => l.subagentId || "main"))].sort();
+
+    return {
+      totalCalls,
+      successCount,
+      errorCount,
+      successRate: Math.round(successRate * 10) / 10,
+      avgLatency,
+      byProvider,
+      byDay,
+      providers,
+      agents,
+    };
+  },
+});
+
+/**
+ * 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;
+  },
+});
+
+/**
+ * Get logs for a specific subagent
+ */
+export const getBySubagent = query({
+  args: {
+    token: v.string(),
+    subagentId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, { token, subagentId, limit = 20 }) => {
+    // Verify session
+    const session = await ctx.db
+      .query("agentSessions")
+      .withIndex("by_sessionToken", (q) => q.eq("sessionToken", token))
+      .first();
+    
+    if (!session) return null;
+    
+    // Get API logs for this subagent
+    const apiLogs = await ctx.db
+      .query("apiLogs")
+      .withIndex("by_subagentId", (q) => q.eq("subagentId", subagentId))
+      .order("desc")
+      .take(limit);
+    
+    // Get search logs for this subagent  
+    const searchLogs = await ctx.db
+      .query("searchLogs")
+      .filter((q) => q.eq(q.field("subagentId"), subagentId))
+      .order("desc")
+      .take(limit);
+    
+    // Merge and sort by timestamp
+    const combined = [
+      ...apiLogs.map(l => ({ 
+        ...l, 
+        type: "direct_call" as const,
+        timestamp: l.createdAt 
+      })),
+      ...searchLogs.map(l => ({ 
+        ...l, 
+        type: "search" as const,
+        timestamp: l.timestamp 
+      })),
+    ].sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+    
+    return combined.slice(0, limit);
+  },
+});
+
+/**
+ * Clear all logs for a workspace (admin cleanup)
+ */
+export const clearWorkspaceLogs = mutation({
+  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) throw new Error("Invalid session");
+    
+    // Delete all apiLogs
+    const apiLogs = await ctx.db
+      .query("apiLogs")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+      .collect();
+    
+    for (const log of apiLogs) {
+      await ctx.db.delete(log._id);
+    }
+    
+    // Delete all searchLogs
+    const searchLogs = await ctx.db
+      .query("searchLogs")
+      .withIndex("by_workspaceId", (q) => q.eq("workspaceId", session.workspaceId))
+      .collect();
+    
+    for (const log of searchLogs) {
+      await ctx.db.delete(log._id);
+    }
+    
+    return { 
+      deleted: { 
+        apiLogs: apiLogs.length, 
+        searchLogs: searchLogs.length 
+      } 
+    };
+  },
+});
+
+// Log proxy API calls from external agents (Hivr bees)
+export const createProxyLog = mutation({
+  args: {
+    workspaceId: v.id("workspaces"),
+    provider: v.string(),
+    action: v.string(),
+    subagentId: v.optional(v.string()),
+    sessionToken: v.optional(v.string()),
+  },
+  handler: async (ctx, { workspaceId, provider, action, subagentId, sessionToken }) => {
+    const now = Date.now();
+    
+    await ctx.db.insert("apiLogs", {
+      workspaceId,
+      provider,
+      action,
+      subagentId: subagentId || "unknown",
+      sessionToken: sessionToken || "proxy",
+      status: "success",
+      latencyMs: 0, // Proxy calls don't track latency
+      createdAt: now,
+    });
+    
+    // Update workspace lastActiveAt (main agent activity)
+    await ctx.db.patch(workspaceId, { lastActiveAt: now });
+    
+    // If this is a subagent call, update that subagent's timestamp
+    if (subagentId && subagentId !== "unknown" && subagentId !== "main") {
+      const subagent = await ctx.db
+        .query("subagents")
+        .withIndex("by_workspaceId_subagentId", (q) => 
+          q.eq("workspaceId", workspaceId).eq("subagentId", subagentId))
+        .first();
+      
+      if (subagent) {
+        await ctx.db.patch(subagent._id, { lastActiveAt: now });
+      }
+    }
+    
+    return { success: true };
+  },
+});

package/convex/mou.d.ts

@@ -0,0 +1,6 @@
+export declare const getByPartnerId: any;
+export declare const create: any;
+export declare const sign: any;
+export declare const list: any;
+export declare const remove: any;
+//# sourceMappingURL=mou.d.ts.map

package/convex/mou.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mou.d.ts","sourceRoot":"","sources":["mou.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,KAQzB,CAAC;AAGH,eAAO,MAAM,MAAM,KAcjB,CAAC;AAGH,eAAO,MAAM,IAAI,KAiCf,CAAC;AAGH,eAAO,MAAM,IAAI,KAKf,CAAC;AAGH,eAAO,MAAM,MAAM,KAcjB,CAAC"}