@exreve/exk 1.0.6 → 1.0.8

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

@@ -0,0 +1,425 @@
+#!/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');
+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;
+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/install-service.sh

@@ -97,7 +97,8 @@ module.exports = {
       HOME: "$HOME",
       USER: "${USER:-$(whoami)}",
       PATH: "$DAEMON_PATH",
-      EXK_PKG_DIR: "$EXK_PKG_DIR"
+      EXK_PKG_DIR: "$EXK_PKG_DIR",
+      NODE_OPTIONS: "--no-experimental-strip-types"
     }
   }]
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {
@@ -8,15 +8,13 @@
   },
   "files": [
     "bin",
-    "shared",
+    "dist",
     "skills",
-    "*.ts",
     "install-service.sh",
-    "container-entrypoint.sh",
-    "tsconfig.json"
+    "container-entrypoint.sh"
   ],
   "scripts": {
-    "build": "node build-cli-tarball.js",
+    "build": "tsc && node build-cli-tarball.js",
     "build:tsc": "tsc",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "node -e \"require('fs').chmodSync('bin/exk', 0o755)\""
@@ -38,7 +36,6 @@
     "@anthropic-ai/claude-agent-sdk": "^0.1.23",
     "@anthropic-ai/sdk": "^0.74.0",
     "@fastify/static": "^9.0.0",
-    "@types/node": "^22.10.2",
     "@xenova/transformers": "^2.17.2",
     "chokidar": "^3.6.0",
     "commander": "^13.1.0",
@@ -47,16 +44,17 @@
     "node-fetch": "^3.3.2",
     "pino-pretty": "^11.0.0",
     "socket.io-client": "^4.8.1",
-    "tsx": "^4.19.0",
     "uuid": "^11.0.3"
   },
   "devDependencies": {
+    "@types/node": "^22.10.2",
     "@types/chokidar": "^2.1.3",
     "@types/uuid": "^10.0.0",
     "@vercel/ncc": "^0.38.1",
     "esbuild": "^0.27.2",
     "js-confuser": "^1.1.0",
     "ts-node": "^10.9.2",
+    "tsx": "^4.19.0",
     "typescript": "^5.7.2"
   },
   "engines": {