@local-labs-jpollock/local-cli 0.0.1

package/bin/lwp.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+/**
+ * Local CLI (lwp) - Command-line interface for Local
+ *
+ * This is the entry point for the lwp command.
+ * It loads the compiled TypeScript from lib/index.js
+ */
+
+require('../lib/index.js');

package/lib/bootstrap/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Bootstrap System
+ *
+ * Connects the CLI to Local's GraphQL server:
+ * - Detects Local installation
+ * - Installs and activates addon if needed
+ * - Starts Local if needed
+ * - Waits for GraphQL server to be ready
+ * - Reads connection info
+ */
+import { getLocalPaths, LocalPaths } from './paths';
+export interface ConnectionInfo {
+    url: string;
+    subscriptionUrl: string;
+    port: number;
+    authToken: string;
+}
+export interface BootstrapResult {
+    success: boolean;
+    connectionInfo?: ConnectionInfo;
+    error?: string;
+    actions: string[];
+}
+/**
+ * Check if Local is installed
+ */
+export declare function isLocalInstalled(): boolean;
+/**
+ * Check if Local is currently running
+ */
+export declare function isLocalRunning(): Promise<boolean>;
+/**
+ * Start Local application
+ */
+export declare function startLocal(): Promise<void>;
+/**
+ * Stop Local application
+ */
+export declare function stopLocal(): Promise<void>;
+/**
+ * Restart Local application
+ */
+export declare function restartLocal(): Promise<void>;
+/**
+ * Get the addon installation path
+ */
+export declare function getAddonPath(): string;
+/**
+ * Check if the addon is installed in Local's addons directory
+ */
+export declare function isAddonInstalled(): boolean;
+/**
+ * Check if the addon is activated in enabled-addons.json
+ */
+export declare function isAddonActivated(): boolean;
+/**
+ * Activate the addon by modifying enabled-addons.json
+ * Returns true if restart is needed (addon was just activated)
+ */
+export declare function activateAddon(): boolean;
+/**
+ * Install the addon from bundled package or create dev symlink
+ */
+export declare function installAddon(options?: {
+    onStatus?: (status: string) => void;
+}): Promise<{
+    success: boolean;
+    error?: string;
+    needsRestart: boolean;
+}>;
+/**
+ * Ensure addon is installed and activated
+ */
+export declare function ensureAddon(options?: {
+    onStatus?: (status: string) => void;
+}): Promise<{
+    success: boolean;
+    error?: string;
+    needsRestart: boolean;
+}>;
+/**
+ * Read GraphQL connection info from graphql-connection-info.json
+ */
+export declare function readConnectionInfo(): ConnectionInfo | null;
+/**
+ * Wait for GraphQL server to be ready
+ */
+export declare function waitForGraphQL(timeoutMs?: number, pollIntervalMs?: number): Promise<boolean>;
+/**
+ * Main bootstrap function
+ * Ensures addon is installed, Local is running, and GraphQL is accessible
+ */
+export declare function bootstrap(options?: {
+    verbose?: boolean;
+    skipAddonInstall?: boolean;
+    onStatus?: (status: string) => void;
+}): Promise<BootstrapResult>;
+export { getLocalPaths, LocalPaths };

package/lib/bootstrap/index.js

@@ -0,0 +1,493 @@
+"use strict";
+/**
+ * Bootstrap System
+ *
+ * Connects the CLI to Local's GraphQL server:
+ * - Detects Local installation
+ * - Installs and activates addon if needed
+ * - Starts Local if needed
+ * - Waits for GraphQL server to be ready
+ * - Reads connection info
+ */
+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.getLocalPaths = void 0;
+exports.isLocalInstalled = isLocalInstalled;
+exports.isLocalRunning = isLocalRunning;
+exports.startLocal = startLocal;
+exports.stopLocal = stopLocal;
+exports.restartLocal = restartLocal;
+exports.getAddonPath = getAddonPath;
+exports.isAddonInstalled = isAddonInstalled;
+exports.isAddonActivated = isAddonActivated;
+exports.activateAddon = activateAddon;
+exports.installAddon = installAddon;
+exports.ensureAddon = ensureAddon;
+exports.readConnectionInfo = readConnectionInfo;
+exports.waitForGraphQL = waitForGraphQL;
+exports.bootstrap = bootstrap;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const paths_1 = require("./paths");
+Object.defineProperty(exports, "getLocalPaths", { enumerable: true, get: function () { return paths_1.getLocalPaths; } });
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Check if Local is installed
+ */
+function isLocalInstalled() {
+    const paths = (0, paths_1.getLocalPaths)();
+    try {
+        if (process.platform === 'darwin') {
+            return fs.existsSync(paths.appExecutable);
+        }
+        else if (process.platform === 'win32') {
+            return fs.existsSync(paths.appExecutable);
+        }
+        else {
+            // Linux - check if 'local' is in PATH or at expected location
+            try {
+                (0, child_process_1.execSync)('which local', { stdio: 'ignore' });
+                return true;
+            }
+            catch {
+                return fs.existsSync(paths.appExecutable);
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if Local is currently running
+ */
+async function isLocalRunning() {
+    try {
+        if (process.platform === 'darwin') {
+            // Use pgrep with -f to match any process containing "Local"
+            // Also check if GraphQL connection info exists and is recent
+            const { stdout } = await execAsync(`pgrep -f "Local.app"`);
+            return stdout.trim().length > 0;
+        }
+        else if (process.platform === 'win32') {
+            const { stdout } = await execAsync(`tasklist /FI "IMAGENAME eq Local.exe"`);
+            return stdout.includes('Local.exe');
+        }
+        else {
+            const { stdout } = await execAsync(`pgrep -f "local"`);
+            return stdout.trim().length > 0;
+        }
+    }
+    catch {
+        // pgrep returns non-zero if no processes found
+        // Check if connection info exists as a fallback
+        const connectionInfo = readConnectionInfo();
+        return connectionInfo !== null;
+    }
+}
+/**
+ * Start Local application
+ */
+async function startLocal() {
+    const paths = (0, paths_1.getLocalPaths)();
+    try {
+        if (process.platform === 'darwin') {
+            // Just activate Local - don't try to hide it (requires accessibility permissions)
+            await execAsync(`open -a "Local"`);
+        }
+        else if (process.platform === 'win32') {
+            // /MIN = start minimized
+            await execAsync(`start /MIN "" "${paths.appExecutable}"`);
+        }
+        else {
+            await execAsync(`${paths.appExecutable} &`);
+        }
+    }
+    catch {
+        // Ignore errors - Local might already be running
+    }
+}
+/**
+ * Stop Local application
+ */
+async function stopLocal() {
+    try {
+        if (process.platform === 'darwin') {
+            await execAsync(`osascript -e 'quit app "Local"'`);
+        }
+        else if (process.platform === 'win32') {
+            await execAsync(`taskkill /IM Local.exe /F`);
+        }
+        else {
+            await execAsync(`pkill -f local`);
+        }
+    }
+    catch {
+        // Ignore errors - Local might not be running
+    }
+}
+/**
+ * Restart Local application
+ */
+async function restartLocal() {
+    await stopLocal();
+    // Wait a bit for the process to fully stop
+    await delay(2000);
+    await startLocal();
+}
+// ===========================================
+// Addon Management
+// ===========================================
+/**
+ * Addon directory name in Local's addons folder
+ * Local uses @scope-name format (replaces / with -)
+ */
+const ADDON_DIR_NAME = '@local-labs-local-addon-cli';
+/**
+ * Addon key in enabled-addons.json (package name)
+ */
+const ADDON_ENABLED_KEY = '@local-labs-jpollock/local-addon-cli';
+/**
+ * Get the addon installation path
+ */
+function getAddonPath() {
+    const paths = (0, paths_1.getLocalPaths)();
+    return path.join(paths.addonsDir, ADDON_DIR_NAME);
+}
+/**
+ * Check if the addon is installed in Local's addons directory
+ */
+function isAddonInstalled() {
+    const addonPath = getAddonPath();
+    // Check for directory or symlink
+    try {
+        const stat = fs.lstatSync(addonPath);
+        return stat.isDirectory() || stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if the addon is activated in enabled-addons.json
+ */
+function isAddonActivated() {
+    const paths = (0, paths_1.getLocalPaths)();
+    try {
+        if (!fs.existsSync(paths.enabledAddonsFile)) {
+            return false;
+        }
+        const content = fs.readFileSync(paths.enabledAddonsFile, 'utf-8');
+        const enabledAddons = JSON.parse(content);
+        return enabledAddons[ADDON_ENABLED_KEY] === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Activate the addon by modifying enabled-addons.json
+ * Returns true if restart is needed (addon was just activated)
+ */
+function activateAddon() {
+    const paths = (0, paths_1.getLocalPaths)();
+    try {
+        let enabledAddons = {};
+        if (fs.existsSync(paths.enabledAddonsFile)) {
+            const content = fs.readFileSync(paths.enabledAddonsFile, 'utf-8');
+            enabledAddons = JSON.parse(content);
+        }
+        // Check if already activated
+        if (enabledAddons[ADDON_ENABLED_KEY] === true) {
+            return false; // Already active, no restart needed
+        }
+        // Activate the addon
+        enabledAddons[ADDON_ENABLED_KEY] = true;
+        fs.writeFileSync(paths.enabledAddonsFile, JSON.stringify(enabledAddons, null, 2));
+        return true; // Restart needed
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Copy a directory recursively
+ */
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Find the bundled addon path (included in npm package)
+ * Located at addon-dist/ relative to the CLI package root
+ */
+function findBundledAddonPath() {
+    // From lib/bootstrap/ -> addon-dist/
+    const bundledPath = path.resolve(__dirname, '..', '..', 'addon-dist');
+    if (fs.existsSync(path.join(bundledPath, 'package.json'))) {
+        return bundledPath;
+    }
+    return null;
+}
+/**
+ * Find the local development addon path (for dev mode)
+ * Looks for the addon relative to the CLI package in monorepo
+ */
+function findDevAddonPath() {
+    // Check if we're in the monorepo structure
+    // Works from both lib/bootstrap (compiled) and src/bootstrap (ts-node)
+    const cliDir = __dirname;
+    const addonPath = path.resolve(cliDir, '..', '..', '..', 'addon');
+    if (fs.existsSync(path.join(addonPath, 'package.json'))) {
+        return addonPath;
+    }
+    return null;
+}
+/**
+ * Install the addon from bundled package or create dev symlink
+ */
+async function installAddon(options = {}) {
+    const log = options.onStatus || (() => { });
+    const paths = (0, paths_1.getLocalPaths)();
+    const addonPath = getAddonPath();
+    try {
+        // Ensure addons directory exists
+        if (!fs.existsSync(paths.addonsDir)) {
+            fs.mkdirSync(paths.addonsDir, { recursive: true });
+        }
+        // Try bundled addon first (production - included in npm package)
+        const bundledAddonPath = findBundledAddonPath();
+        if (bundledAddonPath) {
+            log('Installing bundled addon...');
+            // Copy bundled addon to Local's addons directory
+            copyDirSync(bundledAddonPath, addonPath);
+            log('Addon installed successfully.');
+        }
+        else {
+            // Try development mode - create symlink to local addon in monorepo
+            const devAddonPath = findDevAddonPath();
+            if (devAddonPath) {
+                log('Using development addon (symlink)...');
+                fs.symlinkSync(devAddonPath, addonPath);
+                log(`Created symlink: ${addonPath} -> ${devAddonPath}`);
+            }
+            else {
+                throw new Error('Addon not found. Please reinstall the CLI package: npm install -g @local-labs/local-cli');
+            }
+        }
+        // Activate the addon
+        const needsRestart = activateAddon();
+        return { success: true, needsRestart };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Failed to install addon',
+            needsRestart: false,
+        };
+    }
+}
+/**
+ * Ensure addon is installed and activated
+ */
+async function ensureAddon(options = {}) {
+    const log = options.onStatus || (() => { });
+    // Check if addon is installed
+    if (!isAddonInstalled()) {
+        log('Addon not installed. Installing...');
+        const result = await installAddon(options);
+        if (!result.success) {
+            return result;
+        }
+        return { success: true, needsRestart: true };
+    }
+    // Check if addon is activated
+    if (!isAddonActivated()) {
+        log('Activating addon...');
+        const needsRestart = activateAddon();
+        return { success: true, needsRestart };
+    }
+    return { success: true, needsRestart: false };
+}
+// ===========================================
+// Connection Info
+// ===========================================
+/**
+ * Read GraphQL connection info from graphql-connection-info.json
+ */
+function readConnectionInfo() {
+    const paths = (0, paths_1.getLocalPaths)();
+    try {
+        if (!fs.existsSync(paths.graphqlConnectionInfoFile)) {
+            return null;
+        }
+        const content = fs.readFileSync(paths.graphqlConnectionInfoFile, 'utf-8');
+        const info = JSON.parse(content);
+        return {
+            url: info.url || `http://127.0.0.1:${info.port}/graphql`,
+            subscriptionUrl: info.subscriptionUrl || `ws://127.0.0.1:${info.port}/graphql`,
+            port: info.port,
+            authToken: info.authToken || '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Wait for GraphQL server to be ready
+ */
+async function waitForGraphQL(timeoutMs = 30000, pollIntervalMs = 500) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const connectionInfo = readConnectionInfo();
+        if (connectionInfo) {
+            try {
+                // Use AbortController for per-request timeout (2 seconds)
+                const controller = new AbortController();
+                const requestTimeout = setTimeout(() => controller.abort(), 2000);
+                const response = await fetch(connectionInfo.url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${connectionInfo.authToken}`,
+                    },
+                    body: JSON.stringify({ query: '{ __typename }' }),
+                    signal: controller.signal,
+                });
+                clearTimeout(requestTimeout);
+                if (response.ok) {
+                    return true;
+                }
+            }
+            catch {
+                // Server not ready yet - connection refused, timeout, etc.
+            }
+        }
+        await delay(pollIntervalMs);
+    }
+    return false;
+}
+/**
+ * Delay helper
+ */
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Main bootstrap function
+ * Ensures addon is installed, Local is running, and GraphQL is accessible
+ */
+async function bootstrap(options = {}) {
+    const actions = [];
+    const log = (msg) => {
+        actions.push(msg);
+        if (options.verbose) {
+            console.log(msg);
+        }
+        if (options.onStatus) {
+            options.onStatus(msg);
+        }
+    };
+    // Check if Local is installed
+    if (!isLocalInstalled()) {
+        return {
+            success: false,
+            error: 'Local is not installed. Download from https://localwp.com',
+            actions,
+        };
+    }
+    // Ensure addon is installed and activated (unless skipped)
+    let needsRestart = false;
+    if (!options.skipAddonInstall) {
+        const addonResult = await ensureAddon({ onStatus: log });
+        if (!addonResult.success) {
+            return {
+                success: false,
+                error: addonResult.error || 'Failed to install addon',
+                actions,
+            };
+        }
+        needsRestart = addonResult.needsRestart;
+    }
+    // Check if Local is running
+    const running = await isLocalRunning();
+    if (needsRestart && running) {
+        log('Restarting Local to activate addon...');
+        await restartLocal();
+    }
+    else if (!running) {
+        log('Starting Local...');
+        await startLocal();
+    }
+    // Wait for GraphQL server
+    log('Waiting for GraphQL...');
+    const ready = await waitForGraphQL();
+    if (!ready) {
+        return {
+            success: false,
+            error: 'Timed out waiting for Local. Is Local running?',
+            actions,
+        };
+    }
+    log('GraphQL server ready.');
+    // Read connection info
+    const connectionInfo = readConnectionInfo();
+    if (!connectionInfo) {
+        return {
+            success: false,
+            error: 'Could not read GraphQL connection info.',
+            actions,
+        };
+    }
+    return {
+        success: true,
+        connectionInfo,
+        actions,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bootstrap/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap System\n *\n * Connects the CLI to Local's GraphQL server:\n * - Detects Local installation\n * - Installs and activates addon if needed\n * - Starts Local if needed\n * - Waits for GraphQL server to be ready\n * - Reads connection info\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { exec, execSync } from 'child_process';\nimport { promisify } from 'util';\nimport { getLocalPaths, LocalPaths } from './paths';\n\nconst execAsync = promisify(exec);\n\nexport interface ConnectionInfo {\n  url: string;\n  subscriptionUrl: string;\n  port: number;\n  authToken: string;\n}\n\nexport interface BootstrapResult {\n  success: boolean;\n  connectionInfo?: ConnectionInfo;\n  error?: string;\n  actions: string[];\n}\n\n/**\n * Check if Local is installed\n */\nexport function isLocalInstalled(): boolean {\n  const paths = getLocalPaths();\n\n  try {\n    if (process.platform === 'darwin') {\n      return fs.existsSync(paths.appExecutable);\n    } else if (process.platform === 'win32') {\n      return fs.existsSync(paths.appExecutable);\n    } else {\n      // Linux - check if 'local' is in PATH or at expected location\n      try {\n        execSync('which local', { stdio: 'ignore' });\n        return true;\n      } catch {\n        return fs.existsSync(paths.appExecutable);\n      }\n    }\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if Local is currently running\n */\nexport async function isLocalRunning(): Promise<boolean> {\n  try {\n    if (process.platform === 'darwin') {\n      // Use pgrep with -f to match any process containing \"Local\"\n      // Also check if GraphQL connection info exists and is recent\n      const { stdout } = await execAsync(`pgrep -f \"Local.app\"`);\n      return stdout.trim().length > 0;\n    } else if (process.platform === 'win32') {\n      const { stdout } = await execAsync(`tasklist /FI \"IMAGENAME eq Local.exe\"`);\n      return stdout.includes('Local.exe');\n    } else {\n      const { stdout } = await execAsync(`pgrep -f \"local\"`);\n      return stdout.trim().length > 0;\n    }\n  } catch {\n    // pgrep returns non-zero if no processes found\n    // Check if connection info exists as a fallback\n    const connectionInfo = readConnectionInfo();\n    return connectionInfo !== null;\n  }\n}\n\n/**\n * Start Local application\n */\nexport async function startLocal(): Promise<void> {\n  const paths = getLocalPaths();\n\n  try {\n    if (process.platform === 'darwin') {\n      // Just activate Local - don't try to hide it (requires accessibility permissions)\n      await execAsync(`open -a \"Local\"`);\n    } else if (process.platform === 'win32') {\n      // /MIN = start minimized\n      await execAsync(`start /MIN \"\" \"${paths.appExecutable}\"`);\n    } else {\n      await execAsync(`${paths.appExecutable} &`);\n    }\n  } catch {\n    // Ignore errors - Local might already be running\n  }\n}\n\n/**\n * Stop Local application\n */\nexport async function stopLocal(): Promise<void> {\n  try {\n    if (process.platform === 'darwin') {\n      await execAsync(`osascript -e 'quit app \"Local\"'`);\n    } else if (process.platform === 'win32') {\n      await execAsync(`taskkill /IM Local.exe /F`);\n    } else {\n      await execAsync(`pkill -f local`);\n    }\n  } catch {\n    // Ignore errors - Local might not be running\n  }\n}\n\n/**\n * Restart Local application\n */\nexport async function restartLocal(): Promise<void> {\n  await stopLocal();\n  // Wait a bit for the process to fully stop\n  await delay(2000);\n  await startLocal();\n}\n\n// ===========================================\n// Addon Management\n// ===========================================\n\n/**\n * Addon directory name in Local's addons folder\n * Local uses @scope-name format (replaces / with -)\n */\nconst ADDON_DIR_NAME = '@local-labs-local-addon-cli';\n\n/**\n * Addon key in enabled-addons.json (package name)\n */\nconst ADDON_ENABLED_KEY = '@local-labs-jpollock/local-addon-cli';\n\n/**\n * Get the addon installation path\n */\nexport function getAddonPath(): string {\n  const paths = getLocalPaths();\n  return path.join(paths.addonsDir, ADDON_DIR_NAME);\n}\n\n/**\n * Check if the addon is installed in Local's addons directory\n */\nexport function isAddonInstalled(): boolean {\n  const addonPath = getAddonPath();\n\n  // Check for directory or symlink\n  try {\n    const stat = fs.lstatSync(addonPath);\n    return stat.isDirectory() || stat.isSymbolicLink();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if the addon is activated in enabled-addons.json\n */\nexport function isAddonActivated(): boolean {\n  const paths = getLocalPaths();\n\n  try {\n    if (!fs.existsSync(paths.enabledAddonsFile)) {\n      return false;\n    }\n\n    const content = fs.readFileSync(paths.enabledAddonsFile, 'utf-8');\n    const enabledAddons: Record<string, boolean> = JSON.parse(content);\n\n    return enabledAddons[ADDON_ENABLED_KEY] === true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Activate the addon by modifying enabled-addons.json\n * Returns true if restart is needed (addon was just activated)\n */\nexport function activateAddon(): boolean {\n  const paths = getLocalPaths();\n\n  try {\n    let enabledAddons: Record<string, boolean> = {};\n\n    if (fs.existsSync(paths.enabledAddonsFile)) {\n      const content = fs.readFileSync(paths.enabledAddonsFile, 'utf-8');\n      enabledAddons = JSON.parse(content);\n    }\n\n    // Check if already activated\n    if (enabledAddons[ADDON_ENABLED_KEY] === true) {\n      return false; // Already active, no restart needed\n    }\n\n    // Activate the addon\n    enabledAddons[ADDON_ENABLED_KEY] = true;\n    fs.writeFileSync(paths.enabledAddonsFile, JSON.stringify(enabledAddons, null, 2));\n\n    return true; // Restart needed\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Copy a directory recursively\n */\nfunction copyDirSync(src: string, dest: string): void {\n  fs.mkdirSync(dest, { recursive: true });\n\n  const entries = fs.readdirSync(src, { withFileTypes: true });\n\n  for (const entry of entries) {\n    const srcPath = path.join(src, entry.name);\n    const destPath = path.join(dest, entry.name);\n\n    if (entry.isDirectory()) {\n      copyDirSync(srcPath, destPath);\n    } else {\n      fs.copyFileSync(srcPath, destPath);\n    }\n  }\n}\n\n/**\n * Find the bundled addon path (included in npm package)\n * Located at addon-dist/ relative to the CLI package root\n */\nfunction findBundledAddonPath(): string | null {\n  // From lib/bootstrap/ -> addon-dist/\n  const bundledPath = path.resolve(__dirname, '..', '..', 'addon-dist');\n\n  if (fs.existsSync(path.join(bundledPath, 'package.json'))) {\n    return bundledPath;\n  }\n\n  return null;\n}\n\n/**\n * Find the local development addon path (for dev mode)\n * Looks for the addon relative to the CLI package in monorepo\n */\nfunction findDevAddonPath(): string | null {\n  // Check if we're in the monorepo structure\n  // Works from both lib/bootstrap (compiled) and src/bootstrap (ts-node)\n  const cliDir = __dirname;\n  const addonPath = path.resolve(cliDir, '..', '..', '..', 'addon');\n\n  if (fs.existsSync(path.join(addonPath, 'package.json'))) {\n    return addonPath;\n  }\n\n  return null;\n}\n\n/**\n * Install the addon from bundled package or create dev symlink\n */\nexport async function installAddon(options: {\n  onStatus?: (status: string) => void;\n} = {}): Promise<{ success: boolean; error?: string; needsRestart: boolean }> {\n  const log = options.onStatus || (() => {});\n  const paths = getLocalPaths();\n  const addonPath = getAddonPath();\n\n  try {\n    // Ensure addons directory exists\n    if (!fs.existsSync(paths.addonsDir)) {\n      fs.mkdirSync(paths.addonsDir, { recursive: true });\n    }\n\n    // Try bundled addon first (production - included in npm package)\n    const bundledAddonPath = findBundledAddonPath();\n\n    if (bundledAddonPath) {\n      log('Installing bundled addon...');\n\n      // Copy bundled addon to Local's addons directory\n      copyDirSync(bundledAddonPath, addonPath);\n\n      log('Addon installed successfully.');\n    } else {\n      // Try development mode - create symlink to local addon in monorepo\n      const devAddonPath = findDevAddonPath();\n\n      if (devAddonPath) {\n        log('Using development addon (symlink)...');\n\n        fs.symlinkSync(devAddonPath, addonPath);\n        log(`Created symlink: ${addonPath} -> ${devAddonPath}`);\n      } else {\n        throw new Error(\n          'Addon not found. Please reinstall the CLI package: npm install -g @local-labs/local-cli'\n        );\n      }\n    }\n\n    // Activate the addon\n    const needsRestart = activateAddon();\n\n    return { success: true, needsRestart };\n  } catch (error: any) {\n    return {\n      success: false,\n      error: error.message || 'Failed to install addon',\n      needsRestart: false,\n    };\n  }\n}\n\n/**\n * Ensure addon is installed and activated\n */\nexport async function ensureAddon(options: {\n  onStatus?: (status: string) => void;\n} = {}): Promise<{ success: boolean; error?: string; needsRestart: boolean }> {\n  const log = options.onStatus || (() => {});\n\n  // Check if addon is installed\n  if (!isAddonInstalled()) {\n    log('Addon not installed. Installing...');\n    const result = await installAddon(options);\n    if (!result.success) {\n      return result;\n    }\n    return { success: true, needsRestart: true };\n  }\n\n  // Check if addon is activated\n  if (!isAddonActivated()) {\n    log('Activating addon...');\n    const needsRestart = activateAddon();\n    return { success: true, needsRestart };\n  }\n\n  return { success: true, needsRestart: false };\n}\n\n// ===========================================\n// Connection Info\n// ===========================================\n\n/**\n * Read GraphQL connection info from graphql-connection-info.json\n */\nexport function readConnectionInfo(): ConnectionInfo | null {\n  const paths = getLocalPaths();\n\n  try {\n    if (!fs.existsSync(paths.graphqlConnectionInfoFile)) {\n      return null;\n    }\n\n    const content = fs.readFileSync(paths.graphqlConnectionInfoFile, 'utf-8');\n    const info = JSON.parse(content);\n\n    return {\n      url: info.url || `http://127.0.0.1:${info.port}/graphql`,\n      subscriptionUrl: info.subscriptionUrl || `ws://127.0.0.1:${info.port}/graphql`,\n      port: info.port,\n      authToken: info.authToken || '',\n    };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Wait for GraphQL server to be ready\n */\nexport async function waitForGraphQL(\n  timeoutMs: number = 30000,\n  pollIntervalMs: number = 500\n): Promise<boolean> {\n  const start = Date.now();\n\n  while (Date.now() - start < timeoutMs) {\n    const connectionInfo = readConnectionInfo();\n\n    if (connectionInfo) {\n      try {\n        // Use AbortController for per-request timeout (2 seconds)\n        const controller = new AbortController();\n        const requestTimeout = setTimeout(() => controller.abort(), 2000);\n\n        const response = await fetch(connectionInfo.url, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n            Authorization: `Bearer ${connectionInfo.authToken}`,\n          },\n          body: JSON.stringify({ query: '{ __typename }' }),\n          signal: controller.signal,\n        });\n\n        clearTimeout(requestTimeout);\n\n        if (response.ok) {\n          return true;\n        }\n      } catch {\n        // Server not ready yet - connection refused, timeout, etc.\n      }\n    }\n\n    await delay(pollIntervalMs);\n  }\n\n  return false;\n}\n\n/**\n * Delay helper\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Main bootstrap function\n * Ensures addon is installed, Local is running, and GraphQL is accessible\n */\nexport async function bootstrap(options: {\n  verbose?: boolean;\n  skipAddonInstall?: boolean;\n  onStatus?: (status: string) => void;\n} = {}): Promise<BootstrapResult> {\n  const actions: string[] = [];\n  const log = (msg: string) => {\n    actions.push(msg);\n    if (options.verbose) {\n      console.log(msg);\n    }\n    if (options.onStatus) {\n      options.onStatus(msg);\n    }\n  };\n\n  // Check if Local is installed\n  if (!isLocalInstalled()) {\n    return {\n      success: false,\n      error: 'Local is not installed. Download from https://localwp.com',\n      actions,\n    };\n  }\n\n  // Ensure addon is installed and activated (unless skipped)\n  let needsRestart = false;\n  if (!options.skipAddonInstall) {\n    const addonResult = await ensureAddon({ onStatus: log });\n    if (!addonResult.success) {\n      return {\n        success: false,\n        error: addonResult.error || 'Failed to install addon',\n        actions,\n      };\n    }\n    needsRestart = addonResult.needsRestart;\n  }\n\n  // Check if Local is running\n  const running = await isLocalRunning();\n\n  if (needsRestart && running) {\n    log('Restarting Local to activate addon...');\n    await restartLocal();\n  } else if (!running) {\n    log('Starting Local...');\n    await startLocal();\n  }\n\n  // Wait for GraphQL server\n  log('Waiting for GraphQL...');\n  const ready = await waitForGraphQL();\n\n  if (!ready) {\n    return {\n      success: false,\n      error: 'Timed out waiting for Local. Is Local running?',\n      actions,\n    };\n  }\n\n  log('GraphQL server ready.');\n\n  // Read connection info\n  const connectionInfo = readConnectionInfo();\n\n  if (!connectionInfo) {\n    return {\n      success: false,\n      error: 'Could not read GraphQL connection info.',\n      actions,\n    };\n  }\n\n  return {\n    success: true,\n    connectionInfo,\n    actions,\n  };\n}\n\nexport { getLocalPaths, LocalPaths };\n"]}