@exreve/exk 1.0.55 → 1.0.56

package/dist/sessionHandlers.js

@@ -1,271 +0,0 @@
-/**
- * Session Handlers Module
- *
- * Handles session:create, session:delete, session:prompt,
- * prompt:cancel, emergency:stop, project:config:analyze.
- */
-import fs from 'fs/promises';
-import fsSync from 'fs';
-import path from 'path';
-import { agentSessionManager } from './agentSession.js';
-import { analyzeProjectWithClaude, saveProjectConfig } from './projectAnalyzer.js';
-import { generateRunnerCode } from './runnerGenerator.js';
-/**
- * Register session handlers.
- * `getSocket` is a function that returns the current live socket — this ensures
- * that callbacks registered on a previous socket instance still emit on the
- * active socket after a reconnect (fixes in-flight output loss on disconnect).
- */
-export function registerSessionHandlers(socket, foreground, activeSessions, getSocket) {
-    socket.on('session:create', async (data) => {
-        try {
-            let { sessionId, projectPath } = data;
-            // Remap /home/abc to /tmp/abc if /home/abc doesn't exist (container workaround)
-            if (projectPath === '/home/abc' && !fsSync.existsSync('/home/abc')) {
-                const fallbackPath = '/tmp/abc';
-                fsSync.mkdirSync(fallbackPath, { recursive: true });
-                projectPath = fallbackPath;
-                console.log(`[CLI] Remapped /home/abc -> ${fallbackPath}`);
-            }
-            activeSessions.set(sessionId, { projectPath });
-            if (foreground) {
-                console.log(`💬 Session created: ${sessionId}`);
-                console.log(`   Project: ${projectPath}`);
-            }
-            else {
-                console.log(`Session created: ${sessionId} in project ${projectPath}`);
-            }
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Failed to create session: ${error.message}`);
-            }
-            else {
-                console.error('Failed to create session:', error.message);
-            }
-        }
-    });
-    socket.on('session:delete', async (data) => {
-        try {
-            const { sessionId } = data;
-            if (foreground) {
-                console.log(`🗑️  Deleting session: ${sessionId}`);
-            }
-            await agentSessionManager.deleteSession(sessionId);
-            activeSessions.delete(sessionId);
-            if (foreground) {
-                console.log(`✓ Session deleted: ${sessionId}`);
-            }
-            else {
-                console.log(`Session deleted: ${sessionId}`);
-            }
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Failed to delete session: ${error.message}`);
-            }
-            else {
-                console.error('Failed to delete session:', error.message);
-            }
-        }
-    });
-    socket.on('project:config:analyze', async (data) => {
-        try {
-            const { projectId, projectPath, projectName, analysisId } = data;
-            if (foreground) {
-                console.log(`🔍 Analyzing project: ${projectName} at ${projectPath}`);
-            }
-            const config = await analyzeProjectWithClaude(projectPath, projectName);
-            await saveProjectConfig(projectPath, config);
-            for (const app of config.apps) {
-                const runnerCode = generateRunnerCode(app, projectPath);
-                const runnerFileName = `${app.name}_runner.ts`;
-                const runnerPath = path.join(projectPath, app.directory || '', runnerFileName);
-                const runnerDir = path.dirname(runnerPath);
-                await fs.mkdir(runnerDir, { recursive: true });
-                await fs.writeFile(runnerPath, runnerCode, 'utf-8');
-                if (foreground) {
-                    console.log(`✓ Generated runner: ${runnerFileName}`);
-                }
-            }
-            if (foreground) {
-                console.log(`✓ Analysis complete: Found ${config.apps.length} apps`);
-                console.log(`✓ Generated ${config.apps.length} runner files`);
-            }
-            socket.emit('project:config:analyzed', {
-                projectId,
-                config,
-                analysisId
-            });
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Analysis error: ${error.message}`);
-            }
-            socket.emit('project:config:analyze:error', {
-                projectId: data.projectId,
-                error: error.message,
-                analysisId: data.analysisId
-            });
-        }
-    });
-    socket.on('session:prompt', async (data) => {
-        try {
-            const { sessionId, prompt, projectPath: providedProjectPath, promptId, enhancers, model } = data;
-            if (!promptId) {
-                if (foreground) {
-                    console.error(`✗ Missing required promptId for session: ${sessionId}`);
-                }
-                socket.emit('session:error', { sessionId, error: 'Missing required promptId' });
-                return;
-            }
-            let projectPath = providedProjectPath || activeSessions.get(sessionId)?.projectPath;
-            if (!projectPath) {
-                if (foreground) {
-                    console.error(`✗ Session not found: ${sessionId} (missing projectPath)`);
-                }
-                socket.emit('session:error', { sessionId, error: 'Session not found or projectPath missing' });
-                return;
-            }
-            activeSessions.set(sessionId, { projectPath, currentPromptId: promptId, model });
-            const capturedPromptId = promptId;
-            if (foreground) {
-                console.log(`\n[CLI] 📤 Received prompt for session: ${sessionId}, promptId: ${capturedPromptId}`);
-                console.log(`[CLI]    Prompt: ${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}`);
-            }
-            await agentSessionManager.createSession({
-                sessionId,
-                projectPath,
-            });
-            await agentSessionManager.sendPrompt(sessionId, prompt, enhancers || [], {
-                sessionId,
-                projectPath,
-                promptId: capturedPromptId,
-                model: model,
-                attachments: data.attachments,
-                onStatusUpdate: (status) => {
-                    if (!capturedPromptId) {
-                        console.error(`[CLI] Missing promptId for status update, cannot emit prompt:updated`);
-                        return;
-                    }
-                    console.log(`[CLI] 📊 Status update: promptId=${capturedPromptId}, status=${status}, sessionId=${sessionId}`);
-                    getSocket().emit('prompt:updated', {
-                        promptId: capturedPromptId,
-                        sessionId,
-                        text: prompt,
-                        status,
-                        createdAt: new Date().toISOString(),
-                        ...(status === 'running' ? { startedAt: new Date().toISOString() } : {}),
-                        ...(status === 'completed' || status === 'error' || status === 'cancelled' ? { completedAt: new Date().toISOString() } : {}),
-                        messages: []
-                    });
-                },
-                onOutput: (output) => {
-                    const dataString = typeof output.data === 'string' ? output.data : JSON.stringify(output.data);
-                    if (!capturedPromptId) {
-                        console.error(`[CLI] Missing promptId for session ${sessionId}, cannot emit prompt:output`);
-                        return;
-                    }
-                    if (foreground && output.type === 'stdout') {
-                        process.stdout.write(dataString);
-                    }
-                    getSocket().emit('prompt:output', {
-                        sessionId,
-                        promptId: capturedPromptId,
-                        type: output.type,
-                        data: dataString,
-                        timestamp: output.timestamp,
-                        metadata: output.metadata
-                    });
-                },
-                onError: (error) => {
-                    if (foreground) {
-                        console.error(`\n[CLI] ✗ Session error: ${error}`);
-                    }
-                    getSocket().emit('session:error', { sessionId, error });
-                },
-                onComplete: (exitCode) => {
-                    if (foreground) {
-                        console.log(`\n[CLI] ✓ Session completed with exit code: ${exitCode ?? 'null'}`);
-                    }
-                    if (!capturedPromptId) {
-                        console.error(`[CLI] Missing promptId for session ${sessionId}, cannot emit session:result`);
-                        return;
-                    }
-                    getSocket().emit('session:result', {
-                        sessionId,
-                        promptId: capturedPromptId,
-                        exitCode
-                    });
-                }
-            });
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Error processing prompt: ${error.message}`);
-            }
-            socket.emit('session:error', { sessionId: data.sessionId, error: error.message });
-        }
-    });
-    socket.on('prompt:cancel', async (data, callback) => {
-        try {
-            const { promptId, sessionId } = data;
-            if (!promptId || !sessionId) {
-                callback?.({ success: false, error: 'Missing promptId or sessionId' });
-                return;
-            }
-            if (foreground) {
-                console.log(`[CLI] 🛑 Cancelling prompt: ${promptId}`);
-            }
-            const cancelled = await agentSessionManager.cancelPrompt(promptId, sessionId, (_status) => {
-                getSocket().emit('prompt:updated', {
-                    promptId,
-                    sessionId,
-                    text: '',
-                    status: 'cancelled',
-                    createdAt: new Date().toISOString(),
-                    completedAt: new Date().toISOString(),
-                    messages: []
-                });
-            });
-            if (cancelled) {
-                callback?.({ success: true });
-            }
-            else {
-                callback?.({ success: false, error: 'Prompt not found or already completed' });
-            }
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Error cancelling prompt: ${error.message}`);
-            }
-            callback?.({ success: false, error: error.message });
-        }
-    });
-    socket.on('emergency:stop', async (data, callback) => {
-        try {
-            const { sessionId } = data;
-            if (!sessionId) {
-                callback?.({ success: false, message: 'Missing sessionId' });
-                return;
-            }
-            if (foreground) {
-                console.log(`[CLI] ☠️  EMERGENCY STOP for session: ${sessionId}`);
-            }
-            const result = await agentSessionManager.emergencyStop(sessionId);
-            getSocket().emit('emergency:stopped', {
-                sessionId,
-                success: result.success,
-                message: result.message,
-                timestamp: new Date().toISOString()
-            });
-            callback?.(result);
-        }
-        catch (error) {
-            if (foreground) {
-                console.error(`✗ Error during emergency stop: ${error.message}`);
-            }
-            callback?.({ success: false, message: error.message });
-        }
-    });
-}

package/dist/skills/index.js

@@ -1,117 +0,0 @@
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-const SKILLS_DIR = dirname(fileURLToPath(import.meta.url)); // This file is in the skills directory
-const skillCache = new Map();
-/**
- * Parse frontmatter and content from a skill markdown file
- */
-function parseSkillFile(content) {
-    // Check for YAML frontmatter between --- markers
-    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
-    const match = content.match(frontmatterRegex);
-    if (!match) {
-        // No frontmatter, use filename as name
-        return null;
-    }
-    const frontmatter = match[1];
-    const skillContent = match[2].trim();
-    // Parse name and description from frontmatter
-    const nameMatch = frontmatter.match(/name:\s*(.+)/);
-    const descriptionMatch = frontmatter.match(/description:\s*(.+)/);
-    const name = nameMatch ? nameMatch[1].trim() : '';
-    const description = descriptionMatch ? descriptionMatch[1].trim() : '';
-    if (!name) {
-        return null;
-    }
-    return { name, description, content: skillContent };
-}
-/**
- * Load a single skill by name
- */
-export function loadSkill(name) {
-    // Check cache first
-    if (skillCache.has(name)) {
-        return skillCache.get(name);
-    }
-    const skillPath = path.join(SKILLS_DIR, `${name}.md`);
-    if (!existsSync(skillPath)) {
-        return null;
-    }
-    try {
-        const content = readFileSync(skillPath, 'utf-8');
-        const parsed = parseSkillFile(content);
-        if (!parsed) {
-            return null;
-        }
-        const skill = {
-            name: parsed.name,
-            description: parsed.description,
-            content: parsed.content
-        };
-        skillCache.set(name, skill);
-        return skill;
-    }
-    catch (error) {
-        console.error(`Failed to load skill ${name}:`, error);
-        return null;
-    }
-}
-/**
- * Load all available skills from the skills directory
- */
-export function loadAllSkills() {
-    const skills = [];
-    if (!existsSync(SKILLS_DIR)) {
-        return skills;
-    }
-    try {
-        const files = readdirSync(SKILLS_DIR);
-        for (const file of files) {
-            if (!file.endsWith('.md')) {
-                continue;
-            }
-            const name = file.replace('.md', '');
-            const skill = loadSkill(name);
-            if (skill) {
-                skills.push(skill);
-            }
-        }
-    }
-    catch (error) {
-        console.error('Failed to load skills:', error);
-    }
-    return skills;
-}
-/**
- * Get skill content for injection into prompts
- */
-export function getSkillContent(names) {
-    if (names.length === 0) {
-        return '';
-    }
-    const contents = [];
-    for (const name of names) {
-        const skill = loadSkill(name);
-        if (skill) {
-            contents.push(`# Skill: ${skill.name}\n\n${skill.content}`);
-        }
-    }
-    if (contents.length === 0) {
-        return '';
-    }
-    return `## Active Skills\n\n${contents.join('\n\n---\n\n')}\n\n---\n\n`;
-}
-/**
- * List all available skill names
- */
-export function listSkillNames() {
-    return loadAllSkills().map(s => s.name);
-}
-/**
- * Get skill metadata (name, description) for all skills
- */
-export function getSkillMetadata() {
-    return loadAllSkills().map(s => ({ name: s.name, description: s.description }));
-}

package/dist/transferService.js

@@ -1,284 +0,0 @@
-import { spawn } from 'child_process';
-import { mkdir, unlink } from 'fs/promises';
-import fsSync from 'fs';
-import path from 'path';
-import os from 'os';
-import { createHash } from 'crypto';
-import { Readable, Transform } from 'stream';
-// ============ Transfer Service (CLI side) ============
-// Two-phase transfer via HTTP:
-//   Phase 1 (source): tar selected items → HTTP POST to backend
-//   Phase 2 (dest):   HTTP GET from backend → tar extract
-// Socket.IO carries control events + progress/log.
-// ---- Sender ----
-export function startSending(socket, transfer, foreground) {
-    const { transferId, sourcePath, selectedItems } = transfer;
-    const startTime = Date.now();
-    const apiUrl = getApiUrl(socket);
-    const log = (message) => {
-        if (foreground)
-            console.log(`[transfer:send] ${message}`);
-        socket.emit('transfer:log', { transferId, side: 'source', level: 'info', message });
-    };
-    const sendProgress = (phase, bytesTransferred, totalBytes) => {
-        const elapsed = (Date.now() - startTime) / 1000;
-        const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
-        const eta = speed > 0 ? (totalBytes - bytesTransferred) / speed : 0;
-        socket.emit('transfer:progress', {
-            transferId,
-            side: 'source',
-            phase,
-            bytesTransferred,
-            totalBytes,
-            speed: Math.round(speed),
-            eta: Math.round(eta),
-        });
-    };
-    const sendError = (message) => {
-        console.error(`[transfer:send] Error: ${message}`);
-        socket.emit('transfer:error', { transferId, side: 'source', message });
-    };
-    const items = selectedItems || ['.'];
-    log(`Packing ${items.length} item(s) from ${sourcePath}`);
-    // Estimate size first
-    let totalBytes = 0;
-    const sizeEstimate = spawn('du', ['-sb', ...items.map(i => path.join(sourcePath, i))], { cwd: sourcePath });
-    let duOutput = '';
-    sizeEstimate.stdout.on('data', (d) => { duOutput += d.toString(); });
-    sizeEstimate.on('close', (code) => {
-        if (code === 0) {
-            const lines = duOutput.trim().split('\n');
-            for (const line of lines) {
-                const match = line.match(/^(\d+)/);
-                if (match)
-                    totalBytes += parseInt(match[1], 10);
-            }
-        }
-        log(`Estimated size: ${formatBytes(totalBytes)}`);
-        doPackAndUpload();
-    });
-    sizeEstimate.on('error', () => doPackAndUpload());
-    function doPackAndUpload() {
-        // Create tar with selected items
-        const tarArgs = ['cf', '-', '-C', sourcePath, ...items];
-        const tar = spawn('tar', tarArgs);
-        const hash = createHash('sha256');
-        let bytesTransferred = 0;
-        let lastProgressTime = Date.now();
-        let fileCount = 0;
-        // Count files as we go (approximate from tar output)
-        tar.stderr.on('data', (data) => {
-            const msg = data.toString().trim();
-            if (msg)
-                log(`tar: ${msg}`);
-            // Count lines in tar stderr as approximate file count
-            fileCount += msg.split('\n').length;
-        });
-        tar.on('error', (err) => {
-            sendError(`tar process error: ${err.message}`);
-        });
-        tar.on('close', (code) => {
-            if (code !== 0) {
-                sendError(`tar exited with code ${code}`);
-                return;
-            }
-            log(`Packing complete. Final size: ${formatBytes(bytesTransferred)}`);
-        });
-        // Stream tar output through hash, then HTTP POST
-        const uploadUrl = `${apiUrl}/transfer/${transferId}/upload`;
-        // Pipe tar stdout → hash transform → HTTP upload
-        const hashTransform = new Transform({
-            transform(chunk, _encoding, callback) {
-                hash.update(chunk);
-                bytesTransferred += chunk.length;
-                if (Date.now() - lastProgressTime > 500) {
-                    sendProgress('uploading', bytesTransferred, totalBytes || bytesTransferred);
-                    lastProgressTime = Date.now();
-                }
-                this.push(chunk);
-                callback();
-            },
-        });
-        // Use fetch with streaming body for the upload
-        const tarStream = tar.stdout.pipe(hashTransform);
-        // Node 18+ supports ReadableStream in fetch body
-        const nodeStream = Readable.toWeb(tarStream);
-        fetch(uploadUrl, {
-            method: 'POST',
-            body: nodeStream,
-            headers: {
-                'Content-Type': 'application/x-tar',
-                'Transfer-Encoding': 'chunked',
-            },
-            duplex: 'half',
-        }).then(async (res) => {
-            if (!res.ok) {
-                const text = await res.text();
-                sendError(`Upload failed: HTTP ${res.status} ${text}`);
-                return;
-            }
-            const sha256 = hash.digest('hex');
-            const duration = Date.now() - startTime;
-            // Notify backend that upload is done (only after HTTP confirms success)
-            socket.emit('transfer:uploaded', {
-                transferId,
-                totalBytes: bytesTransferred,
-                sha256,
-                fileCount,
-            });
-            log(`Upload complete: ${formatBytes(bytesTransferred)} in ${(duration / 1000).toFixed(1)}s (sha256: ${sha256.slice(0, 12)}...)`);
-        }).catch((err) => {
-            sendError(`Upload network error: ${err.message}`);
-        });
-        // Handle cancellation
-        const cancelHandler = (data) => {
-            if (data.transferId === transferId) {
-                tar.kill('SIGKILL');
-                socket.off('transfer:cancel', cancelHandler);
-                log('Transfer cancelled');
-            }
-        };
-        socket.on('transfer:cancel', cancelHandler);
-    }
-}
-// ---- Receiver ----
-export function startReceiving(socket, transfer, foreground) {
-    const { transferId, destPath } = transfer;
-    const startTime = Date.now();
-    const apiUrl = getApiUrl(socket);
-    const expectedBytes = transfer.totalBytes || 0;
-    const expectedSha256 = transfer.sha256 || '';
-    const log = (message) => {
-        if (foreground)
-            console.log(`[transfer:recv] ${message}`);
-        socket.emit('transfer:log', { transferId, side: 'dest', level: 'info', message });
-    };
-    const sendProgress = (phase, bytesTransferred, totalBytes) => {
-        const elapsed = (Date.now() - startTime) / 1000;
-        const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
-        const eta = speed > 0 ? (totalBytes - bytesTransferred) / speed : 0;
-        socket.emit('transfer:progress', {
-            transferId,
-            side: 'dest',
-            phase,
-            bytesTransferred,
-            totalBytes,
-            speed: Math.round(speed),
-            eta: Math.round(eta),
-        });
-    };
-    const sendError = (message) => {
-        console.error(`[transfer:recv] Error: ${message}`);
-        socket.emit('transfer:error', { transferId, side: 'dest', message });
-    };
-    const tmpFile = path.join(os.tmpdir(), `ttc-transfer-${transferId}.tar`);
-    log(`Downloading from backend...`);
-    mkdir(destPath, { recursive: true }).then(async () => {
-        try {
-            const downloadUrl = `${apiUrl}/transfer/${transferId}/download`;
-            const res = await fetch(downloadUrl);
-            if (!res.ok) {
-                sendError(`Download failed: HTTP ${res.status}`);
-                return;
-            }
-            if (!res.body) {
-                sendError('Download failed: no response body');
-                return;
-            }
-            // Stream download to temp file while hashing
-            const writeStream = fsSync.createWriteStream(tmpFile);
-            const hash = createHash('sha256');
-            let bytesReceived = 0;
-            let lastProgressTime = Date.now();
-            const reader = res.body.getReader();
-            // Read chunks from the response stream
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                writeStream.write(value);
-                hash.update(value);
-                bytesReceived += value.length;
-                if (Date.now() - lastProgressTime > 500) {
-                    sendProgress('downloading', bytesReceived, expectedBytes || bytesReceived);
-                    lastProgressTime = Date.now();
-                }
-            }
-            writeStream.end();
-            log(`Downloaded ${formatBytes(bytesReceived)}. Verifying...`);
-            // Verify hash
-            const receivedHash = hash.digest('hex');
-            if (expectedSha256 && receivedHash !== expectedSha256) {
-                sendError(`Hash mismatch! Expected ${expectedSha256.slice(0, 16)}... got ${receivedHash.slice(0, 16)}...`);
-                try {
-                    await unlink(tmpFile);
-                }
-                catch { }
-                return;
-            }
-            log(`Hash verified ✓. Extracting to ${destPath}...`);
-            sendProgress('extracting', bytesReceived, bytesReceived);
-            // Extract tar
-            const extractProc = spawn('tar', ['xf', tmpFile, '-C', destPath]);
-            await new Promise((resolve, reject) => {
-                extractProc.on('close', (code) => {
-                    if (code !== 0)
-                        reject(new Error(`tar extraction failed with code ${code}`));
-                    else
-                        resolve();
-                });
-                extractProc.on('error', reject);
-            });
-            // Cleanup temp file
-            try {
-                await unlink(tmpFile);
-            }
-            catch { }
-            const duration = Date.now() - startTime;
-            socket.emit('transfer:complete', {
-                transferId,
-                totalBytes: bytesReceived,
-                sha256: receivedHash,
-                duration,
-                fileCount: 0,
-            });
-            log(`Complete! ${formatBytes(bytesReceived)} extracted to ${destPath} in ${(duration / 1000).toFixed(1)}s`);
-        }
-        catch (err) {
-            sendError(`Download/extract error: ${err.message}`);
-            try {
-                await unlink(tmpFile);
-            }
-            catch { }
-        }
-    }).catch((err) => {
-        sendError(`Failed to create destination directory: ${err.message}`);
-    });
-}
-// ---- Helpers ----
-function getApiUrl(socket) {
-    // Extract the base URL from the socket connection
-    const io = socket.io;
-    const opts = io.opts;
-    if (opts?.hostname) {
-        const protocol = opts.secure !== false ? 'https' : 'http';
-        const port = opts.port ? `:${opts.port}` : '';
-        return `${protocol}://${opts.hostname}${port}`;
-    }
-    // Fallback: read from config
-    try {
-        const configPath = path.join(os.homedir(), '.talk-to-code', 'config.json');
-        const config = JSON.parse(fsSync.readFileSync(configPath, 'utf-8'));
-        return config.apiUrl || 'https://api.talk-to-code.com';
-    }
-    catch {
-        return 'https://api.talk-to-code.com';
-    }
-}
-function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(1024));
-    return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
-}