@exreve/exk 1.0.50 → 1.0.52

package/dist/cli/sessionHandlers.js

@@ -0,0 +1,271 @@
+/**
+ * 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/cli/shared/types.js

@@ -0,0 +1,3 @@
+// Re-export all types from the root shared/types.ts
+// This ensures CLI and frontend use a single canonical source of truth.
+export * from '../../shared/types.js';

package/dist/cli/skills/index.js

@@ -0,0 +1,117 @@
+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/cli/transferService.js

@@ -0,0 +1,284 @@
+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]}`;
+}

package/dist/cli/type-checks.js

@@ -0,0 +1,13 @@
+// Force evaluation — if any assertion resolved to a string literal, this will fail
+// @ts-expect-error — intentional compile-time assertions, never used at runtime
+const _checks = [
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+];
+export {};