@exreve/exk 1.0.50 → 1.0.52

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

@@ -0,0 +1,422 @@
+#!/usr/bin/env node
+/**
+ * TalkToCode CLI Updater - Standalone Update Process
+ *
+ * This is a minimal, robust updater that:
+ * 1. Runs as the main process
+ * 2. Spawns the app as a child process
+ * 3. Can update itself even if app is corrupted
+ * 4. Can recover from failed updates
+ *
+ * Architecture:
+ * - updater.ts (this file) -> Main process, handles updates
+ * - app-child.ts -> Child process, contains all app logic
+ *
+ * File structure:
+ * - ttc (updater) -> Main entry point
+ * - ttc-app.js -> Child bundle (updated via updates)
+ * - ttc-app.js.old -> Backup of last version
+ * - ttc-app.js.backup -> Secondary backup
+ */
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+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');
+// File paths
+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');
+// State
+let childProcess = null;
+let isUpdating = false;
+let restartRequested = false;
+async function readConfig() {
+    try {
+        const data = await fs.readFile(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { apiUrl: 'https://api.talk-to-code.com' };
+    }
+}
+// ============ Hash Utilities ============
+function calculateHash(filePath) {
+    try {
+        const fileData = fsSync.readFileSync(filePath);
+        return crypto.createHash('sha256').update(fileData).digest('hex');
+    }
+    catch {
+        return '';
+    }
+}
+async function getBundleHashes() {
+    try {
+        const data = await fs.readFile(BUNDLE_HASHES_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+async function checkForUpdates() {
+    try {
+        const config = await readConfig();
+        const currentHash = calculateHash(APP_BUNDLE);
+        if (!currentHash) {
+            console.warn('⚠️  Cannot calculate current bundle hash');
+            return null;
+        }
+        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) {
+            console.warn(`⚠️  Update check failed: HTTP ${response.status}`);
+            return null;
+        }
+        const info = await response.json();
+        return info;
+    }
+    catch (error) {
+        console.warn(`⚠️  Update check failed: ${error.message}`);
+        return null;
+    }
+}
+async function downloadUpdate(downloadUrl, expectedHash) {
+    console.log('📥 Downloading update...');
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+        throw new Error(`Download failed: HTTP ${response.status}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const actualHash = crypto.createHash('sha256').update(buffer).digest('hex');
+    if (actualHash !== expectedHash) {
+        throw new Error(`Hash mismatch: expected ${expectedHash}, got ${actualHash}`);
+    }
+    console.log('✓ Download verified');
+    return buffer;
+}
+async function applyUpdate(newBundle) {
+    console.log('🔄 Applying update...');
+    // Create backup of current version if it exists
+    if (fsSync.existsSync(APP_BUNDLE)) {
+        try {
+            // Rotate backups: .old -> .backup (if exists), current -> .old
+            if (fsSync.existsSync(APP_BUNDLE_OLD)) {
+                await fs.copyFile(APP_BUNDLE_OLD, APP_BUNDLE_BACKUP);
+            }
+            await fs.copyFile(APP_BUNDLE, APP_BUNDLE_OLD);
+            console.log('✓ Backup created');
+        }
+        catch (error) {
+            console.warn(`⚠️  Backup creation failed: ${error.message}`);
+        }
+    }
+    // Write new bundle
+    const tempPath = path.join(os.tmpdir(), `ttc-update-${Date.now()}.js`);
+    await fs.writeFile(tempPath, newBundle, { mode: 0o755 });
+    // Replace current bundle
+    await fs.rename(tempPath, APP_BUNDLE);
+    // Make executable
+    if (process.platform !== 'win32') {
+        await fs.chmod(APP_BUNDLE, 0o755);
+    }
+    console.log('✓ Update applied');
+}
+async function performUpdate(info) {
+    if (!info.downloadUrl || !info.hash) {
+        console.error('❌ Invalid update info');
+        return false;
+    }
+    try {
+        const newBundle = await downloadUpdate(info.downloadUrl, info.hash);
+        await applyUpdate(newBundle);
+        if (info.version) {
+            console.log(`✓ Updated to version ${info.version}`);
+        }
+        if (info.changelog) {
+            console.log(`\n📝 Changelog:\n${info.changelog}`);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`❌ Update failed: ${error.message}`);
+        // Attempt rollback
+        if (fsSync.existsSync(APP_BUNDLE_OLD)) {
+            console.log('🔄 Rolling back to previous version...');
+            try {
+                await fs.copyFile(APP_BUNDLE_OLD, APP_BUNDLE);
+                console.log('✓ Rollback complete');
+            }
+            catch (rollbackError) {
+                console.error(`❌ Rollback failed: ${rollbackError.message}`);
+            }
+        }
+        return false;
+    }
+}
+// ============ Child Process Management ============
+function spawnChild() {
+    if (!fsSync.existsSync(APP_BUNDLE)) {
+        console.error(`❌ App bundle not found: ${APP_BUNDLE}`);
+        console.error('Please run: npm run build:cli');
+        process.exit(1);
+    }
+    console.log(`🚀 Spawning child process: ${APP_BUNDLE}`);
+    const child = spawn(process.execPath, [APP_BUNDLE, ...process.argv.slice(2)], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            TTC_IS_CHILD: '1',
+            TTC_UPDATER_PID: process.pid.toString()
+        }
+    });
+    child.on('exit', (code, signal) => {
+        console.log(`\n📦 Child process exited (code: ${code}, signal: ${signal})`);
+        childProcess = null;
+        // If update was requested, restart with new version
+        if (restartRequested) {
+            console.log('🔄 Restarting with updated version...');
+            restartRequested = false;
+            childProcess = spawnChild();
+            return;
+        }
+        // If child crashed, try to recover
+        if (code !== 0 && code !== null && !isUpdating) {
+            console.log('⚠️  Child process crashed, attempting recovery...');
+            // Try backup version if current is corrupted
+            if (fsSync.existsSync(APP_BUNDLE_OLD)) {
+                console.log('🔄 Attempting to recover with backup...');
+                fs.copyFile(APP_BUNDLE_OLD, APP_BUNDLE)
+                    .then(() => {
+                    console.log('✓ Recovered, restarting...');
+                    childProcess = spawnChild();
+                })
+                    .catch((_err) => {
+                    console.error('❌ Recovery failed, giving up');
+                    process.exit(1);
+                });
+            }
+            else {
+                console.error('❌ No backup available, cannot recover');
+                process.exit(1);
+            }
+        }
+        else if (signal !== 'SIGTERM' && signal !== 'SIGINT') {
+            // Normal exit or intentional signal
+            process.exit(code || 0);
+        }
+    });
+    child.on('error', (error) => {
+        console.error('❌ Child process error:', error);
+        childProcess = null;
+    });
+    return child;
+}
+// ============ Signal Handling ============
+function setupSignalHandlers() {
+    // Forward signals to child
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGUSR1', 'SIGUSR2'];
+    signals.forEach(signal => {
+        process.on(signal, () => {
+            if (childProcess) {
+                console.log(`\n📡 Forwarding ${signal} to child process...`);
+                childProcess.kill(signal);
+            }
+            else {
+                process.exit(0);
+            }
+        });
+    });
+    // Handle uncaught exceptions
+    process.on('uncaughtException', (error) => {
+        console.error('❌ Uncaught exception in updater:', error);
+        if (childProcess) {
+            childProcess.kill('SIGTERM');
+        }
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason, _promise) => {
+        console.error('❌ Unhandled rejection in updater:', reason);
+    });
+}
+// ============ CLI Interface ============
+async function cmdUpdate() {
+    console.log('🔍 Checking for updates...');
+    const info = await checkForUpdates();
+    if (!info) {
+        console.log('⚠️  Unable to check for updates');
+        process.exit(1);
+        return;
+    }
+    if (!info.updateAvailable) {
+        console.log('✓ Already up to date');
+        process.exit(0);
+        return;
+    }
+    console.log('📦 Update available!');
+    if (info.version) {
+        console.log(`   Version: ${info.version}`);
+    }
+    if (info.changelog) {
+        console.log(`\n📝 Changelog:\n${info.changelog}`);
+    }
+    // Stop child process if running
+    if (childProcess) {
+        console.log('🛑 Stopping child process...');
+        childProcess.kill('SIGTERM');
+        childProcess = null;
+    }
+    isUpdating = true;
+    const success = await performUpdate(info);
+    isUpdating = false;
+    if (success) {
+        console.log('\n✓ Update complete! Restarting...');
+        restartRequested = true;
+        childProcess = spawnChild();
+    }
+    else {
+        console.error('\n❌ Update failed!');
+        process.exit(1);
+    }
+}
+async function cmdUpdateCheck() {
+    console.log('🔍 Checking for updates...');
+    const info = await checkForUpdates();
+    if (!info) {
+        console.log('⚠️  Unable to check for updates');
+        process.exit(1);
+        return;
+    }
+    if (info.updateAvailable) {
+        console.log('📦 Update available!');
+        if (info.version) {
+            console.log(`   Version: ${info.version}`);
+        }
+        if (info.size) {
+            console.log(`   Size: ${(info.size / 1024 / 1024).toFixed(2)} MB`);
+        }
+        if (info.changelog) {
+            console.log(`\n📝 Changelog:\n${info.changelog}`);
+        }
+        console.log('\nRun "ttc update" to apply the update');
+        process.exit(0);
+    }
+    else {
+        console.log('✓ Already up to date');
+        process.exit(0);
+    }
+}
+async function cmdVersion() {
+    console.log(`TalkToCode CLI Updater`);
+    console.log(`Node: ${process.version}`);
+    console.log(`Platform: ${os.platform()} ${os.arch()}`);
+    const currentHash = calculateHash(APP_BUNDLE);
+    console.log(`Bundle hash: ${currentHash ? currentHash.substring(0, 16) + '...' : 'unknown'}`);
+    const hashes = await getBundleHashes();
+    if (hashes['js-bundle']) {
+        console.log(`Bundle version: ${hashes['js-bundle'].version || 'unknown'}`);
+        console.log(`Bundle date: ${hashes['js-bundle'].date || 'unknown'}`);
+    }
+    process.exit(0);
+}
+// ============ IPC from Child Process ============
+/**
+ * The child process can request updates by writing to a special file
+ * or by sending a signal to the parent
+ */
+function setupChildIPC() {
+    // Listen for update requests via USR1 signal
+    process.on('SIGUSR1', async () => {
+        console.log('\n📨 Update requested by child process...');
+        const info = await checkForUpdates();
+        if (!info || !info.updateAvailable) {
+            console.log('✓ No updates available');
+            return;
+        }
+        console.log('📦 Update available, applying...');
+        // Stop child process
+        if (childProcess) {
+            childProcess.kill('SIGTERM');
+            childProcess = null;
+        }
+        isUpdating = true;
+        const success = await performUpdate(info);
+        isUpdating = false;
+        if (success) {
+            console.log('✓ Update complete! Restarting...');
+            restartRequested = true;
+            childProcess = spawnChild();
+        }
+    });
+}
+// ============ Main Entry Point ============
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    // Handle updater-specific commands
+    if (command === 'update') {
+        await cmdUpdate();
+        return;
+    }
+    if (command === 'update:check' || command === 'check-update') {
+        await cmdUpdateCheck();
+        return;
+    }
+    if (command === 'version' || command === '--version' || command === '-v') {
+        await cmdVersion();
+        return;
+    }
+    if (command === 'help' || command === '--help' || command === '-h') {
+        console.log(`
+TalkToCode CLI Updater
+=====================
+
+Commands:
+  ttc <command>    Run command in child process (default)
+  ttc update       Check and apply updates
+  ttc update:check Check for updates without applying
+  ttc version      Show version information
+  ttc help         Show this help message
+
+The updater runs as the main process and spawns the app as a child.
+This allows the updater to update itself even if the app is corrupted.
+`);
+        process.exit(0);
+        return;
+    }
+    // Default: spawn child process
+    console.log('🎯 TalkToCode CLI Updater');
+    console.log('====================================\n');
+    // Silent update check on startup
+    checkForUpdates().then(info => {
+        if (info?.updateAvailable) {
+            console.log('📦 Update available! Run "ttc update" to apply.\n');
+        }
+    }).catch(() => { });
+    setupSignalHandlers();
+    setupChildIPC();
+    childProcess = spawnChild();
+    // Keep updater alive
+    process.on('exit', () => {
+        if (childProcess) {
+            childProcess.kill('SIGTERM');
+        }
+    });
+}
+main().catch(error => {
+    console.error('❌ Fatal error:', error);
+    process.exit(1);
+});

package/dist/shared/types.js

@@ -1,2 +1,35 @@
 // ============ Core Types ============
-export {};
+// --- Type guard helpers ---
+// These allow narrowing `unknown` to a specific tool output type at runtime.
+export function isBashOutput(r) {
+    return typeof r === 'object' && r !== null && 'stdout' in r && 'interrupted' in r;
+}
+export function isGrepOutput(r) {
+    return typeof r === 'object' && r !== null && 'numFiles' in r && 'filenames' in r && 'mode' in r;
+}
+export function isGlobOutput(r) {
+    return typeof r === 'object' && r !== null && 'durationMs' in r && 'filenames' in r && 'truncated' in r;
+}
+export function isFileReadOutput(r) {
+    return typeof r === 'object' && r !== null && 'file' in r && typeof r.type === 'string';
+}
+export function isFileEditOutput(r) {
+    return typeof r === 'object' && r !== null && 'oldString' in r && 'newString' in r && 'structuredPatch' in r;
+}
+export function isFileWriteOutput(r) {
+    return typeof r === 'object' && r !== null
+        && ('type' in r && (r.type === 'create' || r.type === 'update'))
+        && 'filePath' in r && 'content' in r;
+}
+export function isTodoWriteOutput(r) {
+    return typeof r === 'object' && r !== null && 'oldTodos' in r && 'newTodos' in r;
+}
+export function isWebSearchOutput(r) {
+    return typeof r === 'object' && r !== null && 'query' in r && 'results' in r && 'durationSeconds' in r;
+}
+export function isWebFetchOutput(r) {
+    return typeof r === 'object' && r !== null && 'url' in r && 'result' in r && 'code' in r;
+}
+export function isAgentOutput(r) {
+    return typeof r === 'object' && r !== null && 'agentId' in r && 'status' in r && 'prompt' in r;
+}

package/package.json

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