thaddeus 1.0.26 → 1.0.28

package/src/cli/transports/transportUtils.js

@@ -0,0 +1,39 @@
+import { URL } from 'url';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { HybridTransport } from './HybridTransport.js';
+import { SSETransport } from './SSETransport.js';
+import { WebSocketTransport } from './WebSocketTransport.js';
+/**
+ * Helper function to get the appropriate transport for a URL.
+ *
+ * Transport selection priority:
+ * 1. SSETransport (SSE reads + POST writes) when THADDEUS_USE_CCR_V2 is set
+ * 2. HybridTransport (WS reads + POST writes) when THADDEUS_POST_FOR_SESSION_INGRESS_V2 is set
+ * 3. WebSocketTransport (WS reads + WS writes) — default
+ */
+export function getTransportForUrl(url, headers = {}, sessionId, refreshHeaders) {
+    if (isEnvTruthy(process.env.THADDEUS_USE_CCR_V2)) {
+        // v2: SSE for reads, HTTP POST for writes
+        // --sdk-url is the session URL (.../sessions/{id});
+        // derive the SSE stream URL by appending /worker/events/stream
+        const sseUrl = new URL(url.href);
+        if (sseUrl.protocol === 'wss:') {
+            sseUrl.protocol = 'https:';
+        }
+        else if (sseUrl.protocol === 'ws:') {
+            sseUrl.protocol = 'http:';
+        }
+        sseUrl.pathname =
+            sseUrl.pathname.replace(/\/$/, '') + '/worker/events/stream';
+        return new SSETransport(sseUrl, headers, sessionId, refreshHeaders);
+    }
+    if (url.protocol === 'ws:' || url.protocol === 'wss:') {
+        if (isEnvTruthy(process.env.THADDEUS_POST_FOR_SESSION_INGRESS_V2)) {
+            return new HybridTransport(url, headers, sessionId, refreshHeaders);
+        }
+        return new WebSocketTransport(url, headers, sessionId, refreshHeaders);
+    }
+    else {
+        throw new Error(`Unsupported protocol: ${url.protocol}`);
+    }
+}

package/src/cli/update.js

@@ -0,0 +1,314 @@
+import chalk from 'chalk';
+import { logEvent } from 'src/services/analytics/index.js';
+import { getLatestVersion, installGlobalPackage, } from 'src/utils/autoUpdater.js';
+import { regenerateCompletionCache } from 'src/utils/completionCache.js';
+import { getGlobalConfig, saveGlobalConfig, } from 'src/utils/config.js';
+import { logForDebugging } from 'src/utils/debug.js';
+import { getDoctorDiagnostic } from 'src/utils/doctorDiagnostic.js';
+import { gracefulShutdown } from 'src/utils/gracefulShutdown.js';
+import { installOrUpdateClaudePackage, localInstallationExists, } from 'src/utils/localInstaller.js';
+import { installLatest as installLatestNative, removeInstalledSymlink, } from 'src/utils/nativeInstaller/index.js';
+import { getPackageManager } from 'src/utils/nativeInstaller/packageManagers.js';
+import { writeToStdout } from 'src/utils/process.js';
+import { gte } from 'src/utils/semver.js';
+import { getInitialSettings } from 'src/utils/settings/settings.js';
+export async function update() {
+    logEvent('thaddeus_update_check', {});
+    writeToStdout(`Current version: ${MACRO.VERSION}\n`);
+    const channel = getInitialSettings()?.autoUpdatesChannel ?? 'latest';
+    writeToStdout(`Checking for updates to ${channel} version...\n`);
+    logForDebugging('update: Starting update check');
+    // Run diagnostic to detect potential issues
+    logForDebugging('update: Running diagnostic');
+    const diagnostic = await getDoctorDiagnostic();
+    logForDebugging(`update: Installation type: ${diagnostic.installationType}`);
+    logForDebugging(`update: Config install method: ${diagnostic.configInstallMethod}`);
+    // Check for multiple installations
+    if (diagnostic.multipleInstallations.length > 1) {
+        writeToStdout('\n');
+        writeToStdout(chalk.yellow('Warning: Multiple installations found') + '\n');
+        for (const install of diagnostic.multipleInstallations) {
+            const current = diagnostic.installationType === install.type
+                ? ' (currently running)'
+                : '';
+            writeToStdout(`- ${install.type} at ${install.path}${current}\n`);
+        }
+    }
+    // Display warnings if any exist
+    if (diagnostic.warnings.length > 0) {
+        writeToStdout('\n');
+        for (const warning of diagnostic.warnings) {
+            logForDebugging(`update: Warning detected: ${warning.issue}`);
+            // Don't skip PATH warnings - they're always relevant
+            // The user needs to know that 'which claude' points elsewhere
+            logForDebugging(`update: Showing warning: ${warning.issue}`);
+            writeToStdout(chalk.yellow(`Warning: ${warning.issue}\n`));
+            writeToStdout(chalk.bold(`Fix: ${warning.fix}\n`));
+        }
+    }
+    // Update config if installMethod is not set (but skip for package managers)
+    const config = getGlobalConfig();
+    if (!config.installMethod &&
+        diagnostic.installationType !== 'package-manager') {
+        writeToStdout('\n');
+        writeToStdout('Updating configuration to track installation method...\n');
+        let detectedMethod = 'unknown';
+        // Map diagnostic installation type to config install method
+        switch (diagnostic.installationType) {
+            case 'npm-local':
+                detectedMethod = 'local';
+                break;
+            case 'native':
+                detectedMethod = 'native';
+                break;
+            case 'npm-global':
+                detectedMethod = 'global';
+                break;
+            default:
+                detectedMethod = 'unknown';
+        }
+        saveGlobalConfig(current => ({
+            ...current,
+            installMethod: detectedMethod,
+        }));
+        writeToStdout(`Installation method set to: ${detectedMethod}\n`);
+    }
+    // Check if running from development build
+    if (diagnostic.installationType === 'development') {
+        writeToStdout('\n');
+        writeToStdout(chalk.yellow('Warning: Cannot update development build') + '\n');
+        await gracefulShutdown(1);
+    }
+    // Check if running from a package manager
+    if (diagnostic.installationType === 'package-manager') {
+        const packageManager = await getPackageManager();
+        writeToStdout('\n');
+        if (packageManager === 'homebrew') {
+            writeToStdout('Thaddeus is managed by Homebrew.\n');
+            const latest = await getLatestVersion(channel);
+            if (latest && !gte(MACRO.VERSION, latest)) {
+                writeToStdout(`Update available: ${MACRO.VERSION} → ${latest}\n`);
+                writeToStdout('\n');
+                writeToStdout('To update, run:\n');
+                writeToStdout(chalk.bold('  brew upgrade thaddeus') + '\n');
+            }
+            else {
+                writeToStdout('Thaddeus is up to date!\n');
+            }
+        }
+        else if (packageManager === 'winget') {
+            writeToStdout('Thaddeus is managed by winget.\n');
+            const latest = await getLatestVersion(channel);
+            if (latest && !gte(MACRO.VERSION, latest)) {
+                writeToStdout(`Update available: ${MACRO.VERSION} → ${latest}\n`);
+                writeToStdout('\n');
+                writeToStdout('To update, run:\n');
+                writeToStdout(chalk.bold('  winget upgrade DelphiLabs.Thaddeus') + '\n');
+            }
+            else {
+                writeToStdout('Thaddeus is up to date!\n');
+            }
+        }
+        else if (packageManager === 'apk') {
+            writeToStdout('Thaddeus is managed by apk.\n');
+            const latest = await getLatestVersion(channel);
+            if (latest && !gte(MACRO.VERSION, latest)) {
+                writeToStdout(`Update available: ${MACRO.VERSION} → ${latest}\n`);
+                writeToStdout('\n');
+                writeToStdout('To update, run:\n');
+                writeToStdout(chalk.bold('  apk upgrade thaddeus') + '\n');
+            }
+            else {
+                writeToStdout('Thaddeus is up to date!\n');
+            }
+        }
+        else {
+            // pacman, deb, and rpm don't get specific commands because they each have
+            // multiple frontends (pacman: yay/paru/makepkg, deb: apt/apt-get/aptitude/nala,
+            // rpm: dnf/yum/zypper)
+            writeToStdout('Thaddeus is managed by a package manager.\n');
+            writeToStdout('Please use your package manager to update.\n');
+        }
+        await gracefulShutdown(0);
+    }
+    // Check for config/reality mismatch (skip for package-manager installs)
+    if (config.installMethod &&
+        diagnostic.configInstallMethod !== 'not set' &&
+        diagnostic.installationType !== 'package-manager') {
+        const runningType = diagnostic.installationType;
+        const configExpects = diagnostic.configInstallMethod;
+        // Map installation types for comparison
+        const typeMapping = {
+            'npm-local': 'local',
+            'npm-global': 'global',
+            native: 'native',
+            development: 'development',
+            unknown: 'unknown',
+        };
+        const normalizedRunningType = typeMapping[runningType] || runningType;
+        if (normalizedRunningType !== configExpects &&
+            configExpects !== 'unknown') {
+            writeToStdout('\n');
+            writeToStdout(chalk.yellow('Warning: Configuration mismatch') + '\n');
+            writeToStdout(`Config expects: ${configExpects} installation\n`);
+            writeToStdout(`Currently running: ${runningType}\n`);
+            writeToStdout(chalk.yellow(`Updating the ${runningType} installation you are currently using`) + '\n');
+            // Update config to match reality
+            saveGlobalConfig(current => ({
+                ...current,
+                installMethod: normalizedRunningType,
+            }));
+            writeToStdout(`Config updated to reflect current installation method: ${normalizedRunningType}\n`);
+        }
+    }
+    // Handle native installation updates first
+    if (diagnostic.installationType === 'native') {
+        logForDebugging('update: Detected native installation, using native updater');
+        try {
+            const result = await installLatestNative(channel, true);
+            // Handle lock contention gracefully
+            if (result.lockFailed) {
+                const pidInfo = result.lockHolderPid
+                    ? ` (PID ${result.lockHolderPid})`
+                    : '';
+                writeToStdout(chalk.yellow(`Another Thaddeus process${pidInfo} is currently running. Please try again in a moment.`) + '\n');
+                await gracefulShutdown(0);
+            }
+            if (!result.latestVersion) {
+                process.stderr.write('Failed to check for updates\n');
+                await gracefulShutdown(1);
+            }
+            if (result.latestVersion === MACRO.VERSION) {
+                writeToStdout(chalk.green(`Thaddeus is up to date (${MACRO.VERSION})`) + '\n');
+            }
+            else {
+                writeToStdout(chalk.green(`Successfully updated from ${MACRO.VERSION} to version ${result.latestVersion}`) + '\n');
+                await regenerateCompletionCache();
+            }
+            await gracefulShutdown(0);
+        }
+        catch (error) {
+            process.stderr.write('Error: Failed to install native update\n');
+            process.stderr.write(String(error) + '\n');
+            process.stderr.write('Try running "thaddeus doctor" for diagnostics\n');
+            await gracefulShutdown(1);
+        }
+    }
+    // Fallback to existing JS/npm-based update logic
+    // Remove native installer symlink since we're not using native installation
+    // But only if user hasn't migrated to native installation
+    if (config.installMethod !== 'native') {
+        await removeInstalledSymlink();
+    }
+    logForDebugging('update: Checking npm registry for latest version');
+    logForDebugging(`update: Package URL: ${MACRO.PACKAGE_URL}`);
+    const npmTag = channel === 'stable' ? 'stable' : 'latest';
+    const npmCommand = `npm view ${MACRO.PACKAGE_URL}@${npmTag} version`;
+    logForDebugging(`update: Running: ${npmCommand}`);
+    const latestVersion = await getLatestVersion(channel);
+    logForDebugging(`update: Latest version from npm: ${latestVersion || 'FAILED'}`);
+    if (!latestVersion) {
+        logForDebugging('update: Failed to get latest version from npm registry');
+        process.stderr.write(chalk.red('Failed to check for updates') + '\n');
+        process.stderr.write('Unable to fetch latest version from npm registry\n');
+        process.stderr.write('\n');
+        process.stderr.write('Possible causes:\n');
+        process.stderr.write('  • Network connectivity issues\n');
+        process.stderr.write('  • npm registry is unreachable\n');
+        process.stderr.write('  • Corporate proxy/firewall blocking npm\n');
+        if (MACRO.PACKAGE_URL && !MACRO.PACKAGE_URL.startsWith('@anthropic')) {
+            process.stderr.write('  • Internal/development build not published to npm\n');
+        }
+        process.stderr.write('\n');
+        process.stderr.write('Try:\n');
+        process.stderr.write('  • Check your internet connection\n');
+        process.stderr.write('  • Run with --debug flag for more details\n');
+        const packageName = MACRO.PACKAGE_URL ||
+            (process.env.USER_TYPE === 'ant'
+                ? '@anthropic-ai/claude-cli'
+                : '@anthropic-ai/claude-code');
+        process.stderr.write(`  • Manually check: npm view ${packageName} version\n`);
+        process.stderr.write('  • Check if you need to login: npm whoami\n');
+        await gracefulShutdown(1);
+    }
+    // Check if versions match exactly, including any build metadata (like SHA)
+    if (latestVersion === MACRO.VERSION) {
+        writeToStdout(chalk.green(`Thaddeus is up to date (${MACRO.VERSION})`) + '\n');
+        await gracefulShutdown(0);
+    }
+    writeToStdout(`New version available: ${latestVersion} (current: ${MACRO.VERSION})\n`);
+    writeToStdout('Installing update...\n');
+    // Determine update method based on what's actually running
+    let useLocalUpdate = false;
+    let updateMethodName = '';
+    switch (diagnostic.installationType) {
+        case 'npm-local':
+            useLocalUpdate = true;
+            updateMethodName = 'local';
+            break;
+        case 'npm-global':
+            useLocalUpdate = false;
+            updateMethodName = 'global';
+            break;
+        case 'unknown': {
+            // Fallback to detection if we can't determine installation type
+            const isLocal = await localInstallationExists();
+            useLocalUpdate = isLocal;
+            updateMethodName = isLocal ? 'local' : 'global';
+            writeToStdout(chalk.yellow('Warning: Could not determine installation type') + '\n');
+            writeToStdout(`Attempting ${updateMethodName} update based on file detection...\n`);
+            break;
+        }
+        default:
+            process.stderr.write(`Error: Cannot update ${diagnostic.installationType} installation\n`);
+            await gracefulShutdown(1);
+    }
+    writeToStdout(`Using ${updateMethodName} installation update method...\n`);
+    logForDebugging(`update: Update method determined: ${updateMethodName}`);
+    logForDebugging(`update: useLocalUpdate: ${useLocalUpdate}`);
+    let status;
+    if (useLocalUpdate) {
+        logForDebugging('update: Calling installOrUpdateClaudePackage() for local update');
+        status = await installOrUpdateClaudePackage(channel);
+    }
+    else {
+        logForDebugging('update: Calling installGlobalPackage() for global update');
+        status = await installGlobalPackage();
+    }
+    logForDebugging(`update: Installation status: ${status}`);
+    switch (status) {
+        case 'success':
+            writeToStdout(chalk.green(`Successfully updated from ${MACRO.VERSION} to version ${latestVersion}`) + '\n');
+            await regenerateCompletionCache();
+            break;
+        case 'no_permissions':
+            process.stderr.write('Error: Insufficient permissions to install update\n');
+            if (useLocalUpdate) {
+                process.stderr.write('Try manually updating with:\n');
+                process.stderr.write(`  cd ~/.claude/local && npm update ${MACRO.PACKAGE_URL}\n`);
+            }
+            else {
+                process.stderr.write('Try running with sudo or fix npm permissions\n');
+                process.stderr.write('Or consider using native installation with: thaddeus install\n');
+            }
+            await gracefulShutdown(1);
+            break;
+        case 'install_failed':
+            process.stderr.write('Error: Failed to install update\n');
+            if (useLocalUpdate) {
+                process.stderr.write('Try manually updating with:\n');
+                process.stderr.write(`  cd ~/.claude/local && npm update ${MACRO.PACKAGE_URL}\n`);
+            }
+            else {
+                process.stderr.write('Or consider using native installation with: thaddeus install\n');
+            }
+            await gracefulShutdown(1);
+            break;
+        case 'in_progress':
+            process.stderr.write('Error: Another instance is currently performing an update\n');
+            process.stderr.write('Please wait and try again later\n');
+            await gracefulShutdown(1);
+            break;
+    }
+    await gracefulShutdown(0);
+}

package/src/commandCenter/launch.js

@@ -0,0 +1,39 @@
+// Command Center launcher — starts server + opens browser + auto-tunnel for mobile
+import { exec } from 'child_process';
+import { startCommandCenterServer } from './server.js';
+import { startTunnel, stopTunnel, getTunnelUrl } from './tunnel.js';
+let result = null;
+export function launchCommandCenter(port = 7888) {
+    if (!result) {
+        result = startCommandCenterServer(port);
+    }
+    const url = `${result.protocol}://localhost:${port}`;
+    // Open in default browser
+    if (process.platform === 'darwin') {
+        exec(`open "${url}"`);
+    }
+    else if (process.platform === 'linux') {
+        exec(`xdg-open "${url}"`);
+    }
+    else {
+        exec(`cmd /c start "" "${url}"`);
+    }
+    // Auto-start Cloudflare tunnel for mobile access (non-blocking)
+    const useTLS = result.protocol === 'https';
+    startTunnel(port, useTLS).catch(() => { });
+    return url;
+}
+export function isCommandCenterRunning() {
+    return result !== null;
+}
+/** Get the public mobile URL if tunnel is active */
+export function getMobileUrl() {
+    return getTunnelUrl();
+}
+export function stopCommandCenter() {
+    stopTunnel();
+    if (result) {
+        result.server.stop();
+        result = null;
+    }
+}

package/src/commandCenter/phoneApi.js

@@ -0,0 +1,168 @@
+// Phone API — HTTP endpoint handlers for the Phone Bridge
+// Handles phone ↔ Thaddeus communication via REST polling
+//
+// POST /api/phone/command  — Phone sends a command TO Thaddeus (voice/text)
+// POST /api/phone/register — Phone registers itself (name, platform)
+// GET  /api/phone/pending  — Phone polls for commands FROM Thaddeus
+// POST /api/phone/ack      — Phone acknowledges command execution
+import { randomUUID } from 'crypto';
+import { registerDevice, getPending, ackCommand, getPhoneBridgeStatus, touchDevice } from './phoneStore.js';
+// Broadcast to all connected WebSocket reactor clients (Mac browser tabs)
+// Uses globalThis to avoid circular dependency with server.ts
+function broadcastToReactor(msg) {
+    const G = globalThis;
+    const clients = G.__reactorWsClients;
+    if (!clients)
+        return;
+    const payload = JSON.stringify(msg);
+    for (const ws of clients) {
+        try {
+            ws.send(payload);
+        }
+        catch { }
+    }
+}
+// Track in-flight phone commands — mic stays paused while any are active
+let phoneCommandsInFlight = 0;
+const CORS = { 'Access-Control-Allow-Origin': '*' };
+const JSON_CORS = { 'Content-Type': 'application/json', ...CORS };
+// ---------------------------------------------------------------------------
+// POST /api/phone/command — Phone sends text command to Thaddeus
+// ---------------------------------------------------------------------------
+export function handlePhoneCommand(req, enqueue, registerCallback) {
+    return new Promise(async (resolve) => {
+        try {
+            const body = (await req.json());
+            if (!body.text?.trim()) {
+                resolve(new Response(JSON.stringify({ error: 'Missing "text" field' }), {
+                    status: 400,
+                    headers: JSON_CORS,
+                }));
+                return;
+            }
+            // Touch device if provided
+            if (body.device_id)
+                touchDevice(body.device_id);
+            const uuid = randomUUID();
+            phoneCommandsInFlight++;
+            let resolved = false;
+            console.log(`[Phone API] Command from phone: "${body.text}" (${uuid}) [in-flight: ${phoneCommandsInFlight}]`);
+            // Pause Mac mic while any phone command is active
+            broadcastToReactor({ type: 'mic-pause', reason: 'phone-active' });
+            // Helper: resolve exactly once + manage in-flight count
+            const finishCommand = (response) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                phoneCommandsInFlight = Math.max(0, phoneCommandsInFlight - 1);
+                // Only resume Mac mic when ALL phone commands are done
+                if (phoneCommandsInFlight === 0) {
+                    broadcastToReactor({ type: 'mic-resume', reason: 'phone-done' });
+                }
+                resolve(response);
+            };
+            // Set a 60s timeout (increased from 30s — complex commands need time)
+            const timeout = setTimeout(() => {
+                console.log(`[Phone API] Timeout for ${uuid} — cleaning up reactor bus callback`);
+                // Remove stale callback from reactor bus so it can't interfere with other commands
+                const G = globalThis;
+                G.__reactorPending?.delete(uuid);
+                finishCommand(Response.json({ text: 'Still processing — check back shortly, sir.', uuid, timeout: true }, { headers: CORS }));
+            }, 60_000);
+            // Register callback — fires when CLI finishes processing
+            registerCallback(uuid, (responseText) => {
+                clearTimeout(timeout);
+                console.log(`[Phone API] Response ready (${uuid}): ${responseText.slice(0, 80)}...`);
+                finishCommand(Response.json({ text: responseText, uuid }, { headers: CORS }));
+            });
+            // Inject command into the running Thaddeus CLI queue
+            enqueue({
+                value: body.text.trim(),
+                mode: 'prompt',
+                priority: 'next',
+                uuid,
+            });
+        }
+        catch (e) {
+            console.error('[Phone API] Command error:', e);
+            resolve(new Response(JSON.stringify({ error: String(e) }), {
+                status: 500,
+                headers: JSON_CORS,
+            }));
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// POST /api/phone/register — Phone registers itself
+// ---------------------------------------------------------------------------
+export async function handlePhoneRegister(req) {
+    try {
+        const body = (await req.json());
+        if (!body.name?.trim()) {
+            return Response.json({ error: 'Missing "name" field' }, { status: 400, headers: CORS });
+        }
+        const platform = body.platform === 'android' ? 'android' : 'ios';
+        const device = registerDevice({
+            name: body.name.trim(),
+            platform,
+        });
+        console.log(`[Phone API] Device registered: ${device.name} (${device.platform}) — ${device.id}`);
+        return Response.json({ device_id: device.id, name: device.name, platform: device.platform, registered: true }, { headers: CORS });
+    }
+    catch (e) {
+        console.error('[Phone API] Register error:', e);
+        return new Response(JSON.stringify({ error: String(e) }), {
+            status: 500,
+            headers: JSON_CORS,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// GET /api/phone/pending?device=<device_id> — Phone polls for commands
+// ---------------------------------------------------------------------------
+export function handlePhonePending(deviceId) {
+    if (!deviceId) {
+        return Response.json({ error: 'Missing "device" query parameter' }, { status: 400, headers: CORS });
+    }
+    const commands = getPending(deviceId);
+    return Response.json({
+        commands: commands.map(c => ({
+            id: c.id,
+            action: c.action,
+            params: c.params,
+            created_at: c.createdAt,
+        })),
+        count: commands.length,
+    }, { headers: CORS });
+}
+// ---------------------------------------------------------------------------
+// POST /api/phone/ack — Phone acknowledges command execution
+// ---------------------------------------------------------------------------
+export async function handlePhoneAck(req) {
+    try {
+        const body = (await req.json());
+        if (!body.device_id || !body.command_id) {
+            return Response.json({ error: 'Missing "device_id" or "command_id"' }, { status: 400, headers: CORS });
+        }
+        ackCommand(body.device_id, body.command_id, {
+            success: body.success ?? true,
+            message: body.message,
+            data: body.data,
+        });
+        return Response.json({ acked: true }, { headers: CORS });
+    }
+    catch (e) {
+        console.error('[Phone API] Ack error:', e);
+        return new Response(JSON.stringify({ error: String(e) }), {
+            status: 500,
+            headers: JSON_CORS,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// GET /api/phone/status — Diagnostics
+// ---------------------------------------------------------------------------
+export function handlePhoneStatus() {
+    const status = getPhoneBridgeStatus();
+    return Response.json(status, { headers: CORS });
+}