@siftd/connect-agent 0.2.22 → 0.2.24

package/dist/agent.js

@@ -257,6 +257,14 @@ export async function runAgent(pollInterval = 2000) {
                 console.log(`[WORKERS] ${running.length} running`);
             }
         });
+        // Gallery updates - send worker assets for UI gallery view
+        orchestrator.setGalleryCallback((galleryWorkers) => {
+            if (wsClient?.connected()) {
+                wsClient.sendGalleryWorkers(galleryWorkers);
+                const totalAssets = galleryWorkers.reduce((sum, w) => sum + w.assets.length, 0);
+                console.log(`[GALLERY] ${galleryWorkers.length} workers, ${totalAssets} assets`);
+            }
+        });
         // Worker results - send to user when workers complete
         orchestrator.setWorkerResultCallback((workerId, result) => {
             console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);

package/dist/core/file-tracker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * File Tracker - Detects new/modified files in a directory
+ *
+ * Used to track what workers create or modify for the gallery view.
+ */
+export interface TrackedFile {
+    path: string;
+    name: string;
+    mtime: number;
+    size: number;
+    hash?: string;
+}
+export interface FileSnapshot {
+    workingDir: string;
+    files: Map<string, TrackedFile>;
+    timestamp: number;
+}
+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;
+    }>;
+}
+/**
+ * Take a snapshot of files in a directory
+ */
+export declare function takeSnapshot(workingDir: string): FileSnapshot;
+/**
+ * Compare two snapshots to find new/modified files
+ */
+export declare function compareSnapshots(before: FileSnapshot, after: FileSnapshot): WorkerAsset[];

package/dist/core/file-tracker.js

@@ -0,0 +1,253 @@
+/**
+ * File Tracker - Detects new/modified files in a directory
+ *
+ * Used to track what workers create or modify for the gallery view.
+ */
+import { readdirSync, statSync, readFileSync, existsSync } from 'fs';
+import { join, relative, extname } from 'path';
+import { execSync } from 'child_process';
+// File extensions to track
+const CODE_EXTENSIONS = new Set([
+    '.js', '.ts', '.jsx', '.tsx', '.py', '.rb', '.go', '.rs',
+    '.java', '.c', '.cpp', '.h', '.cs', '.php', '.swift', '.kt',
+    '.json', '.yaml', '.yml', '.toml', '.xml', '.html', '.css',
+    '.scss', '.less', '.vue', '.svelte', '.sh', '.bash', '.zsh',
+    '.sql', '.graphql', '.md', '.mdx'
+]);
+const IMAGE_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.bmp'
+]);
+const TEXT_EXTENSIONS = new Set([
+    '.txt', '.log', '.env', '.gitignore', '.dockerignore', '.editorconfig'
+]);
+// Directories to skip
+const SKIP_DIRS = new Set([
+    'node_modules', '.git', '.next', 'dist', 'build', '__pycache__',
+    '.cache', 'coverage', '.nyc_output', 'vendor', 'target'
+]);
+// Max files to track (performance limit)
+const MAX_FILES = 500;
+// Max depth to traverse
+const MAX_DEPTH = 5;
+/**
+ * Take a snapshot of files in a directory
+ */
+export function takeSnapshot(workingDir) {
+    const files = new Map();
+    function walk(dir, depth) {
+        if (depth > MAX_DEPTH || files.size >= MAX_FILES)
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (files.size >= MAX_FILES)
+                    break;
+                const fullPath = join(dir, entry.name);
+                const relativePath = relative(workingDir, fullPath);
+                if (entry.isDirectory()) {
+                    // Skip ignored directories
+                    if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                        continue;
+                    walk(fullPath, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    // Only track interesting files
+                    const ext = extname(entry.name).toLowerCase();
+                    if (!isInterestingFile(entry.name, ext))
+                        continue;
+                    try {
+                        const stats = statSync(fullPath);
+                        files.set(relativePath, {
+                            path: relativePath,
+                            name: entry.name,
+                            mtime: stats.mtimeMs,
+                            size: stats.size
+                        });
+                    }
+                    catch {
+                        // Skip files we can't stat
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    walk(workingDir, 0);
+    return {
+        workingDir,
+        files,
+        timestamp: Date.now()
+    };
+}
+/**
+ * Compare two snapshots to find new/modified files
+ */
+export function compareSnapshots(before, after) {
+    const assets = [];
+    // Find new and modified files
+    for (const [path, afterFile] of after.files) {
+        const beforeFile = before.files.get(path);
+        if (!beforeFile) {
+            // New file
+            assets.push(createAsset(after.workingDir, afterFile, 'new'));
+        }
+        else if (afterFile.mtime > beforeFile.mtime || afterFile.size !== beforeFile.size) {
+            // Modified file
+            const asset = createAsset(after.workingDir, afterFile, 'modified');
+            // Generate diff for code files
+            if (asset.fileType === 'code') {
+                asset.diff = generateSimpleDiff(after.workingDir, path);
+            }
+            assets.push(asset);
+        }
+    }
+    // Sort: new files first, then by path
+    assets.sort((a, b) => {
+        if (a.type !== b.type)
+            return a.type === 'new' ? -1 : 1;
+        return a.path.localeCompare(b.path);
+    });
+    // Limit to most relevant files
+    return assets.slice(0, 20);
+}
+/**
+ * Create a WorkerAsset from a tracked file
+ */
+function createAsset(workingDir, file, type) {
+    const ext = extname(file.name).toLowerCase();
+    const fileType = getFileType(ext);
+    const fullPath = join(workingDir, file.path);
+    let preview;
+    // Generate preview for small files
+    if (file.size < 10000) {
+        try {
+            if (fileType === 'code' || fileType === 'text') {
+                const content = readFileSync(fullPath, 'utf8');
+                preview = content.slice(0, 1000);
+                if (content.length > 1000)
+                    preview += '\n... (truncated)';
+            }
+            else if (fileType === 'image') {
+                // For images, we could generate a base64 thumbnail
+                // For now, just indicate it's an image
+                preview = `[Image: ${file.name}]`;
+            }
+        }
+        catch {
+            // Skip preview on error
+        }
+    }
+    return {
+        path: file.path,
+        name: file.name,
+        type,
+        fileType,
+        preview
+    };
+}
+/**
+ * Get file type category from extension
+ */
+function getFileType(ext) {
+    if (CODE_EXTENSIONS.has(ext))
+        return 'code';
+    if (IMAGE_EXTENSIONS.has(ext))
+        return 'image';
+    if (TEXT_EXTENSIONS.has(ext))
+        return 'text';
+    if (ext === '.pdf')
+        return 'pdf';
+    return 'other';
+}
+/**
+ * Check if a file is worth tracking
+ */
+function isInterestingFile(name, ext) {
+    // Skip hidden files (except some config files)
+    if (name.startsWith('.') && !TEXT_EXTENSIONS.has(ext))
+        return false;
+    // Skip lock files and generated files
+    if (name.includes('.lock') || name.includes('-lock.'))
+        return false;
+    if (name === 'package-lock.json' || name === 'yarn.lock')
+        return false;
+    // Track code, images, text, pdf
+    return (CODE_EXTENSIONS.has(ext) ||
+        IMAGE_EXTENSIONS.has(ext) ||
+        TEXT_EXTENSIONS.has(ext) ||
+        ext === '.pdf');
+}
+/**
+ * Generate a simple diff for a file using git
+ */
+function generateSimpleDiff(workingDir, relativePath) {
+    try {
+        // Check if we're in a git repo
+        const isGit = existsSync(join(workingDir, '.git'));
+        if (!isGit)
+            return undefined;
+        // Get git diff
+        const diff = execSync(`git diff --no-color -- "${relativePath}"`, {
+            cwd: workingDir,
+            encoding: 'utf8',
+            maxBuffer: 100 * 1024 // 100KB max
+        });
+        if (!diff.trim()) {
+            // No staged changes, try unstaged
+            const unstagedDiff = execSync(`git diff HEAD --no-color -- "${relativePath}"`, {
+                cwd: workingDir,
+                encoding: 'utf8',
+                maxBuffer: 100 * 1024
+            });
+            if (!unstagedDiff.trim())
+                return undefined;
+            return parseDiff(unstagedDiff);
+        }
+        return parseDiff(diff);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parse git diff output into structured format
+ */
+function parseDiff(diffOutput) {
+    const lines = diffOutput.split('\n');
+    const result = [];
+    let inHunk = false;
+    for (const line of lines) {
+        // Skip diff header lines
+        if (line.startsWith('diff --git') ||
+            line.startsWith('index ') ||
+            line.startsWith('---') ||
+            line.startsWith('+++')) {
+            continue;
+        }
+        // Detect hunk header
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (!inHunk)
+            continue;
+        // Parse diff lines
+        if (line.startsWith('+')) {
+            result.push({ type: 'add', content: line.slice(1) });
+        }
+        else if (line.startsWith('-')) {
+            result.push({ type: 'remove', content: line.slice(1) });
+        }
+        else if (line.startsWith(' ')) {
+            result.push({ type: 'context', content: line.slice(1) });
+        }
+        // Limit diff size
+        if (result.length >= 100) {
+            result.push({ type: 'context', content: '... (diff truncated)' });
+            break;
+        }
+    }
+    return result;
+}

package/dist/orchestrator.d.ts

@@ -5,6 +5,7 @@
  * It does NOT do the work itself. Claude Code CLI workers do the work.
  */
 import type { MessageParam } from '@anthropic-ai/sdk/resources/messages';
+import { WorkerAsset } from './core/file-tracker.js';
 export type MessageSender = (message: string) => Promise<void>;
 export interface WorkerStatus {
     id: string;
@@ -15,6 +16,13 @@ export interface WorkerStatus {
     estimated: number;
 }
 export type WorkerStatusCallback = (workers: WorkerStatus[]) => void;
+export interface GalleryWorker {
+    id: string;
+    task: string;
+    status: 'running' | 'completed' | 'failed';
+    assets: WorkerAsset[];
+}
+export type GalleryCallback = (workers: GalleryWorker[]) => void;
 export declare class MasterOrchestrator {
     private client;
     private model;
@@ -26,6 +34,7 @@ export declare class MasterOrchestrator {
     private jobCounter;
     private workerStatusCallback;
     private workerStatusInterval;
+    private galleryCallback;
     private userId;
     private workspaceDir;
     private claudePath;
@@ -51,6 +60,18 @@ export declare class MasterOrchestrator {
      * Set callback for worker status updates (for UI progress bars)
      */
     setWorkerStatusCallback(callback: WorkerStatusCallback | null): void;
+    /**
+     * Set callback for gallery updates (worker assets for UI gallery view)
+     */
+    setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Get gallery workers with their assets
+     */
+    getGalleryWorkers(): GalleryWorker[];
+    /**
+     * Broadcast gallery update to callback
+     */
+    private broadcastGalleryUpdate;
     /**
      * Get current status of all workers (from both delegateToWorker and spawn_worker)
      */

package/dist/orchestrator.js

@@ -17,6 +17,7 @@ import { WorkerTools } from './tools/worker.js';
 import { SharedState } from './workers/shared-state.js';
 import { getKnowledgeForPrompt } from './genesis/index.js';
 import { loadHubContext, formatHubContext, logAction } from './core/hub.js';
+import { takeSnapshot, compareSnapshots } from './core/file-tracker.js';
 const SYSTEM_PROMPT = `You are a MASTER ORCHESTRATOR - NOT a worker. You delegate ALL file/code work to Claude Code CLI workers.
 
 CRITICAL IDENTITY:
@@ -85,6 +86,7 @@ export class MasterOrchestrator {
     jobCounter = 0;
     workerStatusCallback = null;
     workerStatusInterval = null;
+    galleryCallback = null;
     userId;
     workspaceDir;
     claudePath;
@@ -167,6 +169,61 @@ export class MasterOrchestrator {
             }
         }
     }
+    /**
+     * Set callback for gallery updates (worker assets for UI gallery view)
+     */
+    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') {
+                workers.push({
+                    id,
+                    task: job.task,
+                    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;
+    }
+    /**
+     * Broadcast gallery update to callback
+     */
+    broadcastGalleryUpdate() {
+        if (!this.galleryCallback)
+            return;
+        const workers = this.getGalleryWorkers();
+        if (workers.length > 0) {
+            this.galleryCallback(workers);
+        }
+    }
     /**
      * Get current status of all workers (from both delegateToWorker and spawn_worker)
      */
@@ -866,13 +923,24 @@ Be specific about what you want done.`,
         console.log(`[ORCHESTRATOR] Worker ${id} starting: ${task.slice(0, 80)}...`);
         // Estimate task duration
         const estimatedTime = this.estimateTaskDuration(task);
+        // Take snapshot of files before worker starts (for asset tracking)
+        let beforeSnapshot;
+        try {
+            beforeSnapshot = takeSnapshot(cwd);
+            console.log(`[ORCHESTRATOR] Snapshot: ${beforeSnapshot.files.size} files in ${cwd}`);
+        }
+        catch (err) {
+            console.log(`[ORCHESTRATOR] Could not take snapshot: ${err}`);
+        }
         const job = {
             id,
             task: task.slice(0, 200),
             status: 'running',
             startTime: Date.now(),
             output: '',
-            estimatedTime
+            estimatedTime,
+            workingDir: cwd,
+            beforeSnapshot
         };
         // Escape single quotes in prompt for shell safety
         const escapedPrompt = prompt.replace(/'/g, "'\\''");
@@ -914,6 +982,20 @@ Be specific about what you want done.`,
             job.endTime = Date.now();
             const duration = Math.round((job.endTime - job.startTime) / 1000);
             console.log(`[ORCHESTRATOR] Worker ${id} done in ${duration}s`);
+            // Track file changes (for gallery)
+            if (job.beforeSnapshot) {
+                try {
+                    const afterSnapshot = takeSnapshot(job.workingDir);
+                    const assets = compareSnapshots(job.beforeSnapshot, afterSnapshot);
+                    job.assets = assets;
+                    console.log(`[ORCHESTRATOR] Worker ${id} assets: ${assets.length} files (${assets.filter(a => a.type === 'new').length} new, ${assets.filter(a => a.type === 'modified').length} modified)`);
+                    // Broadcast gallery update
+                    this.broadcastGalleryUpdate();
+                }
+                catch (err) {
+                    console.log(`[ORCHESTRATOR] Could not track assets: ${err}`);
+                }
+            }
             const result = job.output.trim() || '(No output)';
             // Notify via callback (sends to user via WebSocket)
             if (this.workerResultCallback) {

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.22",
+  "version": "0.2.24",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",