whale-code 6.4.0

package/dist/server/handlers/discovery.js

@@ -0,0 +1,288 @@
+// server/handlers/discovery.ts — mDNS/DNS-SD local network device discovery
+// Scan for POS terminals, printers, and other services on the local network.
+// Uses bonjour-service (Zeroconf/mDNS implementation in TypeScript).
+import Bonjour from "bonjour-service";
+// ============================================================================
+// MODULE-LEVEL STATE
+// ============================================================================
+/** Single Bonjour instance shared across advertise operations */
+let bonjourInstance = null;
+/** Map of advertised service name -> Service instance for stop/list */
+const advertisedServices = new Map();
+function getBonjour() {
+    if (!bonjourInstance) {
+        bonjourInstance = new Bonjour();
+    }
+    return bonjourInstance;
+}
+/** Common service types to scan when doing a broad discovery */
+const COMMON_SERVICE_TYPES = [
+    "http",
+    "https",
+    "printer",
+    "ipp",
+    "pos",
+    "airplay",
+    "raop",
+    "smb",
+    "ftp",
+    "ssh",
+    "mqtt",
+];
+/**
+ * Scan the local network for mDNS services.
+ * Creates a short-lived Bonjour instance per scan to avoid memory leaks.
+ */
+async function scanServices(serviceType, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let bonjour;
+        try {
+            bonjour = new Bonjour();
+        }
+        catch (err) {
+            reject(new Error(`mDNS not available on this host. This typically happens in Docker/cloud environments without multicast support. (${err instanceof Error ? err.message : String(err)})`));
+            return;
+        }
+        const services = [];
+        const seen = new Set();
+        // Strip leading underscore and trailing protocol if user passed full form
+        // e.g. "_http._tcp" -> "http"
+        let type = serviceType;
+        if (type.startsWith("_"))
+            type = type.slice(1);
+        if (type.endsWith("._tcp"))
+            type = type.slice(0, -5);
+        if (type.endsWith("._udp"))
+            type = type.slice(0, -5);
+        let browser;
+        try {
+            browser = bonjour.find({ type });
+        }
+        catch (err) {
+            bonjour.destroy();
+            reject(new Error(`Failed to start mDNS browser: ${err instanceof Error ? err.message : String(err)}`));
+            return;
+        }
+        browser.on("up", (service) => {
+            const key = `${service.name}::${service.type}::${service.port}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                services.push({
+                    name: service.name,
+                    type: service.type,
+                    host: service.host,
+                    port: service.port,
+                    addresses: service.addresses,
+                    txt: service.txt,
+                });
+            }
+        });
+        const timer = setTimeout(() => {
+            try {
+                browser.stop();
+                bonjour.destroy();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            resolve(services);
+        }, timeoutMs);
+        // Safety: if the browser errors out, resolve with whatever we have
+        browser.on("error", () => {
+            clearTimeout(timer);
+            try {
+                browser.stop();
+                bonjour.destroy();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            resolve(services);
+        });
+    });
+}
+/**
+ * Multi-type scan: run parallel scans for common service types.
+ */
+async function scanAllCommonTypes(timeoutMs) {
+    const results = await Promise.allSettled(COMMON_SERVICE_TYPES.map((type) => scanServices(type, timeoutMs)));
+    const allServices = [];
+    const seen = new Set();
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            for (const svc of result.value) {
+                const key = `${svc.name}::${svc.type}::${svc.port}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    allServices.push(svc);
+                }
+            }
+        }
+    }
+    return allServices;
+}
+// ============================================================================
+// ADVERTISE
+// ============================================================================
+function advertiseService(name, type, port, txt) {
+    if (advertisedServices.has(name)) {
+        return {
+            success: false,
+            error: `Service "${name}" is already being advertised. Stop it first with stop_advertise.`,
+        };
+    }
+    // Strip protocol suffix from type for bonjour-service
+    let cleanType = type;
+    if (cleanType.startsWith("_"))
+        cleanType = cleanType.slice(1);
+    if (cleanType.endsWith("._tcp"))
+        cleanType = cleanType.slice(0, -5);
+    if (cleanType.endsWith("._udp"))
+        cleanType = cleanType.slice(0, -5);
+    try {
+        const bonjour = getBonjour();
+        const service = bonjour.publish({
+            name,
+            type: cleanType,
+            port,
+            txt: txt,
+        });
+        advertisedServices.set(name, service);
+        return { success: true };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Failed to advertise service: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+// ============================================================================
+// STOP ADVERTISE
+// ============================================================================
+function stopAdvertise(name) {
+    const service = advertisedServices.get(name);
+    if (!service) {
+        return {
+            success: false,
+            error: `No advertised service found with name "${name}". Currently advertised: ${advertisedServices.size === 0 ? "none" : Array.from(advertisedServices.keys()).join(", ")}`,
+        };
+    }
+    try {
+        if (service.stop) {
+            service.stop();
+        }
+        // The service also has a 'destroyed' flag — set externally isn't needed
+        // since stop() handles cleanup in bonjour-service
+    }
+    catch {
+        // Best-effort cleanup
+    }
+    advertisedServices.delete(name);
+    return { success: true };
+}
+// ============================================================================
+// LIST ADVERTISED
+// ============================================================================
+function listAdvertised() {
+    const list = Array.from(advertisedServices.entries()).map(([name, svc]) => ({
+        name,
+        type: svc.type,
+        port: svc.port,
+        host: svc.host,
+        txt: svc.txt,
+    }));
+    return { success: true, data: list };
+}
+// ============================================================================
+// MAIN HANDLER
+// ============================================================================
+export async function handleDiscovery(_sb, args, _storeId) {
+    const action = args.action;
+    switch (action) {
+        case "scan": {
+            const serviceType = args.service_type || "";
+            const timeoutMs = Math.min(Math.max(args.timeout_ms || 5000, 1000), 30000); // clamp 1-30s
+            try {
+                let services;
+                if (!serviceType || serviceType === "all") {
+                    services = await scanAllCommonTypes(timeoutMs);
+                }
+                else {
+                    services = await scanServices(serviceType, timeoutMs);
+                }
+                return {
+                    success: true,
+                    data: {
+                        service_type: serviceType || "all (common types)",
+                        timeout_ms: timeoutMs,
+                        count: services.length,
+                        services,
+                    },
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: err instanceof Error
+                        ? err.message
+                        : `Scan failed: ${String(err)}`,
+                };
+            }
+        }
+        case "advertise": {
+            const name = args.name;
+            const type = args.type;
+            const port = args.port;
+            const txt = args.txt;
+            if (!name)
+                return { success: false, error: "name is required for advertise" };
+            if (!type)
+                return { success: false, error: "type is required for advertise (e.g. _http._tcp)" };
+            if (!port || typeof port !== "number")
+                return { success: false, error: "port is required for advertise (must be a number)" };
+            const result = advertiseService(name, type, port, txt);
+            if (result.success) {
+                return {
+                    success: true,
+                    data: {
+                        message: `Service "${name}" is now being advertised as ${type} on port ${port}`,
+                        name,
+                        type,
+                        port,
+                        txt: txt || null,
+                    },
+                };
+            }
+            return result;
+        }
+        case "stop_advertise": {
+            const name = args.name;
+            if (!name)
+                return { success: false, error: "name is required for stop_advertise" };
+            const result = stopAdvertise(name);
+            if (result.success) {
+                return {
+                    success: true,
+                    data: { message: `Stopped advertising service "${name}"` },
+                };
+            }
+            return result;
+        }
+        case "list_advertised": {
+            const result = listAdvertised();
+            return {
+                success: true,
+                data: {
+                    count: result.data.length,
+                    services: result.data,
+                },
+            };
+        }
+        default:
+            return {
+                success: false,
+                error: `Unknown discovery action: "${action}". Valid actions: scan, advertise, stop_advertise, list_advertised`,
+            };
+    }
+}

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

@@ -0,0 +1,92 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleEmbeddings(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    error: string;
+    data?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    data: {
+        id: any;
+        source_type: any;
+        source_id: any;
+        created_at: any;
+    };
+    error?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    count: any;
+    data: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    data: {
+        indexed: number;
+        message: string;
+        total_products?: undefined;
+        deleted?: undefined;
+        source_type?: undefined;
+        source_id?: undefined;
+        total?: undefined;
+        by_source_type?: undefined;
+    };
+    error?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    data: {
+        indexed: number;
+        message?: undefined;
+        total_products?: undefined;
+        deleted?: undefined;
+        source_type?: undefined;
+        source_id?: undefined;
+        total?: undefined;
+        by_source_type?: undefined;
+    };
+    count?: undefined;
+} | {
+    success: boolean;
+    data: {
+        indexed: number;
+        total_products: number;
+        message?: undefined;
+        deleted?: undefined;
+        source_type?: undefined;
+        source_id?: undefined;
+        total?: undefined;
+        by_source_type?: undefined;
+    };
+    error?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    data: {
+        deleted: boolean;
+        source_type: string | undefined;
+        source_id: string | undefined;
+        indexed?: undefined;
+        message?: undefined;
+        total_products?: undefined;
+        total?: undefined;
+        by_source_type?: undefined;
+    };
+    error?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    data: {
+        total: number;
+        by_source_type: Record<string, number>;
+        indexed?: undefined;
+        message?: undefined;
+        total_products?: undefined;
+        deleted?: undefined;
+        source_type?: undefined;
+        source_id?: undefined;
+    };
+    error?: undefined;
+    count?: undefined;
+}>;

package/dist/server/handlers/embeddings.js

@@ -0,0 +1,197 @@
+import OpenAI from "openai";
+// ============================================================================
+// EMBEDDINGS — Semantic vector search via OpenAI + pgvector
+// Actions: embed, search, index_products, delete, stats
+// ============================================================================
+const EMBEDDING_MODEL = "text-embedding-3-small";
+const MAX_CHARS = 32_000; // ~8000 tokens
+const BATCH_SIZE = 100; // OpenAI max per request
+/** Truncate text to stay within token limits */
+function truncateText(text) {
+    return text.length > MAX_CHARS ? text.slice(0, MAX_CHARS) : text;
+}
+/** Get an OpenAI client by decrypting the stored API key */
+async function getOpenAIClient(sb, storeId) {
+    const { data: apiKey, error } = await sb.rpc("decrypt_secret", {
+        p_name: "OPENAI_API_KEY",
+        p_store_id: storeId,
+    });
+    if (error || !apiKey) {
+        throw new Error("OpenAI API key not found. Add OPENAI_API_KEY to your tool secrets.");
+    }
+    return new OpenAI({ apiKey });
+}
+/** Generate embeddings for one or more texts (batched) */
+async function generateEmbeddings(openai, texts) {
+    const results = [];
+    for (let i = 0; i < texts.length; i += BATCH_SIZE) {
+        const batch = texts.slice(i, i + BATCH_SIZE).map(truncateText);
+        const response = await openai.embeddings.create({
+            model: EMBEDDING_MODEL,
+            input: batch,
+        });
+        for (const item of response.data) {
+            results.push(item.embedding);
+        }
+    }
+    return results;
+}
+/** Build a text representation of a product for embedding */
+function productToText(product) {
+    const parts = [];
+    if (product.name)
+        parts.push(String(product.name));
+    if (product.short_description)
+        parts.push(String(product.short_description));
+    if (product.description)
+        parts.push(String(product.description));
+    if (product.field_values && typeof product.field_values === "object") {
+        const fv = product.field_values;
+        for (const [key, val] of Object.entries(fv)) {
+            if (val !== null && val !== undefined && val !== "") {
+                parts.push(`${key}: ${String(val)}`);
+            }
+        }
+    }
+    return parts.join(". ");
+}
+// ============================================================================
+// MAIN HANDLER
+// ============================================================================
+export async function handleEmbeddings(sb, args, storeId) {
+    const sid = storeId;
+    const action = args.action;
+    switch (action) {
+        // ======================== EMBED ========================
+        case "embed": {
+            const content = args.content;
+            if (!content)
+                return { success: false, error: "content is required for embed action" };
+            const openai = await getOpenAIClient(sb, sid);
+            const [embedding] = await generateEmbeddings(openai, [content]);
+            const sourceType = args.source_type || "text";
+            const sourceId = args.source_id;
+            const metadata = args.metadata || {};
+            // Upsert: delete existing embedding for same source_id if provided
+            if (sourceId) {
+                await sb.from("embeddings")
+                    .delete()
+                    .eq("store_id", sid)
+                    .eq("source_type", sourceType)
+                    .eq("source_id", sourceId);
+            }
+            const { data, error } = await sb.from("embeddings").insert({
+                store_id: sid,
+                content: truncateText(content),
+                embedding: JSON.stringify(embedding),
+                metadata,
+                source_type: sourceType,
+                source_id: sourceId || null,
+            }).select("id, source_type, source_id, created_at").single();
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, data };
+        }
+        // ======================== SEARCH ========================
+        case "search": {
+            const query = args.query;
+            if (!query)
+                return { success: false, error: "query is required for search action" };
+            const matchCount = args.match_count || 10;
+            const sourceType = args.source_type || null;
+            const threshold = args.similarity_threshold || 0.5;
+            const openai = await getOpenAIClient(sb, sid);
+            const [queryEmbedding] = await generateEmbeddings(openai, [query]);
+            const { data, error } = await sb.rpc("search_embeddings", {
+                p_store_id: sid,
+                p_query_embedding: JSON.stringify(queryEmbedding),
+                p_match_count: matchCount,
+                p_source_type: sourceType,
+                p_similarity_threshold: threshold,
+            });
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, count: data?.length ?? 0, data };
+        }
+        // ======================== INDEX PRODUCTS ========================
+        case "index_products": {
+            const { data: products, error: fetchErr } = await sb
+                .from("products")
+                .select("id, name, description, short_description, field_values")
+                .eq("store_id", sid);
+            if (fetchErr)
+                return { success: false, error: fetchErr.message };
+            if (!products || products.length === 0) {
+                return { success: true, data: { indexed: 0, message: "No products found to index." } };
+            }
+            const openai = await getOpenAIClient(sb, sid);
+            const texts = products.map(productToText);
+            const embeddings = await generateEmbeddings(openai, texts);
+            // Delete all existing product embeddings for this store
+            await sb.from("embeddings")
+                .delete()
+                .eq("store_id", sid)
+                .eq("source_type", "product");
+            // Insert in batches
+            let inserted = 0;
+            const rows = products.map((p, i) => ({
+                store_id: sid,
+                content: truncateText(texts[i]),
+                embedding: JSON.stringify(embeddings[i]),
+                metadata: { name: p.name },
+                source_type: "product",
+                source_id: p.id,
+            }));
+            for (let i = 0; i < rows.length; i += 500) {
+                const batch = rows.slice(i, i + 500);
+                const { error: insErr } = await sb.from("embeddings").insert(batch);
+                if (insErr)
+                    return { success: false, error: insErr.message, data: { indexed: inserted } };
+                inserted += batch.length;
+            }
+            return {
+                success: true,
+                data: { indexed: inserted, total_products: products.length },
+            };
+        }
+        // ======================== DELETE ========================
+        case "delete": {
+            const sourceType = args.source_type;
+            const sourceId = args.source_id;
+            if (!sourceType && !sourceId) {
+                return { success: false, error: "Provide source_type and/or source_id to delete embeddings." };
+            }
+            let q = sb.from("embeddings").delete().eq("store_id", sid);
+            if (sourceType)
+                q = q.eq("source_type", sourceType);
+            if (sourceId)
+                q = q.eq("source_id", sourceId);
+            const { error } = await q;
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, data: { deleted: true, source_type: sourceType, source_id: sourceId } };
+        }
+        // ======================== STATS ========================
+        case "stats": {
+            const { data, error } = await sb
+                .from("embeddings")
+                .select("source_type")
+                .eq("store_id", sid);
+            if (error)
+                return { success: false, error: error.message };
+            const counts = {};
+            let total = 0;
+            for (const row of data || []) {
+                const st = row.source_type || "unknown";
+                counts[st] = (counts[st] || 0) + 1;
+                total++;
+            }
+            return { success: true, data: { total, by_source_type: counts } };
+        }
+        default:
+            return {
+                success: false,
+                error: `Unknown embeddings action: ${action}. Valid actions: embed, search, index_products, delete, stats`,
+            };
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+export declare function handleEnrichment(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    count?: number;
+    note?: string;
+}>;