@gxp-dev/tools 2.0.62 → 2.0.64

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

@@ -1,204 +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';
+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;
+	cwd?: string
+	withMock?: boolean
 }
 
 export interface SocketEvent {
-  name: string;
-  event: string;
-  channel: string;
-  data: Record<string, unknown>;
+	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, '..', '..', '..');
+	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');
+	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;
+	// 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);
+	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');
+	return serviceManager.stop("socket")
 }
 
 export function isSocketRunning(): boolean {
-  return serviceManager.isRunning('socket');
+	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;
+	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
+	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'}`,
-    };
-  }
+	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

@@ -1,107 +1,107 @@
-import { serviceManager, ServiceConfig } from './ServiceManager.js';
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import dotenv from 'dotenv';
+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;
+	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, '..', '..', '..');
+	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;
+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);
+	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"
+
+	// Vite config always comes from the runtime. Projects extend it via an
+	// optional `vite.extend.js` at the project root.
+	const viteConfigPath = path.join(toolkitRoot, "runtime", "vite.config.js")
+
+	// 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');
+	return serviceManager.stop("vite")
 }
 
 export function isViteRunning(): boolean {
-  return serviceManager.isRunning('vite');
+	return serviceManager.isRunning("vite")
 }

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

@@ -1,24 +1,49 @@
-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';
+	serviceManager,
+	ServiceManager,
+	ServiceStatus,
+	ServiceConfig,
+	ServiceState,
+} from "./ServiceManager.js"
 export {
-  aiService,
-  AIService,
-  AIProvider,
-  AIProviderInfo,
-  AIConfig,
-  loadAIConfig,
-  saveAIConfig,
-  getAvailableProviders,
-  getProviderStatus
-} from './AIService.js';
+	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"
+export {
+	aiService,
+	AIService,
+	AIProvider,
+	AIProviderInfo,
+	AIConfig,
+	loadAIConfig,
+	saveAIConfig,
+	getAvailableProviders,
+	getProviderStatus,
+} from "./AIService.js"