@siftd/connect-agent 0.2.19 → 0.2.20

package/dist/agent.js

@@ -181,9 +181,9 @@ export async function processMessage(message) {
         );
         return response;
     }
-    // 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');
+    // System command: force update (sent by webapp banner)
+    if (content === '/system-update') {
+        console.log('[AGENT] === SYSTEM UPDATE COMMAND ===');
         return await performSelfUpdate();
     }
     try {
@@ -245,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.19'; // 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.19",
+  "version": "0.2.20",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",