@pagebridge/cli 0.0.1 → 0.1.1

package/dist/commands/doctor.js

@@ -0,0 +1,353 @@
+import { Command } from "commander";
+import { createClient as createSanityClient } from "@sanity/client";
+import { GSCClient } from "@pagebridge/core";
+import { createDb, sql, searchAnalytics, queryAnalytics, syncLog, pageIndexStatus, unmatchDiagnostics, } from "@pagebridge/db";
+import { resolve } from "../resolve-config.js";
+import { log } from "../logger.js";
+import { existsSync, readFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+const ENV_FILES = [".env.local", ".env"];
+function loadEnvFile(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        // Don't overwrite existing env vars
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+}
+async function checkEnvFile() {
+    for (const name of ENV_FILES) {
+        const envPath = resolvePath(process.cwd(), name);
+        if (existsSync(envPath)) {
+            loadEnvFile(envPath);
+            return {
+                name: "Environment File",
+                status: "pass",
+                message: `${name} file found and loaded`,
+            };
+        }
+    }
+    return {
+        name: "Environment File",
+        status: "fail",
+        message: "No .env file found",
+        details: "Run 'pagebridge init' to create one (looks for .env.local, .env)",
+    };
+}
+async function checkEnvVars() {
+    const required = [
+        "GOOGLE_SERVICE_ACCOUNT",
+        "DATABASE_URL",
+        "SANITY_PROJECT_ID",
+        "SANITY_DATASET",
+        "SANITY_TOKEN",
+        "SITE_URL",
+    ];
+    const missing = required.filter((key) => !process.env[`PAGEBRIDGE_${key}`] && !process.env[key]);
+    if (missing.length > 0) {
+        return {
+            name: "Environment Variables",
+            status: "fail",
+            message: `Missing ${missing.length} required variables`,
+            details: `Missing: ${missing.map((k) => `PAGEBRIDGE_${k}`).join(", ")}`,
+        };
+    }
+    return {
+        name: "Environment Variables",
+        status: "pass",
+        message: "All required variables are set",
+    };
+}
+async function checkDatabase() {
+    const dbUrl = resolve(undefined, "DATABASE_URL");
+    if (!dbUrl) {
+        return {
+            name: "Database Connection",
+            status: "skip",
+            message: "DATABASE_URL not set",
+        };
+    }
+    try {
+        const { db, close } = createDb(dbUrl);
+        await db.execute(sql `SELECT 1`);
+        await close();
+        return {
+            name: "Database Connection",
+            status: "pass",
+            message: "Connected successfully",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Database Connection",
+            status: "fail",
+            message: "Connection failed",
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function checkDatabaseSchema() {
+    const dbUrl = resolve(undefined, "DATABASE_URL");
+    if (!dbUrl) {
+        return {
+            name: "Database Schema",
+            status: "skip",
+            message: "DATABASE_URL not set",
+        };
+    }
+    try {
+        const { db, close } = createDb(dbUrl);
+        // Check if tables exist by trying to query them
+        const tables = [
+            { name: "search_analytics", table: searchAnalytics },
+            { name: "query_analytics", table: queryAnalytics },
+            { name: "sync_log", table: syncLog },
+            { name: "page_index_status", table: pageIndexStatus },
+            { name: "unmatch_diagnostics", table: unmatchDiagnostics },
+        ];
+        const missingTables = [];
+        for (const { name, table } of tables) {
+            try {
+                await db.select().from(table).limit(1);
+            }
+            catch {
+                missingTables.push(name);
+            }
+        }
+        await close();
+        if (missingTables.length > 0) {
+            return {
+                name: "Database Schema",
+                status: "fail",
+                message: `Missing ${missingTables.length} tables`,
+                details: `Run 'pnpm db:push' or 'pagebridge sync --migrate'. Missing: ${missingTables.join(", ")}`,
+            };
+        }
+        return {
+            name: "Database Schema",
+            status: "pass",
+            message: "All tables exist",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Database Schema",
+            status: "fail",
+            message: "Schema check failed",
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function checkSanity() {
+    const projectId = resolve(undefined, "SANITY_PROJECT_ID");
+    const dataset = resolve(undefined, "SANITY_DATASET");
+    const token = resolve(undefined, "SANITY_TOKEN");
+    if (!projectId || !dataset || !token) {
+        return {
+            name: "Sanity Connection",
+            status: "skip",
+            message: "Sanity credentials not set",
+        };
+    }
+    try {
+        const sanity = createSanityClient({
+            projectId,
+            dataset,
+            token,
+            apiVersion: "2024-01-01",
+            useCdn: false,
+        });
+        await sanity.fetch('*[_type == "gscSite"][0]{ _id }');
+        return {
+            name: "Sanity Connection",
+            status: "pass",
+            message: "Connected successfully",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Sanity Connection",
+            status: "fail",
+            message: "Connection failed",
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function checkGoogleServiceAccount() {
+    const serviceAccount = resolve(undefined, "GOOGLE_SERVICE_ACCOUNT");
+    if (!serviceAccount) {
+        return {
+            name: "Google Service Account",
+            status: "skip",
+            message: "GOOGLE_SERVICE_ACCOUNT not set",
+        };
+    }
+    try {
+        const credentials = JSON.parse(serviceAccount);
+        if (!credentials.private_key || !credentials.client_email) {
+            return {
+                name: "Google Service Account",
+                status: "fail",
+                message: "Invalid service account format",
+                details: "Missing private_key or client_email",
+            };
+        }
+        return {
+            name: "Google Service Account",
+            status: "pass",
+            message: `Valid (${credentials.client_email})`,
+        };
+    }
+    catch {
+        return {
+            name: "Google Service Account",
+            status: "fail",
+            message: "Invalid JSON",
+            details: "Service account must be valid JSON",
+        };
+    }
+}
+async function checkGSCAccess() {
+    const serviceAccount = resolve(undefined, "GOOGLE_SERVICE_ACCOUNT");
+    if (!serviceAccount) {
+        return {
+            name: "GSC API Access",
+            status: "skip",
+            message: "Service account not configured",
+        };
+    }
+    try {
+        const credentials = JSON.parse(serviceAccount);
+        const gsc = new GSCClient({ credentials });
+        const sites = await gsc.listSites();
+        if (sites.length === 0) {
+            return {
+                name: "GSC API Access",
+                status: "warn",
+                message: "No sites found",
+                details: "Make sure the service account has access to your Search Console properties",
+            };
+        }
+        return {
+            name: "GSC API Access",
+            status: "pass",
+            message: `Found ${sites.length} site${sites.length > 1 ? "s" : ""}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "GSC API Access",
+            status: "fail",
+            message: "API access failed",
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split(".")[0] ?? "0");
+    if (major < 18) {
+        return {
+            name: "Node.js Version",
+            status: "fail",
+            message: `Node.js ${version} is too old`,
+            details: "PageBridge requires Node.js 18 or higher",
+        };
+    }
+    return {
+        name: "Node.js Version",
+        status: "pass",
+        message: `Node.js ${version}`,
+    };
+}
+function getStatusIcon(status) {
+    switch (status) {
+        case "pass":
+            return "✅";
+        case "fail":
+            return "❌";
+        case "warn":
+            return "⚠️";
+        case "skip":
+            return "⏭️";
+    }
+}
+export const doctorCommand = new Command("doctor")
+    .description("Diagnose PageBridge setup and configuration issues")
+    .option("--verbose", "Show detailed information")
+    .action(async (options) => {
+    log.info("🏥 PageBridge Health Check\n");
+    const checks = [
+        checkNodeVersion,
+        checkEnvFile,
+        checkEnvVars,
+        checkDatabase,
+        checkDatabaseSchema,
+        checkSanity,
+        checkGoogleServiceAccount,
+        checkGSCAccess,
+    ];
+    const results = [];
+    for (const check of checks) {
+        try {
+            const result = await check();
+            results.push(result);
+            const icon = getStatusIcon(result.status);
+            log.info(`${icon} ${result.name}: ${result.message}`);
+            if (options.verbose && result.details) {
+                log.info(`   ${result.details}`);
+            }
+            else if (!options.verbose &&
+                result.status === "fail" &&
+                result.details) {
+                log.info(`   ${result.details}`);
+            }
+        }
+        catch (error) {
+            results.push({
+                name: "Unknown Check",
+                status: "fail",
+                message: "Check failed",
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Summary
+    const passed = results.filter((r) => r.status === "pass").length;
+    const failed = results.filter((r) => r.status === "fail").length;
+    const warned = results.filter((r) => r.status === "warn").length;
+    const skipped = results.filter((r) => r.status === "skip").length;
+    log.info("\n📊 Summary:");
+    log.info(`   ✅ Passed: ${passed}`);
+    if (failed > 0)
+        log.error(`   ❌ Failed: ${failed}`);
+    if (warned > 0)
+        log.warn(`   ⚠️  Warnings: ${warned}`);
+    if (skipped > 0)
+        log.info(`   ⏭️  Skipped: ${skipped}`);
+    if (failed === 0 && warned === 0) {
+        log.info("\n🎉 All checks passed! PageBridge is ready to use.");
+        log.info("Run 'pagebridge sync --site <url> --migrate' to start syncing.");
+    }
+    else if (failed > 0) {
+        log.error("\n⚠️  Some checks failed. Fix the issues above and run 'pagebridge doctor' again.");
+    }
+    else {
+        log.warn("\n⚠️  Some warnings detected. PageBridge may still work, but review the warnings above.");
+    }
+    process.exit(failed > 0 ? 1 : 0);
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const initCommand: Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmCpC,eAAO,MAAM,WAAW,SA8MpB,CAAC"}

package/dist/commands/init.js

@@ -0,0 +1,182 @@
+import { Command } from "commander";
+import { createClient as createSanityClient } from "@sanity/client";
+import { GSCClient } from "@pagebridge/core";
+import { createDb, sql } from "@pagebridge/db";
+import { log } from "../logger.js";
+import { existsSync, writeFileSync } from "fs";
+import { resolve as resolvePath } from "path";
+import * as readline from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+const rl = readline.createInterface({ input, output });
+async function prompt(question, defaultValue) {
+    const displayQuestion = defaultValue
+        ? `${question} (${defaultValue}): `
+        : `${question}: `;
+    const answer = await rl.question(displayQuestion);
+    return answer.trim() || defaultValue || "";
+}
+async function confirmPrompt(question, defaultYes = true) {
+    const suffix = defaultYes ? " (Y/n): " : " (y/N): ";
+    const answer = await rl.question(question + suffix);
+    const normalized = answer.trim().toLowerCase();
+    if (!normalized)
+        return defaultYes;
+    return normalized === "y" || normalized === "yes";
+}
+export const initCommand = new Command("init")
+    .description("Interactive setup wizard for PageBridge")
+    .option("--skip-db-check", "Skip database connection test")
+    .option("--skip-sanity-check", "Skip Sanity API test")
+    .option("--skip-gsc-check", "Skip Google Search Console API test")
+    .action(async (options) => {
+    log.info("🚀 PageBridge Interactive Setup\n");
+    const envPath = resolvePath(process.cwd(), ".env");
+    // Check if .env already exists
+    if (existsSync(envPath)) {
+        const overwrite = await confirmPrompt(".env file already exists. Do you want to overwrite it?", false);
+        if (!overwrite) {
+            log.info("Skipping .env creation. Exiting...");
+            rl.close();
+            return;
+        }
+    }
+    log.info("Let's configure your environment variables.\n");
+    // Database URL
+    log.info("📦 Database Configuration");
+    const dbUrl = await prompt("PostgreSQL connection string", "postgresql://postgres:postgres@localhost:5432/gsc_sanity");
+    if (!options.skipDbCheck && dbUrl) {
+        try {
+            log.info("Testing database connection...");
+            const { db, close } = createDb(dbUrl);
+            await db.execute(sql `SELECT 1`);
+            await close();
+            log.info("✅ Database connection successful\n");
+        }
+        catch (error) {
+            log.error(`❌ Database connection failed: ${error instanceof Error ? error.message : String(error)}`);
+            log.warn("You can continue anyway, but you'll need to fix this before syncing.\n");
+        }
+    }
+    // Sanity Configuration
+    log.info("🎨 Sanity Configuration");
+    const sanityProjectId = await prompt("Sanity Project ID");
+    const sanityDataset = await prompt("Sanity Dataset", "production");
+    const sanityToken = await prompt("Sanity API Token (with Editor permissions)");
+    if (!options.skipSanityCheck && sanityProjectId && sanityToken) {
+        try {
+            log.info("Testing Sanity API connection...");
+            const sanity = createSanityClient({
+                projectId: sanityProjectId,
+                dataset: sanityDataset,
+                token: sanityToken,
+                apiVersion: "2024-01-01",
+                useCdn: false,
+            });
+            await sanity.fetch('*[_type == "gscSite"][0]{ _id }');
+            log.info("✅ Sanity connection successful\n");
+        }
+        catch (error) {
+            log.error(`❌ Sanity connection failed: ${error instanceof Error ? error.message : String(error)}`);
+            log.warn("Check your project ID, dataset, and token permissions.\n");
+        }
+    }
+    // Google Service Account
+    log.info("🔐 Google Search Console Configuration");
+    log.info("You need a Google Cloud service account with Search Console API access.");
+    log.info('Paste the entire service account JSON (it should start with {"type":"service_account"...):\n');
+    const googleServiceAccount = await prompt("Google Service Account JSON");
+    // Validate JSON
+    let credentials = null;
+    try {
+        credentials = JSON.parse(googleServiceAccount);
+        if (!credentials) {
+            throw new Error("Parsed credentials is null");
+        }
+        log.info(`✅ Valid JSON for service account: ${credentials.client_email}\n`);
+    }
+    catch {
+        log.error("❌ Invalid JSON format for service account");
+        log.warn("You'll need to fix this in .env before syncing.\n");
+    }
+    // Test GSC API
+    if (!options.skipGscCheck && credentials) {
+        try {
+            log.info("Testing Google Search Console API access...");
+            const gsc = new GSCClient({ credentials });
+            const sites = await gsc.listSites();
+            log.info(`✅ GSC API access successful. Found ${sites.length} sites:`);
+            sites.forEach((site) => log.info(`   - ${site}`));
+            log.info("");
+        }
+        catch (error) {
+            log.error(`❌ GSC API access failed: ${error instanceof Error ? error.message : String(error)}`);
+            log.warn("Make sure the service account has access to your Search Console properties.\n");
+        }
+    }
+    // Site URL
+    log.info("🌐 Site Configuration");
+    const siteUrl = await prompt("Your website base URL (e.g., https://example.com)");
+    // Write .env file
+    const envContent = `# PageBridge Environment Variables
+# Generated by 'pagebridge init' on ${new Date().toISOString()}
+# Uses PAGEBRIDGE_ prefix to avoid conflicts with your project's env vars.
+
+# Google Service Account JSON (stringified)
+PAGEBRIDGE_GOOGLE_SERVICE_ACCOUNT='${googleServiceAccount}'
+
+# PostgreSQL connection string
+PAGEBRIDGE_DATABASE_URL='${dbUrl}'
+
+# Sanity Studio configuration
+PAGEBRIDGE_SANITY_PROJECT_ID='${sanityProjectId}'
+PAGEBRIDGE_SANITY_DATASET='${sanityDataset}'
+PAGEBRIDGE_SANITY_TOKEN='${sanityToken}'
+
+# Your site URL
+PAGEBRIDGE_SITE_URL='${siteUrl}'
+`;
+    writeFileSync(envPath, envContent, "utf-8");
+    log.info("✅ .env file created successfully!\n");
+    // Offer to run migrations
+    const runMigrations = await confirmPrompt("Would you like to run database migrations now?", true);
+    if (runMigrations && dbUrl) {
+        log.info("Running database migrations...");
+        try {
+            // Import migrate function
+            const { migrateIfRequested } = await import("../migrate.js");
+            await migrateIfRequested(true, dbUrl);
+            log.info("✅ Migrations completed\n");
+        }
+        catch (error) {
+            log.error(`❌ Migration failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    // Offer to run first sync
+    if (credentials) {
+        const runSync = await confirmPrompt("Would you like to run your first sync now?", false);
+        if (runSync) {
+            const sites = await new GSCClient({ credentials }).listSites();
+            if (sites.length === 0) {
+                log.warn("No sites found in your Search Console account.");
+            }
+            else if (sites.length === 1) {
+                log.info(`\nUsing site: ${sites[0]}`);
+                // Note: You'd import and call the sync command here
+                log.info(`Run: pagebridge sync --site "${sites[0]}" --migrate`);
+            }
+            else {
+                log.info("\nAvailable sites:");
+                sites.forEach((site, i) => log.info(`  ${i + 1}. ${site}`));
+                const siteChoice = await prompt("\nEnter site number or full URL");
+                const selectedSite = sites[parseInt(siteChoice) - 1] || siteChoice;
+                log.info(`\nRun: pagebridge sync --site "${selectedSite}" --migrate`);
+            }
+        }
+    }
+    log.info("\n🎉 Setup complete!");
+    log.info("\nNext steps:");
+    log.info("  1. Review your .env file");
+    log.info("  2. Run: pagebridge sync --site <your-site-url> --migrate");
+    log.info("  3. Open Sanity Studio to see your performance data\n");
+    rl.close();
+});

package/dist/commands/list-sites.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-sites.d.ts","sourceRoot":"","sources":["../../src/commands/list-sites.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,eAAO,MAAM,gBAAgB,SA2CzB,CAAC"}
+{"version":3,"file":"list-sites.d.ts","sourceRoot":"","sources":["../../src/commands/list-sites.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,eAAO,MAAM,gBAAgB,SA6CzB,CAAC"}

package/dist/commands/list-sites.js

@@ -1,38 +1,43 @@
 import { Command } from "commander";
 import { GSCClient } from "@pagebridge/core";
+import { resolve, requireConfig } from "../resolve-config.js";
+import { log } from "../logger.js";
 export const listSitesCommand = new Command("list-sites")
     .description("List all sites the service account has access to")
-    .action(async () => {
-    if (!process.env.GOOGLE_SERVICE_ACCOUNT) {
-        console.error("❌ Missing GOOGLE_SERVICE_ACCOUNT environment variable");
-        process.exit(1);
-    }
+    .option("--google-service-account <json>", "Google service account JSON")
+    .action(async (options) => {
+    const googleServiceAccount = resolve(options.googleServiceAccount, "GOOGLE_SERVICE_ACCOUNT");
+    requireConfig([
+        { name: "GOOGLE_SERVICE_ACCOUNT", flag: "--google-service-account <json>", envVar: "GOOGLE_SERVICE_ACCOUNT", value: googleServiceAccount },
+    ]);
     let credentials;
     try {
-        credentials = JSON.parse(process.env.GOOGLE_SERVICE_ACCOUNT);
+        credentials = JSON.parse(googleServiceAccount);
     }
     catch {
-        console.error("❌ Failed to parse GOOGLE_SERVICE_ACCOUNT as JSON");
+        log.error("Failed to parse GOOGLE_SERVICE_ACCOUNT as JSON");
         process.exit(1);
     }
-    console.log(`🔑 Using service account: ${credentials.client_email}`);
+    log.info(`Using service account: ${credentials.client_email}`);
     const gsc = new GSCClient({ credentials });
     try {
         const sites = await gsc.listSites();
         if (sites.length === 0) {
-            console.log("\n⚠️  No sites found. The service account has no access to any GSC properties.");
-            console.log("\nTo fix this:");
-            console.log("1. Go to Google Search Console → Settings → Users and permissions");
-            console.log(`2. Add user: ${credentials.client_email}`);
-            console.log("3. Set permission level to 'Full'");
+            log.warn("No sites found. The service account has no access to any GSC properties.");
+            log.info("\nTo fix this:");
+            log.info("1. Go to Google Search Console > Settings > Users and permissions");
+            log.info(`2. Add user: ${credentials.client_email}`);
+            log.info("3. Set permission level to 'Full'");
         }
         else {
-            console.log(`\n✅ Found ${sites.length} site(s):\n`);
-            sites.forEach((site) => console.log(`   ${site}`));
-            console.log('\nUse one of these exact values with: pnpm sync --site "<value>"');
+            log.info(`Found ${sites.length} site(s):\n`);
+            sites.forEach((site) => log.info(`   ${site}`));
+            log.info('\nUse one of these exact values with: pnpm sync --site "<value>"');
         }
     }
     catch (error) {
-        console.error("❌ Failed to list sites:", error);
+        const message = error instanceof Error ? error.message : String(error);
+        log.error(`Failed to list sites: ${message}`);
+        process.exit(1);
     }
 });

package/dist/commands/sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgCpC,eAAO,MAAM,WAAW,SAmUpB,CAAC"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkCpC,eAAO,MAAM,WAAW,SAkYpB,CAAC"}