@gxp-dev/tools 2.0.5

package/bin/lib/tui/services/ServiceManager.ts

@@ -0,0 +1,336 @@
+import { spawn, ChildProcess, execSync } from 'child_process';
+import { EventEmitter } from 'events';
+
+export type ServiceStatus = 'stopped' | 'starting' | 'running' | 'error';
+
+export interface ServiceConfig {
+  id: string;
+  name: string;
+  command: string;
+  args: string[];
+  cwd: string;
+  env?: Record<string, string>;
+}
+
+// Store configs for restart capability
+const serviceConfigs: Map<string, ServiceConfig> = new Map();
+
+export interface ServiceState {
+  id: string;
+  name: string;
+  status: ServiceStatus;
+  logs: string[];
+  process?: ChildProcess;
+  pid?: number;
+  error?: string;
+}
+
+export class ServiceManager extends EventEmitter {
+  private services: Map<string, ServiceState> = new Map();
+  private maxLogLines = 1000;
+  private cleanupRegistered = false;
+
+  constructor() {
+    super();
+    this.registerCleanupHandlers();
+  }
+
+  // Register cleanup handlers to kill all services on exit
+  private registerCleanupHandlers(): void {
+    if (this.cleanupRegistered) return;
+    this.cleanupRegistered = true;
+
+    const cleanup = () => {
+      this.forceStopAll();
+    };
+
+    // Handle various exit scenarios
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    process.on('SIGHUP', cleanup);
+    process.on('beforeExit', cleanup);
+
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (err) => {
+      console.error('Uncaught exception:', err);
+      cleanup();
+      process.exit(1);
+    });
+  }
+
+  getService(id: string): ServiceState | undefined {
+    return this.services.get(id);
+  }
+
+  getAllServices(): ServiceState[] {
+    return Array.from(this.services.values());
+  }
+
+  isRunning(id: string): boolean {
+    const service = this.services.get(id);
+    return service?.status === 'running' || service?.status === 'starting';
+  }
+
+  start(config: ServiceConfig): ServiceState {
+    // Store config for restart capability
+    serviceConfigs.set(config.id, config);
+
+    // Check if already running
+    const existing = this.services.get(config.id);
+    if (existing && (existing.status === 'running' || existing.status === 'starting')) {
+      this.addLog(config.id, `[${config.name}] Already running`);
+      return existing;
+    }
+
+    // Create or reset service state
+    const state: ServiceState = {
+      id: config.id,
+      name: config.name,
+      status: 'starting',
+      logs: existing?.logs || [],
+    };
+    this.services.set(config.id, state);
+
+    this.addLog(config.id, `[${config.name}] Starting...`);
+    this.emit('statusChange', config.id, 'starting');
+
+    try {
+      // Spawn the process with environment variables to prevent stdin access
+      // CI=true disables interactive prompts in many tools
+      // These prevent child processes from trying to use raw stdin mode
+      // detached: true creates a new process group that doesn't share the parent's tty
+      const proc = spawn(config.command, config.args, {
+        cwd: config.cwd,
+        env: {
+          ...process.env,
+          ...config.env,
+          FORCE_COLOR: '1',
+          CI: 'true',
+        },
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true,
+      });
+
+      state.process = proc;
+      state.pid = proc.pid;
+
+      // Handle stdout
+      proc.stdout?.on('data', (data: Buffer) => {
+        const lines = data.toString().split('\n').filter(line => line.trim());
+        lines.forEach(line => {
+          this.addLog(config.id, line);
+        });
+
+        // Detect when service is ready
+        const output = data.toString();
+        if (state.status === 'starting') {
+          // Vite ready indicators
+          if (output.includes('ready in') || output.includes('Local:') || output.includes('VITE')) {
+            state.status = 'running';
+            this.emit('statusChange', config.id, 'running');
+          }
+          // Socket.IO ready indicator
+          if (output.includes('Socket.IO server') || output.includes('listening on port')) {
+            state.status = 'running';
+            this.emit('statusChange', config.id, 'running');
+          }
+        }
+      });
+
+      // Handle stderr
+      proc.stderr?.on('data', (data: Buffer) => {
+        const lines = data.toString().split('\n').filter(line => line.trim());
+        lines.forEach(line => {
+          this.addLog(config.id, `[stderr] ${line}`);
+        });
+      });
+
+      // Handle process exit
+      proc.on('close', (code) => {
+        state.process = undefined;
+        if (code === 0 || code === null) {
+          state.status = 'stopped';
+          this.addLog(config.id, `[${config.name}] Stopped`);
+        } else {
+          state.status = 'error';
+          state.error = `Process exited with code ${code}`;
+          this.addLog(config.id, `[${config.name}] Error: exited with code ${code}`);
+        }
+        this.emit('statusChange', config.id, state.status);
+      });
+
+      // Handle spawn errors
+      proc.on('error', (err) => {
+        state.status = 'error';
+        state.error = err.message;
+        state.process = undefined;
+        this.addLog(config.id, `[${config.name}] Error: ${err.message}`);
+        this.emit('statusChange', config.id, 'error');
+      });
+
+      // Set running after a short delay if no ready message detected
+      setTimeout(() => {
+        if (state.status === 'starting' && state.process) {
+          state.status = 'running';
+          this.emit('statusChange', config.id, 'running');
+        }
+      }, 3000);
+
+    } catch (err) {
+      state.status = 'error';
+      state.error = err instanceof Error ? err.message : 'Unknown error';
+      this.addLog(config.id, `[${config.name}] Failed to start: ${state.error}`);
+      this.emit('statusChange', config.id, 'error');
+    }
+
+    return state;
+  }
+
+  stop(id: string): boolean {
+    const service = this.services.get(id);
+    if (!service || !service.process) {
+      return false;
+    }
+
+    this.addLog(id, `[${service.name}] Stopping...`);
+
+    // Kill the process tree
+    try {
+      process.kill(-service.process.pid!, 'SIGTERM');
+    } catch {
+      // Process group kill failed, try direct kill
+      service.process.kill('SIGTERM');
+    }
+
+    // Force kill after timeout
+    setTimeout(() => {
+      if (service.process && !service.process.killed) {
+        try {
+          process.kill(-service.process.pid!, 'SIGKILL');
+        } catch {
+          service.process.kill('SIGKILL');
+        }
+      }
+    }, 2000);
+
+    return true;
+  }
+
+  stopAll(): void {
+    for (const [id] of this.services) {
+      this.stop(id);
+    }
+  }
+
+  // Force stop all services synchronously - used during process exit
+  forceStopAll(): void {
+    for (const [id, service] of this.services) {
+      if (service.pid) {
+        try {
+          // Try to kill the process group first
+          process.kill(-service.pid, 'SIGKILL');
+        } catch {
+          // Process group kill failed, try direct kill
+          try {
+            process.kill(service.pid, 'SIGKILL');
+          } catch {
+            // Process may already be dead
+          }
+        }
+      }
+      if (service.process && !service.process.killed) {
+        try {
+          service.process.kill('SIGKILL');
+        } catch {
+          // Ignore errors
+        }
+      }
+    }
+
+    // Also try to kill any orphaned vite/nodemon processes using lsof on common ports
+    try {
+      // Kill processes on typical dev ports synchronously
+      execSync('lsof -ti :3060 | xargs kill -9 2>/dev/null || true', { stdio: 'ignore' });
+      execSync('lsof -ti :3069 | xargs kill -9 2>/dev/null || true', { stdio: 'ignore' });
+    } catch {
+      // Ignore errors - best effort cleanup
+    }
+  }
+
+  restart(id: string): boolean {
+    const config = serviceConfigs.get(id);
+    if (!config) {
+      return false;
+    }
+
+    const service = this.services.get(id);
+    if (service?.process) {
+      // Stop first, then restart after process exits
+      this.addLog(id, `[${config.name}] Restarting...`);
+
+      const onExit = () => {
+        // Small delay to ensure cleanup
+        setTimeout(() => {
+          this.start(config);
+        }, 500);
+      };
+
+      // Listen for process exit once
+      service.process.once('close', onExit);
+
+      // Kill the process
+      try {
+        process.kill(-service.process.pid!, 'SIGTERM');
+      } catch {
+        service.process.kill('SIGTERM');
+      }
+
+      // Force kill after timeout
+      setTimeout(() => {
+        if (service.process && !service.process.killed) {
+          try {
+            process.kill(-service.process.pid!, 'SIGKILL');
+          } catch {
+            service.process.kill('SIGKILL');
+          }
+        }
+      }, 2000);
+    } else {
+      // Not running, just start
+      this.start(config);
+    }
+
+    return true;
+  }
+
+  getConfig(id: string): ServiceConfig | undefined {
+    return serviceConfigs.get(id);
+  }
+
+  clearLogs(id: string): void {
+    const service = this.services.get(id);
+    if (service) {
+      service.logs = [];
+      this.emit('logsCleared', id);
+    }
+  }
+
+  private addLog(id: string, message: string): void {
+    const service = this.services.get(id);
+    if (!service) return;
+
+    service.logs.push(message);
+
+    // Trim logs if too many
+    if (service.logs.length > this.maxLogLines) {
+      service.logs = service.logs.slice(-this.maxLogLines);
+    }
+
+    this.emit('log', id, message);
+  }
+}
+
+// Singleton instance
+export const serviceManager = new ServiceManager();

package/bin/lib/tui/services/SocketService.ts

@@ -0,0 +1,204 @@
+import { serviceManager, ServiceConfig } from './ServiceManager.js';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import https from 'https';
+import http from 'http';
+
+export interface SocketOptions {
+  cwd?: string;
+  withMock?: boolean;
+}
+
+export interface SocketEvent {
+  name: string;
+  event: string;
+  channel: string;
+  data: Record<string, unknown>;
+}
+
+// Get toolkit root
+function getToolkitRoot(): string {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  // From dist/tui/services/ go up 3 levels to toolkit root
+  return path.resolve(__dirname, '..', '..', '..');
+}
+
+// Get the path to the runtime server.js
+function getServerPath(): string {
+  const toolkitRoot = getToolkitRoot();
+  return path.join(toolkitRoot, 'runtime', 'server.js');
+}
+
+// Get the socket events directory
+function getSocketEventsDir(cwd: string): string | null {
+  // Check local project first
+  const localDir = path.join(cwd, 'socket-events');
+  if (fs.existsSync(localDir)) {
+    return localDir;
+  }
+
+  // Fall back to toolkit's socket-events
+  const toolkitDir = path.join(getToolkitRoot(), 'socket-events');
+  if (fs.existsSync(toolkitDir)) {
+    return toolkitDir;
+  }
+
+  return null;
+}
+
+export function startSocket(options: SocketOptions = {}): void {
+  const cwd = options.cwd || process.cwd();
+  const withMock = options.withMock || false;
+
+  const env: Record<string, string> = {
+    FORCE_COLOR: '1',
+  };
+
+  // Enable mock API if requested
+  if (withMock) {
+    env.MOCK_API_ENABLED = 'true';
+  }
+
+  const config: ServiceConfig = {
+    id: 'socket',
+    name: withMock ? 'Socket.IO + Mock API' : 'Socket.IO',
+    command: 'node',
+    args: [getServerPath()],
+    cwd,
+    env,
+  };
+
+  serviceManager.start(config);
+}
+
+export function stopSocket(): boolean {
+  return serviceManager.stop('socket');
+}
+
+export function isSocketRunning(): boolean {
+  return serviceManager.isRunning('socket');
+}
+
+// List available socket events
+export function listSocketEvents(cwd?: string): SocketEvent[] {
+  const eventsDir = getSocketEventsDir(cwd || process.cwd());
+  if (!eventsDir) {
+    return [];
+  }
+
+  const events: SocketEvent[] = [];
+  const files = fs.readdirSync(eventsDir).filter(f => f.endsWith('.json'));
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(eventsDir, file), 'utf-8');
+      const data = JSON.parse(content);
+      events.push({
+        name: path.basename(file, '.json'),
+        event: data.event,
+        channel: data.channel,
+        data: data.data,
+      });
+    } catch {
+      // Skip invalid files
+    }
+  }
+
+  return events;
+}
+
+// Send a socket event
+export async function sendSocketEvent(
+  eventName: string,
+  identifier?: string,
+  cwd?: string
+): Promise<{ success: boolean; message: string }> {
+  const eventsDir = getSocketEventsDir(cwd || process.cwd());
+  if (!eventsDir) {
+    return { success: false, message: 'Socket events directory not found' };
+  }
+
+  const eventPath = path.join(eventsDir, `${eventName}.json`);
+  if (!fs.existsSync(eventPath)) {
+    return { success: false, message: `Event "${eventName}" not found` };
+  }
+
+  try {
+    const content = fs.readFileSync(eventPath, 'utf-8');
+    const eventData = JSON.parse(content);
+
+    // Update channel if identifier provided
+    if (identifier) {
+      const channelParts = eventData.channel.split('.');
+      if (channelParts.length >= 2) {
+        const model = channelParts[1];
+        eventData.channel = `private.${model}.${identifier}`;
+      }
+    }
+
+    const socketPort = process.env.SOCKET_IO_PORT || 3069;
+    const payload = JSON.stringify({
+      event: eventData.event,
+      channel: eventData.channel,
+      data: eventData.data,
+    });
+
+    return new Promise((resolve) => {
+      // Try HTTPS first, then HTTP
+      const tryRequest = (useHttps: boolean) => {
+        const protocol = useHttps ? https : http;
+        const url = `${useHttps ? 'https' : 'http'}://localhost:${socketPort}/emit`;
+
+        const req = protocol.request(
+          url,
+          {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Content-Length': Buffer.byteLength(payload),
+            },
+            rejectUnauthorized: false, // Allow self-signed certs
+          },
+          (res) => {
+            if (res.statusCode === 200) {
+              resolve({
+                success: true,
+                message: `Sent "${eventData.event}" to channel "${eventData.channel}"`,
+              });
+            } else {
+              resolve({
+                success: false,
+                message: `Server returned status ${res.statusCode}`,
+              });
+            }
+          }
+        );
+
+        req.on('error', (err) => {
+          if (useHttps && err.message.includes('ECONNREFUSED')) {
+            // Try HTTP if HTTPS fails
+            tryRequest(false);
+          } else {
+            resolve({
+              success: false,
+              message: err.message.includes('ECONNREFUSED')
+                ? 'Socket.IO server not running. Start it with /socket'
+                : `Error: ${err.message}`,
+            });
+          }
+        });
+
+        req.write(payload);
+        req.end();
+      };
+
+      tryRequest(true);
+    });
+  } catch (err) {
+    return {
+      success: false,
+      message: `Error reading event file: ${err instanceof Error ? err.message : 'Unknown error'}`,
+    };
+  }
+}

package/bin/lib/tui/services/ViteService.ts

@@ -0,0 +1,107 @@
+import { serviceManager, ServiceConfig } from './ServiceManager.js';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+
+export interface ViteOptions {
+  noHttps?: boolean;
+  cwd?: string;
+}
+
+// Get the toolkit root directory
+function getToolkitRoot(): string {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  // Navigate from dist/tui/services to project root (3 levels up)
+  return path.resolve(__dirname, '..', '..', '..');
+}
+
+// Find existing SSL certificates in a directory
+function findExistingCertificates(certsDir: string): { certPath: string; keyPath: string } | null {
+  if (!fs.existsSync(certsDir)) return null;
+
+  const files = fs.readdirSync(certsDir);
+  const certFile = files.find(f => f.endsWith('.pem') && !f.includes('key'));
+  const keyFile = files.find(f => f.includes('key') && f.endsWith('.pem'));
+
+  if (certFile && keyFile) {
+    return {
+      certPath: path.join(certsDir, certFile),
+      keyPath: path.join(certsDir, keyFile),
+    };
+  }
+  return null;
+}
+
+export function startVite(options: ViteOptions = {}): void {
+  const cwd = options.cwd || process.cwd();
+  const toolkitRoot = getToolkitRoot();
+
+  // Load .env file if it exists
+  const envPath = path.join(cwd, '.env');
+  let envVars: Record<string, string> = {};
+
+  if (fs.existsSync(envPath)) {
+    const envResult = dotenv.config({ path: envPath });
+    if (envResult.parsed) {
+      envVars = { ...envResult.parsed };
+    }
+  }
+
+  // Determine HTTPS settings
+  let useHttps = !options.noHttps;
+  let certPath = '';
+  let keyPath = '';
+
+  if (useHttps) {
+    const certsDir = path.join(cwd, '.certs');
+    const existingCerts = findExistingCertificates(certsDir);
+    if (existingCerts) {
+      certPath = existingCerts.certPath;
+      keyPath = existingCerts.keyPath;
+    } else {
+      useHttps = false; // No certs found, fall back to HTTP
+    }
+  }
+
+  // Determine the port (priority: .env > default)
+  const port = envVars.NODE_PORT || '3060';
+
+  // Find vite.config.js (local or toolkit runtime)
+  const localViteConfig = path.join(cwd, 'vite.config.js');
+  // The correct vite.config.js is in the runtime directory, not the root
+  const toolkitViteConfig = path.join(toolkitRoot, 'runtime', 'vite.config.js');
+  const viteConfigPath = fs.existsSync(localViteConfig) ? localViteConfig : toolkitViteConfig;
+
+  // Build final environment variables
+  const env: Record<string, string> = {
+    ...envVars,
+    FORCE_COLOR: '1',
+    NODE_PORT: port,
+    USE_HTTPS: useHttps ? 'true' : 'false',
+    CERT_PATH: certPath,
+    KEY_PATH: keyPath,
+    COMPONENT_PATH: envVars.COMPONENT_PATH || './src/Plugin.vue',
+    NODE_LOG_LEVEL: envVars.NODE_LOG_LEVEL || 'info',
+  };
+
+  // Run vite directly with the correct config
+  const config: ServiceConfig = {
+    id: 'vite',
+    name: 'Vite',
+    command: 'npx',
+    args: ['vite', 'dev', '--config', viteConfigPath],
+    cwd,
+    env,
+  };
+
+  serviceManager.start(config);
+}
+
+export function stopVite(): boolean {
+  return serviceManager.stop('vite');
+}
+
+export function isViteRunning(): boolean {
+  return serviceManager.isRunning('vite');
+}

package/bin/lib/tui/services/index.ts

@@ -0,0 +1,13 @@
+export { serviceManager, ServiceManager, ServiceStatus, ServiceConfig, ServiceState } from './ServiceManager.js';
+export { startVite, stopVite, isViteRunning, ViteOptions } from './ViteService.js';
+export { startSocket, stopSocket, isSocketRunning, listSocketEvents, sendSocketEvent, SocketOptions, SocketEvent } from './SocketService.js';
+export { startExtension, stopExtension, isExtensionRunning, BrowserType, ExtensionOptions } from './ExtensionService.js';
+export {
+  geminiService,
+  GeminiService,
+  GeminiConfig,
+  isAuthenticated,
+  loadGeminiConfig,
+  saveGeminiConfig,
+  clearAuthTokens
+} from './GeminiService.js';