@siftd/connect-agent 0.2.16 → 0.2.18

package/dist/agent.js

@@ -1,4 +1,4 @@
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import { pollMessages, sendResponse } from './api.js';
 import { getUserId, getAnthropicApiKey, isCloudMode, getDeploymentInfo } from './config.js';
 import { MasterOrchestrator } from './orchestrator.js';
@@ -8,6 +8,112 @@ 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
+ */
+async function performSelfUpdate() {
+    // Prevent concurrent updates
+    if (updateInProgress) {
+        return '⏳ Update already in progress. Please wait...';
+    }
+    updateInProgress = true;
+    console.log('[AGENT] Starting self-update...');
+    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})`;
+        }
+        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...');
+        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...`;
+    }
+    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`;
+    }
+}
 // Conversation history for orchestrator mode
 let conversationHistory = [];
 let orchestrator = null;
@@ -152,6 +258,12 @@ 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');
+        return await performSelfUpdate();
+    }
     try {
         if (orchestrator) {
             return await sendToOrchestrator(message.content, orchestrator, message.id, message.apiKey);

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.16'; // Should match package.json
+const VERSION = '0.2.18'; // 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.16",
+  "version": "0.2.18",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",