@exreve/exk 1.0.54 → 1.0.56

package/dist/containerHandlers.js

@@ -1,193 +0,0 @@
-/**
- * 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

@@ -1,86 +0,0 @@
-/**
- * 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 });
-        }
-    });
-}