@exreve/exk 1.0.44 → 1.0.46

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 });
+        }
+    });
+}

package/dist/fsHandlers.js

@@ -0,0 +1,86 @@
+/**
+ * Filesystem Handlers Module
+ *
+ * Handles fs:list, fs:write, fs:read operations on the CLI device.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+export function registerFsHandlers(socket) {
+    socket.on('fs:list', async (data) => {
+        try {
+            const { dirPath } = data;
+            if (!dirPath) {
+                socket.emit('fs:list:response', { success: false, error: 'dirPath is required' });
+                return;
+            }
+            const entries = [];
+            try {
+                const dirents = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const dirent of dirents) {
+                    if (dirent.name.startsWith('.'))
+                        continue;
+                    const fullPath = path.join(dirPath, dirent.name);
+                    entries.push({
+                        name: dirent.name,
+                        path: fullPath,
+                        isDir: dirent.isDirectory()
+                    });
+                }
+                entries.sort((a, b) => {
+                    if (a.isDir && !b.isDir)
+                        return -1;
+                    if (!a.isDir && b.isDir)
+                        return 1;
+                    return a.name.localeCompare(b.name);
+                });
+                socket.emit('fs:list:response', { success: true, entries });
+            }
+            catch (err) {
+                socket.emit('fs:list:response', { success: false, error: err.message });
+            }
+        }
+        catch (error) {
+            socket.emit('fs:list:response', { success: false, error: error.message });
+        }
+    });
+    socket.on('fs:write', async (data) => {
+        try {
+            const { filePath, content, encoding = 'utf-8' } = data;
+            if (!filePath) {
+                socket.emit('fs:write:response', { success: false, error: 'filePath is required' });
+                return;
+            }
+            try {
+                const dir = path.dirname(filePath);
+                await fs.mkdir(dir, { recursive: true });
+                await fs.writeFile(filePath, content, encoding);
+                socket.emit('fs:write:response', { success: true });
+            }
+            catch (err) {
+                socket.emit('fs:write:response', { success: false, error: err.message });
+            }
+        }
+        catch (error) {
+            socket.emit('fs:write:response', { success: false, error: error.message });
+        }
+    });
+    socket.on('fs:read', async (data) => {
+        try {
+            const { filePath, encoding = 'utf-8' } = data;
+            if (!filePath) {
+                socket.emit('fs:read:response', { success: false, error: 'filePath is required' });
+                return;
+            }
+            try {
+                const content = await fs.readFile(filePath, encoding);
+                socket.emit('fs:read:response', { success: true, content });
+            }
+            catch (err) {
+                socket.emit('fs:read:response', { success: false, error: err.message });
+            }
+        }
+        catch (error) {
+            socket.emit('fs:read:response', { success: false, error: error.message });
+        }
+    });
+}