whale-code 6.4.0 → 6.5.1

package/dist/server/handlers/remove-bg.js

@@ -0,0 +1,96 @@
+// server/handlers/remove-bg.ts — Remove.bg background removal
+// Removes background from images, uploads result to Supabase storage + store_media
+async function getRemoveBgKey(sb, storeId) {
+    try {
+        const { data } = await sb.rpc("decrypt_secret", { p_name: "REMOVE_BG_API_KEY", p_store_id: storeId });
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+async function uploadResult(sb, storeId, buffer, sourceUrl) {
+    const id = crypto.randomUUID();
+    const fileName = `${id}.png`;
+    const storagePath = `remove-bg/${storeId.toUpperCase()}/${fileName}`;
+    const { error: uploadErr } = await sb.storage
+        .from("product-images")
+        .upload(storagePath, buffer, { contentType: "image/png", upsert: true });
+    if (uploadErr)
+        throw new Error(`Storage upload failed: ${uploadErr.message}`);
+    const { data: urlData } = sb.storage.from("product-images").getPublicUrl(storagePath);
+    const fileUrl = urlData.publicUrl;
+    const { data: mediaRow, error: mediaErr } = await sb
+        .from("store_media")
+        .insert({
+        store_id: storeId,
+        file_name: fileName,
+        file_path: storagePath,
+        file_url: fileUrl,
+        file_size: buffer.length,
+        file_type: "image/png",
+        category: "ai_generated",
+        ai_tags: ["background-removed", "remove.bg"],
+        ai_description: `Background removed from: ${sourceUrl.substring(0, 200)}`,
+        source: "remove-bg",
+        folder: "remove-bg",
+    })
+        .select("id")
+        .single();
+    if (mediaErr)
+        console.error("[remove-bg] store_media insert error:", mediaErr.message);
+    return { file_url: fileUrl, media_id: mediaRow?.id || id, file_name: fileName };
+}
+export async function handleRemoveBg(sb, args, storeId) {
+    if (!storeId)
+        return { success: false, error: "store_id is required" };
+    const apiKey = await getRemoveBgKey(sb, storeId);
+    if (!apiKey)
+        return { success: false, error: "Remove.bg API key not configured. Add REMOVE_BG_API_KEY to platform_secrets." };
+    const imageUrl = args.image_url;
+    const imageBase64 = args.image_base64;
+    const size = args.size || "auto";
+    const type = args.type || "auto";
+    if (!imageUrl && !imageBase64) {
+        return { success: false, error: "Provide image_url (public URL), image_base64, or image_path (local file — handled by CLI)" };
+    }
+    // Reject local file paths passed as image_url
+    if (imageUrl && (imageUrl.startsWith("/") || /^[A-Z]:\\/i.test(imageUrl))) {
+        return { success: false, error: `Local paths cannot be used as image_url. Use image_path instead: remove_bg(image_path="${imageUrl}")` };
+    }
+    // Build form data for remove.bg API
+    const form = new FormData();
+    if (imageUrl) {
+        form.append("image_url", imageUrl);
+    }
+    else {
+        // Strip data URI prefix if present
+        const b64 = imageBase64.replace(/^data:image\/[a-z]+;base64,/, "");
+        const buf = Buffer.from(b64, "base64");
+        form.append("image_file", new Blob([buf]), "image.png");
+    }
+    form.append("size", size);
+    form.append("type", type);
+    const resp = await fetch("https://api.remove.bg/v1.0/removebg", {
+        method: "POST",
+        headers: { "X-Api-Key": apiKey },
+        body: form,
+    });
+    if (!resp.ok) {
+        const errText = await resp.text().catch(() => resp.statusText);
+        return { success: false, error: `remove.bg API error ${resp.status}: ${errText}` };
+    }
+    const resultBuffer = Buffer.from(await resp.arrayBuffer());
+    const sourceRef = imageUrl || "base64-input";
+    const { file_url, media_id, file_name } = await uploadResult(sb, storeId, resultBuffer, sourceRef);
+    return {
+        success: true,
+        data: {
+            file_url,
+            media_id,
+            file_name,
+            file_size: resultBuffer.length,
+            source: sourceRef,
+        },
+    };
+}

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

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

package/dist/server/handlers/storefront.js

@@ -0,0 +1,477 @@
+// handlers/storefront.ts — Consumer-facing commerce tool for AI shopping agents.
+// Read-heavy, limited writes (cart + checkout). Only exposes published/active products.
+import { sanitizeFilterValue } from "../lib/utils.js";
+// ============================================================================
+// HELPERS
+// ============================================================================
+/** Resolve the primary display price from pricing_data JSON.
+ *  pricing_data is a Record<tierName, { default_price?, price?, ... }>.
+ *  Returns the first tier's default_price or price, or 0. */
+function resolvePrimaryPrice(pricingData) {
+    if (!pricingData || typeof pricingData !== "object")
+        return 0;
+    const tiers = Object.values(pricingData);
+    if (tiers.length === 0)
+        return 0;
+    return tiers[0].default_price ?? tiers[0].price ?? 0;
+}
+/** Format pricing tiers for consumer display (name + price, no cost data). */
+function formatPricingTiers(pricingData) {
+    if (!pricingData || typeof pricingData !== "object")
+        return null;
+    const entries = Object.entries(pricingData);
+    if (entries.length === 0)
+        return null;
+    return entries.map(([tier, data]) => ({
+        tier,
+        price: data.default_price ?? data.price ?? 0,
+    }));
+}
+/** Strip internal/admin fields from a product row for public display. */
+function filterPublicFields(product) {
+    const { cost_price, wholesale_price, is_wholesale, wholesale_only, minimum_wholesale_quantity, manage_stock, tax_status, tax_class, catalog_id, pricing_schema_id, ...publicFields } = product;
+    return publicFields;
+}
+// ============================================================================
+// MAIN HANDLER
+// ============================================================================
+export async function handleStorefront(sb, args, storeId) {
+    const sid = storeId;
+    switch (args.action) {
+        // ======================== BROWSE ========================
+        case "browse": {
+            const page = args.page || 1;
+            const perPage = Math.min(args.per_page || 20, 50);
+            const offset = (page - 1) * perPage;
+            let q = sb.from("products")
+                .select("id, name, sku, slug, short_description, featured_image, pricing_data, status, primary_category_id, featured", { count: "exact" })
+                .eq("store_id", sid)
+                .in("status", ["published", "active"])
+                .order("created_at", { ascending: false })
+                .range(offset, offset + perPage - 1);
+            if (args.category_id) {
+                const catId = args.category_id;
+                // Include sub-categories
+                const { data: children } = await sb.from("categories").select("id").eq("parent_id", catId).eq("store_id", sid);
+                const catIds = [catId, ...(children || []).map((c) => c.id)];
+                q = q.in("primary_category_id", catIds);
+            }
+            if (args.featured === true)
+                q = q.eq("featured", true);
+            const sortBy = args.sort;
+            if (sortBy === "price_asc" || sortBy === "price_desc") {
+                // price sort not directly supported on JSON column — sort in JS below
+            }
+            else if (sortBy === "name") {
+                q = q.order("name", { ascending: true });
+            }
+            const { data, error, count } = await q;
+            if (error)
+                return { success: false, error: error.message };
+            let products = (data || []).map((p) => ({
+                ...filterPublicFields(p),
+                price: resolvePrimaryPrice(p.pricing_data),
+                pricing_tiers: formatPricingTiers(p.pricing_data),
+            }));
+            // Client-side price sort when requested
+            if (sortBy === "price_asc")
+                products.sort((a, b) => a.price - b.price);
+            if (sortBy === "price_desc")
+                products.sort((a, b) => b.price - a.price);
+            return {
+                success: true,
+                data: {
+                    products,
+                    page,
+                    per_page: perPage,
+                    total: count || 0,
+                    total_pages: Math.ceil((count || 0) / perPage),
+                },
+            };
+        }
+        // ======================== PRODUCT DETAIL ========================
+        case "product_detail": {
+            const pid = args.product_id;
+            if (!pid)
+                return { success: false, error: "product_id is required" };
+            const { data: product, error: pErr } = await sb.from("products")
+                .select("*, category:categories!primary_category_id(id, name, slug)")
+                .eq("id", pid)
+                .eq("store_id", sid)
+                .in("status", ["published", "active"])
+                .single();
+            if (pErr || !product)
+                return { success: false, error: "Product not found or not available" };
+            // Inventory availability per location
+            const { data: inventory } = await sb.from("inventory")
+                .select("quantity, location:locations!location_id(id, name)")
+                .eq("product_id", pid)
+                .eq("store_id", sid)
+                .gt("quantity", 0);
+            return {
+                success: true,
+                data: {
+                    ...filterPublicFields(product),
+                    price: resolvePrimaryPrice(product.pricing_data),
+                    pricing_tiers: formatPricingTiers(product.pricing_data),
+                    availability: (inventory || []).map((inv) => ({
+                        location_id: inv.location?.id,
+                        location_name: inv.location?.name,
+                        in_stock: (inv.quantity ?? 0) > 0,
+                        quantity: inv.quantity,
+                    })),
+                },
+            };
+        }
+        // ======================== SEARCH ========================
+        case "search": {
+            const query = args.query;
+            if (!query)
+                return { success: false, error: "query is required" };
+            const sq = sanitizeFilterValue(query);
+            const limit = Math.min(args.limit || 20, 50);
+            const { data, error } = await sb.from("products")
+                .select("id, name, sku, slug, short_description, featured_image, pricing_data, status, primary_category_id")
+                .eq("store_id", sid)
+                .in("status", ["published", "active"])
+                .or(`name.ilike.%${sq}%,description.ilike.%${sq}%,sku.ilike.%${sq}%`)
+                .order("name")
+                .limit(limit);
+            if (error)
+                return { success: false, error: error.message };
+            const products = (data || []).map((p) => ({
+                ...filterPublicFields(p),
+                price: resolvePrimaryPrice(p.pricing_data),
+            }));
+            return { success: true, data: { products, count: products.length, query } };
+        }
+        // ======================== CATEGORIES ========================
+        case "categories": {
+            const { data, error } = await sb.from("categories")
+                .select("id, name, slug, description, icon, parent_id, display_order, product_count")
+                .eq("store_id", sid)
+                .eq("is_active", true)
+                .order("display_order", { ascending: true });
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, data: { categories: data || [] } };
+        }
+        // ======================== CART CREATE ========================
+        case "cart_create": {
+            // Resolve default location if not provided
+            let locationId = args.location_id;
+            if (!locationId) {
+                const { data: loc } = await sb.from("locations")
+                    .select("id")
+                    .eq("store_id", sid)
+                    .eq("is_active", true)
+                    .limit(1)
+                    .single();
+                if (loc)
+                    locationId = loc.id;
+            }
+            const expiresAt = new Date(Date.now() + 4 * 60 * 60 * 1000).toISOString();
+            const record = {
+                store_id: sid,
+                status: "active",
+                expires_at: expiresAt,
+            };
+            if (locationId)
+                record.location_id = locationId;
+            if (args.customer_id)
+                record.customer_id = args.customer_id;
+            if (args.customer_email)
+                record.customer_email = args.customer_email;
+            const { data, error } = await sb.from("carts").insert(record).select().single();
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, data: { cart: data, items: [] } };
+        }
+        // ======================== CART ADD ========================
+        case "cart_add": {
+            const cartId = args.cart_id;
+            const productId = args.product_id;
+            const quantity = args.quantity || 1;
+            if (!cartId)
+                return { success: false, error: "cart_id is required" };
+            if (!productId)
+                return { success: false, error: "product_id is required" };
+            if (quantity < 1)
+                return { success: false, error: "quantity must be at least 1" };
+            // Validate cart is active
+            const { data: cart, error: cartErr } = await sb.from("carts")
+                .select("id, status")
+                .eq("id", cartId)
+                .eq("store_id", sid)
+                .single();
+            if (cartErr || !cart)
+                return { success: false, error: "Cart not found" };
+            if (cart.status !== "active")
+                return { success: false, error: "Cart is not active" };
+            // Validate product is published
+            const { data: product, error: prodErr } = await sb.from("products")
+                .select("id, name, sku, status, pricing_data")
+                .eq("id", productId)
+                .eq("store_id", sid)
+                .single();
+            if (prodErr || !product)
+                return { success: false, error: "Product not found" };
+            if (product.status !== "published" && product.status !== "active") {
+                return { success: false, error: "Product is not available for purchase" };
+            }
+            // Resolve price from pricing_data
+            let unitPrice = args.unit_price;
+            if (unitPrice === undefined) {
+                if (product.pricing_data) {
+                    const pd = product.pricing_data;
+                    if (args.tier && pd[args.tier]) {
+                        unitPrice = pd[args.tier].default_price ?? pd[args.tier].price ?? 0;
+                    }
+                    else {
+                        unitPrice = resolvePrimaryPrice(pd);
+                    }
+                }
+                else {
+                    unitPrice = 0;
+                }
+            }
+            const itemRecord = {
+                cart_id: cartId,
+                product_id: productId,
+                product_name: product.name,
+                sku: product.sku,
+                quantity,
+                unit_price: unitPrice,
+            };
+            if (args.tier)
+                itemRecord.tier_label = args.tier;
+            const { data: item, error: insertErr } = await sb.from("cart_items")
+                .insert(itemRecord).select().single();
+            if (insertErr)
+                return { success: false, error: insertErr.message };
+            return { success: true, data: { item, line_total: Math.round(quantity * (unitPrice || 0) * 100) / 100 } };
+        }
+        // ======================== CART VIEW ========================
+        case "cart_view": {
+            const cartId = args.cart_id;
+            if (!cartId)
+                return { success: false, error: "cart_id is required" };
+            const { data: cart, error: cartErr } = await sb.from("carts")
+                .select("*")
+                .eq("id", cartId)
+                .eq("store_id", sid)
+                .single();
+            if (cartErr || !cart)
+                return { success: false, error: "Cart not found" };
+            const { data: items } = await sb.from("cart_items")
+                .select("*")
+                .eq("cart_id", cartId)
+                .order("created_at", { ascending: true });
+            const cartItems = items || [];
+            const subtotal = cartItems.reduce((sum, i) => sum + (i.quantity ?? 0) * (i.unit_price ?? 0), 0);
+            return {
+                success: true,
+                data: {
+                    cart: { id: cart.id, status: cart.status, expires_at: cart.expires_at },
+                    items: cartItems.map((i) => ({
+                        id: i.id,
+                        product_id: i.product_id,
+                        product_name: i.product_name,
+                        sku: i.sku,
+                        quantity: i.quantity,
+                        unit_price: i.unit_price,
+                        line_total: Math.round((i.quantity ?? 0) * (i.unit_price ?? 0) * 100) / 100,
+                        tier_label: i.tier_label,
+                    })),
+                    subtotal: Math.round(subtotal * 100) / 100,
+                    item_count: cartItems.length,
+                },
+            };
+        }
+        // ======================== CART UPDATE ========================
+        case "cart_update": {
+            const cartId = args.cart_id;
+            const itemId = args.item_id;
+            const quantity = args.quantity;
+            if (!cartId)
+                return { success: false, error: "cart_id is required" };
+            if (!itemId)
+                return { success: false, error: "item_id is required" };
+            if (!quantity || quantity < 1)
+                return { success: false, error: "quantity must be a positive integer" };
+            // Validate cart is active
+            const { data: cart } = await sb.from("carts")
+                .select("id, status")
+                .eq("id", cartId)
+                .eq("store_id", sid)
+                .single();
+            if (!cart)
+                return { success: false, error: "Cart not found" };
+            if (cart.status !== "active")
+                return { success: false, error: "Cart is not active" };
+            const { data, error } = await sb.from("cart_items")
+                .update({ quantity, updated_at: new Date().toISOString() })
+                .eq("id", itemId)
+                .eq("cart_id", cartId)
+                .select()
+                .single();
+            if (error || !data)
+                return { success: false, error: error?.message || "Cart item not found" };
+            return {
+                success: true,
+                data: {
+                    item: data,
+                    line_total: Math.round(data.quantity * (data.unit_price ?? 0) * 100) / 100,
+                },
+            };
+        }
+        // ======================== CART REMOVE ========================
+        case "cart_remove": {
+            const cartId = args.cart_id;
+            const itemId = args.item_id;
+            if (!cartId)
+                return { success: false, error: "cart_id is required" };
+            if (!itemId)
+                return { success: false, error: "item_id is required" };
+            // Validate cart is active
+            const { data: cart } = await sb.from("carts")
+                .select("id, status")
+                .eq("id", cartId)
+                .eq("store_id", sid)
+                .single();
+            if (!cart)
+                return { success: false, error: "Cart not found" };
+            if (cart.status !== "active")
+                return { success: false, error: "Cart is not active" };
+            const { error } = await sb.from("cart_items")
+                .delete()
+                .eq("id", itemId)
+                .eq("cart_id", cartId);
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, data: { removed: true, item_id: itemId } };
+        }
+        // ======================== CHECKOUT ========================
+        case "checkout": {
+            const cartId = args.cart_id;
+            if (!cartId)
+                return { success: false, error: "cart_id is required" };
+            // 1. Validate cart
+            const { data: cart, error: cartErr } = await sb.from("carts")
+                .select("*")
+                .eq("id", cartId)
+                .eq("store_id", sid)
+                .single();
+            if (cartErr || !cart)
+                return { success: false, error: "Cart not found" };
+            if (cart.status !== "active")
+                return { success: false, error: "Cart is not active" };
+            // 2. Fetch cart items
+            const { data: cartItems, error: itemsErr } = await sb.from("cart_items")
+                .select("*")
+                .eq("cart_id", cartId)
+                .order("created_at", { ascending: true });
+            if (itemsErr)
+                return { success: false, error: itemsErr.message };
+            if (!cartItems || cartItems.length === 0)
+                return { success: false, error: "Cart has no items" };
+            // 3. Compute totals
+            const subtotal = cartItems.reduce((sum, i) => sum + (i.quantity ?? 0) * (i.unit_price ?? 0), 0);
+            const taxAmount = cart.tax_amount ?? 0;
+            const total = Math.round((subtotal + taxAmount) * 100) / 100;
+            const roundedSubtotal = Math.round(subtotal * 100) / 100;
+            // 4. Generate sequential order number
+            const { data: maxOrder } = await sb.from("orders")
+                .select("order_number")
+                .eq("store_id", sid)
+                .order("created_at", { ascending: false })
+                .limit(1)
+                .single();
+            let nextNum = 10001;
+            if (maxOrder?.order_number) {
+                const parsed = parseInt(maxOrder.order_number.replace("#", ""), 10);
+                if (!isNaN(parsed))
+                    nextNum = parsed + 1;
+            }
+            const orderNumber = `#${String(nextNum).padStart(5, "0")}`;
+            // 5. Insert order
+            const orderRecord = {
+                store_id: sid,
+                location_id: cart.location_id ?? null,
+                customer_id: cart.customer_id ?? null,
+                order_number: orderNumber,
+                channel: "online",
+                status: "pending",
+                subtotal: roundedSubtotal,
+                tax_amount: Math.round(taxAmount * 100) / 100,
+                total_amount: total,
+                payment_method: "pending",
+                payment_status: "pending",
+            };
+            const { data: order, error: orderErr } = await sb.from("orders")
+                .insert(orderRecord).select().single();
+            if (orderErr)
+                return { success: false, error: orderErr.message };
+            // 6. Bulk insert order_items
+            const orderItems = cartItems.map((ci) => ({
+                order_id: order.id,
+                product_id: ci.product_id,
+                product_name: ci.product_name,
+                quantity: ci.quantity,
+                unit_price: ci.unit_price,
+                line_total: Math.round((ci.quantity ?? 0) * (ci.unit_price ?? 0) * 100) / 100,
+                variant_id: ci.variant_id ?? null,
+                variant_name: ci.variant_name ?? null,
+                tier_label: ci.tier_label ?? null,
+            }));
+            await sb.from("order_items").insert(orderItems);
+            // 7. Deduct inventory per item (best-effort)
+            const locationId = cart.location_id;
+            if (locationId) {
+                for (const ci of cartItems) {
+                    try {
+                        await sb.rpc("atomic_inventory_adjust", {
+                            p_store_id: sid,
+                            p_product_id: ci.product_id,
+                            p_location_id: locationId,
+                            p_adjustment: -(ci.quantity ?? 0),
+                            p_reason: "sale",
+                        });
+                    }
+                    catch {
+                        // Inventory deduction non-critical — order still stands
+                    }
+                }
+            }
+            // 8. Mark cart as completed
+            await sb.from("carts")
+                .update({ status: "completed", updated_at: new Date().toISOString() })
+                .eq("id", cartId)
+                .eq("store_id", sid);
+            // 9. Return order summary
+            return {
+                success: true,
+                data: {
+                    order_id: order.id,
+                    order_number: orderNumber,
+                    status: "pending",
+                    subtotal: roundedSubtotal,
+                    tax_amount: Math.round(taxAmount * 100) / 100,
+                    total,
+                    items: orderItems.map((oi) => ({
+                        product_id: oi.product_id,
+                        product_name: oi.product_name,
+                        quantity: oi.quantity,
+                        unit_price: oi.unit_price,
+                        line_total: oi.line_total,
+                    })),
+                },
+            };
+        }
+        default:
+            return {
+                success: false,
+                error: `Unknown storefront action: ${args.action}. Valid: browse, product_detail, search, categories, cart_create, cart_add, cart_view, cart_update, cart_remove, checkout`,
+            };
+    }
+}

package/dist/server/handlers/supply-chain.js

@@ -140,14 +140,32 @@ export async function handlePurchaseOrders(sb, args, storeId) {
             if (poErr || !po)
                 return { success: false, error: poErr?.message || "PO not found" };
             // If caller provides specific items use those, otherwise receive all remaining
-            const receiveItems = args.items
-                ? args.items
-                : (po.items || [])
+            const poItems = po.items || [];
+            let receiveItems;
+            if (args.items) {
+                // Normalize caller-provided items: accept item_id, po_item_id, or product_id
+                const callerItems = args.items;
+                receiveItems = callerItems.map((ci) => {
+                    let itemId = ci.item_id || ci.po_item_id || ci.line_item_id;
+                    // If caller used product_id instead, resolve to PO line item ID
+                    if (!itemId && ci.product_id) {
+                        const match = poItems.find((pi) => pi.id === ci.product_id || pi.product_id === ci.product_id);
+                        if (match)
+                            itemId = match.id;
+                    }
+                    return { item_id: itemId || null, quantity: Number(ci.quantity) || 0 };
+                }).filter((i) => i.item_id && i.quantity > 0);
+                if (!receiveItems.length)
+                    return { success: false, error: "No valid items to receive — provide item_id or product_id matching a PO line item" };
+            }
+            else {
+                receiveItems = poItems
                     .map((item) => ({
                     item_id: item.id,
                     quantity: Math.max((item.quantity || 0) - (item.received_quantity || 0), 0),
                 }))
                     .filter((item) => item.quantity > 0);
+            }
             if (!receiveItems.length)
                 return { success: false, error: "No items to receive (all fully received)" };
             const locationId = args.location_id || po.location_id;