@siftd/connect-agent 0.2.23 → 0.2.25

package/dist/heartbeat.js

@@ -8,9 +8,26 @@
  */
 import { hostname } from 'os';
 import { createHash } from 'crypto';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 import { getServerUrl, getAgentToken, getUserId, isCloudMode } from './config.js';
 const HEARTBEAT_INTERVAL = 10000; // 10 seconds
-const VERSION = '0.2.20'; // Should match package.json
+// Read version from package.json dynamically
+function getVersion() {
+    try {
+        // Try to find package.json relative to this file
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const pkgPath = join(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        return pkg.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const VERSION = getVersion();
 const state = {
     intervalId: null,
     runnerId: null,

package/dist/orchestrator.js

@@ -174,12 +174,19 @@ export class MasterOrchestrator {
      */
     setGalleryCallback(callback) {
         this.galleryCallback = callback;
+        // Also set on workerTools for spawn_worker jobs
+        this.workerTools.setGalleryCallback(callback ? (workers) => {
+            // Merge with delegate_to_worker jobs and broadcast
+            this.broadcastGalleryUpdate();
+        } : null);
     }
     /**
      * Get gallery workers with their assets
      */
     getGalleryWorkers() {
         const workers = [];
+        const seenIds = new Set();
+        // Include jobs from delegateToWorker (this.jobs)
         for (const [id, job] of this.jobs) {
             // Only include jobs with assets or that are running
             if (job.assets || job.status === 'running') {
@@ -189,8 +196,21 @@ export class MasterOrchestrator {
                     status: job.status === 'timeout' ? 'failed' : job.status,
                     assets: job.assets || []
                 });
+                seenIds.add(id);
+            }
+        }
+        // Include jobs from workerTools (spawn_worker)
+        try {
+            const spawnedWorkers = this.workerTools.getGalleryWorkers();
+            for (const worker of spawnedWorkers) {
+                if (!seenIds.has(worker.id)) {
+                    workers.push(worker);
+                }
             }
         }
+        catch {
+            // WorkerTools not available
+        }
         return workers;
     }
     /**

package/dist/tools/worker.d.ts

@@ -2,10 +2,20 @@
  * Worker Tools
  * Tools for spawning and managing Claude Code workers
  */
+import { GalleryCallback, GalleryWorker } from '../workers/manager.js';
 import type { ToolResult } from './bash.js';
+export { GalleryCallback, GalleryWorker };
 export declare class WorkerTools {
     private manager;
     constructor(workspaceDir: string);
+    /**
+     * Set callback for gallery updates (worker assets for UI)
+     */
+    setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Get gallery workers with assets
+     */
+    getGalleryWorkers(): GalleryWorker[];
     /**
      * Spawn a new Claude Code worker
      */

package/dist/tools/worker.js

@@ -8,6 +8,18 @@ export class WorkerTools {
     constructor(workspaceDir) {
         this.manager = new WorkerManager(workspaceDir);
     }
+    /**
+     * Set callback for gallery updates (worker assets for UI)
+     */
+    setGalleryCallback(callback) {
+        this.manager.setGalleryCallback(callback);
+    }
+    /**
+     * Get gallery workers with assets
+     */
+    getGalleryWorkers() {
+        return this.manager.getGalleryWorkers();
+    }
     /**
      * Spawn a new Claude Code worker
      */

package/dist/workers/manager.d.ts

@@ -2,11 +2,32 @@
  * Claude Code Worker Manager
  * Spawns and manages Claude Code CLI instances for parallel task execution
  */
-import { WorkerJob, SpawnOptions, WorkerConfig } from './types.js';
+import { WorkerJob, SpawnOptions, WorkerConfig, WorkerAsset } from './types.js';
+export interface GalleryWorker {
+    id: string;
+    task: string;
+    status: 'running' | 'completed' | 'failed';
+    assets: WorkerAsset[];
+}
+export type GalleryCallback = (workers: GalleryWorker[]) => void;
 export declare class WorkerManager {
     private config;
     private activeWorkers;
+    private fileSnapshots;
+    private galleryCallback;
     constructor(workspaceDir: string, configOverrides?: Partial<WorkerConfig>);
+    /**
+     * Set callback for gallery updates (worker assets for UI)
+     */
+    setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Get gallery workers with assets for UI
+     */
+    getGalleryWorkers(): GalleryWorker[];
+    /**
+     * Broadcast gallery update
+     */
+    private broadcastGalleryUpdate;
     /**
      * Generate a unique job ID
      */

package/dist/workers/manager.js

@@ -6,9 +6,12 @@ import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { DEFAULT_WORKER_CONFIG } from './types.js';
+import { takeSnapshot, compareSnapshots } from '../core/file-tracker.js';
 export class WorkerManager {
     config;
     activeWorkers = new Map();
+    fileSnapshots = new Map(); // Before-snapshots per job
+    galleryCallback = null;
     constructor(workspaceDir, configOverrides) {
         this.config = {
             ...DEFAULT_WORKER_CONFIG,
@@ -20,6 +23,39 @@ export class WorkerManager {
             fs.mkdirSync(this.config.jobsDir, { recursive: true });
         }
     }
+    /**
+     * Set callback for gallery updates (worker assets for UI)
+     */
+    setGalleryCallback(callback) {
+        this.galleryCallback = callback;
+    }
+    /**
+     * Get gallery workers with assets for UI
+     */
+    getGalleryWorkers() {
+        const jobs = this.list();
+        return jobs
+            .filter(job => job.assets && job.assets.length > 0 || job.status === 'running')
+            .slice(0, 20) // Limit for UI
+            .map(job => ({
+            id: job.id,
+            task: job.task.slice(0, 60),
+            status: (job.status === 'timeout' || job.status === 'cancelled') ? 'failed' :
+                (job.status === 'pending' ? 'running' : job.status),
+            assets: job.assets || []
+        }));
+    }
+    /**
+     * Broadcast gallery update
+     */
+    broadcastGalleryUpdate() {
+        if (!this.galleryCallback)
+            return;
+        const workers = this.getGalleryWorkers();
+        if (workers.length > 0) {
+            this.galleryCallback(workers);
+        }
+    }
     /**
      * Generate a unique job ID
      */
@@ -58,6 +94,15 @@ export class WorkerManager {
         // Validate timeout
         const effectiveTimeout = Math.min(timeout, this.config.maxTimeout);
         const jobId = this.generateJobId();
+        // Take snapshot before spawning (for asset tracking)
+        try {
+            const beforeSnapshot = takeSnapshot(workspace);
+            this.fileSnapshots.set(jobId, beforeSnapshot);
+            console.log(`[WORKER] Snapshot for ${jobId}: ${beforeSnapshot.files.size} files`);
+        }
+        catch (err) {
+            console.log(`[WORKER] Could not take snapshot for ${jobId}: ${err}`);
+        }
         const job = {
             id: jobId,
             task,
@@ -155,6 +200,25 @@ This ensures nothing is lost even if your output gets truncated.`;
                     if (stderr && code !== 0) {
                         currentJob.error = stderr.trim();
                     }
+                    // Track file changes (for gallery)
+                    const beforeSnapshot = this.fileSnapshots.get(jobId);
+                    if (beforeSnapshot) {
+                        try {
+                            const afterSnapshot = takeSnapshot(currentJob.workspace);
+                            const assets = compareSnapshots(beforeSnapshot, afterSnapshot);
+                            currentJob.assets = assets;
+                            const newCount = assets.filter(a => a.type === 'new').length;
+                            const modCount = assets.filter(a => a.type === 'modified').length;
+                            console.log(`[WORKER] ${jobId} assets: ${assets.length} files (${newCount} new, ${modCount} modified)`);
+                            // Clean up snapshot
+                            this.fileSnapshots.delete(jobId);
+                            // Broadcast gallery update
+                            this.broadcastGalleryUpdate();
+                        }
+                        catch (err) {
+                            console.log(`[WORKER] Could not track assets for ${jobId}: ${err}`);
+                        }
+                    }
                     this.saveJob(currentJob);
                 }
             });

package/dist/workers/types.d.ts

@@ -1,6 +1,17 @@
 /**
  * Worker System Types
  */
+export interface WorkerAsset {
+    path: string;
+    name: string;
+    type: 'new' | 'modified' | 'unchanged';
+    fileType: 'code' | 'image' | 'pdf' | 'text' | 'other';
+    preview?: string;
+    diff?: Array<{
+        type: 'context' | 'add' | 'remove';
+        content: string;
+    }>;
+}
 export interface WorkerJob {
     id: string;
     task: string;
@@ -15,6 +26,7 @@ export interface WorkerJob {
     pid?: number;
     timeout: number;
     exitCode?: number;
+    assets?: WorkerAsset[];
 }
 export interface SpawnOptions {
     workspace?: string;

package/package.json

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