@local-labs-jpollock/local-cli 0.0.1

package/addon-dist/lib/renderer/index.js

@@ -0,0 +1,479 @@
+"use strict";
+/**
+ * MCP Server Addon - Renderer Entry Point
+ * Adds MCP Server preferences panel to Local
+ *
+ * Uses class components for compatibility with Local's Electron environment.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const theme_1 = require("../common/theme");
+// MCP Preferences Panel Component (Class-based for Local compatibility)
+class McpPreferencesPanel extends react_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.state = {
+            status: null,
+            connectionInfo: null,
+            loading: true,
+            copied: false,
+            actionInProgress: false,
+            activeTab: 'status',
+            colors: (0, theme_1.getThemeColors)(),
+        };
+        this.fetchStatus = async () => {
+            try {
+                const result = (await this.props.electron?.ipcRenderer?.invoke('mcp:getStatus'));
+                if (result) {
+                    this.setState({ status: result });
+                }
+            }
+            catch (error) {
+                console.error('Failed to fetch MCP status:', error);
+            }
+        };
+        this.fetchConnectionInfo = async () => {
+            try {
+                const result = (await this.props.electron?.ipcRenderer?.invoke('mcp:getConnectionInfo'));
+                if (result) {
+                    this.setState({ connectionInfo: result });
+                }
+            }
+            catch (error) {
+                console.error('Failed to fetch connection info:', error);
+            }
+        };
+        this.handleCopyStdioConfig = () => {
+            const config = {
+                mcpServers: {
+                    local: {
+                        type: 'stdio',
+                        command: 'node',
+                        args: ['/path/to/local-addon-mcp-server/bin/mcp-stdio.js'],
+                    },
+                },
+            };
+            navigator.clipboard.writeText(JSON.stringify(config, null, 2));
+            this.setState({ copied: true });
+            setTimeout(() => this.setState({ copied: false }), 2000);
+        };
+        this.handleCopySseConfig = () => {
+            const { connectionInfo } = this.state;
+            if (connectionInfo) {
+                const config = {
+                    mcpServers: {
+                        local: {
+                            url: `${connectionInfo.url}/mcp/sse`,
+                            transport: 'sse',
+                            headers: {
+                                Authorization: `Bearer ${connectionInfo.authToken}`,
+                            },
+                        },
+                    },
+                };
+                navigator.clipboard.writeText(JSON.stringify(config, null, 2));
+                this.setState({ copied: true });
+                setTimeout(() => this.setState({ copied: false }), 2000);
+            }
+        };
+        this.handleTestConnection = async () => {
+            const { connectionInfo } = this.state;
+            try {
+                const response = await fetch(`http://127.0.0.1:${connectionInfo?.port}/health`);
+                const data = await response.json();
+                if (data.status === 'ok') {
+                    alert('Connection successful! MCP server is healthy.');
+                }
+                else {
+                    alert('Connection failed: Server returned unexpected response');
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                alert(`Connection failed: ${message}`);
+            }
+        };
+        this.handleStartStop = async () => {
+            const { status } = this.state;
+            this.setState({ actionInProgress: true });
+            try {
+                if (status?.running) {
+                    await this.props.electron?.ipcRenderer?.invoke('mcp:stop');
+                }
+                else {
+                    await this.props.electron?.ipcRenderer?.invoke('mcp:start');
+                }
+                await this.fetchStatus();
+                await this.fetchConnectionInfo();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                alert(`Action failed: ${message}`);
+            }
+            finally {
+                this.setState({ actionInProgress: false });
+            }
+        };
+        this.handleRestart = async () => {
+            this.setState({ actionInProgress: true });
+            try {
+                await this.props.electron?.ipcRenderer?.invoke('mcp:restart');
+                await this.fetchStatus();
+                await this.fetchConnectionInfo();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                alert(`Restart failed: ${message}`);
+            }
+            finally {
+                this.setState({ actionInProgress: false });
+            }
+        };
+        this.handleRegenerateToken = async () => {
+            if (!confirm('Regenerate authentication token? You will need to update your AI tool configuration.')) {
+                return;
+            }
+            this.setState({ actionInProgress: true });
+            try {
+                const result = (await this.props.electron?.ipcRenderer?.invoke('mcp:regenerateToken'));
+                if (result?.success) {
+                    await this.fetchConnectionInfo();
+                    alert('Token regenerated successfully. Please update your AI tool configuration.');
+                }
+                else {
+                    alert(`Failed to regenerate token: ${result?.error}`);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                alert(`Failed to regenerate token: ${message}`);
+            }
+            finally {
+                this.setState({ actionInProgress: false });
+            }
+        };
+    }
+    componentDidMount() {
+        this.init();
+        this.statusInterval = setInterval(() => this.fetchStatus(), 5000);
+        this.themeCleanup = (0, theme_1.onThemeChange)(() => {
+            this.setState({ colors: (0, theme_1.getThemeColors)() });
+        });
+    }
+    componentWillUnmount() {
+        if (this.statusInterval) {
+            clearInterval(this.statusInterval);
+        }
+        if (this.themeCleanup) {
+            this.themeCleanup();
+        }
+    }
+    async init() {
+        await Promise.all([this.fetchStatus(), this.fetchConnectionInfo()]);
+        this.setState({ loading: false });
+    }
+    getStatusColor() {
+        const { status, colors } = this.state;
+        if (!status)
+            return colors.textMuted;
+        if (status.running)
+            return colors.successText;
+        return colors.errorText;
+    }
+    getStatusText() {
+        const { loading, status } = this.state;
+        if (loading)
+            return 'Loading...';
+        if (!status)
+            return 'Unknown';
+        if (status.running)
+            return 'Running';
+        return 'Stopped';
+    }
+    formatUptime(seconds) {
+        if (seconds < 60)
+            return `${Math.floor(seconds)}s`;
+        if (seconds < 3600)
+            return `${Math.floor(seconds / 60)}m`;
+        return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+    }
+    getTabStyle(isActive) {
+        const { colors } = this.state;
+        return {
+            padding: '8px 16px',
+            border: 'none',
+            borderBottom: isActive ? `2px solid ${colors.primary}` : '2px solid transparent',
+            backgroundColor: 'transparent',
+            color: isActive ? colors.primary : colors.textSecondary,
+            cursor: 'pointer',
+            fontSize: '14px',
+            fontWeight: isActive ? 600 : 400,
+        };
+    }
+    getButtonStyle(bgColor, disabled) {
+        return {
+            padding: '8px 16px',
+            backgroundColor: bgColor,
+            color: 'white',
+            border: 'none',
+            borderRadius: '4px',
+            cursor: disabled ? 'not-allowed' : 'pointer',
+            fontSize: '13px',
+            opacity: disabled ? 0.5 : 1,
+        };
+    }
+    renderStatusTab() {
+        const { status, connectionInfo, actionInProgress, colors } = this.state;
+        return (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Server Status"),
+                react_1.default.createElement("div", { style: {
+                        display: 'flex',
+                        alignItems: 'center',
+                        gap: '12px',
+                        padding: '12px',
+                        backgroundColor: colors.panelBgSecondary,
+                        borderRadius: '6px',
+                    } },
+                    react_1.default.createElement("span", { style: {
+                            width: '12px',
+                            height: '12px',
+                            borderRadius: '50%',
+                            backgroundColor: this.getStatusColor(),
+                        } }),
+                    react_1.default.createElement("span", { style: { fontWeight: 500, color: colors.textPrimary } }, this.getStatusText()),
+                    status?.running && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement("span", { style: { color: colors.textSecondary } }, "|"),
+                        react_1.default.createElement("span", { style: { color: colors.textSecondary } },
+                            "Port: ",
+                            status.port),
+                        react_1.default.createElement("span", { style: { color: colors.textSecondary } }, "|"),
+                        react_1.default.createElement("span", { style: { color: colors.textSecondary } },
+                            "Uptime: ",
+                            this.formatUptime(status.uptime)))))),
+            react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Server Controls"),
+                react_1.default.createElement("div", { style: { display: 'flex', gap: '12px', flexWrap: 'wrap' } },
+                    react_1.default.createElement("button", { onClick: this.handleStartStop, disabled: actionInProgress, style: this.getButtonStyle(status?.running ? colors.errorText : colors.successText, actionInProgress) }, status?.running ? 'Stop Server' : 'Start Server'),
+                    react_1.default.createElement("button", { onClick: this.handleRestart, disabled: actionInProgress || !status?.running, style: this.getButtonStyle('#6c757d', actionInProgress || !status?.running) }, "Restart Server"),
+                    react_1.default.createElement("button", { onClick: this.handleTestConnection, disabled: !status?.running, style: this.getButtonStyle(status?.running ? '#17a2b8' : colors.textMuted, !status?.running) }, "Test Connection"))),
+            connectionInfo && (react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Connection Info"),
+                react_1.default.createElement("div", { style: {
+                        padding: '12px',
+                        backgroundColor: colors.panelBgSecondary,
+                        borderRadius: '6px',
+                        fontFamily: 'monospace',
+                        fontSize: '12px',
+                        color: colors.textPrimary,
+                    } },
+                    react_1.default.createElement("div", { style: { marginBottom: '8px' } },
+                        react_1.default.createElement("strong", null, "URL:"),
+                        " ",
+                        connectionInfo.url),
+                    react_1.default.createElement("div", { style: { marginBottom: '8px' } },
+                        react_1.default.createElement("strong", null, "stdio script:"),
+                        " bin/mcp-stdio.js"),
+                    react_1.default.createElement("div", { style: { marginBottom: '8px' } },
+                        react_1.default.createElement("strong", null, "Version:"),
+                        " ",
+                        connectionInfo.version),
+                    react_1.default.createElement("div", null,
+                        react_1.default.createElement("strong", null, "Tools:"),
+                        " ",
+                        connectionInfo.tools.join(', '))))),
+            react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Security"),
+                react_1.default.createElement("div", { style: { display: 'flex', gap: '12px', flexWrap: 'wrap' } },
+                    react_1.default.createElement("button", { onClick: this.handleRegenerateToken, disabled: actionInProgress || !status?.running, style: {
+                            padding: '8px 16px',
+                            backgroundColor: '#ffc107',
+                            color: '#212529',
+                            border: 'none',
+                            borderRadius: '4px',
+                            cursor: actionInProgress || !status?.running ? 'not-allowed' : 'pointer',
+                            fontSize: '13px',
+                            opacity: actionInProgress || !status?.running ? 0.5 : 1,
+                        } }, "Regenerate Token")),
+                react_1.default.createElement("p", { style: { fontSize: '12px', color: colors.textSecondary, marginTop: '8px' } }, "Regenerating the token will require you to update your AI tool configuration."))));
+    }
+    renderSetupTab() {
+        const { connectionInfo, copied, colors } = this.state;
+        return (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Claude Code (Recommended)"),
+                react_1.default.createElement("div", { style: {
+                        padding: '16px',
+                        backgroundColor: colors.panelBgSecondary,
+                        borderRadius: '6px',
+                    } },
+                    react_1.default.createElement("p", { style: { margin: '0 0 12px 0', fontSize: '13px', color: colors.textPrimary } },
+                        "Add the following to your",
+                        ' ',
+                        react_1.default.createElement("code", { style: {
+                                backgroundColor: colors.panelBgCode,
+                                padding: '2px 4px',
+                                borderRadius: '3px',
+                                color: '#f8f8f2',
+                            } }, "~/.claude.json"),
+                        ' ',
+                        "file:"),
+                    react_1.default.createElement("pre", { style: {
+                            backgroundColor: colors.panelBgCode,
+                            color: '#f8f8f2',
+                            padding: '12px',
+                            borderRadius: '4px',
+                            fontSize: '11px',
+                            overflow: 'auto',
+                            margin: '0 0 12px 0',
+                        } }, `{
+  "mcpServers": {
+    "local": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/path/to/local-addon-mcp-server/bin/mcp-stdio.js"]
+    }
+  }
+}`),
+                    react_1.default.createElement("button", { onClick: this.handleCopyStdioConfig, style: this.getButtonStyle(colors.primary) }, copied ? 'Copied!' : 'Copy Config'))),
+            react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Claude.ai / ChatGPT / Other AI Tools"),
+                react_1.default.createElement("div", { style: {
+                        padding: '16px',
+                        backgroundColor: colors.panelBgSecondary,
+                        borderRadius: '6px',
+                    } },
+                    react_1.default.createElement("p", { style: { margin: '0 0 12px 0', fontSize: '13px', color: colors.textPrimary } }, "For tools that support SSE transport, use this configuration:"),
+                    react_1.default.createElement("pre", { style: {
+                            backgroundColor: colors.panelBgCode,
+                            color: '#f8f8f2',
+                            padding: '12px',
+                            borderRadius: '4px',
+                            fontSize: '11px',
+                            overflow: 'auto',
+                            margin: '0 0 12px 0',
+                        } }, connectionInfo
+                        ? `{
+  "mcpServers": {
+    "local": {
+      "url": "${connectionInfo.url}/mcp/sse",
+      "transport": "sse",
+      "headers": {
+        "Authorization": "Bearer ${connectionInfo.authToken.substring(0, 20)}..."
+      }
+    }
+  }
+}`
+                        : 'Server not running'),
+                    react_1.default.createElement("button", { onClick: this.handleCopySseConfig, disabled: !connectionInfo, style: this.getButtonStyle(connectionInfo ? colors.primary : colors.textMuted, !connectionInfo) }, copied ? 'Copied!' : 'Copy SSE Config'))),
+            react_1.default.createElement("div", { style: { marginBottom: '24px' } },
+                react_1.default.createElement("h3", { style: {
+                        fontSize: '14px',
+                        fontWeight: 600,
+                        marginBottom: '12px',
+                        color: colors.textPrimary,
+                    } }, "Example Commands"),
+                react_1.default.createElement("div", { style: {
+                        padding: '16px',
+                        backgroundColor: colors.infoBg,
+                        borderRadius: '6px',
+                        border: `1px solid ${colors.infoBorder}`,
+                    } },
+                    react_1.default.createElement("p", { style: {
+                            margin: '0 0 8px 0',
+                            fontSize: '13px',
+                            fontWeight: 500,
+                            color: colors.infoText,
+                        } }, "Try saying to your AI assistant:"),
+                    react_1.default.createElement("ul", { style: { margin: 0, paddingLeft: '20px', fontSize: '13px', color: colors.infoText } },
+                        react_1.default.createElement("li", null, "\"List my Local sites\""),
+                        react_1.default.createElement("li", null, "\"Start the blog site\""),
+                        react_1.default.createElement("li", null, "\"Create a new site called test-project\""),
+                        react_1.default.createElement("li", null, "\"Run wp plugin list on my-site\""),
+                        react_1.default.createElement("li", null, "\"Stop all running sites\""),
+                        react_1.default.createElement("li", null, "\"What plugins are installed on my-site?\""))))));
+    }
+    render() {
+        const { activeTab, colors } = this.state;
+        return (react_1.default.createElement("div", { style: { padding: '20px', color: colors.textPrimary } },
+            react_1.default.createElement("h2", { style: {
+                    marginBottom: '20px',
+                    fontSize: '18px',
+                    fontWeight: 600,
+                    color: colors.textPrimary,
+                } }, "MCP Server"),
+            react_1.default.createElement("p", { style: { color: colors.textSecondary, marginBottom: '24px' } }, "The MCP (Model Context Protocol) server enables AI tools like Claude Code to control your Local sites."),
+            react_1.default.createElement("div", { style: { borderBottom: `1px solid ${colors.border}`, marginBottom: '24px' } },
+                react_1.default.createElement("button", { style: this.getTabStyle(activeTab === 'status'), onClick: () => this.setState({ activeTab: 'status' }) }, "Status & Controls"),
+                react_1.default.createElement("button", { style: this.getTabStyle(activeTab === 'setup'), onClick: () => this.setState({ activeTab: 'setup' }) }, "AI Tool Setup")),
+            activeTab === 'status' && this.renderStatusTab(),
+            activeTab === 'setup' && this.renderSetupTab()));
+    }
+}
+// Export as a constructor function that Local can instantiate
+module.exports = function McpServerRenderer(context) {
+    // CLI-only mode - preferences panel disabled
+    // To enable MCP preferences UI, uncomment the following:
+    /*
+    const { hooks, electron } = context as {
+      hooks: { addFilter: (name: string, callback: (items: unknown[]) => unknown[]) => void };
+      electron: McpPreferencesPanelProps['electron'];
+    };
+  
+    console.log('[MCP Server] Renderer loading...');
+  
+    // Add MCP Server to preferences menu
+    hooks.addFilter('preferencesMenuItems', (menuItems: unknown[]) => {
+      console.log('[MCP Server] Adding MCP Server to preferences');
+  
+      (menuItems as Array<Record<string, unknown>>).push({
+        path: 'mcp-server',
+        displayName: 'MCP Server',
+        sections: () => <McpPreferencesPanel electron={electron} />,
+        onApply: () => {
+          // No apply action needed for read-only display
+        },
+      });
+  
+      return menuItems;
+    });
+  
+    console.log('[MCP Server] Renderer setup complete');
+    */
+    // Silence unused variable warnings
+    void context;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/renderer/index.tsx"],"names":[],"mappings":"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","sourcesContent":["/**\n * MCP Server Addon - Renderer Entry Point\n * Adds MCP Server preferences panel to Local\n *\n * Uses class components for compatibility with Local's Electron environment.\n */\n\nimport React from 'react';\nimport { getThemeColors, onThemeChange, ThemeColors } from '../common/theme';\n\n// Type definitions\ninterface McpStatus {\n  running: boolean;\n  port: number;\n  uptime: number;\n  error?: string;\n}\n\ninterface ConnectionInfo {\n  url: string;\n  authToken: string;\n  port: number;\n  version: string;\n  tools: string[];\n}\n\ninterface McpPreferencesPanelProps {\n  electron: {\n    ipcRenderer?: {\n      invoke: (channel: string, ...args: unknown[]) => Promise<unknown>;\n    };\n  };\n}\n\ninterface McpPreferencesPanelState {\n  status: McpStatus | null;\n  connectionInfo: ConnectionInfo | null;\n  loading: boolean;\n  copied: boolean;\n  actionInProgress: boolean;\n  activeTab: 'status' | 'setup';\n  colors: ThemeColors;\n}\n\n// MCP Preferences Panel Component (Class-based for Local compatibility)\nclass McpPreferencesPanel extends React.Component<\n  McpPreferencesPanelProps,\n  McpPreferencesPanelState\n> {\n  private statusInterval?: ReturnType<typeof setInterval>;\n  private themeCleanup?: () => void;\n\n  state: McpPreferencesPanelState = {\n    status: null,\n    connectionInfo: null,\n    loading: true,\n    copied: false,\n    actionInProgress: false,\n    activeTab: 'status',\n    colors: getThemeColors(),\n  };\n\n  componentDidMount(): void {\n    this.init();\n    this.statusInterval = setInterval(() => this.fetchStatus(), 5000);\n    this.themeCleanup = onThemeChange(() => {\n      this.setState({ colors: getThemeColors() });\n    });\n  }\n\n  componentWillUnmount(): void {\n    if (this.statusInterval) {\n      clearInterval(this.statusInterval);\n    }\n    if (this.themeCleanup) {\n      this.themeCleanup();\n    }\n  }\n\n  private async init(): Promise<void> {\n    await Promise.all([this.fetchStatus(), this.fetchConnectionInfo()]);\n    this.setState({ loading: false });\n  }\n\n  private fetchStatus = async (): Promise<void> => {\n    try {\n      const result = (await this.props.electron?.ipcRenderer?.invoke('mcp:getStatus')) as\n        | McpStatus\n        | undefined;\n      if (result) {\n        this.setState({ status: result });\n      }\n    } catch (error) {\n      console.error('Failed to fetch MCP status:', error);\n    }\n  };\n\n  private fetchConnectionInfo = async (): Promise<void> => {\n    try {\n      const result = (await this.props.electron?.ipcRenderer?.invoke('mcp:getConnectionInfo')) as\n        | ConnectionInfo\n        | undefined;\n      if (result) {\n        this.setState({ connectionInfo: result });\n      }\n    } catch (error) {\n      console.error('Failed to fetch connection info:', error);\n    }\n  };\n\n  private handleCopyStdioConfig = (): void => {\n    const config = {\n      mcpServers: {\n        local: {\n          type: 'stdio',\n          command: 'node',\n          args: ['/path/to/local-addon-mcp-server/bin/mcp-stdio.js'],\n        },\n      },\n    };\n    navigator.clipboard.writeText(JSON.stringify(config, null, 2));\n    this.setState({ copied: true });\n    setTimeout(() => this.setState({ copied: false }), 2000);\n  };\n\n  private handleCopySseConfig = (): void => {\n    const { connectionInfo } = this.state;\n    if (connectionInfo) {\n      const config = {\n        mcpServers: {\n          local: {\n            url: `${connectionInfo.url}/mcp/sse`,\n            transport: 'sse',\n            headers: {\n              Authorization: `Bearer ${connectionInfo.authToken}`,\n            },\n          },\n        },\n      };\n      navigator.clipboard.writeText(JSON.stringify(config, null, 2));\n      this.setState({ copied: true });\n      setTimeout(() => this.setState({ copied: false }), 2000);\n    }\n  };\n\n  private handleTestConnection = async (): Promise<void> => {\n    const { connectionInfo } = this.state;\n    try {\n      const response = await fetch(`http://127.0.0.1:${connectionInfo?.port}/health`);\n      const data = await response.json();\n      if (data.status === 'ok') {\n        alert('Connection successful! MCP server is healthy.');\n      } else {\n        alert('Connection failed: Server returned unexpected response');\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      alert(`Connection failed: ${message}`);\n    }\n  };\n\n  private handleStartStop = async (): Promise<void> => {\n    const { status } = this.state;\n    this.setState({ actionInProgress: true });\n    try {\n      if (status?.running) {\n        await this.props.electron?.ipcRenderer?.invoke('mcp:stop');\n      } else {\n        await this.props.electron?.ipcRenderer?.invoke('mcp:start');\n      }\n      await this.fetchStatus();\n      await this.fetchConnectionInfo();\n    } catch (error) {\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      alert(`Action failed: ${message}`);\n    } finally {\n      this.setState({ actionInProgress: false });\n    }\n  };\n\n  private handleRestart = async (): Promise<void> => {\n    this.setState({ actionInProgress: true });\n    try {\n      await this.props.electron?.ipcRenderer?.invoke('mcp:restart');\n      await this.fetchStatus();\n      await this.fetchConnectionInfo();\n    } catch (error) {\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      alert(`Restart failed: ${message}`);\n    } finally {\n      this.setState({ actionInProgress: false });\n    }\n  };\n\n  private handleRegenerateToken = async (): Promise<void> => {\n    if (\n      !confirm(\n        'Regenerate authentication token? You will need to update your AI tool configuration.'\n      )\n    ) {\n      return;\n    }\n    this.setState({ actionInProgress: true });\n    try {\n      const result = (await this.props.electron?.ipcRenderer?.invoke('mcp:regenerateToken')) as {\n        success?: boolean;\n        error?: string;\n      };\n      if (result?.success) {\n        await this.fetchConnectionInfo();\n        alert('Token regenerated successfully. Please update your AI tool configuration.');\n      } else {\n        alert(`Failed to regenerate token: ${result?.error}`);\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : 'Unknown error';\n      alert(`Failed to regenerate token: ${message}`);\n    } finally {\n      this.setState({ actionInProgress: false });\n    }\n  };\n\n  private getStatusColor(): string {\n    const { status, colors } = this.state;\n    if (!status) return colors.textMuted;\n    if (status.running) return colors.successText;\n    return colors.errorText;\n  }\n\n  private getStatusText(): string {\n    const { loading, status } = this.state;\n    if (loading) return 'Loading...';\n    if (!status) return 'Unknown';\n    if (status.running) return 'Running';\n    return 'Stopped';\n  }\n\n  private formatUptime(seconds: number): string {\n    if (seconds < 60) return `${Math.floor(seconds)}s`;\n    if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;\n    return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;\n  }\n\n  private getTabStyle(isActive: boolean): React.CSSProperties {\n    const { colors } = this.state;\n    return {\n      padding: '8px 16px',\n      border: 'none',\n      borderBottom: isActive ? `2px solid ${colors.primary}` : '2px solid transparent',\n      backgroundColor: 'transparent',\n      color: isActive ? colors.primary : colors.textSecondary,\n      cursor: 'pointer',\n      fontSize: '14px',\n      fontWeight: isActive ? 600 : 400,\n    };\n  }\n\n  private getButtonStyle(bgColor: string, disabled?: boolean): React.CSSProperties {\n    return {\n      padding: '8px 16px',\n      backgroundColor: bgColor,\n      color: 'white',\n      border: 'none',\n      borderRadius: '4px',\n      cursor: disabled ? 'not-allowed' : 'pointer',\n      fontSize: '13px',\n      opacity: disabled ? 0.5 : 1,\n    };\n  }\n\n  private renderStatusTab(): React.ReactNode {\n    const { status, connectionInfo, actionInProgress, colors } = this.state;\n\n    return (\n      <>\n        {/* Status Section */}\n        <div style={{ marginBottom: '24px' }}>\n          <h3\n            style={{\n              fontSize: '14px',\n              fontWeight: 600,\n              marginBottom: '12px',\n              color: colors.textPrimary,\n            }}\n          >\n            Server Status\n          </h3>\n          <div\n            style={{\n              display: 'flex',\n              alignItems: 'center',\n              gap: '12px',\n              padding: '12px',\n              backgroundColor: colors.panelBgSecondary,\n              borderRadius: '6px',\n            }}\n          >\n            <span\n              style={{\n                width: '12px',\n                height: '12px',\n                borderRadius: '50%',\n                backgroundColor: this.getStatusColor(),\n              }}\n            />\n            <span style={{ fontWeight: 500, color: colors.textPrimary }}>\n              {this.getStatusText()}\n            </span>\n            {status?.running && (\n              <>\n                <span style={{ color: colors.textSecondary }}>|</span>\n                <span style={{ color: colors.textSecondary }}>Port: {status.port}</span>\n                <span style={{ color: colors.textSecondary }}>|</span>\n                <span style={{ color: colors.textSecondary }}>\n                  Uptime: {this.formatUptime(status.uptime)}\n                </span>\n              </>\n            )}\n          </div>\n        </div>\n\n        {/* Server Controls */}\n        <div style={{ marginBottom: '24px' }}>\n          <h3\n            style={{\n              fontSize: '14px',\n              fontWeight: 600,\n              marginBottom: '12px',\n              color: colors.textPrimary,\n            }}\n          >\n            Server Controls\n          </h3>\n          <div style={{ display: 'flex', gap: '12px', flexWrap: 'wrap' }}>\n            <button\n              onClick={this.handleStartStop}\n              disabled={actionInProgress}\n              style={this.getButtonStyle(\n                status?.running ? colors.errorText : colors.successText,\n                actionInProgress\n              )}\n            >\n              {status?.running ? 'Stop Server' : 'Start Server'}\n            </button>\n            <button\n              onClick={this.handleRestart}\n              disabled={actionInProgress || !status?.running}\n              style={this.getButtonStyle('#6c757d', actionInProgress || !status?.running)}\n            >\n              Restart Server\n            </button>\n            <button\n              onClick={this.handleTestConnection}\n              disabled={!status?.running}\n              style={this.getButtonStyle(\n                status?.running ? '#17a2b8' : colors.textMuted,\n                !status?.running\n              )}\n            >\n              Test Connection\n            </button>\n          </div>\n        </div>\n\n        {/* Connection Info Section */}\n        {connectionInfo && (\n          <div style={{ marginBottom: '24px' }}>\n            <h3\n              style={{\n                fontSize: '14px',\n                fontWeight: 600,\n                marginBottom: '12px',\n                color: colors.textPrimary,\n              }}\n            >\n              Connection Info\n            </h3>\n            <div\n              style={{\n                padding: '12px',\n                backgroundColor: colors.panelBgSecondary,\n                borderRadius: '6px',\n                fontFamily: 'monospace',\n                fontSize: '12px',\n                color: colors.textPrimary,\n              }}\n            >\n              <div style={{ marginBottom: '8px' }}>\n                <strong>URL:</strong> {connectionInfo.url}\n              </div>\n              <div style={{ marginBottom: '8px' }}>\n                <strong>stdio script:</strong> bin/mcp-stdio.js\n              </div>\n              <div style={{ marginBottom: '8px' }}>\n                <strong>Version:</strong> {connectionInfo.version}\n              </div>\n              <div>\n                <strong>Tools:</strong> {connectionInfo.tools.join(', ')}\n              </div>\n            </div>\n          </div>\n        )}\n\n        {/* Security Section */}\n        <div style={{ marginBottom: '24px' }}>\n          <h3\n            style={{\n              fontSize: '14px',\n              fontWeight: 600,\n              marginBottom: '12px',\n              color: colors.textPrimary,\n            }}\n          >\n            Security\n          </h3>\n          <div style={{ display: 'flex', gap: '12px', flexWrap: 'wrap' }}>\n            <button\n              onClick={this.handleRegenerateToken}\n              disabled={actionInProgress || !status?.running}\n              style={{\n                padding: '8px 16px',\n                backgroundColor: '#ffc107',\n                color: '#212529',\n                border: 'none',\n                borderRadius: '4px',\n                cursor: actionInProgress || !status?.running ? 'not-allowed' : 'pointer',\n                fontSize: '13px',\n                opacity: actionInProgress || !status?.running ? 0.5 : 1,\n              }}\n            >\n              Regenerate Token\n            </button>\n          </div>\n          <p style={{ fontSize: '12px', color: colors.textSecondary, marginTop: '8px' }}>\n            Regenerating the token will require you to update your AI tool configuration.\n          </p>\n        </div>\n      </>\n    );\n  }\n\n  private renderSetupTab(): React.ReactNode {\n    const { connectionInfo, copied, colors } = this.state;\n\n    return (\n      <>\n        {/* Claude Code Setup */}\n        <div style={{ marginBottom: '24px' }}>\n          <h3\n            style={{\n              fontSize: '14px',\n              fontWeight: 600,\n              marginBottom: '12px',\n              color: colors.textPrimary,\n            }}\n          >\n            Claude Code (Recommended)\n          </h3>\n          <div\n            style={{\n              padding: '16px',\n              backgroundColor: colors.panelBgSecondary,\n              borderRadius: '6px',\n            }}\n          >\n            <p style={{ margin: '0 0 12px 0', fontSize: '13px', color: colors.textPrimary }}>\n              Add the following to your{' '}\n              <code\n                style={{\n                  backgroundColor: colors.panelBgCode,\n                  padding: '2px 4px',\n                  borderRadius: '3px',\n                  color: '#f8f8f2',\n                }}\n              >\n                ~/.claude.json\n              </code>{' '}\n              file:\n            </p>\n            <pre\n              style={{\n                backgroundColor: colors.panelBgCode,\n                color: '#f8f8f2',\n                padding: '12px',\n                borderRadius: '4px',\n                fontSize: '11px',\n                overflow: 'auto',\n                margin: '0 0 12px 0',\n              }}\n            >\n              {`{\n  \"mcpServers\": {\n    \"local\": {\n      \"type\": \"stdio\",\n      \"command\": \"node\",\n      \"args\": [\"/path/to/local-addon-mcp-server/bin/mcp-stdio.js\"]\n    }\n  }\n}`}\n            </pre>\n            <button\n              onClick={this.handleCopyStdioConfig}\n              style={this.getButtonStyle(colors.primary)}\n            >\n              {copied ? 'Copied!' : 'Copy Config'}\n            </button>\n          </div>\n        </div>\n\n        {/* Claude.ai / ChatGPT Setup */}\n        <div style={{ marginBottom: '24px' }}>\n          <h3\n            style={{\n              fontSize: '14px',\n              fontWeight: 600,\n              marginBottom: '12px',\n              color: colors.textPrimary,\n            }}\n          >\n            Claude.ai / ChatGPT / Other AI Tools\n          </h3>\n          <div\n            style={{\n              padding: '16px',\n              backgroundColor: colors.panelBgSecondary,\n              borderRadius: '6px',\n            }}\n          >\n            <p style={{ margin: '0 0 12px 0', fontSize: '13px', color: colors.textPrimary }}>\n              For tools that support SSE transport, use this configuration:\n            </p>\n            <pre\n              style={{\n                backgroundColor: colors.panelBgCode,\n                color: '#f8f8f2',\n                padding: '12px',\n                borderRadius: '4px',\n                fontSize: '11px',\n                overflow: 'auto',\n                margin: '0 0 12px 0',\n              }}\n            >\n              {connectionInfo\n                ? `{\n  \"mcpServers\": {\n    \"local\": {\n      \"url\": \"${connectionInfo.url}/mcp/sse\",\n      \"transport\": \"sse\",\n      \"headers\": {\n        \"Authorization\": \"Bearer ${connectionInfo.authToken.substring(0, 20)}...\"\n      }\n    }\n  }\n}`\n                : 'Server not running'}\n            </pre>\n            <button\n              onClick={this.handleCopySseConfig}\n              disabled={!connectionInfo}\n              style={this.getButtonStyle(\n                connectionInfo ? colors.primary : colors.textMuted,\n                !connectionInfo\n              )}\n            >\n              {copied ? 'Copied!' : 'Copy SSE Config'}\n            </button>\n          </div>\n        </div>\n\n        {/* Available Commands */}\n        <div style={{ marginBottom: '24px' }}>\n          <h3\n            style={{\n              fontSize: '14px',\n              fontWeight: 600,\n              marginBottom: '12px',\n              color: colors.textPrimary,\n            }}\n          >\n            Example Commands\n          </h3>\n          <div\n            style={{\n              padding: '16px',\n              backgroundColor: colors.infoBg,\n              borderRadius: '6px',\n              border: `1px solid ${colors.infoBorder}`,\n            }}\n          >\n            <p\n              style={{\n                margin: '0 0 8px 0',\n                fontSize: '13px',\n                fontWeight: 500,\n                color: colors.infoText,\n              }}\n            >\n              Try saying to your AI assistant:\n            </p>\n            <ul\n              style={{ margin: 0, paddingLeft: '20px', fontSize: '13px', color: colors.infoText }}\n            >\n              <li>&quot;List my Local sites&quot;</li>\n              <li>&quot;Start the blog site&quot;</li>\n              <li>&quot;Create a new site called test-project&quot;</li>\n              <li>&quot;Run wp plugin list on my-site&quot;</li>\n              <li>&quot;Stop all running sites&quot;</li>\n              <li>&quot;What plugins are installed on my-site?&quot;</li>\n            </ul>\n          </div>\n        </div>\n      </>\n    );\n  }\n\n  render(): React.ReactNode {\n    const { activeTab, colors } = this.state;\n\n    return (\n      <div style={{ padding: '20px', color: colors.textPrimary }}>\n        <h2\n          style={{\n            marginBottom: '20px',\n            fontSize: '18px',\n            fontWeight: 600,\n            color: colors.textPrimary,\n          }}\n        >\n          MCP Server\n        </h2>\n\n        <p style={{ color: colors.textSecondary, marginBottom: '24px' }}>\n          The MCP (Model Context Protocol) server enables AI tools like Claude Code to control your\n          Local sites.\n        </p>\n\n        {/* Tab Navigation */}\n        <div style={{ borderBottom: `1px solid ${colors.border}`, marginBottom: '24px' }}>\n          <button\n            style={this.getTabStyle(activeTab === 'status')}\n            onClick={() => this.setState({ activeTab: 'status' })}\n          >\n            Status &amp; Controls\n          </button>\n          <button\n            style={this.getTabStyle(activeTab === 'setup')}\n            onClick={() => this.setState({ activeTab: 'setup' })}\n          >\n            AI Tool Setup\n          </button>\n        </div>\n\n        {activeTab === 'status' && this.renderStatusTab()}\n        {activeTab === 'setup' && this.renderSetupTab()}\n      </div>\n    );\n  }\n}\n\n// Export as a constructor function that Local can instantiate\nmodule.exports = function McpServerRenderer(context: { hooks: unknown; electron: unknown }): void {\n  // CLI-only mode - preferences panel disabled\n  // To enable MCP preferences UI, uncomment the following:\n  /*\n  const { hooks, electron } = context as {\n    hooks: { addFilter: (name: string, callback: (items: unknown[]) => unknown[]) => void };\n    electron: McpPreferencesPanelProps['electron'];\n  };\n\n  console.log('[MCP Server] Renderer loading...');\n\n  // Add MCP Server to preferences menu\n  hooks.addFilter('preferencesMenuItems', (menuItems: unknown[]) => {\n    console.log('[MCP Server] Adding MCP Server to preferences');\n\n    (menuItems as Array<Record<string, unknown>>).push({\n      path: 'mcp-server',\n      displayName: 'MCP Server',\n      sections: () => <McpPreferencesPanel electron={electron} />,\n      onApply: () => {\n        // No apply action needed for read-only display\n      },\n    });\n\n    return menuItems;\n  });\n\n  console.log('[MCP Server] Renderer setup complete');\n  */\n\n  // Silence unused variable warnings\n  void context;\n};\n"]}

package/addon-dist/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@local-labs-jpollock/local-addon-cli",
+  "productName": "Local CLI",
+  "version": "0.0.1",
+  "description": "Command-line interface for Local WordPress development",
+  "main": "lib/main/index.js",
+  "renderer": "lib/renderer/index.js",
+  "bin": {
+    "local-mcp": "./bin/mcp-stdio.js"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "watch": "tsc --watch",
+    "clean": "rm -rf lib coverage",
+    "lint": "eslint src --ext .ts,.tsx --max-warnings=0",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx}\"",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "local",
+    "addon",
+    "cli",
+    "wordpress",
+    "development"
+  ],
+  "author": "Jeremy Pollock <jpollock911@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jpollock/local-addon-cli.git",
+    "directory": "packages/addon"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@getflywheel/local": "^9.0.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.0.0",
+    "@types/react": "^19.2.10",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-react": "^7.34.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "graphql-tag": "^2.12.6",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.0.0"
+  },
+  "localAddon": {
+    "minimumLocalVersion": "9.0.0",
+    "type": "addon",
+    "category": "developer-tools"
+  },
+  "dependencies": {
+    "node-stream-zip": "^1.15.0"
+  }
+}