@siftd/connect-agent 0.2.17 → 0.2.19

package/dist/agent.js

@@ -9,48 +9,32 @@ function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
 }
 /**
- * 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() {
-    console.log('[AGENT] Starting self-update...');
+    console.log('[AGENT] === SELF-UPDATE STARTING ===');
     try {
-        // Get current version
-        let currentVersion = 'unknown';
-        try {
-            currentVersion = execSync('npm list -g @siftd/connect-agent --json 2>/dev/null | grep version || echo "unknown"', { encoding: 'utf8', shell: '/bin/bash' }).trim();
-        }
-        catch { /* ignore */ }
-        console.log('[AGENT] Current version:', currentVersion);
+        // Just do it - npm install latest
         console.log('[AGENT] Running: npm install -g @siftd/connect-agent@latest');
-        // Actually run the npm install
-        const installOutput = execSync('npm install -g @siftd/connect-agent@latest 2>&1', {
+        execSync('npm install -g @siftd/connect-agent@latest', {
             encoding: 'utf8',
             shell: '/bin/bash',
-            timeout: 120000 // 2 minute timeout
+            stdio: 'inherit', // Show output in real-time
+            timeout: 180000
         });
-        console.log('[AGENT] Install output:', installOutput);
-        // Get new version
-        let newVersion = 'unknown';
-        try {
-            const versionOutput = execSync('npm list -g @siftd/connect-agent --depth=0 2>/dev/null', { encoding: 'utf8', shell: '/bin/bash' });
-            const match = versionOutput.match(/@siftd\/connect-agent@([\d.]+)/);
-            if (match)
-                newVersion = match[1];
-        }
-        catch { /* ignore */ }
-        console.log('[AGENT] New version:', newVersion);
-        // Schedule restart
-        console.log('[AGENT] Scheduling restart in 2 seconds...');
+        console.log('[AGENT] Update installed. Restarting in 2 seconds...');
+        // Restart the agent
         setTimeout(() => {
-            console.log('[AGENT] Restarting...');
-            process.exit(0); // Exit - systemd/pm2/user will restart
+            console.log('[AGENT] === RESTARTING ===');
+            process.exit(0);
         }, 2000);
-        return `✅ Update complete!\n\nInstalled: @siftd/connect-agent@${newVersion}\n\nRestarting agent in 2 seconds...`;
+        return '✅ Update installed. Restarting...';
     }
     catch (error) {
-        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
@@ -197,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');
+    // Handle self-update requests - trigger on "update" keyword
+    if (content.includes('update') && (content.includes('agent') || content.includes('yourself') || content.includes('latest'))) {
+        console.log('[AGENT] Update request detected');
         return await performSelfUpdate();
     }
     try {

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.17'; // Should match package.json
+const VERSION = '0.2.19'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -106,6 +106,15 @@ export declare class MasterOrchestrator {
      * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
      */
     private delegateToWorker;
+    /**
+     * Try to recover worker output from log file
+     * Workers are instructed to write logs to /tmp/worker-{id}-log.txt
+     */
+    private recoverWorkerLog;
+    /**
+     * Log worker failure to memory for learning
+     */
+    private logWorkerFailure;
     /**
      * Extract memory and coordination contributions from worker output
      * Workers can contribute using:

package/dist/orchestrator.js

@@ -6,7 +6,7 @@
  */
 import Anthropic from '@anthropic-ai/sdk';
 import { spawn, execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { AdvancedMemoryStore } from './core/memory-advanced.js';
 import { PostgresMemoryStore, isPostgresConfigured } from './core/memory-postgres.js';
 import { TaskScheduler } from './core/scheduler.js';
@@ -917,10 +917,11 @@ This enables parallel workers to coordinate.`;
             this.jobs.set(id, job);
             // Configurable timeout (default 30 min, max 60 min)
             const timeoutMinutes = Math.round(workerTimeout / 60000);
-            const timeout = setTimeout(() => {
+            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
@@ -929,14 +930,26 @@ This enables parallel workers to coordinate.`;
                             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();
-                    // Check for log file that worker should have created
-                    const logFile = `/tmp/worker-${id}-log.txt`;
+                    // 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: partialOutput
-                            ? `Worker timed out after ${timeoutMinutes} minutes. Check ${logFile} for full logs. Partial findings:\n${partialOutput.slice(-3000)}`
-                            : `Worker timed out after ${timeoutMinutes} minutes with no output. Check ${logFile} for any saved progress.`
+                        output: combinedOutput
+                            ? `Worker timed out after ${timeoutMinutes} minutes. Recovered output:\n${combinedOutput}`
+                            : `Worker timed out after ${timeoutMinutes} minutes with no recoverable output.`
                     });
                 }
             }, workerTimeout);
@@ -954,38 +967,98 @@ This enables parallel workers to coordinate.`;
                 clearTimeout(timeout);
                 job.status = code === 0 ? 'completed' : 'failed';
                 job.endTime = Date.now();
-                const duration = ((job.endTime - job.startTime) / 1000).toFixed(1);
+                const duration = Math.round((job.endTime - job.startTime) / 1000);
                 console.log(`[ORCHESTRATOR] Worker ${id} finished in ${duration}s (code: ${code})`);
-                if (code !== 0 || job.output.length === 0) {
-                    console.log(`[ORCHESTRATOR] Worker ${id} output: ${job.output.slice(0, 200) || '(empty)'}`);
+                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(job.output, id);
+                await this.extractWorkerMemories(finalOutput, id);
                 resolve({
                     success: code === 0,
-                    output: job.output.trim() || '(No output)'
+                    output: finalOutput || '(No output)'
                 });
             });
             child.on('error', async (err) => {
                 clearTimeout(timeout);
                 job.status = 'failed';
                 job.endTime = Date.now();
+                const duration = Math.round((job.endTime - job.startTime) / 1000);
                 console.error(`[ORCHESTRATOR] Worker ${id} spawn error:`, err.message);
-                // Retry on ENOENT (intermittent spawn failures)
-                if (err.message.includes('ENOENT') && retryCount < maxRetries) {
-                    console.log(`[ORCHESTRATOR] Retrying worker (attempt ${retryCount + 2}/${maxRetries + 1})...`);
-                    await new Promise(r => setTimeout(r, 500)); // Small delay before retry
-                    const retryResult = await this.delegateToWorker(task, context, workingDir, retryCount + 1);
+                // 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;
                 }
+                // 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: `Worker error: ${err.message}`
+                    output: recoveredLog
+                        ? `Worker error: ${err.message}\n\n[Recovered from log]\n${recoveredLog}`
+                        : `Worker error: ${err.message}`
                 });
             });
         });
     }
+    /**
+     * Try to recover worker output from log file
+     * Workers are instructed to write logs to /tmp/worker-{id}-log.txt
+     */
+    recoverWorkerLog(workerId) {
+        const logFile = `/tmp/worker-${workerId}-log.txt`;
+        try {
+            if (existsSync(logFile)) {
+                const content = readFileSync(logFile, 'utf8');
+                if (content.trim()) {
+                    console.log(`[ORCHESTRATOR] Recovered ${content.length} bytes from worker log: ${logFile}`);
+                    return content;
+                }
+            }
+        }
+        catch (error) {
+            console.log(`[ORCHESTRATOR] Could not read worker log: ${error}`);
+        }
+        return null;
+    }
+    /**
+     * Log worker failure to memory for learning
+     */
+    async logWorkerFailure(workerId, task, error, duration, recoveredOutput) {
+        try {
+            const content = `Worker ${workerId} failed after ${duration}s. Task: "${task.slice(0, 100)}..." Error: ${error}${recoveredOutput ? ` (recovered ${recoveredOutput.length} chars from log)` : ''}`;
+            await this.memory.remember(content, {
+                type: 'episodic',
+                source: `worker-failure:${workerId}`,
+                importance: 0.6,
+                tags: ['worker-failure', 'debugging', 'auto-logged']
+            });
+            console.log(`[ORCHESTRATOR] Logged worker failure to memory for future learning`);
+        }
+        catch (err) {
+            // Don't fail on memory errors
+            console.log(`[ORCHESTRATOR] Could not log failure to memory: ${err}`);
+        }
+    }
     /**
      * Extract memory and coordination contributions from worker output
      * Workers can contribute using:

package/dist/workers/manager.js

@@ -139,7 +139,19 @@ This ensures nothing is lost even if your output gets truncated.`;
                     currentJob.status = code === 0 ? 'completed' : 'failed';
                     currentJob.completed = new Date().toISOString();
                     currentJob.exitCode = code ?? undefined;
-                    currentJob.result = stdout.trim();
+                    // Try to recover from log file if output is empty or failed
+                    let finalResult = stdout.trim();
+                    if ((code !== 0 || !finalResult) && fs.existsSync(logFile)) {
+                        try {
+                            const logContent = fs.readFileSync(logFile, 'utf8');
+                            if (logContent.trim()) {
+                                console.log(`[WORKER] Recovered ${logContent.length} bytes from ${logFile}`);
+                                finalResult = logContent + (finalResult ? `\n\n[stdout]\n${finalResult}` : '');
+                            }
+                        }
+                        catch { /* ignore read errors */ }
+                    }
+                    currentJob.result = finalResult;
                     if (stderr && code !== 0) {
                         currentJob.error = stderr.trim();
                     }

package/package.json

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