@siftd/connect-agent 0.2.30 → 0.2.31

package/dist/agent.js

@@ -5,6 +5,7 @@ import { MasterOrchestrator } from './orchestrator.js';
 import { AgentWebSocket } from './websocket.js';
 import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js';
 import { loadHubContext, readScratchpad } from './core/hub.js';
+import { startPreviewWorker, stopPreviewWorker } from './core/preview-worker.js';
 // Strip ANSI escape codes for clean output
 function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
@@ -246,6 +247,21 @@ export async function runAgent(pollInterval = 2000) {
             console.log(`[AGENT] Scratchpad: ${scratchpad.length} chars of pending notes`);
         }
     }
+    // Start preview worker for fast-path asset previews (no LLM)
+    const previewWorker = startPreviewWorker({
+        verbose: true,
+        onAsset: (manifest) => {
+            console.log(`[PREVIEW] New asset: ${manifest.name} (${manifest.id})`);
+            // Send gallery state update via WebSocket
+            if (wsClient?.connected()) {
+                wsClient.sendGalleryState();
+            }
+        },
+        onPreview: (preview) => {
+            console.log(`[PREVIEW] Preview ready: ${preview.assetId}`);
+        },
+    });
+    console.log('[AGENT] Preview worker started (fast-path asset system)');
     // Start heartbeat to maintain presence in runner registry
     const runnerType = isCloudMode() ? 'vm' : 'local';
     startHeartbeat({
@@ -262,6 +278,7 @@ export async function runAgent(pollInterval = 2000) {
     process.on('SIGINT', async () => {
         console.log('\n[AGENT] Shutting down...');
         stopHeartbeat();
+        stopPreviewWorker();
         if (wsClient) {
             wsClient.close();
         }

package/dist/core/asset-api.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Asset API - WebSocket-based asset serving
+ *
+ * Handles asset requests from the Connect web UI:
+ * - asset.list - List all assets
+ * - asset.get - Get asset bytes (streamed)
+ * - asset.preview - Get preview metadata + thumbnail
+ * - asset.group - Get assets by group
+ * - view.get - Get ViewSpec
+ */
+import { AssetManifest, AssetPreview, ViewSpec } from './assets.js';
+export interface AssetRequest {
+    type: 'asset.list' | 'asset.get' | 'asset.preview' | 'asset.group' | 'view.get' | 'view.list';
+    requestId: string;
+    assetId?: string;
+    groupId?: string;
+    viewId?: string;
+}
+export interface AssetListResponse {
+    type: 'asset.list';
+    requestId: string;
+    assets: AssetManifest[];
+}
+export interface AssetGetResponse {
+    type: 'asset.get';
+    requestId: string;
+    assetId: string;
+    data: string;
+    mime: string;
+    size: number;
+}
+export interface AssetPreviewResponse {
+    type: 'asset.preview';
+    requestId: string;
+    assetId: string;
+    manifest: AssetManifest;
+    preview: AssetPreview | null;
+}
+export interface AssetGroupResponse {
+    type: 'asset.group';
+    requestId: string;
+    groupId: string;
+    assets: AssetManifest[];
+    previews: (AssetPreview | null)[];
+}
+export interface ViewGetResponse {
+    type: 'view.get';
+    requestId: string;
+    view: ViewSpec | null;
+}
+export interface ViewListResponse {
+    type: 'view.list';
+    requestId: string;
+    views: ViewSpec[];
+}
+export interface AssetErrorResponse {
+    type: 'asset.error';
+    requestId: string;
+    error: string;
+}
+export type AssetResponse = AssetListResponse | AssetGetResponse | AssetPreviewResponse | AssetGroupResponse | ViewGetResponse | ViewListResponse | AssetErrorResponse;
+export declare function registerView(view: ViewSpec): void;
+export declare function getView(viewId: string): ViewSpec | undefined;
+export declare function getAllViews(): ViewSpec[];
+/**
+ * Handle asset request from WebSocket
+ */
+export declare function handleAssetRequest(request: AssetRequest): Promise<AssetResponse>;
+/**
+ * Build gallery state for WebSocket broadcast
+ * This replaces the old extractFilesFromOutput approach
+ */
+export interface GalleryState {
+    assets: AssetManifest[];
+    previews: Map<string, AssetPreview>;
+    groups: Map<string, AssetManifest[]>;
+    views: ViewSpec[];
+}
+export declare function buildGalleryState(): GalleryState;
+/**
+ * Convert gallery state to WebSocket message format
+ * Compatible with existing gallery_workers message
+ */
+export declare function galleryStateToMessage(state: GalleryState): {
+    type: 'gallery_state';
+    assets: AssetManifest[];
+    previews: {
+        [key: string]: AssetPreview;
+    };
+    groups: {
+        [key: string]: string[];
+    };
+    views: ViewSpec[];
+};

package/dist/core/asset-api.js

@@ -0,0 +1,182 @@
+/**
+ * Asset API - WebSocket-based asset serving
+ *
+ * Handles asset requests from the Connect web UI:
+ * - asset.list - List all assets
+ * - asset.get - Get asset bytes (streamed)
+ * - asset.preview - Get preview metadata + thumbnail
+ * - asset.group - Get assets by group
+ * - view.get - Get ViewSpec
+ */
+import { readFileSync, existsSync, statSync } from 'fs';
+import { getAsset, getPreview, getAllAssets, getAssetsByGroup, getAssetRegistry, } from './preview-worker.js';
+// ============================================================================
+// VIEW REGISTRY
+// ============================================================================
+const viewRegistry = new Map();
+export function registerView(view) {
+    viewRegistry.set(view.id, view);
+}
+export function getView(viewId) {
+    return viewRegistry.get(viewId);
+}
+export function getAllViews() {
+    return Array.from(viewRegistry.values());
+}
+// ============================================================================
+// REQUEST HANDLER
+// ============================================================================
+/**
+ * Handle asset request from WebSocket
+ */
+export async function handleAssetRequest(request) {
+    try {
+        switch (request.type) {
+            case 'asset.list':
+                return handleAssetList(request);
+            case 'asset.get':
+                return handleAssetGet(request);
+            case 'asset.preview':
+                return handleAssetPreview(request);
+            case 'asset.group':
+                return handleAssetGroup(request);
+            case 'view.get':
+                return handleViewGet(request);
+            case 'view.list':
+                return handleViewList(request);
+            default:
+                return {
+                    type: 'asset.error',
+                    requestId: request.requestId,
+                    error: `Unknown request type: ${request.type}`,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            type: 'asset.error',
+            requestId: request.requestId,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function handleAssetList(request) {
+    return {
+        type: 'asset.list',
+        requestId: request.requestId,
+        assets: getAllAssets(),
+    };
+}
+function handleAssetGet(request) {
+    const { assetId, requestId } = request;
+    if (!assetId) {
+        return { type: 'asset.error', requestId, error: 'Missing assetId' };
+    }
+    const manifest = getAsset(assetId);
+    if (!manifest) {
+        return { type: 'asset.error', requestId, error: `Asset not found: ${assetId}` };
+    }
+    if (!existsSync(manifest.path)) {
+        return { type: 'asset.error', requestId, error: `File not found: ${manifest.path}` };
+    }
+    // Read file and encode as base64
+    const data = readFileSync(manifest.path);
+    const stats = statSync(manifest.path);
+    return {
+        type: 'asset.get',
+        requestId,
+        assetId,
+        data: data.toString('base64'),
+        mime: manifest.mime,
+        size: stats.size,
+    };
+}
+function handleAssetPreview(request) {
+    const { assetId, requestId } = request;
+    if (!assetId) {
+        return { type: 'asset.error', requestId, error: 'Missing assetId' };
+    }
+    const manifest = getAsset(assetId);
+    if (!manifest) {
+        return { type: 'asset.error', requestId, error: `Asset not found: ${assetId}` };
+    }
+    const preview = getPreview(assetId) || null;
+    return {
+        type: 'asset.preview',
+        requestId,
+        assetId,
+        manifest,
+        preview,
+    };
+}
+function handleAssetGroup(request) {
+    const { groupId, requestId } = request;
+    if (!groupId) {
+        return { type: 'asset.error', requestId, error: 'Missing groupId' };
+    }
+    const assets = getAssetsByGroup(groupId);
+    const previews = assets.map(a => getPreview(a.id) || null);
+    return {
+        type: 'asset.group',
+        requestId,
+        groupId,
+        assets,
+        previews,
+    };
+}
+function handleViewGet(request) {
+    const { viewId, requestId } = request;
+    if (!viewId) {
+        return { type: 'asset.error', requestId, error: 'Missing viewId' };
+    }
+    const view = getView(viewId) || null;
+    return {
+        type: 'view.get',
+        requestId,
+        view,
+    };
+}
+function handleViewList(request) {
+    return {
+        type: 'view.list',
+        requestId: request.requestId,
+        views: getAllViews(),
+    };
+}
+export function buildGalleryState() {
+    const registry = getAssetRegistry();
+    const groups = new Map();
+    for (const [groupId, assetIds] of registry.byGroup) {
+        const assets = Array.from(assetIds)
+            .map(id => registry.assets.get(id))
+            .filter(Boolean);
+        groups.set(groupId, assets);
+    }
+    return {
+        assets: getAllAssets(),
+        previews: registry.previews,
+        groups,
+        views: getAllViews(),
+    };
+}
+/**
+ * Convert gallery state to WebSocket message format
+ * Compatible with existing gallery_workers message
+ */
+export function galleryStateToMessage(state) {
+    const previews = {};
+    for (const [id, preview] of state.previews) {
+        previews[id] = preview;
+    }
+    const groups = {};
+    for (const [groupId, assets] of state.groups) {
+        groups[groupId] = assets.map(a => a.id);
+    }
+    return {
+        type: 'gallery_state',
+        assets: state.assets,
+        previews,
+        groups,
+        views: state.views,
+    };
+}

package/dist/core/assets.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Asset System - Fast-path preview architecture
+ *
+ * Assets are files produced by workers with metadata for instant preview.
+ * The preview-worker generates thumbnails/metadata WITHOUT using the LLM.
+ */
+export interface AssetManifest {
+    /** Unique asset ID */
+    id: string;
+    /** Absolute path to the file */
+    path: string;
+    /** Filename */
+    name: string;
+    /** MIME type */
+    mime: string;
+    /** SHA256 content hash for caching */
+    sha256: string;
+    /** File size in bytes */
+    size: number;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Worker/run group ID for grouping related assets */
+    groupId?: string;
+    /** Label for the asset (old, new, diff, etc.) */
+    label?: 'old' | 'new' | 'diff' | 'output' | 'source';
+    /** Asset kind */
+    kind: 'file' | 'view';
+    /** For kind=view, the ViewSpec */
+    viewSpec?: ViewSpec;
+}
+export interface AssetPreview {
+    /** Reference to the asset */
+    assetId: string;
+    /** Thumbnail path (for images/PDFs) */
+    thumbnailPath?: string;
+    /** Thumbnail as base64 data URL (for inline display) */
+    thumbnailData?: string;
+    /** Extracted text snippet (first ~500 chars) */
+    textSnippet?: string;
+    /** Image dimensions */
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    /** PDF page count */
+    pageCount?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** When preview was generated */
+    generatedAt: number;
+    /** Cache key: sha256 + transform params */
+    cacheKey: string;
+}
+export interface ViewSpec {
+    /** View ID */
+    id: string;
+    /** Display title */
+    title: string;
+    /** Layout type */
+    layout: 'single' | 'grid' | 'twoColumn' | 'compare' | 'stack' | 'tabs';
+    /** Items in the view */
+    items?: ViewItem[];
+    /** For twoColumn layout */
+    left?: ViewItem[];
+    right?: ViewItem[];
+    /** For compare layout */
+    before?: ViewItem;
+    after?: ViewItem;
+    /** Optional description */
+    description?: string;
+    /** Created timestamp */
+    createdAt: number;
+}
+export interface ViewItem {
+    /** Item type */
+    type: 'asset' | 'markdown' | 'text' | 'html';
+    /** For type=asset, the asset ID */
+    assetId?: string;
+    /** For type=markdown/text/html, the content */
+    content?: string;
+    /** Viewer to use */
+    viewer?: 'image' | 'pdf' | 'code' | 'markdown' | 'text' | 'video' | 'audio';
+    /** Viewer params (overlays, annotations, etc.) */
+    params?: ViewerParams;
+    /** Optional label */
+    label?: string;
+}
+export interface ViewerParams {
+    /** Scale bar overlay for microscopy images */
+    overlay?: 'scaleBar' | 'grid' | 'ruler';
+    /** Brightness adjustment (-100 to 100) */
+    brightness?: number;
+    /** Contrast adjustment (-100 to 100) */
+    contrast?: number;
+    /** Crop region */
+    crop?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Zoom level */
+    zoom?: number;
+    /** Highlight lines (for code) */
+    highlightLines?: number[];
+    /** Annotations */
+    annotations?: Annotation[];
+}
+export interface Annotation {
+    type: 'box' | 'circle' | 'arrow' | 'text';
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    label?: string;
+    color?: string;
+}
+/**
+ * Generate SHA256 hash of file contents
+ */
+export declare function hashFile(filePath: string): string;
+/**
+ * Get MIME type from file extension
+ */
+export declare function getMimeType(filePath: string): string;
+/**
+ * Generate unique asset ID
+ */
+export declare function generateAssetId(): string;
+/**
+ * Create asset manifest for a file
+ */
+export declare function createAssetManifest(filePath: string, options?: {
+    groupId?: string;
+    label?: AssetManifest['label'];
+}): AssetManifest;
+/**
+ * Write asset manifest alongside the file
+ */
+export declare function writeAssetManifest(manifest: AssetManifest): void;
+/**
+ * Read asset manifest for a file
+ */
+export declare function readAssetManifest(filePath: string): AssetManifest | null;
+/**
+ * Get preview cache directory
+ */
+export declare function getPreviewCacheDir(): string;
+/**
+ * Generate cache key for preview
+ */
+export declare function getPreviewCacheKey(sha256: string, params?: ViewerParams): string;
+/**
+ * Check if preview exists in cache
+ */
+export declare function getPreviewFromCache(cacheKey: string): AssetPreview | null;
+/**
+ * Save preview to cache
+ */
+export declare function savePreviewToCache(preview: AssetPreview): void;
+/**
+ * Create a ViewSpec for comparing two assets
+ */
+export declare function createCompareView(beforeAssetId: string, afterAssetId: string, title?: string): ViewSpec;
+/**
+ * Create a ViewSpec for a grid of assets
+ */
+export declare function createGridView(assetIds: string[], title?: string): ViewSpec;
+/**
+ * Create a ViewSpec for a report with markdown and assets
+ */
+export declare function createReportView(title: string, sections: Array<{
+    markdown?: string;
+    assetId?: string;
+    label?: string;
+}>): ViewSpec;

package/dist/core/assets.js

@@ -0,0 +1,192 @@
+/**
+ * Asset System - Fast-path preview architecture
+ *
+ * Assets are files produced by workers with metadata for instant preview.
+ * The preview-worker generates thumbnails/metadata WITHOUT using the LLM.
+ */
+import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'fs';
+import { basename, extname, join } from 'path';
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+/**
+ * Generate SHA256 hash of file contents
+ */
+export function hashFile(filePath) {
+    const content = readFileSync(filePath);
+    return createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Get MIME type from file extension
+ */
+export function getMimeType(filePath) {
+    const ext = extname(filePath).toLowerCase().slice(1);
+    const mimeMap = {
+        // Images
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        webp: 'image/webp',
+        ico: 'image/x-icon',
+        // Documents
+        pdf: 'application/pdf',
+        doc: 'application/msword',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        // Code/Text
+        js: 'text/javascript',
+        ts: 'text/typescript',
+        jsx: 'text/javascript',
+        tsx: 'text/typescript',
+        json: 'application/json',
+        html: 'text/html',
+        css: 'text/css',
+        md: 'text/markdown',
+        txt: 'text/plain',
+        csv: 'text/csv',
+        xml: 'text/xml',
+        yaml: 'text/yaml',
+        yml: 'text/yaml',
+        sh: 'text/x-shellscript',
+        py: 'text/x-python',
+        // Data
+        sqlite: 'application/x-sqlite3',
+        db: 'application/x-sqlite3',
+        // Video/Audio
+        mp4: 'video/mp4',
+        webm: 'video/webm',
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+    };
+    return mimeMap[ext] || 'application/octet-stream';
+}
+/**
+ * Generate unique asset ID
+ */
+export function generateAssetId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `asset_${timestamp}_${random}`;
+}
+/**
+ * Create asset manifest for a file
+ */
+export function createAssetManifest(filePath, options = {}) {
+    const stats = statSync(filePath);
+    return {
+        id: generateAssetId(),
+        path: filePath,
+        name: basename(filePath),
+        mime: getMimeType(filePath),
+        sha256: hashFile(filePath),
+        size: stats.size,
+        createdAt: Date.now(),
+        groupId: options.groupId,
+        label: options.label,
+        kind: 'file',
+    };
+}
+/**
+ * Write asset manifest alongside the file
+ */
+export function writeAssetManifest(manifest) {
+    const manifestPath = manifest.path + '.asset.json';
+    writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+/**
+ * Read asset manifest for a file
+ */
+export function readAssetManifest(filePath) {
+    const manifestPath = filePath + '.asset.json';
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get preview cache directory
+ */
+export function getPreviewCacheDir() {
+    const home = process.env.HOME || '/tmp';
+    const cacheDir = join(home, '.connect-hub', 'preview-cache');
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+    }
+    return cacheDir;
+}
+/**
+ * Generate cache key for preview
+ */
+export function getPreviewCacheKey(sha256, params) {
+    const paramsStr = params ? JSON.stringify(params) : '';
+    return createHash('sha256').update(sha256 + paramsStr).digest('hex').substring(0, 16);
+}
+/**
+ * Check if preview exists in cache
+ */
+export function getPreviewFromCache(cacheKey) {
+    const cachePath = join(getPreviewCacheDir(), `${cacheKey}.json`);
+    if (!existsSync(cachePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(cachePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save preview to cache
+ */
+export function savePreviewToCache(preview) {
+    const cachePath = join(getPreviewCacheDir(), `${preview.cacheKey}.json`);
+    writeFileSync(cachePath, JSON.stringify(preview, null, 2));
+}
+/**
+ * Create a ViewSpec for comparing two assets
+ */
+export function createCompareView(beforeAssetId, afterAssetId, title = 'Comparison') {
+    return {
+        id: `view_${Date.now().toString(36)}`,
+        title,
+        layout: 'compare',
+        before: { type: 'asset', assetId: beforeAssetId, label: 'Before' },
+        after: { type: 'asset', assetId: afterAssetId, label: 'After' },
+        createdAt: Date.now(),
+    };
+}
+/**
+ * Create a ViewSpec for a grid of assets
+ */
+export function createGridView(assetIds, title = 'Gallery') {
+    return {
+        id: `view_${Date.now().toString(36)}`,
+        title,
+        layout: 'grid',
+        items: assetIds.map(id => ({ type: 'asset', assetId: id })),
+        createdAt: Date.now(),
+    };
+}
+/**
+ * Create a ViewSpec for a report with markdown and assets
+ */
+export function createReportView(title, sections) {
+    return {
+        id: `view_${Date.now().toString(36)}`,
+        title,
+        layout: 'stack',
+        items: sections.map(section => {
+            if (section.markdown) {
+                return { type: 'markdown', content: section.markdown, label: section.label };
+            }
+            return { type: 'asset', assetId: section.assetId, label: section.label };
+        }),
+        createdAt: Date.now(),
+    };
+}