@exreve/exk 1.0.45 → 1.0.47

package/dist/openaiAdapter.js

@@ -147,17 +147,6 @@ export async function startOpenAIAdapter(config) {
     }
     throw new Error(`Failed to start anthropic-proxy for ${config.targetBaseUrl}`);
 }
-/** Stop all running proxy instances */
-export function stopAllAdapters() {
-    for (const [key, { process }] of runningProxies) {
-        try {
-            if (!process.killed)
-                process.kill('SIGTERM');
-        }
-        catch { }
-        runningProxies.delete(key);
-    }
-}
 /**
  * Get the adapter configuration for a local model.
  * Reads from ~/.talk-to-code/openai-adapters.json or falls back to defaults.

package/dist/projectManager.js

@@ -3,7 +3,7 @@ import path from 'path';
 const toAbsolutePath = (p) => path.isAbsolute(p) ? p : path.resolve(p);
 export async function createProject(request) {
     try {
-        const { projectId, name, path: projectPath, sourcePath } = request;
+        const { path: projectPath, sourcePath } = request;
         const absolutePath = toAbsolutePath(projectPath);
         // Check if source path exists (if linking)
         if (sourcePath) {
@@ -67,26 +67,3 @@ export async function deleteProject(projectPath) {
         return { success: false, error: error.message };
     }
 }
-export async function getProjectInfo(projectPath) {
-    try {
-        const absolutePath = toAbsolutePath(projectPath);
-        try {
-            const stat = await fs.stat(absolutePath);
-            if (!stat.isDirectory()) {
-                return null;
-            }
-            return {
-                projectId: '', // Will be set by caller
-                name: path.basename(absolutePath),
-                path: absolutePath,
-                exists: true
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    catch {
-        return null;
-    }
-}

package/dist/runnerGenerator.js

@@ -2,7 +2,6 @@
  * Generate TypeScript runner code for an app
  */
 export function generateRunnerCode(app, projectPath) {
-    const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_'); // Sanitize app name for filename
     const appType = app.appType || (app.framework?.toLowerCase().includes('react') ||
         app.framework?.toLowerCase().includes('vue') ||
         app.framework?.toLowerCase().includes('angular') ||
@@ -14,7 +13,7 @@ export function generateRunnerCode(app, projectPath) {
         return generateBackendRunner(app, projectPath);
     }
 }
-function generateStaticFrontendRunner(app, projectPath) {
+function generateStaticFrontendRunner(app, _projectPath) {
     const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_'); // Sanitize app name for filename
     const port = app.port || 3000;
     const buildDir = app.buildDir || 'dist';
@@ -99,7 +98,7 @@ process.on('SIGINT', async () => {
 start()
 `;
 }
-function generateBackendRunner(app, projectPath) {
+function generateBackendRunner(app, _projectPath) {
     const appName = app.name.replace(/[^a-zA-Z0-9_-]/g, '_'); // Sanitize app name for filename
     const appDir = app.directory || '';
     const startCommand = app.startCommand;

package/dist/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/updateHandlers.js

@@ -0,0 +1,82 @@
+/**
+ * Update & Version Handlers Module
+ *
+ * Handles update:check, update:start, version:info operations.
+ */
+import fsSync from 'fs';
+import os from 'os';
+import path from 'path';
+import { createHash } from 'crypto';
+import { fileURLToPath } from 'url';
+export function registerUpdateHandlers(socket, _foreground, readConfig, requestUpdateFromParent) {
+    socket.on('update:check', async (_data, callback) => {
+        try {
+            const config = await readConfig();
+            const currentHash = createHash('sha256').update(fsSync.readFileSync(fileURLToPath(import.meta.url))).digest('hex');
+            const response = await fetch(`${config.apiUrl}/update/check`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    hash: currentHash,
+                    platform: os.platform(),
+                    arch: os.arch()
+                })
+            });
+            if (!response.ok) {
+                callback?.({ success: false, error: `HTTP ${response.status}` });
+                return;
+            }
+            const info = await response.json();
+            callback?.({
+                success: true,
+                updateAvailable: info.updateAvailable,
+                version: info.version,
+                changelog: info.changelog,
+                size: info.size
+            });
+        }
+        catch (error) {
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('update:start', async (_data, callback) => {
+        try {
+            requestUpdateFromParent();
+            callback?.({
+                success: true,
+                message: 'Update initiated. The CLI will restart automatically when complete.'
+            });
+        }
+        catch (error) {
+            callback?.({ success: false, error: error.message });
+        }
+    });
+    socket.on('version:info', async (_data, callback) => {
+        try {
+            const currentHash = createHash('sha256').update(fsSync.readFileSync(fileURLToPath(import.meta.url))).digest('hex');
+            let version = 'unknown';
+            let date = undefined;
+            try {
+                const hashesPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'binary-hashes.json');
+                const hashes = JSON.parse(fsSync.readFileSync(hashesPath, 'utf-8'));
+                if (hashes['js-bundle']) {
+                    version = hashes['js-bundle'].version || version;
+                    date = hashes['js-bundle'].date;
+                }
+            }
+            catch { }
+            callback?.({
+                success: true,
+                version,
+                hash: currentHash.substring(0, 16) + '...',
+                date,
+                nodeVersion: process.version,
+                platform: os.platform(),
+                arch: os.arch()
+            });
+        }
+        catch (error) {
+            callback?.({ success: false, error: error.message });
+        }
+    });
+}

package/dist/updater.js

@@ -28,14 +28,11 @@ import { fileURLToPath } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CONFIG_DIR = path.join(os.homedir(), '.talk-to-code');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const DEVICE_ID_FILE = path.join(CONFIG_DIR, 'device-id.json');
 // File paths
-const UPDATER_FILE = fileURLToPath(import.meta.url);
 const APP_BUNDLE = path.join(__dirname, 'dist', 'app-child.js');
 const APP_BUNDLE_BACKUP = APP_BUNDLE + '.backup';
 const APP_BUNDLE_OLD = APP_BUNDLE + '.old';
 const BUNDLE_HASHES_FILE = path.join(__dirname, 'binary-hashes.json');
-const UPDATE_LOCK_FILE = path.join(CONFIG_DIR, '.update-lock');
 // State
 let childProcess = null;
 let isUpdating = false;
@@ -207,7 +204,7 @@ function spawnChild() {
                     console.log('✓ Recovered, restarting...');
                     childProcess = spawnChild();
                 })
-                    .catch((err) => {
+                    .catch((_err) => {
                     console.error('❌ Recovery failed, giving up');
                     process.exit(1);
                 });
@@ -251,7 +248,7 @@ function setupSignalHandlers() {
         }
         process.exit(1);
     });
-    process.on('unhandledRejection', (reason, promise) => {
+    process.on('unhandledRejection', (reason, _promise) => {
         console.error('❌ Unhandled rejection in updater:', reason);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {