@siftd/connect-agent 0.2.30 → 0.2.32

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, ClientAssetManifest } 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: ClientAssetManifest[];
+}
+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: ClientAssetManifest;
+    preview: AssetPreview | null;
+}
+export interface AssetGroupResponse {
+    type: 'asset.group';
+    requestId: string;
+    groupId: string;
+    assets: ClientAssetManifest[];
+    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
+ * Strips absolute paths from assets for client safety
+ */
+export declare function galleryStateToMessage(state: GalleryState): {
+    type: 'gallery_state';
+    assets: ClientAssetManifest[];
+    previews: {
+        [key: string]: AssetPreview;
+    };
+    groups: {
+        [key: string]: string[];
+    };
+    views: ViewSpec[];
+};

package/dist/core/asset-api.js

@@ -0,0 +1,204 @@
+/**
+ * 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 { toClientManifest, isPathWithinRoot, } from './assets.js';
+import { getAsset, getPreview, getAllAssets, getAssetsByGroup, getAssetRegistry, } from './preview-worker.js';
+import { getSharedOutputPath } from './hub.js';
+// Allowed roots for asset access (security)
+function getAllowedRoots() {
+    const home = process.env.HOME || '/tmp';
+    return [
+        getSharedOutputPath(),
+        `${home}/Lia-Hub`,
+        '/tmp',
+    ];
+}
+/**
+ * Validate that a path is within allowed roots (uses realpath to prevent traversal/symlink escapes)
+ */
+function isPathAllowed(filePath) {
+    const allowedRoots = getAllowedRoots();
+    return allowedRoots.some(root => isPathWithinRoot(filePath, root));
+}
+// ============================================================================
+// 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().map(toClientManifest),
+    };
+}
+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}` };
+    }
+    // Security: validate path is within allowed roots
+    if (!isPathAllowed(manifest.path)) {
+        return { type: 'asset.error', requestId, error: 'Access denied' };
+    }
+    if (!existsSync(manifest.path)) {
+        return { type: 'asset.error', requestId, error: 'File not found' };
+    }
+    // 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: toClientManifest(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: assets.map(toClientManifest),
+        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
+ * Strips absolute paths from assets for client safety
+ */
+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.map(toClientManifest),
+        previews,
+        groups,
+        views: state.views,
+    };
+}

package/dist/core/assets.d.ts

@@ -0,0 +1,203 @@
+/**
+ * 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 (content-addressed) */
+    id: string;
+    /** Absolute path to the file (INTERNAL ONLY - never send to client) */
+    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;
+}
+/**
+ * Client-safe asset manifest - no absolute paths exposed
+ */
+export interface ClientAssetManifest {
+    id: string;
+    name: string;
+    mime: string;
+    sha256: string;
+    size: number;
+    createdAt: number;
+    groupId?: string;
+    label?: 'old' | 'new' | 'diff' | 'output' | 'source';
+    kind: 'file' | 'view';
+    viewSpec?: ViewSpec;
+}
+/**
+ * Convert internal manifest to client-safe version (strips path)
+ */
+export declare function toClientManifest(manifest: AssetManifest): ClientAssetManifest;
+/**
+ * Validate that a resolved path is within an allowed root (prevents traversal/symlink escapes)
+ */
+export declare function isPathWithinRoot(filePath: string, rootDir: string): boolean;
+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 deterministic asset ID from content hash + relative path
+ * Content-addressed: same file always gets same ID
+ */
+export declare function generateAssetId(sha256: string, relativePath?: string): string;
+/**
+ * Create asset manifest for a file
+ * @param rootDir - Root directory for computing relative path (for ID stability)
+ */
+export declare function createAssetManifest(filePath: string, options?: {
+    groupId?: string;
+    label?: AssetManifest['label'];
+    rootDir?: string;
+}): 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
+ * Uses canonical stringify for stable key generation regardless of key order
+ */
+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;