@siftd/connect-agent 0.2.15 → 0.2.17

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,51 @@ import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js
 function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
 }
+/**
+ * Actually perform a self-update - runs npm install and restarts
+ */
+async function performSelfUpdate() {
+    console.log('[AGENT] Starting self-update...');
+    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);
+        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', {
+            encoding: 'utf8',
+            shell: '/bin/bash',
+            timeout: 120000 // 2 minute timeout
+        });
+        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...');
+        setTimeout(() => {
+            console.log('[AGENT] Restarting...');
+            process.exit(0); // Exit - systemd/pm2/user will restart
+        }, 2000);
+        return `✅ Update complete!\n\nInstalled: @siftd/connect-agent@${newVersion}\n\nRestarting agent in 2 seconds...`;
+    }
+    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`;
+    }
+}
 // Conversation history for orchestrator mode
 let conversationHistory = [];
 let orchestrator = null;
@@ -152,6 +197,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);
@@ -211,16 +262,21 @@ 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)
+    if (orchestrator) {
+        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(', ')}`);
+            }
+        });
+    }
     if (wsConnected) {
         console.log('[AGENT] Using WebSocket for real-time communication\n');
-        // Set up worker status callback for progress bars
-        if (orchestrator) {
-            orchestrator.setWorkerStatusCallback((workers) => {
-                if (wsClient?.connected()) {
-                    wsClient.sendWorkersUpdate(workers);
-                }
-            });
-        }
         // Handle messages via WebSocket
         wsClient.onMessage(async (wsMsg) => {
             if (wsMsg.type === 'message' && wsMsg.content && wsMsg.id) {

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

package/dist/orchestrator.d.ts

@@ -52,7 +52,7 @@ export declare class MasterOrchestrator {
      */
     setWorkerStatusCallback(callback: WorkerStatusCallback | null): void;
     /**
-     * Get current status of all workers
+     * Get current status of all workers (from both delegateToWorker and spawn_worker)
      */
     getWorkerStatus(): WorkerStatus[];
     /**
@@ -103,6 +103,7 @@ export declare class MasterOrchestrator {
     private processToolCalls;
     /**
      * Delegate task to Claude Code CLI worker with retry logic
+     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
      */
     private delegateToWorker;
     /**

package/dist/orchestrator.js

@@ -16,60 +16,63 @@ import { WebTools } from './tools/web.js';
 import { WorkerTools } from './tools/worker.js';
 import { SharedState } from './workers/shared-state.js';
 import { getKnowledgeForPrompt } from './genesis/index.js';
-const SYSTEM_PROMPT = `You're the user's personal assistant - the friendly brain behind their Connect app. You chat with them from any browser, remember everything about them, and dispatch Claude Code workers to do things on their machine.
+const SYSTEM_PROMPT = `You are a MASTER ORCHESTRATOR - NOT a worker. You delegate ALL file/code work to Claude Code CLI workers.
 
-CRITICAL - READ THIS:
-The user is on a WEB BROWSER. They CANNOT run terminal commands. They CANNOT access a shell.
-YOU are their hands. When something needs to be done, YOU do it with your tools.
-NEVER say "run this command" or "you'll need to..." - the user CAN'T do that.
+CRITICAL IDENTITY:
+- You are the BRAIN, not the hands
+- You ORCHESTRATE workers - you don't do the work yourself
+- You REMEMBER everything using your memory tools
+- You PLAN and COORDINATE, then delegate execution
 
-YOUR TOOLS (use them!):
-- bash: Run any shell command directly
-- web_search: Search the internet for information
-- fetch_url: Fetch and read web page content
-- spawn_worker: Spawn background Claude Code workers for complex multi-step tasks
-- delegate_to_worker: Delegate complex tasks that need full CLI autonomy
-- remember/search_memory: Persistent memory across conversations
-- start_local_server/open_browser: Serve and preview web projects
+STRICT TOOL USAGE RULES:
 
-WHEN TO USE WHAT:
-- Simple commands (ls, cat, git status, npm install) → use bash directly
-- Web research → use web_search + fetch_url
-- Complex multi-file changes, builds, deployments → spawn_worker or delegate_to_worker
-- Quick checks or reads → bash
-- Long-running background tasks → spawn_worker (non-blocking)
+✅ USE bash ONLY for READ-ONLY operations:
+- ls, pwd, cat, head, tail, find, which, echo, date
+- git status, git log, git diff (viewing only)
+- Checking if files/directories exist
 
-FILESYSTEM AWARENESS:
-You know the user's filesystem. Their projects, directories, and files are indexed in your memory.
-When they mention "that project", "the connect app", "downloads folder", etc. - SEARCH YOUR MEMORY.
-Use search_memory to find the actual paths before working.
+❌ NEVER use bash for:
+- Creating files (echo >, touch, mkdir)
+- Editing files (sed, awk, tee)
+- Moving/copying/deleting (mv, cp, rm)
+- Installing packages (npm install, pip install)
+- Running builds or tests
+- ANY file modification whatsoever
 
-WHO YOU ARE:
-Warm, helpful, and genuinely interested in what the user is working on. Like a knowledgeable friend with superpowers - you remember their preferences, track their projects, and make things happen.
+✅ USE delegate_to_worker or spawn_worker for:
+- Creating, editing, or deleting ANY files
+- Running npm/pip/cargo install
+- Building, testing, deploying
+- Complex multi-step tasks
+- ANY filesystem modification
 
-WHAT YOU CAN DO:
-- Run shell commands directly with bash
-- Search the web and fetch URLs
-- Dispatch Claude Code workers for complex work
-- Start local servers and open browsers
-- Remember things across conversations
-- Schedule tasks for later
-- Have real conversations
+MEMORY IS MANDATORY:
+- ALWAYS use search_memory before starting work
+- ALWAYS use remember after significant actions
+- Log your orchestration decisions to memory
+- Learn from failures - remember what went wrong
+
+WORKER ORCHESTRATION:
+- spawn_worker: For parallel/background tasks (non-blocking)
+- delegate_to_worker: For sequential tasks needing full autonomy
+- ALWAYS include logging instructions in worker prompts
+- Tell workers to save their logs to /tmp/worker-{job_id}.log
 
-HOW TO TALK:
-- Be yourself - warm, direct, helpful
-- Keep it conversational
-- Show you remember them
-- Celebrate progress - "Nice, that's done!" not "Task completed successfully."
-- Be honest about what you're doing
-- If something fails, try a different approach or explain what happened
+AFTER EVERY SIGNIFICANT ACTION:
+1. Log it to memory with remember
+2. Note what worked or failed
+3. Update your understanding of the user's system
+
+WHO YOU ARE:
+Warm, helpful orchestrator. You coordinate, remember, and delegate. You're the persistent layer that makes AI feel personal - but you do it by managing workers, not by doing tasks yourself.
 
 SLASH COMMANDS:
 - /reset - Clear conversation and memory context
-- /verbose - Toggle showing tool execution details
+- /mode - Show current mode and capabilities
+- /memory - Show memory stats
 - /help - Show available commands
 
-You're the persistent layer that makes AI feel personal. You ACT on behalf of the user - you don't give them homework.`;
+You ACT through workers. You REMEMBER through memory. You NEVER do file operations directly.`;
 export class MasterOrchestrator {
     client;
     model;
@@ -164,11 +167,12 @@ export class MasterOrchestrator {
         }
     }
     /**
-     * Get current status of all workers
+     * Get current status of all workers (from both delegateToWorker and spawn_worker)
      */
     getWorkerStatus() {
         const now = Date.now();
         const workers = [];
+        // Include jobs from delegateToWorker (this.jobs)
         for (const [id, job] of this.jobs) {
             const elapsed = (now - job.startTime) / 1000;
             const estimated = job.estimatedTime;
@@ -192,6 +196,29 @@ export class MasterOrchestrator {
                 estimated: Math.round(estimated)
             });
         }
+        // Also include jobs from spawn_worker (workerTools)
+        try {
+            const spawnedWorkers = this.workerTools.getRunningWorkers();
+            for (const worker of spawnedWorkers) {
+                // Don't duplicate if already in this.jobs
+                if (workers.some(w => w.id === worker.id))
+                    continue;
+                const elapsed = (now - worker.startTime) / 1000;
+                const estimated = worker.estimatedTime;
+                const progress = Math.min(90, (elapsed / estimated) * 100);
+                workers.push({
+                    id: worker.id,
+                    task: worker.task.slice(0, 60),
+                    status: worker.status,
+                    progress: Math.round(progress),
+                    elapsed: Math.round(elapsed),
+                    estimated: Math.round(estimated)
+                });
+            }
+        }
+        catch (error) {
+            // WorkerTools not available, skip
+        }
         return workers;
     }
     /**
@@ -401,16 +428,21 @@ export class MasterOrchestrator {
      */
     getToolDefinitions() {
         return [
-            // Direct bash execution - for simple commands
+            // Direct bash execution - READ-ONLY OPERATIONS ONLY
             {
                 name: 'bash',
-                description: 'Execute a shell command directly. Use for simple commands like ls, cat, git status, npm install, etc. For complex multi-step tasks, use spawn_worker instead.',
+                description: `Execute a READ-ONLY shell command. ONLY use for viewing/checking - NEVER for modifications.
+
+ALLOWED: ls, pwd, cat, head, tail, find, which, echo, date, git status, git log, git diff, test -f, test -d
+FORBIDDEN: touch, mkdir, rm, mv, cp, echo >, tee, sed -i, npm install, pip install, ANY file creation/modification
+
+For ANY file creation, editing, or system modification, use delegate_to_worker instead.`,
                 input_schema: {
                     type: 'object',
                     properties: {
                         command: {
                             type: 'string',
-                            description: 'The bash command to execute'
+                            description: 'READ-ONLY bash command (no file modifications allowed)'
                         },
                         timeout: {
                             type: 'number',
@@ -798,9 +830,12 @@ Be specific about what you want done.`,
     }
     /**
      * Delegate task to Claude Code CLI worker with retry logic
+     * @param timeoutMs - Timeout in milliseconds (default: 30 minutes, max: 60 minutes)
      */
-    async delegateToWorker(task, context, workingDir, retryCount = 0) {
+    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);
         const id = `worker_${Date.now()}_${++this.jobCounter}`;
         const cwd = workingDir || this.workspaceDir;
         // Search for relevant memories to inject into worker prompt
@@ -880,8 +915,8 @@ This enables parallel workers to coordinate.`;
             });
             job.process = child;
             this.jobs.set(id, job);
-            // Timeout after 10 minutes (increased from 5 for complex tasks)
-            const WORKER_TIMEOUT = 10 * 60 * 1000;
+            // Configurable timeout (default 30 min, max 60 min)
+            const timeoutMinutes = Math.round(workerTimeout / 60000);
             const timeout = setTimeout(() => {
                 if (job.status === 'running') {
                     job.status = 'timeout';
@@ -895,14 +930,16 @@ This enables parallel workers to coordinate.`;
                         }
                     }, 5000);
                     const partialOutput = job.output.trim();
+                    // Check for log file that worker should have created
+                    const logFile = `/tmp/worker-${id}-log.txt`;
                     resolve({
                         success: false,
                         output: partialOutput
-                            ? `Worker timed out after 10 minutes. Partial findings:\n${partialOutput.slice(-2000)}`
-                            : 'Worker timed out after 10 minutes with no output. The task may be too complex - try breaking it into smaller steps.'
+                            ? `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.`
                     });
                 }
-            }, WORKER_TIMEOUT);
+            }, workerTimeout);
             child.stdout?.on('data', (data) => {
                 job.output += data.toString();
             });

package/dist/tools/worker.d.ts

@@ -33,4 +33,18 @@ export declare class WorkerTools {
      * Clean up old jobs
      */
     cleanupWorkers(): Promise<ToolResult>;
+    /**
+     * Get all running workers for progress tracking
+     */
+    getRunningWorkers(): Array<{
+        id: string;
+        task: string;
+        status: string;
+        startTime: number;
+        estimatedTime: number;
+    }>;
+    /**
+     * Estimate task duration based on content
+     */
+    private estimateTaskDuration;
 }

package/dist/tools/worker.js

@@ -146,4 +146,37 @@ export class WorkerTools {
             output: `Cleaned up ${cleaned} old job(s).`
         };
     }
+    /**
+     * Get all running workers for progress tracking
+     */
+    getRunningWorkers() {
+        const jobs = this.manager.list({ status: 'running' });
+        return jobs.map(job => ({
+            id: job.id,
+            task: job.task,
+            status: job.status,
+            startTime: job.started ? new Date(job.started).getTime() : Date.now(),
+            // Estimate based on task content
+            estimatedTime: this.estimateTaskDuration(job.task)
+        }));
+    }
+    /**
+     * Estimate task duration based on content
+     */
+    estimateTaskDuration(task) {
+        const lower = task.toLowerCase();
+        if (lower.includes('refactor') || lower.includes('implement') ||
+            lower.includes('create') || lower.includes('build')) {
+            return 180; // 3 minutes
+        }
+        if (lower.includes('fix') || lower.includes('update') ||
+            lower.includes('modify') || lower.includes('add')) {
+            return 90; // 90 seconds
+        }
+        if (lower.includes('find') || lower.includes('search') ||
+            lower.includes('read') || lower.includes('list')) {
+            return 45; // 45 seconds
+        }
+        return 60; // default 1 minute
+    }
 }

package/package.json

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