whale-code 6.4.0

package/dist/server/handlers/operations.d.ts

@@ -0,0 +1,138 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleLocations(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: {
+        id: any;
+        name: any;
+        address_line1: any;
+        city: any;
+        state: any;
+        is_active: any;
+        type: any;
+    }[];
+    error?: undefined;
+}>;
+export declare function handleSuppliers(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: {
+        id: any;
+        external_name: any;
+        external_company: any;
+        contact_name: any;
+        contact_email: any;
+        contact_phone: any;
+        city: any;
+        state: any;
+        is_active: any;
+    }[];
+    error?: undefined;
+}>;
+export declare function handleAlerts(sb: SupabaseClient, _args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    data: {
+        summary: {
+            low_stock: number;
+            out_of_stock: number;
+            pending_orders: number;
+        };
+        low_stock: {
+            type: "low_stock";
+            severity: "warning";
+            product: any;
+            sku: any;
+            location: any;
+            quantity: any;
+        }[];
+        out_of_stock: {
+            type: "out_of_stock";
+            severity: "critical";
+            product: any;
+            sku: any;
+            location: any;
+        }[];
+        pending_orders: {
+            order_number: any;
+            total: any;
+            created_at: any;
+        }[];
+    };
+}>;
+export declare function handleStore(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: {
+        locations: {
+            id: any;
+            name: any;
+            address_line1: any;
+            city: any;
+            state: any;
+            zip_code: any;
+            is_active: any;
+            type: any;
+        }[];
+        id: any;
+        store_name: any;
+        email: any;
+        logo_url: any;
+        brand_colors: any;
+        store_tagline: any;
+    };
+    error?: undefined;
+}>;
+export declare function handleAuditTrail(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: {
+        query: string;
+        entries: {
+            id: any;
+            action: any;
+            severity: any;
+            source: any;
+            resource_type: any;
+            resource_id: any;
+            user_email: any;
+            details: any;
+            created_at: any;
+        }[];
+        count: number;
+        days: number;
+        summary?: undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    data: {
+        entries: {
+            id: any;
+            action: any;
+            severity: any;
+            source: any;
+            resource_type: any;
+            resource_id: any;
+            details: any;
+            user_email: any;
+            created_at: any;
+        }[];
+        summary: Record<string, number>;
+        days: number;
+        count: number;
+        query?: undefined;
+    };
+    error?: undefined;
+}>;

package/dist/server/handlers/operations.js

@@ -0,0 +1,131 @@
+// server/handlers/operations.ts — Locations, Suppliers, Alerts, Audit Trail handlers
+import { sanitizeFilterValue } from "../lib/utils.js";
+export async function handleLocations(sb, args, storeId) {
+    const sid = storeId;
+    let q = sb.from("locations").select("id, name, address_line1, city, state, is_active, type").eq("store_id", sid);
+    if (args.is_active !== undefined)
+        q = q.eq("is_active", args.is_active);
+    if (args.name) {
+        const sn = sanitizeFilterValue(args.name);
+        q = q.ilike("name", `%${sn}%`);
+    }
+    const { data, error } = await q;
+    return error ? { success: false, error: error.message } : { success: true, data };
+}
+export async function handleSuppliers(sb, args, storeId) {
+    const sid = storeId;
+    let q = sb.from("suppliers").select("id, external_name, external_company, contact_name, contact_email, contact_phone, city, state, is_active").eq("store_id", sid);
+    if (args.name) {
+        const sn = sanitizeFilterValue(args.name);
+        q = q.or(`external_name.ilike.%${sn}%,external_company.ilike.%${sn}%,contact_name.ilike.%${sn}%`);
+    }
+    const { data, error } = await q;
+    return error ? { success: false, error: error.message } : { success: true, data };
+}
+export async function handleAlerts(sb, _args, storeId) {
+    const sid = storeId;
+    // Low stock alerts (quantity < 10)
+    const { data: lowStock } = await sb.from("inventory")
+        .select("quantity, product:products(name, sku), location:locations(name)")
+        .eq("store_id", sid).lt("quantity", 10).gt("quantity", 0);
+    const lowStockAlerts = (lowStock || []).map((item) => ({
+        type: "low_stock", severity: "warning",
+        product: item.product?.name || "?", sku: item.product?.sku || "?",
+        location: item.location?.name || "?", quantity: item.quantity,
+    }));
+    // Out of stock
+    const { data: outOfStock } = await sb.from("inventory")
+        .select("product:products(name, sku), location:locations(name)")
+        .eq("store_id", sid).eq("quantity", 0);
+    const outOfStockAlerts = (outOfStock || []).map((item) => ({
+        type: "out_of_stock", severity: "critical",
+        product: item.product?.name || "?", sku: item.product?.sku || "?",
+        location: item.location?.name || "?",
+    }));
+    // Pending orders
+    const { data: pendingOrders } = await sb.from("orders")
+        .select("id, order_number, total_amount, created_at")
+        .eq("store_id", sid).eq("status", "pending");
+    return {
+        success: true,
+        data: {
+            summary: {
+                low_stock: lowStockAlerts.length,
+                out_of_stock: outOfStockAlerts.length,
+                pending_orders: pendingOrders?.length || 0,
+            },
+            low_stock: lowStockAlerts,
+            out_of_stock: outOfStockAlerts,
+            pending_orders: (pendingOrders || []).map((o) => ({
+                order_number: o.order_number, total: o.total_amount, created_at: o.created_at,
+            })),
+        },
+    };
+}
+export async function handleStore(sb, args, storeId) {
+    const sid = storeId;
+    // Get store info with all locations
+    const { data: store, error: storeErr } = await sb.from("stores")
+        .select("id, store_name, email, logo_url, brand_colors, store_tagline")
+        .eq("id", sid)
+        .single();
+    if (storeErr || !store)
+        return { success: false, error: storeErr?.message || "Store not found" };
+    // Fetch locations for this store
+    const { data: locations } = await sb.from("locations")
+        .select("id, name, address_line1, city, state, zip_code, is_active, type")
+        .eq("store_id", sid)
+        .eq("is_active", true);
+    return { success: true, data: { ...store, locations: locations || [] } };
+}
+export async function handleAuditTrail(sb, args, storeId) {
+    const sid = storeId;
+    const days = args.days || 1;
+    const cutoff = new Date(Date.now() - days * 86400_000).toISOString();
+    // "search" action: full-text search across logs
+    if (args.action === "search") {
+        const query = args.query;
+        if (!query)
+            return { success: false, error: "query parameter is required for search action" };
+        let sq = sb.from("audit_logs")
+            .select("id, action, severity, source, resource_type, resource_id, user_email, details, created_at")
+            .eq("store_id", sid)
+            .gte("created_at", cutoff)
+            .or(`action.ilike.%${sanitizeFilterValue(query)}%,error_message.ilike.%${sanitizeFilterValue(query)}%,user_email.ilike.%${sanitizeFilterValue(query)}%,resource_id.ilike.%${sanitizeFilterValue(query)}%`)
+            .order("created_at", { ascending: false });
+        if (args.limit)
+            sq = sq.limit(args.limit);
+        const { data, error } = await sq;
+        if (error)
+            return { success: false, error: error.message };
+        return { success: true, data: { query, entries: data, count: data?.length || 0, days } };
+    }
+    // Default action: filtered list
+    let q = sb.from("audit_logs")
+        .select("id, action, severity, source, resource_type, resource_id, details, user_email, created_at")
+        .eq("store_id", sid)
+        .gte("created_at", cutoff)
+        .order("created_at", { ascending: false });
+    if (args.limit)
+        q = q.limit(args.limit);
+    // Optional filters
+    if (args.action_filter) {
+        const sf = sanitizeFilterValue(args.action_filter);
+        q = q.ilike("action", `%${sf}%`);
+    }
+    if (args.resource_type)
+        q = q.eq("resource_type", args.resource_type);
+    if (args.severity)
+        q = q.eq("severity", args.severity);
+    if (args.source)
+        q = q.eq("source", args.source);
+    const { data, error } = await q;
+    if (error)
+        return { success: false, error: error.message };
+    // Summarize by action for quick overview
+    const byAction = {};
+    for (const entry of data || []) {
+        byAction[entry.action] = (byAction[entry.action] || 0) + 1;
+    }
+    return { success: true, data: { entries: data, summary: byAction, days, count: data?.length || 0 } };
+}

package/dist/server/handlers/platform.d.ts

@@ -0,0 +1,23 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleWebSearch(sb: SupabaseClient, args: Record<string, unknown>, _storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: {
+        query: string;
+        results: any;
+        autopromptString: any;
+    };
+    error?: undefined;
+}>;
+export declare function handleTelemetry(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: any;
+    error?: undefined;
+}>;

package/dist/server/handlers/platform.js

@@ -0,0 +1,227 @@
+export async function handleWebSearch(sb, args, _storeId) {
+    const query = args.query;
+    const numResults = args.num_results || 5;
+    // Read from platform_secrets table first, fall back to env var
+    const { data: secret } = await sb.from("platform_secrets").select("value").eq("key", "exa_api_key").single();
+    const exaApiKey = secret?.value || process.env["EXA_API_KEY"];
+    if (!exaApiKey) {
+        return { success: false, error: "Exa API key not configured. Add 'exa_api_key' to platform_secrets table." };
+    }
+    if (!query) {
+        return { success: false, error: "Query parameter is required" };
+    }
+    try {
+        const response = await fetch("https://api.exa.ai/search", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": exaApiKey
+            },
+            body: JSON.stringify({
+                query,
+                numResults,
+                useAutoprompt: true,
+                type: "auto"
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return { success: false, error: `Exa API error: ${response.status} - ${errorText}` };
+        }
+        const data = await response.json();
+        return {
+            success: true,
+            data: {
+                query,
+                results: data.results || [],
+                autopromptString: data.autopromptString
+            }
+        };
+    }
+    catch (err) {
+        return { success: false, error: `Web search failed: ${err}` };
+    }
+}
+export async function handleTelemetry(sb, args, storeId) {
+    const sid = storeId;
+    const hoursBack = args.hours_back || 24;
+    const limit = Math.min(args.limit || 50, 200);
+    switch (args.action) {
+        // ---- conversation_detail: Full conversation with messages + audit entries ----
+        case "conversation_detail": {
+            const convId = args.conversation_id;
+            if (!convId)
+                return { success: false, error: "conversation_id is required" };
+            const [convResult, msgResult, auditResult] = await Promise.all([
+                sb.from("ai_conversations").select("*").eq("id", convId).eq("store_id", sid).single(),
+                sb.from("ai_messages").select("*").eq("conversation_id", convId).order("created_at", { ascending: true }),
+                sb.from("audit_logs").select("id, action, severity, duration_ms, status_code, error_message, resource_id, input_tokens, output_tokens, model, created_at")
+                    .eq("conversation_id", convId).order("created_at", { ascending: true }).limit(200)
+            ]);
+            if (convResult.error)
+                return { success: false, error: convResult.error.message };
+            return {
+                success: true,
+                data: {
+                    conversation: convResult.data,
+                    messages: msgResult.data || [],
+                    audit_entries: auditResult.data || [],
+                    message_count: msgResult.data?.length || 0,
+                    audit_count: auditResult.data?.length || 0
+                }
+            };
+        }
+        // ---- conversations: List recent conversations ----
+        case "conversations": {
+            const convLimit = Math.min(args.limit || 20, 100);
+            let q = sb.from("ai_conversations")
+                .select("*")
+                .eq("store_id", sid)
+                .gte("created_at", new Date(Date.now() - hoursBack * 3600_000).toISOString())
+                .order("created_at", { ascending: false })
+                .limit(convLimit);
+            if (args.agent_id)
+                q = q.eq("agent_id", args.agent_id);
+            const { data, error } = await q;
+            return error ? { success: false, error: error.message } : { success: true, data: { count: data?.length || 0, conversations: data } };
+        }
+        // ---- agent_performance: Agent-level analytics via RPC ----
+        case "agent_performance": {
+            const agentId = args.agent_id;
+            if (!agentId)
+                return { success: false, error: "agent_id is required" };
+            // Verify agent belongs to this store
+            const { data: conv } = await sb.from("ai_conversations").select("id").eq("agent_id", agentId).eq("store_id", sid).limit(1);
+            if (!conv?.length)
+                return { success: false, error: "Agent not found for this store" };
+            const days = args.days || 7;
+            const { data, error } = await sb.rpc("get_agent_analytics", { p_agent_id: agentId, p_days: days });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        // ---- tool_analytics: Per-tool performance metrics via RPC ----
+        case "tool_analytics": {
+            const { data, error } = await sb.rpc("get_tool_analytics", {
+                p_store_id: sid,
+                p_hours_back: hoursBack,
+                p_tool_name: args.tool_name || null
+            });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        // ---- tool_timeline: Time-bucketed tool metrics via RPC ----
+        case "tool_timeline": {
+            const bucketMinutes = args.bucket_minutes || 15;
+            const { data, error } = await sb.rpc("get_tool_timeline", {
+                p_store_id: sid,
+                p_hours_back: hoursBack,
+                p_bucket_minutes: bucketMinutes,
+                p_tool_name: args.tool_name || null
+            });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        // ---- trace: Full trace reconstruction via RPC ----
+        case "trace": {
+            const traceId = args.trace_id;
+            if (!traceId)
+                return { success: false, error: "trace_id is required" };
+            // Verify trace belongs to this store
+            const { data: traceLog } = await sb.from("audit_logs").select("id").eq("trace_id", traceId).eq("store_id", sid).limit(1);
+            if (!traceLog?.length)
+                return { success: false, error: "Trace not found for this store" };
+            const { data, error } = await sb.rpc("get_trace", { p_trace_id: traceId });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        // ---- span_detail: Individual span deep-dive via RPC ----
+        case "span_detail": {
+            const spanId = args.span_id;
+            if (!spanId)
+                return { success: false, error: "span_id is required" };
+            // Verify span belongs to this store via audit_logs
+            const { data: spanLog } = await sb.from("audit_logs").select("id").eq("id", spanId).eq("store_id", sid).limit(1);
+            if (!spanLog?.length)
+                return { success: false, error: "Span not found for this store" };
+            const { data, error } = await sb.rpc("get_tool_trace_detail", { p_span_id: spanId });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        // ---- error_patterns: Error correlation + burst detection via RPC ----
+        case "error_patterns": {
+            const { data, error } = await sb.rpc("get_tool_error_patterns", {
+                p_store_id: sid,
+                p_hours_back: hoursBack
+            });
+            return error ? { success: false, error: error.message } : { success: true, data };
+        }
+        // ---- token_usage: Token consumption by model/day ----
+        case "token_usage": {
+            const cutoff = new Date(Date.now() - hoursBack * 3600_000).toISOString();
+            // Build base query — if agent_id is provided, get conversation IDs first
+            let conversationFilter = null;
+            if (args.agent_id) {
+                const { data: convs } = await sb.from("ai_conversations")
+                    .select("id").eq("agent_id", args.agent_id).eq("store_id", sid);
+                conversationFilter = convs?.map(c => c.id) || [];
+            }
+            let q = sb.from("audit_logs")
+                .select("model, input_tokens, output_tokens, total_cost, created_at")
+                .eq("store_id", sid)
+                .gte("created_at", cutoff)
+                .not("input_tokens", "is", null);
+            if (conversationFilter !== null) {
+                if (conversationFilter.length === 0)
+                    return { success: true, data: { rows: [], summary: { total_input: 0, total_output: 0, total_cost: 0 } } };
+                q = q.in("conversation_id", conversationFilter);
+            }
+            const { data, error } = await q.order("created_at", { ascending: false }).limit(1000);
+            if (error)
+                return { success: false, error: error.message };
+            // Aggregate in-memory by model + day
+            const buckets = {};
+            for (const row of data || []) {
+                const day = row.created_at.substring(0, 10);
+                const model = row.model || "unknown";
+                const key = `${model}|${day}`;
+                if (!buckets[key])
+                    buckets[key] = { model, day, requests: 0, input_tokens: 0, output_tokens: 0, total_cost: 0 };
+                buckets[key].requests++;
+                buckets[key].input_tokens += row.input_tokens || 0;
+                buckets[key].output_tokens += row.output_tokens || 0;
+                buckets[key].total_cost += parseFloat(row.total_cost || "0");
+            }
+            const rows = Object.values(buckets).sort((a, b) => b.day.localeCompare(a.day) || b.total_cost - a.total_cost);
+            const summary = rows.reduce((acc, r) => ({
+                total_input: acc.total_input + r.input_tokens,
+                total_output: acc.total_output + r.output_tokens,
+                total_cost: acc.total_cost + r.total_cost,
+                total_requests: acc.total_requests + r.requests
+            }), { total_input: 0, total_output: 0, total_cost: 0, total_requests: 0 });
+            return { success: true, data: { rows, summary, hours_back: hoursBack } };
+        }
+        // ---- sources: List all telemetry sources with counts ----
+        case "sources": {
+            const cutoff = new Date(Date.now() - hoursBack * 3600_000).toISOString();
+            const { data, error } = await sb.from("audit_logs")
+                .select("source, severity, created_at")
+                .eq("store_id", sid)
+                .gte("created_at", cutoff)
+                .not("source", "is", null)
+                .limit(1000);
+            if (error)
+                return { success: false, error: error.message };
+            // Aggregate by source
+            const sourceMap = {};
+            for (const row of data || []) {
+                const src = row.source;
+                if (!sourceMap[src])
+                    sourceMap[src] = { source: src, count: 0, errors: 0, last_seen: row.created_at };
+                sourceMap[src].count++;
+                if (row.severity === "error")
+                    sourceMap[src].errors++;
+                if (row.created_at > sourceMap[src].last_seen)
+                    sourceMap[src].last_seen = row.created_at;
+            }
+            const sources = Object.values(sourceMap).sort((a, b) => b.count - a.count);
+            return { success: true, data: { sources, total_entries: data?.length || 0, hours_back: hoursBack } };
+        }
+        default:
+            return { success: false, error: `Unknown telemetry action: ${args.action}. Available: conversation_detail, conversations, agent_performance, tool_analytics, tool_timeline, trace, span_detail, error_patterns, token_usage, sources. For activity logs and inventory changes, use the audit_trail tool instead.` };
+    }
+}

package/dist/server/handlers/supply-chain.d.ts

@@ -0,0 +1,19 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handlePurchaseOrders(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: any;
+    error?: undefined;
+}>;
+export declare function handleTransfers(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+} | {
+    success: boolean;
+    data: any;
+    error?: undefined;
+}>;