@siftd/connect-agent 0.2.24 → 0.2.26

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.d.ts

@@ -5,7 +5,6 @@
  * 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;
@@ -16,6 +15,17 @@ export interface WorkerStatus {
     estimated: number;
 }
 export type WorkerStatusCallback = (workers: WorkerStatus[]) => void;
+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 GalleryWorker {
     id: string;
     task: string;

package/dist/orchestrator.js

@@ -17,7 +17,49 @@ 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';
+/**
+ * Extract file paths from worker output
+ * Workers naturally mention files they create: "Created /tmp/foo.html", "Saved to /path/file"
+ */
+function extractFilesFromOutput(output) {
+    const assets = [];
+    const seen = new Set();
+    // Common patterns for file creation/modification in worker output
+    const patterns = [
+        /(?:created|wrote|saved|generated|writing|creating)\s+(?:file\s+)?[`"']?([\/~][^\s`"']+\.[a-z0-9]+)[`"']?/gi,
+        /(?:output|file|saved)\s*(?:to|:)\s*[`"']?([\/~][^\s`"']+\.[a-z0-9]+)[`"']?/gi,
+        /[`"']([\/~][^\s`"']+\.[a-z0-9]+)[`"']\s*(?:created|saved|written)/gi,
+        /(?:^|\n)\s*[✓✅]\s*[`"']?([\/~][^\s`"']+\.[a-z0-9]+)[`"']?/gm,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(output)) !== null) {
+            const filePath = match[1].replace(/^~/, process.env.HOME || '/tmp');
+            if (!seen.has(filePath)) {
+                seen.add(filePath);
+                assets.push({
+                    path: filePath,
+                    name: filePath.split('/').pop() || filePath,
+                    type: 'new',
+                    fileType: getFileType(filePath)
+                });
+            }
+        }
+    }
+    return assets;
+}
+function getFileType(path) {
+    const ext = path.split('.').pop()?.toLowerCase() || '';
+    if (['js', 'ts', 'jsx', 'tsx', 'py', 'html', 'css', 'json', 'md', 'sh'].includes(ext))
+        return 'code';
+    if (['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp'].includes(ext))
+        return 'image';
+    if (ext === 'pdf')
+        return 'pdf';
+    if (['txt', 'log', 'csv'].includes(ext))
+        return 'text';
+    return 'other';
+}
 const SYSTEM_PROMPT = `You are a MASTER ORCHESTRATOR - NOT a worker. You delegate ALL file/code work to Claude Code CLI workers.
 
 CRITICAL IDENTITY:
@@ -923,15 +965,6 @@ 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),
@@ -939,8 +972,7 @@ Be specific about what you want done.`,
             startTime: Date.now(),
             output: '',
             estimatedTime,
-            workingDir: cwd,
-            beforeSnapshot
+            workingDir: cwd
         };
         // Escape single quotes in prompt for shell safety
         const escapedPrompt = prompt.replace(/'/g, "'\\''");
@@ -982,21 +1014,27 @@ 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) {
+            const result = job.output.trim() || '(No output)';
+            // Extract files from worker output (workers naturally mention what they created)
+            const assets = extractFilesFromOutput(result);
+            job.assets = assets;
+            if (assets.length > 0) {
+                console.log(`[ORCHESTRATOR] Worker ${id} created ${assets.length} files: ${assets.map(a => a.name).join(', ')}`);
+                // Store in memory for gallery queries
                 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();
+                    await this.memory.remember(`Worker ${id} completed task "${job.task}" and created files: ${assets.map(a => a.path).join(', ')}`, {
+                        type: 'episodic',
+                        source: 'worker_output',
+                        tags: ['worker', 'files', id],
+                        importance: 0.7
+                    });
                 }
                 catch (err) {
-                    console.log(`[ORCHESTRATOR] Could not track assets: ${err}`);
+                    console.log(`[ORCHESTRATOR] Could not store worker output in memory: ${err}`);
                 }
+                // Broadcast gallery update
+                this.broadcastGalleryUpdate();
             }
-            const result = job.output.trim() || '(No output)';
             // Notify via callback (sends to user via WebSocket)
             if (this.workerResultCallback) {
                 this.workerResultCallback(id, result);

package/dist/workers/manager.d.ts

@@ -13,7 +13,6 @@ export type GalleryCallback = (workers: GalleryWorker[]) => void;
 export declare class WorkerManager {
     private config;
     private activeWorkers;
-    private fileSnapshots;
     private galleryCallback;
     constructor(workspaceDir: string, configOverrides?: Partial<WorkerConfig>);
     /**

package/dist/workers/manager.js

@@ -6,11 +6,51 @@ 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';
+// Removed file-tracker - now extract files from worker output
+/**
+ * Extract file paths from worker output
+ */
+function extractFilesFromOutput(output) {
+    const assets = [];
+    const seen = new Set();
+    const patterns = [
+        /(?:created|wrote|saved|generated|writing|creating)\s+(?:file\s+)?[`"']?([\/~][^\s`"']+\.[a-z0-9]+)[`"']?/gi,
+        /(?:output|file|saved)\s*(?:to|:)\s*[`"']?([\/~][^\s`"']+\.[a-z0-9]+)[`"']?/gi,
+        /[`"']([\/~][^\s`"']+\.[a-z0-9]+)[`"']\s*(?:created|saved|written)/gi,
+        /(?:^|\n)\s*[✓✅]\s*[`"']?([\/~][^\s`"']+\.[a-z0-9]+)[`"']?/gm,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(output)) !== null) {
+            const filePath = match[1].replace(/^~/, process.env.HOME || '/tmp');
+            if (!seen.has(filePath)) {
+                seen.add(filePath);
+                const ext = filePath.split('.').pop()?.toLowerCase() || '';
+                assets.push({
+                    path: filePath,
+                    name: filePath.split('/').pop() || filePath,
+                    type: 'new',
+                    fileType: getFileType(ext)
+                });
+            }
+        }
+    }
+    return assets;
+}
+function getFileType(ext) {
+    if (['js', 'ts', 'jsx', 'tsx', 'py', 'html', 'css', 'json', 'md', 'sh'].includes(ext))
+        return 'code';
+    if (['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp'].includes(ext))
+        return 'image';
+    if (ext === 'pdf')
+        return 'pdf';
+    if (['txt', 'log', 'csv'].includes(ext))
+        return 'text';
+    return 'other';
+}
 export class WorkerManager {
     config;
     activeWorkers = new Map();
-    fileSnapshots = new Map(); // Before-snapshots per job
     galleryCallback = null;
     constructor(workspaceDir, configOverrides) {
         this.config = {
@@ -94,15 +134,6 @@ 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,
@@ -200,24 +231,12 @@ 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}`);
-                        }
+                    // Extract files from worker output (workers mention what they created)
+                    const assets = extractFilesFromOutput(finalResult);
+                    if (assets.length > 0) {
+                        currentJob.assets = assets;
+                        console.log(`[WORKER] ${jobId} created ${assets.length} files: ${assets.map(a => a.name).join(', ')}`);
+                        this.broadcastGalleryUpdate();
                     }
                     this.saveJob(currentJob);
                 }

package/package.json

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