@siftd/connect-agent 0.2.30 → 0.2.32

package/dist/core/assets.js

@@ -0,0 +1,238 @@
+/**
+ * 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, realpathSync } from 'fs';
+import { basename, extname, join, relative, sep } from 'path';
+/**
+ * Convert internal manifest to client-safe version (strips path)
+ */
+export function toClientManifest(manifest) {
+    const { path, ...clientSafe } = manifest;
+    return clientSafe;
+}
+/**
+ * Validate that a resolved path is within an allowed root (prevents traversal/symlink escapes)
+ */
+export function isPathWithinRoot(filePath, rootDir) {
+    try {
+        const resolvedPath = realpathSync(filePath);
+        const resolvedRoot = realpathSync(rootDir);
+        return resolvedPath.startsWith(resolvedRoot + sep);
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// 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 deterministic asset ID from content hash + relative path
+ * Content-addressed: same file always gets same ID
+ */
+export function generateAssetId(sha256, relativePath) {
+    // Use first 12 chars of sha256 + path hash for uniqueness
+    const prefix = sha256.substring(0, 12);
+    if (relativePath) {
+        const pathHash = createHash('sha256').update(relativePath).digest('hex').substring(0, 6);
+        return `asset_${prefix}_${pathHash}`;
+    }
+    return `asset_${prefix}`;
+}
+/**
+ * Create asset manifest for a file
+ * @param rootDir - Root directory for computing relative path (for ID stability)
+ */
+export function createAssetManifest(filePath, options = {}) {
+    const stats = statSync(filePath);
+    const sha256 = hashFile(filePath);
+    // Compute relative path using path.relative() for stable IDs
+    const relativePath = options.rootDir
+        ? relative(options.rootDir, filePath)
+        : basename(filePath);
+    return {
+        id: generateAssetId(sha256, relativePath),
+        path: filePath,
+        name: basename(filePath),
+        mime: getMimeType(filePath),
+        sha256,
+        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;
+}
+/**
+ * Canonical JSON stringify - sorts keys recursively for stable hashing
+ */
+function canonicalStringify(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return JSON.stringify(obj);
+    }
+    if (Array.isArray(obj)) {
+        return '[' + obj.map(canonicalStringify).join(',') + ']';
+    }
+    const sortedKeys = Object.keys(obj).sort();
+    const pairs = sortedKeys.map(key => JSON.stringify(key) + ':' + canonicalStringify(obj[key]));
+    return '{' + pairs.join(',') + '}';
+}
+/**
+ * Generate cache key for preview
+ * Uses canonical stringify for stable key generation regardless of key order
+ */
+export function getPreviewCacheKey(sha256, params) {
+    const paramsStr = params ? canonicalStringify(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(),
+    };
+}

package/dist/core/preview-worker.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Preview Worker - Fast-path local preview generation
+ *
+ * Watches ~/Lia-Hub/shared/outputs/ and generates:
+ * - Thumbnails (for images)
+ * - Metadata extraction (dimensions, page count, text snippets)
+ * - Preview JSON for instant gallery display
+ *
+ * NO LLM involvement - pure local, deterministic processing.
+ * Targets sub-second response for most assets.
+ *
+ * Uses chokidar for reliable cross-platform file watching with:
+ * - awaitWriteFinish to handle half-written files
+ * - Ignore patterns to avoid loops (*.asset.json, thumbs, etc.)
+ */
+import { AssetManifest, AssetPreview } from './assets.js';
+export interface PreviewWorkerOptions {
+    /** Directories to watch */
+    watchDirs?: string[];
+    /** Max concurrent preview jobs */
+    concurrency?: number;
+    /** Callback when asset is discovered */
+    onAsset?: (manifest: AssetManifest) => void;
+    /** Callback when preview is ready */
+    onPreview?: (preview: AssetPreview) => void;
+    /** Enable verbose logging */
+    verbose?: boolean;
+}
+export declare class PreviewWorker {
+    private watcher;
+    private queue;
+    private processing;
+    private debounceTimers;
+    private concurrency;
+    private options;
+    private running;
+    private rootDir;
+    constructor(options?: PreviewWorkerOptions);
+    /**
+     * Start watching directories
+     */
+    start(): void;
+    /**
+     * Handle file add/change with debouncing
+     */
+    private handleFile;
+    /**
+     * Stop watching
+     */
+    stop(): void;
+    /**
+     * Add file to processing queue
+     */
+    private enqueue;
+    /**
+     * Process queue with concurrency limit
+     */
+    private processQueue;
+    /**
+     * Process a single file - generate manifest and preview
+     */
+    private processFile;
+    /**
+     * Generate preview for an asset
+     */
+    private generatePreview;
+    /**
+     * Get image dimensions using sips (macOS) or file command
+     */
+    private getImageInfo;
+    /**
+     * Generate thumbnail as base64 data URL
+     * Uses sips on macOS for fast resizing
+     */
+    private generateImageThumbnail;
+    /**
+     * Get PDF info using pdfinfo or mdls
+     */
+    private getPdfInfo;
+    /**
+     * Get text snippet from file
+     */
+    private getTextSnippet;
+    /**
+     * Extract group ID from file path
+     * e.g., ~/Lia-Hub/shared/outputs/run_abc123/file.png -> run_abc123
+     */
+    private extractGroupId;
+    private log;
+}
+export interface AssetRegistry {
+    assets: Map<string, AssetManifest>;
+    previews: Map<string, AssetPreview>;
+    byGroup: Map<string, Set<string>>;
+}
+export declare function getAssetRegistry(): AssetRegistry;
+export declare function registerAsset(manifest: AssetManifest): void;
+export declare function registerPreview(preview: AssetPreview): void;
+export declare function getAsset(assetId: string): AssetManifest | undefined;
+export declare function getPreview(assetId: string): AssetPreview | undefined;
+export declare function getAssetsByGroup(groupId: string): AssetManifest[];
+export declare function getAllAssets(): AssetManifest[];
+export declare function startPreviewWorker(options?: PreviewWorkerOptions): PreviewWorker;
+export declare function stopPreviewWorker(): void;