@empline/preflight 1.1.0

package/dist/checks/integrations/integrations-consolidated.js

@@ -0,0 +1,912 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Consolidated Integrations Preflight
+ *
+ * Validates all platform integrations (Amazon, eBay, TCGPlayer, WooCommerce)
+ * to ensure they are properly implemented and maintain consistency.
+ *
+ * Checks:
+ * - Integration service files exist and have required methods
+ * - Feed error handling is implemented
+ * - Database schema supports all platforms
+ * - UI components display platform status
+ * - API routes are properly configured
+ *
+ * Usage:
+ *   pnpm preflight:integrations           # All checks
+ *   pnpm preflight:integrations --verbose # Detailed output
+ *   pnpm preflight:integrations amazon    # Single platform
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationsConsolidatedPreflight = exports.requires = exports.tags = exports.blocking = exports.category = exports.description = exports.name = exports.id = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// METADATA - Required for plugin loader discovery
+exports.id = "integrations/integrations-consolidated";
+exports.name = "Consolidated Integrations Validation";
+exports.description = "Validates Amazon, eBay, TCGPlayer, and WooCommerce integrations are properly implemented";
+exports.category = "integrations";
+exports.blocking = true;
+exports.tags = ["integrations", "amazon", "ebay", "tcgplayer", "woocommerce"];
+exports.requires = ["trading-card-system"];
+const INTEGRATIONS = [
+    {
+        name: "Amazon",
+        slug: "amazon",
+        integrationFile: "lib/integrations/amazon-client.ts",
+        feedServiceFile: "lib/integrations/amazon-feed-service.ts",
+        requiredExports: ["AmazonClient", "AmazonIntegration"],
+        requiredMethods: [
+            "testConnection",
+            "importListings",
+            "exportListing",
+            "importOrders",
+            "syncInventory",
+            "syncPrices",
+        ],
+        hasUI: true,
+        critical: false, // Client file exists, integration class may vary
+    },
+    {
+        name: "eBay",
+        slug: "ebay",
+        integrationFile: "lib/integrations/ebay-client.ts",
+        feedServiceFile: "lib/integrations/ebay-feed-service.ts",
+        requiredExports: ["EbayClient", "EbayIntegration"],
+        requiredMethods: [
+            "testConnection",
+            "importListings",
+            "exportListing",
+            "importOrders",
+            "syncInventory",
+        ],
+        hasUI: true,
+        critical: false, // Client file exists, integration class may vary
+    },
+    {
+        name: "TCGPlayer",
+        slug: "tcgplayer",
+        integrationFile: "lib/integrations/tcgplayer-feed-service.ts",
+        requiredExports: ["TcgplayerFeedService"],
+        requiredMethods: ["syncInventory"],
+        hasUI: true,
+        critical: false,
+    },
+    {
+        name: "Shopify",
+        slug: "shopify",
+        integrationFile: "lib/integrations/shopify-client.ts",
+        requiredExports: ["ShopifyClient"],
+        requiredMethods: ["testConnection"],
+        hasUI: true,
+        critical: false,
+    },
+    {
+        name: "Etsy",
+        slug: "etsy",
+        integrationFile: "lib/integrations/etsy-client.ts",
+        requiredExports: ["EtsyClient"],
+        requiredMethods: [],
+        hasUI: true,
+        critical: false,
+    },
+];
+class IntegrationsConsolidatedPreflight {
+    verbose;
+    targetPlatform;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.targetPlatform = options.platform || null;
+    }
+    fileExists(filePath) {
+        return fs.existsSync(path.join(process.cwd(), filePath));
+    }
+    readFile(filePath) {
+        const fullPath = path.join(process.cwd(), filePath);
+        if (!fs.existsSync(fullPath))
+            return null;
+        return fs.readFileSync(fullPath, "utf-8");
+    }
+    /**
+     * Validate a single integration
+     */
+    validateIntegration(config) {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        // Check integration file exists
+        if (!this.fileExists(config.integrationFile)) {
+            if (config.critical) {
+                errors.push(`Integration file not found: ${config.integrationFile}`);
+            }
+            else {
+                warnings.push(`Integration not yet implemented: ${config.integrationFile}`);
+            }
+            return {
+                name: `${config.name} Integration`,
+                passed: !config.critical,
+                duration: Date.now() - startTime,
+                errors,
+                warnings,
+            };
+        }
+        const content = this.readFile(config.integrationFile);
+        if (!content) {
+            if (config.critical) {
+                errors.push(`Could not read integration file: ${config.integrationFile}`);
+            }
+            else {
+                warnings.push(`Could not read integration file: ${config.integrationFile}`);
+            }
+            return {
+                name: `${config.name} Integration`,
+                passed: !config.critical,
+                duration: Date.now() - startTime,
+                errors,
+                warnings,
+            };
+        }
+        // Check for required exports
+        for (const exportName of config.requiredExports) {
+            if (!content.includes(`export class ${exportName}`) &&
+                !content.includes(`export { ${exportName}`)) {
+                if (config.critical) {
+                    errors.push(`Missing required export: ${exportName}`);
+                }
+                else {
+                    warnings.push(`Missing required export: ${exportName}`);
+                }
+            }
+        }
+        // Check for required methods
+        for (const method of config.requiredMethods) {
+            const methodPattern = new RegExp(`(async\\s+${method}|${method}\\s*\\(|override\\s+async\\s+${method})`, "m");
+            if (!methodPattern.test(content)) {
+                if (config.critical) {
+                    errors.push(`Missing required method: ${method}`);
+                }
+                else {
+                    warnings.push(`Missing required method: ${method}`);
+                }
+            }
+        }
+        // Check for proper error handling
+        if (!content.includes("IntegrationError") && !content.includes("throw new Error")) {
+            warnings.push("Consider using IntegrationError for consistent error handling");
+        }
+        // Check for base integration extension
+        if (!content.includes("extends BaseIntegration")) {
+            warnings.push("Consider extending BaseIntegration for consistent behavior");
+        }
+        // Check feed service if applicable
+        if (config.feedServiceFile) {
+            if (!this.fileExists(config.feedServiceFile)) {
+                warnings.push(`Feed service not yet implemented: ${config.feedServiceFile}`);
+            }
+        }
+        return {
+            name: `${config.name} Integration`,
+            passed: errors.length === 0,
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate integration UI consistency
+     * - Must use IntegrationStepper (not raw Stepper)
+     * - Must use useStatusSafe for toast notifications (not inline Alert for success)
+     */
+    validateUIConsistency() {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        const integrationUIFiles = [
+            "app/store/integrations/woocommerce/WooCommerceIntegrationClient.tsx",
+            "app/store/integrations/shopify/ShopifyIntegrationClient.tsx",
+            "app/store/integrations/etsy/page.tsx",
+            "app/store/integrations/ebay/page.tsx",
+            "app/store/integrations/amazon/page.tsx",
+            "app/store/integrations/walmart/WalmartIntegrationClient.tsx",
+            "app/store/integrations/tiktok-shop/TikTokShopIntegrationClient.tsx",
+            "app/store/integrations/whatnot/WhatnotIntegrationClient.tsx",
+            "app/store/integrations/csv/page.tsx",
+        ];
+        for (const filePath of integrationUIFiles) {
+            if (!this.fileExists(filePath))
+                continue;
+            const content = this.readFile(filePath);
+            if (!content)
+                continue;
+            const fileName = path.basename(filePath);
+            const lines = content.split("\n");
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 1: Must use IntegrationStepper (not raw Stepper)
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("<Stepper") && !content.includes("IntegrationStepper")) {
+                errors.push(`${fileName}: Use IntegrationStepper instead of raw Stepper`);
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 2: Should use useStatusSafe for toast notifications
+            // ═══════════════════════════════════════════════════════════════════
+            const successMessagePatterns = [
+                /connected successfully/i,
+                /connection test successful/i,
+                /import completed/i,
+                /export completed/i,
+                /sync completed/i,
+                /saved successfully/i,
+                /configuration saved/i,
+                /smart mapping generated/i,
+                /fields? mapped/i,
+                /\d+ fields? \(\d+ required\)/i,
+            ];
+            const hasSuccessMessage = successMessagePatterns.some((pattern) => pattern.test(content));
+            if (hasSuccessMessage) {
+                // Check for inline Alert with success severity (should use toast instead)
+                // Pattern: <Alert ... severity="success"> with success message text
+                const alertSuccessPattern = /<Alert[^>]*severity=["']success["'][^>]*>[\s\S]*?(generated|completed|saved|mapped|successful)/i;
+                const hasInlineSuccessAlert = alertSuccessPattern.test(content) && !content.includes("useStatusSafe");
+                if (hasInlineSuccessAlert) {
+                    // This is now an error - success messages should use toast
+                    errors.push(`${fileName}: Use useStatusSafe toast for success messages instead of inline Alert with severity="success"`);
+                }
+                // If they have success messages but no toast system at all, that's an error
+                if (!content.includes("useStatusSafe") && !content.includes("success(") && !content.includes("UnifiedStatus")) {
+                    errors.push(`${fileName}: Must use useStatusSafe for success/error notifications`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 3: IntegrationStepper must always be visible (not conditional)
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("IntegrationStepper")) {
+                // Pattern 1: {condition && <IntegrationStepper
+                if (/\{[^}]*&&\s*<IntegrationStepper/.test(content)) {
+                    errors.push(`${fileName}: IntegrationStepper should always be visible, not conditionally rendered`);
+                }
+                // Pattern 2: {condition ? <IntegrationStepper : null}
+                if (/\{[^}]*\?\s*<IntegrationStepper/.test(content)) {
+                    errors.push(`${fileName}: IntegrationStepper should always be visible, not in ternary`);
+                }
+                // Pattern 3: connectionStatus === "connected" && <IntegrationStepper
+                if (/connectionStatus\s*===?\s*["']connected["']\s*&&/.test(content)) {
+                    errors.push(`${fileName}: IntegrationStepper visibility should not depend on connection status`);
+                }
+            }
+            else {
+                // Integration page should have IntegrationStepper
+                if (filePath.includes("/integrations/") &&
+                    !filePath.includes("/api/") &&
+                    !filePath.includes("shippo") &&
+                    !filePath.includes("shipstation") &&
+                    !filePath.includes("webhook") &&
+                    !filePath.includes("rest-api") &&
+                    !filePath.includes("reconcile")) {
+                    warnings.push(`${fileName}: Consider adding IntegrationStepper for consistent UX`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 4: Must use SellerPageLayout wrapper (or be wrapped by page.tsx)
+            // ═══════════════════════════════════════════════════════════════════
+            const isClientComponent = fileName.includes("Client");
+            if (!content.includes("SellerPageLayout") && !isClientComponent) {
+                errors.push(`${fileName}: Must use SellerPageLayout wrapper`);
+            }
+            // For client components, check if there's a corresponding page.tsx with SellerPageLayout
+            if (isClientComponent) {
+                const pageFilePath = filePath.replace(/[^/]+$/, "page.tsx");
+                const pageContent = this.readFile(pageFilePath);
+                if (pageContent && !pageContent.includes("SellerPageLayout")) {
+                    errors.push(`${fileName}: Parent page.tsx must use SellerPageLayout wrapper`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 5: Must have proper error handling with showError
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("catch") && content.includes("error")) {
+                if (!content.includes("showError") && !content.includes("error:")) {
+                    warnings.push(`${fileName}: Consider using showError from useStatusSafe for error handling`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 6: Steps array should be defined as const (not inline)
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("IntegrationStepper")) {
+                const hasStepsConst = /const\s+\w*[Ss]teps\s*=\s*\[/.test(content) ||
+                    /const\s+STEPS\s*=\s*\[/.test(content) ||
+                    /const\s+\w+_STEPS\s*=\s*\[/.test(content) ||
+                    // Also accept referencing imported steps constants
+                    /const\s+STEPS\s*=\s*\w+_STEPS/.test(content) ||
+                    /import.*STEPS/.test(content);
+                if (!hasStepsConst) {
+                    warnings.push(`${fileName}: Define steps as a const array (e.g., const STEPS = [...])`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 7: Must have loading state for async operations
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("async") && content.includes("fetch(")) {
+                if (!content.includes("isLoading") && !content.includes("loading")) {
+                    warnings.push(`${fileName}: Consider adding loading state for async operations`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 8: Config state should use proper typing
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("useState") && content.includes("config")) {
+                // Check for typed useState with any type annotation
+                const hasTypedConfig = /useState<\w+Config>/.test(content) ||
+                    /useState<\w+>.*config/i.test(content) ||
+                    // Also accept hooks that return typed config
+                    /use\w+Config/.test(content);
+                if (!hasTypedConfig) {
+                    warnings.push(`${fileName}: Consider typing config state (e.g., useState<WooCommerceConfig>)`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 9: No duplicate form fields (credential fields shown twice)
+            // ═══════════════════════════════════════════════════════════════════
+            const credentialFields = ["storeUrl", "consumerKey", "consumerSecret", "apiKey", "accessToken"];
+            for (const field of credentialFields) {
+                const fieldRegex = new RegExp(`label=["'].*${field}`, "gi");
+                const matches = content.match(fieldRegex);
+                if (matches && matches.length > 1) {
+                    errors.push(`${fileName}: Duplicate form field detected: ${field} appears ${matches.length} times`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 10: MarketplaceLogo should be used for integration headers
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("UnifiedHeader") && !content.includes("MarketplaceLogo")) {
+                const integrationName = fileName.replace(/Client\.tsx$|\.tsx$/, "").toLowerCase();
+                if (["woocommerce", "shopify", "etsy", "ebay", "amazon", "walmart", "tiktok", "whatnot"].some((name) => integrationName.includes(name))) {
+                    warnings.push(`${fileName}: Consider using MarketplaceLogo in UnifiedHeader icon prop`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 11: API endpoints should use consistent naming pattern
+            // ═══════════════════════════════════════════════════════════════════
+            const apiCallMatches = content.match(/fetch\s*\(\s*["'`]([^"'`]+)["'`]/g) || [];
+            for (const apiCall of apiCallMatches) {
+                const endpoint = apiCall.match(/["'`]([^"'`]+)["'`]/)?.[1] || "";
+                // Check for inconsistent API patterns
+                if (endpoint.includes("/api/") && !endpoint.includes("/api/store/") && !endpoint.includes("/api/integrations/")) {
+                    warnings.push(`${fileName}: API endpoint "${endpoint}" should follow /api/store/integrations/ or /api/integrations/ pattern`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 12: Must disable buttons during loading state
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("isLoading")) {
+                const buttonMatches = content.match(/<Button[^>]*>/g) || [];
+                const hasDisabledLoading = buttonMatches.some((btn) => btn.includes("disabled") && (btn.includes("isLoading") || btn.includes("loading")));
+                if (buttonMatches.length > 0 && !hasDisabledLoading) {
+                    warnings.push(`${fileName}: Consider disabling buttons during loading state (disabled={isLoading})`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 13: Test connection should be separate from save/submit
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("testConnection") || content.includes("Test Connection")) {
+                if (!content.includes("handleTestConnection") && !content.includes("onTestConnection")) {
+                    warnings.push(`${fileName}: Consider extracting test connection to a dedicated handler function`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 14: Credentials should use password type for secrets
+            // ═══════════════════════════════════════════════════════════════════
+            const secretFields = ["secret", "token", "password", "apiKey", "accessToken"];
+            for (const field of secretFields) {
+                const fieldPattern = new RegExp(`label=["'][^"']*${field}[^"']*["']`, "gi");
+                if (fieldPattern.test(content)) {
+                    const hasPasswordType = new RegExp(`${field}[\\s\\S]{0,200}type=["']password["']`, "gi").test(content);
+                    if (!hasPasswordType) {
+                        warnings.push(`${fileName}: Field containing "${field}" should use type="password" for security`);
+                    }
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 16: Form validation before submission
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("handleSubmit") || content.includes("handleConnect") || content.includes("handleSave")) {
+                if (!content.includes("disabled=") && !content.includes("isValid")) {
+                    warnings.push(`${fileName}: Consider adding form validation before submission`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 17: Consistent step naming convention
+            // ═══════════════════════════════════════════════════════════════════
+            const stepsMatch = content.match(/const\s+\w*[Ss]teps\s*=\s*\[([\s\S]*?)\]/);
+            if (stepsMatch) {
+                const stepsContent = stepsMatch[1];
+                // Check for common step names that should be consistent
+                const expectedFirstSteps = ["Connect", "Connection", "Store Connection", "Configuration", "Setup"];
+                const hasProperFirstStep = expectedFirstSteps.some((step) => stepsContent.includes(step));
+                if (!hasProperFirstStep) {
+                    warnings.push(`${fileName}: First step should be connection/configuration related`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 18: No hardcoded URLs (should use env vars or constants)
+            // ═══════════════════════════════════════════════════════════════════
+            const hardcodedUrls = content.match(/https?:\/\/[a-zA-Z0-9.-]+\.(com|io|org|net)/g) || [];
+            const allowedDomains = ["example.com", "yourstore.com", "placeholder"];
+            for (const url of hardcodedUrls) {
+                const isAllowed = allowedDomains.some((domain) => url.includes(domain));
+                const isInComment = lines.some((line) => line.includes("//") && line.includes(url));
+                const isInPlaceholder = content.includes(`placeholder="${url}"`) || content.includes(`placeholder={"${url}"}`);
+                if (!isAllowed && !isInComment && !isInPlaceholder) {
+                    warnings.push(`${fileName}: Hardcoded URL "${url}" - consider using environment variable`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 19: Should handle network errors gracefully
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("fetch(")) {
+                if (!content.includes("catch") && !content.includes(".catch")) {
+                    errors.push(`${fileName}: fetch() calls must have error handling (try/catch or .catch())`);
+                }
+                if (!content.includes("response.ok") && !content.includes("!response.ok")) {
+                    warnings.push(`${fileName}: Consider checking response.ok for non-2xx status codes`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 20: Accessibility - buttons should have aria labels or text
+            // ═══════════════════════════════════════════════════════════════════
+            const iconOnlyButtons = content.match(/<IconButton[^>]*>/g) || [];
+            for (const btn of iconOnlyButtons) {
+                if (!btn.includes("aria-label") && !btn.includes("label=")) {
+                    warnings.push(`${fileName}: IconButton should have aria-label or label prop for accessibility`);
+                    break; // Only warn once per file
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 21: Should use CardSection or CardSectionHeader for consistency
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("<Card>") && content.includes("<CardContent>")) {
+                if (!content.includes("CardSection") && !content.includes("CardSectionHeader")) {
+                    warnings.push(`${fileName}: Consider using CardSection or CardSectionHeader for consistent card styling`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 22: TextField should have slotProps for label shrink
+            // ═══════════════════════════════════════════════════════════════════
+            const textFieldCount = (content.match(/<TextField/g) || []).length;
+            const shrinkCount = (content.match(/slotProps.*inputLabel.*shrink/g) || []).length;
+            if (textFieldCount > 0 && shrinkCount < textFieldCount) {
+                warnings.push(`${fileName}: TextFields should have slotProps={{ inputLabel: { shrink: true } }} for consistent label behavior`);
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 23: Wizard/multi-step should have reset functionality
+            // ═══════════════════════════════════════════════════════════════════
+            if (content.includes("activeStep") && content.includes("setActiveStep")) {
+                if (!content.includes("handleReset") && !content.includes("onReset") && !content.includes("setActiveStep(0)")) {
+                    warnings.push(`${fileName}: Multi-step wizard should have reset functionality`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 24: Import order - shared components before local
+            // ═══════════════════════════════════════════════════════════════════
+            const importLines = lines.filter((line) => line.startsWith("import"));
+            let foundLocal = false;
+            for (const importLine of importLines) {
+                if (importLine.includes("./") || importLine.includes("../")) {
+                    foundLocal = true;
+                }
+                if (foundLocal && importLine.includes("@/components/shared")) {
+                    warnings.push(`${fileName}: Import order - @/components/shared should come before local imports`);
+                    break;
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 25: Auto-save credentials on successful connection
+            // ═══════════════════════════════════════════════════════════════════
+            // Integrations with credential fields should save config after successful connection
+            const hasCredentialFields = credentialFields.some((field) => content.includes(field));
+            const hasTestConnection = content.includes("handleTestConnection") || content.includes("testConnection");
+            if (hasCredentialFields && hasTestConnection) {
+                // Check if there's a save/persist mechanism after connection
+                const hasSaveAfterConnect = content.includes("saveIntegrationConfig") ||
+                    content.includes("saveConfig") ||
+                    content.includes("persistConfig") ||
+                    (content.includes("fetch") && content.includes("POST") && content.includes("/api/store/integrations/"));
+                if (!hasSaveAfterConnect) {
+                    warnings.push(`${fileName}: Should auto-save credentials after successful connection test (user shouldn't re-enter credentials)`);
+                }
+                // Check if there's a load mechanism on mount
+                const hasLoadOnMount = content.includes("loadSavedConfig") ||
+                    content.includes("loadConfig") ||
+                    content.includes("useEffect") && content.includes("GET") && content.includes("/api/store/integrations/");
+                if (!hasLoadOnMount) {
+                    warnings.push(`${fileName}: Should load saved credentials on mount (check for existing integration)`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 26: Product selection must support batch selection by category
+            // ═══════════════════════════════════════════════════════════════════
+            // For integrations that import products, must have category-based batch selection
+            const isProductImportIntegration = filePath.includes("woocommerce") ||
+                filePath.includes("shopify") ||
+                filePath.includes("ebay") ||
+                filePath.includes("amazon") ||
+                filePath.includes("etsy");
+            if (isProductImportIntegration && content.includes("ProductSelection")) {
+                // Check for category batch selection capability
+                const hasCategoryBatchSelection = content.includes("selectedCategories") ||
+                    content.includes("selectAllInCategories") ||
+                    content.includes("Batch Selection") ||
+                    content.includes("category chip");
+                if (!hasCategoryBatchSelection) {
+                    // Warning for now - feature enhancement, not blocking
+                    warnings.push(`${fileName}: Consider adding batch selection by category (e.g., "Select all Baseball Cards")`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 27: Integrations must support granular feature selection
+            // ═══════════════════════════════════════════════════════════════════
+            // Users should be able to independently enable/disable:
+            // - Import Products (create new listings from external platform)
+            // - Sync Inventory (keep stock levels in sync)
+            // - Sync Prices (keep prices in sync)
+            // - Sync Orders (import and sync order status)
+            if (isProductImportIntegration) {
+                const hasGranularFeatures = 
+                // New pattern: IntegrationFeatures with checkboxes
+                content.includes("IntegrationFeatures") ||
+                    content.includes("integrationFeatures") ||
+                    // Check for individual feature toggles
+                    (content.includes("importProducts") && content.includes("syncInventory")) ||
+                    (content.includes("syncOrders") && content.includes("syncPrices")) ||
+                    // Legacy pattern: ImportMode (still acceptable but deprecated)
+                    content.includes("importMode") ||
+                    content.includes("sync-only") ||
+                    content.includes("Sync Only");
+                if (!hasGranularFeatures) {
+                    warnings.push(`${fileName}: Consider using IntegrationFeatures for granular control (importProducts, syncInventory, syncPrices, syncOrders)`);
+                }
+                // Check specifically for order sync capability
+                const hasOrderSync = content.includes("syncOrders") ||
+                    content.includes("Sync Orders") ||
+                    content.includes("importOrders") ||
+                    content.includes("Order Sync");
+                if (!hasOrderSync) {
+                    warnings.push(`${fileName}: Consider adding order sync capability (syncOrders feature)`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 28: Product filters should be in separate card from product table
+            // ═══════════════════════════════════════════════════════════════════
+            // For better UX, filters should be visually separated from the product list
+            if (isProductImportIntegration && content.includes("ProductSelection")) {
+                const hasFilterCard = content.includes("Product Filters") ||
+                    content.includes("FilterBar") ||
+                    (content.includes("<Card") && content.includes("filter"));
+                if (!hasFilterCard) {
+                    warnings.push(`${fileName}: Consider separating product filters into their own Card for better UX`);
+                }
+            }
+            // ═══════════════════════════════════════════════════════════════════
+            // CHECK 29: Category counts must come from API (not just current page)
+            // ═══════════════════════════════════════════════════════════════════
+            // When displaying category chips for batch selection, counts should reflect
+            // total products across ALL pages, not just the currently loaded page
+            if (isProductImportIntegration && content.includes("ProductSelection")) {
+                // Check if there's a fetchCategories call or categories API usage
+                const hasCategoryApiCall = content.includes("fetchCategories") ||
+                    content.includes("/categories") ||
+                    content.includes("loadingCategories") ||
+                    // Also accept if categories are fetched from a dedicated endpoint
+                    content.includes("api/store/integrations") && content.includes("categories");
+                // Check for the anti-pattern: computing categories from loaded products only
+                const computesCategoriesFromProducts = content.includes("products.forEach") && content.includes("categories") ||
+                    content.includes("productsToScan") && content.includes("categoryMap");
+                if (computesCategoriesFromProducts && !hasCategoryApiCall) {
+                    warnings.push(`${fileName}: Category counts should come from API, not computed from current page products`);
+                }
+            }
+        }
+        return {
+            name: "Integration UI Consistency",
+            passed: errors.length === 0,
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate base integration class
+     */
+    validateBaseIntegration() {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        // Check for common integration utilities
+        const indexPath = "lib/integrations/index.ts";
+        if (!this.fileExists(indexPath)) {
+            warnings.push("Integration index file not found - consider adding lib/integrations/index.ts");
+        }
+        // Check for tracking sync service (common utility)
+        const trackingPath = "lib/integrations/tracking-sync-service.ts";
+        if (!this.fileExists(trackingPath)) {
+            warnings.push("Tracking sync service not found");
+        }
+        return {
+            name: "Base Integration",
+            passed: errors.length === 0,
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate integration configuration model
+     */
+    validateConfigModel() {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        const schemaPath = "prisma/schema.prisma";
+        const content = this.readFile(schemaPath);
+        if (!content) {
+            errors.push("Could not read Prisma schema");
+            return {
+                name: "Integration Config Model",
+                passed: false,
+                duration: Date.now() - startTime,
+                errors,
+                warnings,
+            };
+        }
+        // Check for IntegrationConfigs model (warning only - may use different name)
+        if (!content.includes("model IntegrationConfigs") &&
+            !content.includes("model StoreIntegrations")) {
+            warnings.push("Consider adding IntegrationConfigs model for storing platform credentials");
+        }
+        else {
+            // Check required fields
+            const requiredFields = ["platform", "configData", "isActive", "storeId"];
+            for (const field of requiredFields) {
+                if (!content.includes(field)) {
+                    warnings.push(`Integration config may be missing field: ${field}`);
+                }
+            }
+        }
+        // Check for platform enum or type
+        if (!content.includes("IntegrationPlatform") && !content.includes("platform")) {
+            warnings.push("Consider adding IntegrationPlatform enum for type safety");
+        }
+        return {
+            name: "Integration Config Model",
+            passed: true, // Warnings only, doesn't block
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate integration API routes
+     */
+    validateAPIRoutes() {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        const apiPaths = [
+            "app/api/integrations/route.ts",
+            "app/api/integrations/[platform]/route.ts",
+            "app/api/integrations/[platform]/test/route.ts",
+        ];
+        for (const apiPath of apiPaths) {
+            if (!this.fileExists(apiPath)) {
+                warnings.push(`API route not found: ${apiPath}`);
+            }
+        }
+        // Check for store-specific integration routes
+        const storeIntegrationPath = "app/api/store/integrations";
+        if (!this.fileExists(storeIntegrationPath)) {
+            warnings.push("Store integration API routes not found");
+        }
+        return {
+            name: "Integration API Routes",
+            passed: errors.length === 0,
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Run platform feed integrity check
+     */
+    async runFeedIntegrityCheck() {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        try {
+            (0, child_process_1.execSync)("tsx scripts/preflights/business-logic/integrations/platform-feed-integrity.ts", {
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+        }
+        catch (error) {
+            const output = error.stdout?.toString() || error.stderr?.toString() || "";
+            if (output.includes("FAILED")) {
+                errors.push("Platform feed integrity check failed");
+                // Extract specific errors from output
+                const errorLines = output
+                    .split("\n")
+                    .filter((line) => line.includes(console_chars_1.emoji.error) || line.includes("[ERR]"));
+                errors.push(...errorLines.slice(0, 5).map((l) => l.trim()));
+            }
+        }
+        return {
+            name: "Platform Feed Integrity",
+            passed: errors.length === 0,
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Run WooCommerce preflight if available
+     */
+    async runWooCommercePreflight() {
+        const startTime = Date.now();
+        const errors = [];
+        const warnings = [];
+        // preflight-ignore: Optional path - file may not exist
+        const wooPath = "scripts/active/preflights/consolidated/woocommerce.ts";
+        if (!this.fileExists(wooPath)) {
+            return null;
+        }
+        try {
+            (0, child_process_1.execSync)(`tsx ${wooPath}`, { stdio: "pipe", encoding: "utf-8" });
+        }
+        catch (error) {
+            const output = error.stdout?.toString() || error.stderr?.toString() || "";
+            if (output.includes("FAILED")) {
+                // WooCommerce is not critical, treat as warning
+                warnings.push("WooCommerce preflight has issues (non-blocking)");
+            }
+        }
+        return {
+            name: "WooCommerce Preflight",
+            passed: true, // Non-critical, always passes
+            duration: Date.now() - startTime,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Run all checks
+     */
+    async runAll() {
+        console.log("\n" + console_chars_1.emoji.globe + " CONSOLIDATED INTEGRATIONS PREFLIGHT");
+        console.log((0, console_chars_1.createDivider)(60, "heavy"));
+        const results = [];
+        // Filter integrations if specific platform requested
+        const targetSlug = this.targetPlatform?.toLowerCase();
+        const integrations = targetSlug
+            ? INTEGRATIONS.filter((i) => i.slug === targetSlug)
+            : INTEGRATIONS;
+        if (this.targetPlatform && integrations.length === 0) {
+            console.log(`${console_chars_1.emoji.warning} Unknown platform: ${this.targetPlatform}`);
+            console.log(`Available platforms: ${INTEGRATIONS.map((i) => i.slug).join(", ")}`);
+            return { passed: false, results: [] };
+        }
+        // Validate base integration
+        if (!this.targetPlatform) {
+            results.push(this.validateBaseIntegration());
+            results.push(this.validateConfigModel());
+            results.push(this.validateAPIRoutes());
+            results.push(this.validateUIConsistency());
+        }
+        // Validate each integration
+        for (const integration of integrations) {
+            results.push(this.validateIntegration(integration));
+        }
+        // Run feed integrity check
+        if (!this.targetPlatform || ["amazon", "ebay", "tcgplayer"].includes(this.targetPlatform)) {
+            results.push(await this.runFeedIntegrityCheck());
+        }
+        // Run WooCommerce preflight if checking all or WooCommerce specifically
+        if (!this.targetPlatform || this.targetPlatform === "woocommerce") {
+            const wooResult = await this.runWooCommercePreflight();
+            if (wooResult) {
+                results.push(wooResult);
+            }
+        }
+        // Print results
+        this.printResults(results);
+        const allPassed = results.every((r) => r.passed);
+        return { passed: allPassed, results };
+    }
+    printResults(results) {
+        console.log("\n" + (0, console_chars_1.createDivider)(60, "light"));
+        for (const result of results) {
+            const icon = result.passed ? console_chars_1.emoji.success : console_chars_1.emoji.error;
+            // Show ms for fast checks, seconds for slow ones
+            const time = result.duration < 1000
+                ? `${result.duration}ms`
+                : `${(result.duration / 1000).toFixed(1)}s`;
+            console.log(`${icon} ${result.name.padEnd(35)} ${time.padStart(8)}`);
+            if (this.verbose || !result.passed) {
+                for (const error of result.errors) {
+                    console.log(`   ${console_chars_1.emoji.error} ${error}`);
+                }
+            }
+            if (this.verbose && result.warnings.length > 0) {
+                for (const warning of result.warnings) {
+                    console.log(`   ${console_chars_1.emoji.warning} ${warning}`);
+                }
+            }
+        }
+        console.log("\n" + (0, console_chars_1.createDivider)(60, "heavy"));
+        const passed = results.filter((r) => r.passed).length;
+        const failed = results.filter((r) => !r.passed).length;
+        const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
+        const totalTime = results.reduce((sum, r) => sum + r.duration, 0);
+        console.log(`${console_chars_1.emoji.chart} Results: ${passed} passed, ${failed} failed`);
+        if (totalWarnings > 0) {
+            console.log(`${console_chars_1.emoji.warning} Warnings: ${totalWarnings}`);
+        }
+        console.log(`${console_chars_1.emoji.clock} Total time: ${(totalTime / 1000).toFixed(1)}s`);
+        if (failed === 0) {
+            console.log(`\n${console_chars_1.emoji.success} INTEGRATIONS PREFLIGHT PASSED`);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.error} INTEGRATIONS PREFLIGHT FAILED`);
+        }
+    }
+}
+exports.IntegrationsConsolidatedPreflight = IntegrationsConsolidatedPreflight;
+// CLI
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    const args = process.argv.slice(2);
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    // Get platform argument (first non-flag argument)
+    const platform = args.find((arg) => !arg.startsWith("-"));
+    const preflight = new IntegrationsConsolidatedPreflight({ verbose, platform });
+    const { passed } = await preflight.runAll();
+    process.exit(passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=integrations-consolidated.js.map