@siftd/connect-agent 0.2.14 → 0.2.15

package/dist/agent.js

@@ -213,6 +213,14 @@ export async function runAgent(pollInterval = 2000) {
     const wsConnected = await wsClient.connect();
     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.14'; // Should match package.json
+const VERSION = '0.2.15'; // Should match package.json
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.d.ts

@@ -6,6 +6,15 @@
  */
 import type { MessageParam } from '@anthropic-ai/sdk/resources/messages';
 export type MessageSender = (message: string) => Promise<void>;
+export interface WorkerStatus {
+    id: string;
+    task: string;
+    status: 'running' | 'completed' | 'failed' | 'timeout';
+    progress: number;
+    elapsed: number;
+    estimated: number;
+}
+export type WorkerStatusCallback = (workers: WorkerStatus[]) => void;
 export declare class MasterOrchestrator {
     private client;
     private model;
@@ -15,6 +24,8 @@ export declare class MasterOrchestrator {
     private indexer;
     private jobs;
     private jobCounter;
+    private workerStatusCallback;
+    private workerStatusInterval;
     private userId;
     private workspaceDir;
     private claudePath;
@@ -36,6 +47,22 @@ export declare class MasterOrchestrator {
      * Initialize the orchestrator - indexes filesystem on first call
      */
     initialize(): Promise<void>;
+    /**
+     * Set callback for worker status updates (for UI progress bars)
+     */
+    setWorkerStatusCallback(callback: WorkerStatusCallback | null): void;
+    /**
+     * Get current status of all workers
+     */
+    getWorkerStatus(): WorkerStatus[];
+    /**
+     * Broadcast worker status to callback
+     */
+    private broadcastWorkerStatus;
+    /**
+     * Estimate task duration based on content
+     */
+    private estimateTaskDuration;
     /**
      * Find the claude binary path
      */

package/dist/orchestrator.js

@@ -79,6 +79,8 @@ export class MasterOrchestrator {
     indexer;
     jobs = new Map();
     jobCounter = 0;
+    workerStatusCallback = null;
+    workerStatusInterval = null;
     userId;
     workspaceDir;
     claudePath;
@@ -140,6 +142,104 @@ export class MasterOrchestrator {
         }
         this.initialized = true;
     }
+    /**
+     * Set callback for worker status updates (for UI progress bars)
+     */
+    setWorkerStatusCallback(callback) {
+        this.workerStatusCallback = callback;
+        if (callback) {
+            // Start broadcasting status every 500ms when workers are running
+            if (!this.workerStatusInterval) {
+                this.workerStatusInterval = setInterval(() => {
+                    this.broadcastWorkerStatus();
+                }, 500);
+            }
+        }
+        else {
+            // Stop broadcasting
+            if (this.workerStatusInterval) {
+                clearInterval(this.workerStatusInterval);
+                this.workerStatusInterval = null;
+            }
+        }
+    }
+    /**
+     * Get current status of all workers
+     */
+    getWorkerStatus() {
+        const now = Date.now();
+        const workers = [];
+        for (const [id, job] of this.jobs) {
+            const elapsed = (now - job.startTime) / 1000;
+            const estimated = job.estimatedTime;
+            // Calculate progress: cap at 90% while running, 100% when done
+            let progress;
+            if (job.status === 'completed') {
+                progress = 100;
+            }
+            else if (job.status === 'failed' || job.status === 'timeout') {
+                progress = 100; // Show as complete even on failure
+            }
+            else {
+                progress = Math.min(90, (elapsed / estimated) * 100);
+            }
+            workers.push({
+                id,
+                task: job.task.slice(0, 60),
+                status: job.status,
+                progress: Math.round(progress),
+                elapsed: Math.round(elapsed),
+                estimated: Math.round(estimated)
+            });
+        }
+        return workers;
+    }
+    /**
+     * Broadcast worker status to callback
+     */
+    broadcastWorkerStatus() {
+        if (!this.workerStatusCallback)
+            return;
+        const workers = this.getWorkerStatus();
+        // Only broadcast if there are running workers
+        const hasRunning = workers.some(w => w.status === 'running');
+        if (hasRunning || workers.length > 0) {
+            this.workerStatusCallback(workers);
+        }
+        // Clean up completed jobs after 3 seconds
+        const now = Date.now();
+        for (const [id, job] of this.jobs) {
+            if (job.status !== 'running' && job.endTime && (now - job.endTime) > 3000) {
+                this.jobs.delete(id);
+            }
+        }
+    }
+    /**
+     * Estimate task duration based on content
+     */
+    estimateTaskDuration(task) {
+        const lower = task.toLowerCase();
+        // Complex tasks: 3 minutes
+        if (lower.includes('refactor') || lower.includes('implement') ||
+            lower.includes('create') || lower.includes('build') ||
+            lower.includes('write tests') || lower.includes('add tests')) {
+            return 180;
+        }
+        // Medium tasks: 90 seconds
+        if (lower.includes('fix') || lower.includes('update') ||
+            lower.includes('modify') || lower.includes('change') ||
+            lower.includes('add') || lower.includes('install')) {
+            return 90;
+        }
+        // Simple tasks: 45 seconds
+        if (lower.includes('find') || lower.includes('search') ||
+            lower.includes('read') || lower.includes('list') ||
+            lower.includes('check') || lower.includes('show')) {
+            return 45;
+        }
+        // Default: 60 seconds
+        return 60;
+    }
     /**
      * Find the claude binary path
      */
@@ -757,13 +857,16 @@ If you need to share data with other workers or signal completion:
 [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
+        const estimatedTime = this.estimateTaskDuration(task);
         return new Promise((resolve) => {
             const job = {
                 id,
                 task: task.slice(0, 200),
                 status: 'running',
                 startTime: Date.now(),
-                output: ''
+                output: '',
+                estimatedTime
             };
             // Escape single quotes in prompt for shell safety
             // Replace ' with '\'' (end quote, escaped quote, start quote)
@@ -1141,6 +1244,11 @@ This enables parallel workers to coordinate.`;
      * Shutdown cleanly
      */
     async shutdown() {
+        // Stop worker status broadcasting
+        if (this.workerStatusInterval) {
+            clearInterval(this.workerStatusInterval);
+            this.workerStatusInterval = null;
+        }
         this.scheduler.shutdown();
         if (this.memory instanceof PostgresMemoryStore) {
             await this.memory.close();

package/dist/websocket.d.ts

@@ -6,6 +6,7 @@
  * - Streams responses as they're generated
  * - Supports interruption and progress updates
  */
+import type { WorkerStatus } from './orchestrator.js';
 export type MessageHandler = (message: WebSocketMessage) => Promise<void>;
 export type StreamHandler = (chunk: string) => void;
 export interface WebSocketMessage {
@@ -57,6 +58,10 @@ export declare class AgentWebSocket {
      * Send typing indicator
      */
     sendTyping(isTyping: boolean): void;
+    /**
+     * Send workers status update for progress bars
+     */
+    sendWorkersUpdate(workers: WorkerStatus[]): void;
     /**
      * Check if connected
      */

package/dist/websocket.js

@@ -159,6 +159,15 @@ export class AgentWebSocket {
             isTyping
         });
     }
+    /**
+     * Send workers status update for progress bars
+     */
+    sendWorkersUpdate(workers) {
+        this.sendToServer({
+            type: 'workers_update',
+            workers
+        });
+    }
     /**
      * Check if connected
      */

package/package.json

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