@siftd/connect-agent 0.2.18 → 0.2.20

package/dist/agent.js

@@ -8,110 +8,33 @@ import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js
 function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
 }
-// Lock to prevent concurrent updates
-let updateInProgress = false;
 /**
- * Get the installed version of connect-agent
- */
-function getInstalledVersion() {
-    try {
-        const output = execSync('npm list -g @siftd/connect-agent --depth=0 2>/dev/null', {
-            encoding: 'utf8',
-            shell: '/bin/bash'
-        });
-        const match = output.match(/@siftd\/connect-agent@([\d.]+)/);
-        return match ? match[1] : 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-/**
- * Get the latest published version from npm
- */
-function getLatestVersion() {
-    try {
-        const output = execSync('npm view @siftd/connect-agent version 2>/dev/null', {
-            encoding: 'utf8',
-            shell: '/bin/bash'
-        });
-        return output.trim();
-    }
-    catch {
-        return 'unknown';
-    }
-}
-/**
- * Actually perform a self-update - runs npm install and restarts
+ * Self-update: npm install latest and restart
+ * Called from webapp banner or update command
  */
 async function performSelfUpdate() {
-    // Prevent concurrent updates
-    if (updateInProgress) {
-        return '⏳ Update already in progress. Please wait...';
-    }
-    updateInProgress = true;
-    console.log('[AGENT] Starting self-update...');
+    console.log('[AGENT] === SELF-UPDATE STARTING ===');
     try {
-        // Get current version
-        const currentVersion = getInstalledVersion();
-        console.log('[AGENT] Current version:', currentVersion);
-        // Check latest version first
-        const latestVersion = getLatestVersion();
-        console.log('[AGENT] Latest available:', latestVersion);
-        if (currentVersion === latestVersion && currentVersion !== 'unknown') {
-            updateInProgress = false;
-            return `✅ Already on latest version (${currentVersion})`;
-        }
+        // Just do it - npm install latest
         console.log('[AGENT] Running: npm install -g @siftd/connect-agent@latest');
-        // Actually run the npm install with more detailed error capture
-        let installOutput;
-        try {
-            installOutput = execSync('npm install -g @siftd/connect-agent@latest 2>&1', {
-                encoding: 'utf8',
-                shell: '/bin/bash',
-                timeout: 180000, // 3 minute timeout
-                maxBuffer: 10 * 1024 * 1024 // 10MB buffer
-            });
-        }
-        catch (installError) {
-            const err = installError;
-            const output = err.stdout || err.stderr || err.message || 'Unknown install error';
-            console.error('[AGENT] npm install failed:', output);
-            updateInProgress = false;
-            // Parse common npm errors
-            if (output.includes('EACCES') || output.includes('permission denied')) {
-                return `❌ Permission denied. Try running:\nsudo npm install -g @siftd/connect-agent@latest`;
-            }
-            if (output.includes('ENOTFOUND') || output.includes('network')) {
-                return `❌ Network error. Check your internet connection and try again.`;
-            }
-            if (output.includes('E404')) {
-                return `❌ Package not found on npm. The package may have been unpublished.`;
-            }
-            return `❌ Update failed:\n${output.slice(0, 500)}\n\nRun manually:\nnpm install -g @siftd/connect-agent@latest`;
-        }
-        console.log('[AGENT] Install output:', installOutput.slice(0, 500));
-        // Verify the update succeeded
-        const newVersion = getInstalledVersion();
-        console.log('[AGENT] New version:', newVersion);
-        if (newVersion === currentVersion && currentVersion !== 'unknown') {
-            updateInProgress = false;
-            return `⚠️ Version unchanged (${currentVersion}). npm may have used cache.\n\nTry: npm cache clean --force && npm install -g @siftd/connect-agent@latest`;
-        }
-        // Schedule restart
-        console.log('[AGENT] Scheduling restart in 3 seconds...');
+        execSync('npm install -g @siftd/connect-agent@latest', {
+            encoding: 'utf8',
+            shell: '/bin/bash',
+            stdio: 'inherit', // Show output in real-time
+            timeout: 180000
+        });
+        console.log('[AGENT] Update installed. Restarting in 2 seconds...');
+        // Restart the agent
         setTimeout(() => {
-            console.log('[AGENT] Restarting...');
-            updateInProgress = false;
-            process.exit(0); // Exit - systemd/pm2/user will restart
-        }, 3000);
-        return `✅ Update complete!\n\n${currentVersion} → ${newVersion}\n\nRestarting agent in 3 seconds...`;
+            console.log('[AGENT] === RESTARTING ===');
+            process.exit(0);
+        }, 2000);
+        return '✅ Update installed. Restarting...';
     }
     catch (error) {
-        updateInProgress = false;
-        const errMsg = error instanceof Error ? error.message : String(error);
-        console.error('[AGENT] Update failed:', errMsg);
-        return `❌ Update failed: ${errMsg}\n\nYou may need to run manually:\nnpm install -g @siftd/connect-agent@latest`;
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error('[AGENT] Update failed:', msg);
+        return `❌ Update failed: ${msg}`;
     }
 }
 // Conversation history for orchestrator mode
@@ -258,10 +181,9 @@ export async function processMessage(message) {
         );
         return response;
     }
-    // Handle self-update requests - ACTUALLY run the update, don't just pretend
-    if (content.includes('update') && content.includes('connect-agent') &&
-        (content.includes('npm install') || content.includes('latest'))) {
-        console.log('[AGENT] Self-update request detected - forcing actual execution');
+    // System command: force update (sent by webapp banner)
+    if (content === '/system-update') {
+        console.log('[AGENT] === SYSTEM UPDATE COMMAND ===');
         return await performSelfUpdate();
     }
     try {
@@ -323,16 +245,24 @@ export async function runAgent(pollInterval = 2000) {
     // Try WebSocket first
     wsClient = new AgentWebSocket();
     const wsConnected = await wsClient.connect();
-    // Always set up worker status callback for progress bars (works with or without WebSocket)
+    // Set up worker callbacks
     if (orchestrator) {
+        // Progress bars
         orchestrator.setWorkerStatusCallback((workers) => {
             if (wsClient?.connected()) {
                 wsClient.sendWorkersUpdate(workers);
             }
-            // Log running workers count for visibility even without WebSocket
             const running = workers.filter(w => w.status === 'running');
             if (running.length > 0) {
-                console.log(`[WORKERS] ${running.length} running: ${running.map(w => `${w.id} (${w.progress}%)`).join(', ')}`);
+                console.log(`[WORKERS] ${running.length} running`);
+            }
+        });
+        // Worker results - send to user when workers complete
+        orchestrator.setWorkerResultCallback((workerId, result) => {
+            console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);
+            if (wsClient?.connected()) {
+                // Send as response with worker ID as message ID
+                wsClient.sendResponse(workerId, `**Worker completed:**\n\n${result}`);
             }
         });
     }

package/dist/heartbeat.js

@@ -10,7 +10,7 @@ import { hostname } from 'os';
 import { createHash } from 'crypto';
 import { getServerUrl, getAgentToken, getUserId, isCloudMode } from './config.js';
 const HEARTBEAT_INTERVAL = 10000; // 10 seconds
-const VERSION = '0.2.18'; // Should match package.json
+const VERSION = '0.2.20'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -101,9 +101,14 @@ export declare class MasterOrchestrator {
      * Process tool calls
      */
     private processToolCalls;
+    private workerResultCallback;
     /**
-     * Delegate task to Claude Code CLI worker with retry logic
-     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
+     * Set callback for when workers complete (for async notification)
+     */
+    setWorkerResultCallback(callback: ((workerId: string, result: string) => void) | null): void;
+    /**
+     * Delegate task to Claude Code CLI worker - NON-BLOCKING
+     * Returns immediately, sends results via callback when done
      */
     private delegateToWorker;
     /**

package/dist/orchestrator.js

@@ -828,197 +828,99 @@ Be specific about what you want done.`,
         }
         return results;
     }
+    // Callback for sending results when worker completes
+    workerResultCallback = null;
     /**
-     * Delegate task to Claude Code CLI worker with retry logic
-     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
+     * Set callback for when workers complete (for async notification)
      */
-    async delegateToWorker(task, context, workingDir, retryCount = 0, timeoutMs) {
-        const maxRetries = 2;
-        // Default 30 min, max 60 min
-        const workerTimeout = Math.min(timeoutMs || 30 * 60 * 1000, 60 * 60 * 1000);
+    setWorkerResultCallback(callback) {
+        this.workerResultCallback = callback;
+    }
+    /**
+     * Delegate task to Claude Code CLI worker - NON-BLOCKING
+     * Returns immediately, sends results via callback when done
+     */
+    async delegateToWorker(task, context, workingDir) {
         const id = `worker_${Date.now()}_${++this.jobCounter}`;
         const cwd = workingDir || this.workspaceDir;
-        // Search for relevant memories to inject into worker prompt
-        let memoryContext = '';
-        try {
-            const relevantMemories = await this.memory.search(task, { limit: 5, minImportance: 0.3 });
-            if (relevantMemories.length > 0) {
-                memoryContext = '\n\nRELEVANT KNOWLEDGE FROM MEMORY:\n' +
-                    relevantMemories.map(m => `[${m.type}] ${m.content}`).join('\n');
-            }
-        }
-        catch (error) {
-            // Memory search failed, continue without it
-            console.log('[ORCHESTRATOR] Memory search failed, continuing without context');
-        }
-        // Get shared state context for worker coordination
-        const sharedContext = this.sharedState.getSummaryForWorker(id);
-        // Build prompt for worker with memory context and checkpoint instructions
+        // Build simple prompt - no bloat
         let prompt = task;
         if (context) {
             prompt = `Context: ${context}\n\nTask: ${task}`;
         }
-        if (memoryContext) {
-            prompt += memoryContext;
-        }
-        if (sharedContext) {
-            prompt += `\n\nWORKER COORDINATION:${sharedContext}`;
-        }
-        // Add checkpoint and logging instructions to prevent data loss
-        const logFile = `/tmp/worker-${id}-log.txt`;
-        prompt += `
-
-IMPORTANT - Progress & Logging:
-- Output findings as you go, don't wait until the end
-- Print discoveries, file paths, and insights immediately as you find them
-- Report on each file/step before moving to the next
-
-REQUIRED - Log Export:
-At the END of your work, create a final log file at: ${logFile}
-Include: job_id=${id}, timestamp, summary of work done, files modified, key findings.
-This ensures nothing is lost even if your output gets truncated.
-
-LEARNING EXPORT (optional but valuable):
-If you discover something important (patterns, user preferences, technical insights),
-end your response with a line like:
-[MEMORY] type=semantic | content=User prefers X over Y for this type of task
-[MEMORY] type=procedural | content=When doing X, always check Y first
-This helps me remember and improve for future tasks.
-
-WORKER COORDINATION (optional):
-If you need to share data with other workers or signal completion:
-[SHARE] key=myData | value={"result": "something useful"}
-[SIGNAL] name=step1_complete | data={"files": ["a.ts", "b.ts"]}
-[MESSAGE] to=worker_xyz | content=Please review the changes I made
-This enables parallel workers to coordinate.`;
-        console.log(`[ORCHESTRATOR] Delegating to worker ${id}: ${task.slice(0, 80)}...`);
-        // Estimate task duration based on content
+        // Add brief instruction
+        prompt += `\n\nBe concise. Output results directly.`;
+        console.log(`[ORCHESTRATOR] Worker ${id} starting: ${task.slice(0, 80)}...`);
+        // Estimate task duration
         const estimatedTime = this.estimateTaskDuration(task);
-        return new Promise((resolve) => {
-            const job = {
-                id,
-                task: task.slice(0, 200),
-                status: 'running',
-                startTime: Date.now(),
-                output: '',
-                estimatedTime
-            };
-            // Escape single quotes in prompt for shell safety
-            // Replace ' with '\'' (end quote, escaped quote, start quote)
-            const escapedPrompt = prompt.replace(/'/g, "'\\''");
-            // Spawn using /bin/bash -l -c to ensure proper PATH resolution (NVM, etc.)
-            // Use absolute path to bash to avoid ENOENT errors in restricted environments
-            const child = spawn('/bin/bash', ['-l', '-c', `claude -p '${escapedPrompt}' --dangerously-skip-permissions`], {
-                cwd,
-                env: { ...process.env },
-                stdio: ['pipe', 'pipe', 'pipe']
-            });
-            job.process = child;
-            this.jobs.set(id, job);
-            // Configurable timeout (default 30 min, max 60 min)
-            const timeoutMinutes = Math.round(workerTimeout / 60000);
-            const timeout = setTimeout(async () => {
-                if (job.status === 'running') {
-                    job.status = 'timeout';
-                    job.endTime = Date.now();
-                    const duration = Math.round((job.endTime - job.startTime) / 1000);
-                    // Send SIGINT first to allow graceful shutdown and output flush
-                    child.kill('SIGINT');
-                    // Give 5 seconds for graceful shutdown before SIGTERM
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            child.kill('SIGTERM');
-                        }
-                    }, 5000);
-                    // Wait a moment for graceful shutdown to flush logs
-                    await new Promise(r => setTimeout(r, 2000));
-                    const partialOutput = job.output.trim();
-                    // Try to recover from log file
-                    const recoveredLog = this.recoverWorkerLog(id);
-                    // Log failure to memory for learning
-                    await this.logWorkerFailure(id, task, `Timeout after ${timeoutMinutes} minutes`, duration, recoveredLog || undefined);
-                    // Build combined output
-                    let combinedOutput = '';
-                    if (recoveredLog) {
-                        combinedOutput = `[Recovered from log file]\n${recoveredLog}\n\n`;
-                    }
-                    if (partialOutput) {
-                        combinedOutput += `[Partial stdout]\n${partialOutput.slice(-3000)}`;
-                    }
-                    resolve({
-                        success: false,
-                        output: combinedOutput
-                            ? `Worker timed out after ${timeoutMinutes} minutes. Recovered output:\n${combinedOutput}`
-                            : `Worker timed out after ${timeoutMinutes} minutes with no recoverable output.`
-                    });
-                }
-            }, workerTimeout);
-            child.stdout?.on('data', (data) => {
-                job.output += data.toString();
-            });
-            child.stderr?.on('data', (data) => {
-                // Ignore status messages
-                const text = data.toString();
-                if (!text.includes('Checking') && !text.includes('Connected')) {
-                    job.output += text;
-                }
-            });
-            child.on('close', async (code) => {
-                clearTimeout(timeout);
-                job.status = code === 0 ? 'completed' : 'failed';
-                job.endTime = Date.now();
-                const duration = Math.round((job.endTime - job.startTime) / 1000);
-                console.log(`[ORCHESTRATOR] Worker ${id} finished in ${duration}s (code: ${code})`);
-                let finalOutput = job.output.trim();
-                if (code !== 0 || finalOutput.length === 0) {
-                    console.log(`[ORCHESTRATOR] Worker ${id} output: ${finalOutput.slice(0, 200) || '(empty)'}`);
-                    // Try to recover from log file on failure or empty output
-                    const recoveredLog = this.recoverWorkerLog(id);
-                    if (recoveredLog) {
-                        finalOutput = recoveredLog + (finalOutput ? `\n\n[Additional stdout]\n${finalOutput}` : '');
-                    }
-                    // Log failure to memory
-                    if (code !== 0) {
-                        await this.logWorkerFailure(id, task, `Exit code ${code}`, duration, recoveredLog || undefined);
-                    }
-                }
-                // Extract and store memory contributions from worker output
-                await this.extractWorkerMemories(finalOutput, id);
-                resolve({
-                    success: code === 0,
-                    output: finalOutput || '(No output)'
-                });
-            });
-            child.on('error', async (err) => {
-                clearTimeout(timeout);
-                job.status = 'failed';
+        const job = {
+            id,
+            task: task.slice(0, 200),
+            status: 'running',
+            startTime: Date.now(),
+            output: '',
+            estimatedTime
+        };
+        // Escape single quotes in prompt for shell safety
+        const escapedPrompt = prompt.replace(/'/g, "'\\''");
+        // Spawn worker
+        const child = spawn('/bin/bash', ['-l', '-c', `claude -p '${escapedPrompt}' --dangerously-skip-permissions`], {
+            cwd,
+            env: { ...process.env },
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        job.process = child;
+        this.jobs.set(id, job);
+        // 5 minute timeout
+        const timeout = setTimeout(() => {
+            if (job.status === 'running') {
+                job.status = 'timeout';
                 job.endTime = Date.now();
-                const duration = Math.round((job.endTime - job.startTime) / 1000);
-                console.error(`[ORCHESTRATOR] Worker ${id} spawn error:`, err.message);
-                // Retryable errors: ENOENT (command not found), EAGAIN (resource busy), ENOMEM (out of memory)
-                const retryableErrors = ['ENOENT', 'EAGAIN', 'ENOMEM', 'ETIMEDOUT', 'ECONNRESET'];
-                const isRetryable = retryableErrors.some(code => err.message.includes(code));
-                if (isRetryable && retryCount < maxRetries) {
-                    console.log(`[ORCHESTRATOR] Retrying worker (attempt ${retryCount + 2}/${maxRetries + 1}) after ${err.message}...`);
-                    // Exponential backoff: 500ms, 1000ms, 2000ms
-                    const delay = 500 * Math.pow(2, retryCount);
-                    await new Promise(r => setTimeout(r, delay));
-                    const retryResult = await this.delegateToWorker(task, context, workingDir, retryCount + 1, timeoutMs);
-                    resolve(retryResult);
-                    return;
+                child.kill('SIGTERM');
+                console.log(`[ORCHESTRATOR] Worker ${id} timed out`);
+                if (this.workerResultCallback) {
+                    this.workerResultCallback(id, `Worker timed out. Partial output: ${job.output.slice(-1000) || 'none'}`);
                 }
-                // Log failure to memory
-                await this.logWorkerFailure(id, task, err.message, duration);
-                // Try to recover any partial output from log file
-                const recoveredLog = this.recoverWorkerLog(id);
-                resolve({
-                    success: false,
-                    output: recoveredLog
-                        ? `Worker error: ${err.message}\n\n[Recovered from log]\n${recoveredLog}`
-                        : `Worker error: ${err.message}`
-                });
-            });
+            }
+        }, 5 * 60 * 1000);
+        child.stdout?.on('data', (data) => {
+            const text = data.toString();
+            job.output += text;
+            // Stream output to console
+            process.stdout.write(`[${id}] ${text}`);
+        });
+        child.stderr?.on('data', (data) => {
+            const text = data.toString();
+            if (!text.includes('Checking') && !text.includes('Connected')) {
+                job.output += text;
+            }
+        });
+        child.on('close', async (code) => {
+            clearTimeout(timeout);
+            job.status = code === 0 ? 'completed' : 'failed';
+            job.endTime = Date.now();
+            const duration = Math.round((job.endTime - job.startTime) / 1000);
+            console.log(`[ORCHESTRATOR] Worker ${id} done in ${duration}s`);
+            const result = job.output.trim() || '(No output)';
+            // Notify via callback (sends to user via WebSocket)
+            if (this.workerResultCallback) {
+                this.workerResultCallback(id, result);
+            }
         });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            job.status = 'failed';
+            job.endTime = Date.now();
+            console.error(`[ORCHESTRATOR] Worker ${id} error:`, err.message);
+            if (this.workerResultCallback) {
+                this.workerResultCallback(id, `Worker error: ${err.message}`);
+            }
+        });
+        // Return immediately - worker runs in background
+        return {
+            success: true,
+            output: `Worker ${id} started. I'll notify you when it completes.`
+        };
     }
     /**
      * Try to recover worker output from log file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",