@exreve/exk 1.0.45 → 1.0.46

package/dist/appHandlers.js

@@ -0,0 +1,142 @@
+/**
+ * App Control Handlers Module
+ *
+ * Handles app:start, app:stop, app:restart, app:status, app:logs.
+ */
+import { getProjectConfig } from './projectAnalyzer.js';
+import { startApp, stopApp, restartApp, getAppStatuses, getAppLogs } from './appManager.js';
+export function registerAppHandlers(socket, foreground) {
+    socket.on('app:start', async (data, callback) => {
+        try {
+            const { projectId, projectPath, appName } = data;
+            const config = await getProjectConfig(projectPath);
+            if (!config) {
+                callback?.({ success: false, error: 'Project config not found' });
+                return;
+            }
+            const app = config.apps.find(a => a.name === appName);
+            if (!app) {
+                callback?.({ success: false, error: `App "${appName}" not found in project config` });
+                return;
+            }
+            const result = await startApp(projectPath, projectId, app);
+            if (result.success) {
+                if (foreground)
+                    console.log(`✓ Started app: ${appName} (PID: ${result.pid})`);
+                socket.emit('app:started', {
+                    projectId,
+                    appName,
+                    processId: result.processId,
+                    pid: result.pid,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error starting app: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:stop', async (data, callback) => {
+        try {
+            const { projectId, appName } = data;
+            const config = await getProjectConfig(data.projectPath);
+            const app = config?.apps.find(a => a.name === appName);
+            const result = await stopApp(projectId, appName, app);
+            if (result.success) {
+                if (foreground)
+                    console.log(`✓ Stopped app: ${appName}`);
+                socket.emit('app:stopped', {
+                    projectId,
+                    appName,
+                    appControlId: data.appControlId,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error stopping app: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:restart', async (data, callback) => {
+        try {
+            const { projectId, projectPath, appName } = data;
+            const config = await getProjectConfig(projectPath);
+            if (!config) {
+                callback?.({ success: false, error: 'Project config not found' });
+                return;
+            }
+            const app = config.apps.find(a => a.name === appName);
+            if (!app) {
+                callback?.({ success: false, error: `App "${appName}" not found in project config` });
+                return;
+            }
+            const result = await restartApp(projectPath, projectId, app);
+            if (result.success) {
+                if (foreground)
+                    console.log(`✓ Restarted app: ${appName} (PID: ${result.pid})`);
+                socket.emit('app:restarted', {
+                    projectId,
+                    appName,
+                    processId: result.processId,
+                    pid: result.pid,
+                    appControlId: data.appControlId,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error restarting app: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:status', async (data, callback) => {
+        try {
+            const { projectId, projectPath, appName } = data;
+            const config = await getProjectConfig(projectPath);
+            if (!config) {
+                callback?.({ success: false, error: 'Project config not found' });
+                return;
+            }
+            const appsToCheck = appName
+                ? config.apps.filter(a => a.name === appName)
+                : config.apps;
+            const statuses = getAppStatuses(projectId, appsToCheck);
+            if (data.appControlId) {
+                socket.emit('app:control:response', {
+                    appControlId: data.appControlId,
+                    success: true,
+                    apps: statuses,
+                });
+            }
+            callback?.({ success: true, apps: statuses });
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error getting app status: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('app:logs', async (data, callback) => {
+        try {
+            const { projectId, appName } = data;
+            const result = await getAppLogs(projectId, appName, 100);
+            if (data.appControlId) {
+                socket.emit('app:control:response', {
+                    appControlId: data.appControlId,
+                    ...result,
+                });
+            }
+            callback?.(result);
+        }
+        catch (error) {
+            if (foreground)
+                console.error(`✗ Error getting app logs: ${error.message}`);
+            callback?.({ success: false, error: error.message });
+        }
+    });
+}

package/dist/appManager.js

@@ -46,16 +46,16 @@ export async function startApp(projectPath, projectId, app) {
         const logFile = getLogFilePath(projectId, app.name);
         // Create runner based on app type
         const runner = createRunner(app, projectPath, projectId, {
-            onOutput: async (output) => {
+            onOutput: async (_output) => {
                 // Logs are handled by the runner itself
             },
-            onError: (error) => {
+            onError: (_error) => {
                 // Errors are logged by runner
             },
-            onExit: (code) => {
+            onExit: (_code) => {
                 removeAppFromRunning(projectId, app.name);
             },
-            onStats: (stats) => {
+            onStats: (_stats) => {
                 // Stats updates can be used for monitoring
             },
         });
@@ -90,7 +90,7 @@ export async function startApp(projectPath, projectId, app) {
 /**
  * Stop an app using wrapper runner
  */
-export async function stopApp(projectId, appName, app) {
+export async function stopApp(projectId, appName, _app) {
     try {
         const running = getRunningApp(projectId, appName);
         if (!running) {

package/dist/appRunner.js

@@ -140,7 +140,7 @@ export class StaticFrontendRunner extends BaseRunner {
             // Create a mock process for compatibility
             this.process = {
                 pid: process.pid,
-                kill: (signal) => {
+                kill: (_signal) => {
                     this.stop();
                 },
             };
@@ -291,7 +291,7 @@ export class BackendRunner extends BaseRunner {
                         ? path.join(this.projectPath, this.app.directory)
                         : this.projectPath;
                     const { shell: stopShell, args: stopArgs } = shellSpawnOpts(this.app.stopCommand);
-                    const stopProcess = spawn(stopShell, stopArgs, {
+                    spawn(stopShell, stopArgs, {
                         cwd: workingDir,
                         stdio: 'ignore',
                     });

package/dist/cloudflaredHandlers.js

@@ -0,0 +1,279 @@
+/**
+ * Cloudflared Handlers Module
+ *
+ * Handles cloudflared:check, cloudflared:sync, cloudflared:login,
+ * cloudflared:regenerate operations.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { spawn, execSync } from 'child_process';
+export function registerCloudflaredHandlers(socket, foreground) {
+    socket.on('cloudflared:check:request', async () => {
+        try {
+            let installed = false;
+            let hasCert = false;
+            try {
+                execSync('which cloudflared', { stdio: 'ignore' });
+                installed = true;
+                const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
+                try {
+                    const stats = await fs.stat(certPath);
+                    hasCert = stats.isFile();
+                    if (foreground && hasCert) {
+                        console.log(`✓ Found cert.pem at ${certPath}`);
+                    }
+                }
+                catch (err) {
+                    hasCert = false;
+                    if (foreground) {
+                        console.log(`✗ cert.pem not found at ${certPath}: ${err.message}`);
+                    }
+                }
+            }
+            catch {
+                installed = false;
+            }
+            socket.emit('cloudflared:check:response', { installed, hasCert });
+            if (foreground) {
+                console.log(`Cloudflared check: installed=${installed}, hasCert=${hasCert}`);
+            }
+        }
+        catch (error) {
+            socket.emit('cloudflared:check:response', { installed: false, hasCert: false });
+        }
+    });
+    socket.on('cloudflared:sync:request', async () => {
+        try {
+            const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
+            if (foreground) {
+                console.log(`Syncing credentials from ${certPath}`);
+            }
+            const certContent = await fs.readFile(certPath, 'utf-8');
+            const tokenMatch = certContent.match(/-----BEGIN ARGO TUNNEL TOKEN-----\s*([\s\S]*?)\s*-----END ARGO TUNNEL TOKEN-----/);
+            if (tokenMatch && tokenMatch[1]) {
+                const tokenBase64 = tokenMatch[1].replace(/\s/g, '');
+                const tokenJson = Buffer.from(tokenBase64, 'base64').toString('utf-8');
+                const tokenData = JSON.parse(tokenJson);
+                const apiToken = tokenData.apiToken;
+                const accountId = tokenData.accountID;
+                const zoneId = tokenData.zoneID;
+                if (foreground) {
+                    console.log(`✓ Extracted credentials: accountId=${accountId}, zoneId=${zoneId}`);
+                }
+                socket.emit('cloudflared:sync:complete', {
+                    accountId,
+                    accountName: undefined,
+                    apiToken,
+                    zoneId
+                });
+            }
+            else {
+                const error = 'Failed to extract token from cert.pem';
+                if (foreground) {
+                    console.error(`✗ ${error}`);
+                }
+                socket.emit('cloudflared:sync:error', { error });
+            }
+        }
+        catch (error) {
+            const errorMsg = `Failed to read cert.pem: ${error.message}`;
+            if (foreground) {
+                console.error(`✗ ${errorMsg}`);
+            }
+            socket.emit('cloudflared:sync:error', { error: errorMsg });
+        }
+    });
+    socket.on('cloudflared:login:request', async () => {
+        try {
+            // Check if cloudflared is installed
+            try {
+                execSync('which cloudflared', { stdio: 'ignore' });
+            }
+            catch {
+                socket.emit('cloudflared:login:error', { error: 'cloudflared is not installed' });
+                return;
+            }
+            const loginProcess = spawn('cloudflared', ['tunnel', 'login'], {
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            let urlEmitted = false;
+            let alreadyLoggedIn = false;
+            let certPath = null;
+            const extractCertPath = (text) => {
+                const pathMatch = text.match(/existing certificate at\s+([^\s]+)/i) ||
+                    text.match(/certificate at\s+([^\s]+)/i) ||
+                    text.match(/cert\.pem.*?at\s+([^\s]+)/i);
+                return pathMatch ? pathMatch[1] : null;
+            };
+            const extractLoginUrl = (text) => {
+                const urlPatterns = [
+                    /https:\/\/dash\.cloudflare\.com\/argotunnel[^\s\)]+/g,
+                    /https:\/\/[^\s\)]+cloudflareaccess\.org[^\s\)]+/g,
+                    /https:\/\/[^\s\)]+cloudflare\.com[^\s\)]+/g
+                ];
+                for (const pattern of urlPatterns) {
+                    const matches = text.match(pattern);
+                    if (matches && matches.length > 0) {
+                        return matches[0];
+                    }
+                }
+                return null;
+            };
+            loginProcess.stdout.on('data', (data) => {
+                const text = data.toString();
+                stdout += text;
+                if (text.includes('existing certificate') || text.includes('cert.pem which login would overwrite')) {
+                    alreadyLoggedIn = true;
+                    const extractedPath = extractCertPath(text);
+                    if (extractedPath) {
+                        certPath = extractedPath;
+                    }
+                }
+                if (!alreadyLoggedIn && !urlEmitted) {
+                    const url = extractLoginUrl(text);
+                    if (url) {
+                        urlEmitted = true;
+                        socket.emit('cloudflared:login:url', { loginUrl: url });
+                    }
+                }
+            });
+            loginProcess.stderr.on('data', (data) => {
+                const text = data.toString();
+                stderr += text;
+                if (text.includes('existing certificate') || text.includes('cert.pem which login would overwrite')) {
+                    alreadyLoggedIn = true;
+                    const extractedPath = extractCertPath(text);
+                    if (extractedPath) {
+                        certPath = extractedPath;
+                    }
+                }
+                if (!alreadyLoggedIn && !urlEmitted) {
+                    const url = extractLoginUrl(text);
+                    if (url) {
+                        urlEmitted = true;
+                        socket.emit('cloudflared:login:url', { loginUrl: url });
+                    }
+                }
+            });
+            loginProcess.on('close', async (code) => {
+                if (alreadyLoggedIn && certPath) {
+                    // Already logged in - extract credentials from existing cert
+                    try {
+                        if (foreground) {
+                            console.log(`Already logged in, extracting credentials from ${certPath}`);
+                        }
+                        const certContent = await fs.readFile(certPath, 'utf-8');
+                        const tokenMatch = certContent.match(/-----BEGIN ARGO TUNNEL TOKEN-----\s*([\s\S]*?)\s*-----END ARGO TUNNEL TOKEN-----/);
+                        if (tokenMatch && tokenMatch[1]) {
+                            const tokenBase64 = tokenMatch[1].replace(/\s/g, '');
+                            const tokenJson = Buffer.from(tokenBase64, 'base64').toString('utf-8');
+                            const tokenData = JSON.parse(tokenJson);
+                            if (foreground) {
+                                console.log(`✓ Extracted credentials from existing cert`);
+                            }
+                            socket.emit('cloudflared:login:complete', {
+                                accountId: tokenData.accountID,
+                                accountName: undefined,
+                                apiToken: tokenData.apiToken,
+                                zoneId: tokenData.zoneID
+                            });
+                        }
+                        else {
+                            const error = 'Failed to extract token from existing cert.pem';
+                            if (foreground) {
+                                console.error(`✗ ${error}`);
+                            }
+                            socket.emit('cloudflared:login:error', { error });
+                        }
+                    }
+                    catch (error) {
+                        const errorMsg = `Failed to read cert.pem: ${error.message}`;
+                        if (foreground) {
+                            console.error(`✗ ${errorMsg}`);
+                        }
+                        socket.emit('cloudflared:login:error', { error: errorMsg });
+                    }
+                }
+                else if (code === 0 && !alreadyLoggedIn) {
+                    // Login completed successfully - wait a moment then extract credentials
+                    if (foreground) {
+                        console.log('Login completed, extracting credentials...');
+                    }
+                    setTimeout(async () => {
+                        try {
+                            const certFilePath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
+                            const certContent = await fs.readFile(certFilePath, 'utf-8');
+                            const tokenMatch = certContent.match(/-----BEGIN ARGO TUNNEL TOKEN-----\s*([\s\S]*?)\s*-----END ARGO TUNNEL TOKEN-----/);
+                            if (tokenMatch && tokenMatch[1]) {
+                                const tokenBase64 = tokenMatch[1].replace(/\s/g, '');
+                                const tokenJson = Buffer.from(tokenBase64, 'base64').toString('utf-8');
+                                const tokenData = JSON.parse(tokenJson);
+                                if (foreground) {
+                                    console.log(`✓ Extracted credentials after login`);
+                                }
+                                socket.emit('cloudflared:login:complete', {
+                                    accountId: tokenData.accountID,
+                                    accountName: undefined,
+                                    apiToken: tokenData.apiToken,
+                                    zoneId: tokenData.zoneID
+                                });
+                            }
+                            else {
+                                const error = 'Failed to extract token from cert.pem after login';
+                                if (foreground) {
+                                    console.error(`✗ ${error}`);
+                                }
+                                socket.emit('cloudflared:login:error', { error });
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = `Failed to read cert.pem after login: ${error.message}`;
+                            if (foreground) {
+                                console.error(`✗ ${errorMsg}`);
+                            }
+                            socket.emit('cloudflared:login:error', { error: errorMsg });
+                        }
+                    }, 1000);
+                }
+                else if (!alreadyLoggedIn) {
+                    const error = `Login failed with code ${code}: ${stderr || stdout}`;
+                    if (foreground) {
+                        console.error(`✗ ${error}`);
+                    }
+                    socket.emit('cloudflared:login:error', { error });
+                }
+            });
+            loginProcess.on('error', (error) => {
+                socket.emit('cloudflared:login:error', { error: error.message });
+            });
+        }
+        catch (error) {
+            socket.emit('cloudflared:login:error', { error: error.message });
+        }
+    });
+    socket.on('cloudflared:regenerate:request', async () => {
+        try {
+            const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem');
+            // Delete existing cert.pem
+            try {
+                await fs.unlink(certPath);
+                if (foreground) {
+                    console.log(`✓ Deleted existing cert.pem`);
+                }
+            }
+            catch (error) {
+                if (foreground && error.code !== 'ENOENT') {
+                    console.log(`Note: Could not delete cert.pem: ${error.message}`);
+                }
+            }
+            // Emit success - frontend will then trigger login
+            socket.emit('cloudflared:regenerate:complete', {});
+        }
+        catch (error) {
+            socket.emit('cloudflared:regenerate:error', { error: error.message });
+        }
+    });
+}

package/dist/containerHandlers.js

@@ -0,0 +1,193 @@
+/**
+ * Container Handlers Module
+ *
+ * Handles container:check, container:list, container:start,
+ * container:stop, container:remove, container:logs operations.
+ */
+import path from 'path';
+import { execSync } from 'child_process';
+function getContainerRuntime() {
+    try {
+        execSync('which docker', { stdio: 'ignore' });
+        return 'docker';
+    }
+    catch {
+        try {
+            execSync('which podman', { stdio: 'ignore' });
+            return 'podman';
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function registerContainerHandlers(socket, foreground, cliDir) {
+    socket.on('container:check:request', async () => {
+        try {
+            let enabled = false;
+            let runtime;
+            let version = '';
+            try {
+                execSync('which docker', { stdio: 'ignore' });
+                runtime = 'docker';
+                version = execSync('docker --version', { encoding: 'utf-8' }).trim();
+                enabled = true;
+            }
+            catch {
+                try {
+                    execSync('which podman', { stdio: 'ignore' });
+                    runtime = 'podman';
+                    version = execSync('podman --version', { encoding: 'utf-8' }).trim();
+                    enabled = true;
+                }
+                catch {
+                    enabled = false;
+                }
+            }
+            socket.emit('container:check:response', { enabled, runtime, version });
+            if (foreground) {
+                console.log(`Container runtime check: ${enabled ? `${runtime} (${version})` : 'Not found'}`);
+            }
+        }
+        catch (error) {
+            socket.emit('container:check:response', { enabled: false, runtime: undefined, version: '' });
+        }
+    });
+    socket.on('container:list:request', async () => {
+        try {
+            const runtime = getContainerRuntime();
+            if (!runtime) {
+                socket.emit('container:list:response', { success: false, error: 'No container runtime found' });
+                return;
+            }
+            const output = execSync(`${runtime} ps -a --format "{{json .}}"`, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            const containers = output.trim().split('\n').filter(Boolean).map(line => {
+                try {
+                    const c = JSON.parse(line);
+                    const ports = [];
+                    if (c.Ports) {
+                        const portMatches = c.Ports.match(/(\d+)->(\d+)/g);
+                        if (portMatches) {
+                            portMatches.forEach((p) => {
+                                const [host, container] = p.split('->').map(Number);
+                                ports.push({ host, container });
+                            });
+                        }
+                    }
+                    return {
+                        containerId: c.ID,
+                        name: c.Names.replace(/^\//, ''),
+                        image: c.Image,
+                        status: c.State === 'running' ? 'running' : c.State === 'paused' ? 'paused' : c.Status === 'exited' ? 'exited' : 'stopped',
+                        ports,
+                        createdAt: new Date(c.CreatedAt).toISOString()
+                    };
+                }
+                catch {
+                    return null;
+                }
+            }).filter(Boolean);
+            socket.emit('container:list:response', { success: true, containers });
+        }
+        catch (error) {
+            socket.emit('container:list:response', { success: false, error: error.message });
+        }
+    });
+    socket.on('container:start:request', async (data) => {
+        try {
+            const runtime = getContainerRuntime();
+            if (!runtime) {
+                socket.emit('container:start:response', { success: false, error: 'No container runtime found' });
+                return;
+            }
+            const { name, image, ports = [], env = {}, runAsRoot = false } = data;
+            let cmd = `${runtime} run -d --name ${name}`;
+            if (!runAsRoot) {
+                cmd += ' --user 1000:1000';
+            }
+            cmd += ' --memory=8g';
+            cmd += ` -v "${cliDir}:/opt/ttc:ro"`;
+            const entrypointScript = path.join(cliDir, 'container-entrypoint.sh');
+            cmd += ` -v "${entrypointScript}:/entrypoint.sh:ro"`;
+            ports.forEach(p => {
+                cmd += ` -p ${p.host}:${p.container}`;
+            });
+            Object.entries(env).forEach(([k, v]) => {
+                const escapedValue = String(v).replace(/"/g, '\\"');
+                cmd += ` -e ${k}="${escapedValue}"`;
+            });
+            cmd += ` -e CONTAINER_NAME="${name}"`;
+            cmd += ` -e HOSTNAME="${name}"`;
+            cmd += ` --entrypoint /bin/sh ${image} /entrypoint.sh`;
+            if (foreground) {
+                console.log(`Starting container: ${cmd}`);
+            }
+            try {
+                execSync(`${runtime} pull ${image}`, { stdio: 'ignore' });
+            }
+            catch {
+                // Pull failed, but might already exist locally
+            }
+            const output = execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+            const containerId = output.trim();
+            socket.emit('container:start:response', { success: true, containerId });
+            if (foreground) {
+                console.log(`✓ Container started: ${containerId}`);
+            }
+        }
+        catch (error) {
+            socket.emit('container:start:response', { success: false, error: error.message });
+        }
+    });
+    socket.on('container:stop:request', async (data) => {
+        try {
+            const runtime = getContainerRuntime();
+            if (!runtime) {
+                socket.emit('container:stop:response', { success: false, error: 'No container runtime found' });
+                return;
+            }
+            const { containerId } = data;
+            execSync(`${runtime} stop ${containerId}`, { stdio: 'ignore' });
+            socket.emit('container:stop:response', { success: true });
+            if (foreground) {
+                console.log(`✓ Container stopped: ${containerId}`);
+            }
+        }
+        catch (error) {
+            socket.emit('container:stop:response', { success: false, error: error.message });
+        }
+    });
+    socket.on('container:remove:request', async (data) => {
+        try {
+            const runtime = getContainerRuntime();
+            if (!runtime) {
+                socket.emit('container:remove:response', { success: false, error: 'No container runtime found' });
+                return;
+            }
+            const { containerId } = data;
+            execSync(`${runtime} rm -f ${containerId}`, { stdio: 'ignore' });
+            socket.emit('container:remove:response', { success: true });
+            if (foreground) {
+                console.log(`✓ Container removed: ${containerId}`);
+            }
+        }
+        catch (error) {
+            socket.emit('container:remove:response', { success: false, error: error.message });
+        }
+    });
+    socket.on('container:logs:request', async (data) => {
+        try {
+            const runtime = getContainerRuntime();
+            if (!runtime) {
+                socket.emit('container:logs:response', { success: false, error: 'No container runtime found' });
+                return;
+            }
+            const { containerId, lines = 100 } = data;
+            const logs = execSync(`${runtime} logs --tail ${lines} ${containerId}`, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            socket.emit('container:logs:response', { success: true, logs });
+        }
+        catch (error) {
+            socket.emit('container:logs:response', { success: false, error: error.message });
+        }
+    });
+}