@affectively/dash 5.0.0

package/dist/src/mcp/server.js

@@ -0,0 +1,87 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { dash } from '../engine/sqlite.js';
+export class DashMCPServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: 'dash-local-db',
+            version: '2.0.0',
+        }, {
+            capabilities: {
+                resources: {},
+                tools: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        // List Resources: Expose all tables as resources
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            await dash.ready();
+            // Get all table names
+            const tables = dash.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+            return {
+                resources: tables.map((t) => ({
+                    uri: `mcp://local/dash/${t.name}`,
+                    name: t.name,
+                    mimeType: 'application/json',
+                    description: `Table: ${t.name}`,
+                })),
+            };
+        });
+        // Read Resource: Return table content
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            const uri = request.params.uri;
+            const tableName = uri.split('/').pop();
+            if (!tableName)
+                throw new Error('Invalid URI');
+            const rows = dash.execute(`SELECT * FROM ${tableName} LIMIT 100`);
+            return {
+                contents: [{
+                        uri: uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(rows, null, 2),
+                    }],
+            };
+        });
+        // List Tools: Expose Semantic Search
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [{
+                        name: 'semantic_search',
+                        description: 'Search the Dash database using vector similarity (semantic search).',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: { type: 'string', description: 'The search query string.' },
+                            },
+                            required: ['query'],
+                        },
+                    }],
+            };
+        });
+        // Call Tool: Execute Semantic Search
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            if (request.params.name === 'semantic_search') {
+                const query = request.params.arguments?.query;
+                if (!query)
+                    throw new Error('Missing query argument');
+                const results = await dash.search(query);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(results, null, 2),
+                        }],
+                };
+            }
+            throw new Error('Tool not found');
+        });
+    }
+    // Method to connect to a transport (e.g., SSE for web)
+    async connect(transport) {
+        await this.server.connect(transport);
+        console.log('Dash MCP Server Connected');
+    }
+}
+export const mcpServer = new DashMCPServer();

package/dist/src/reactivity/signal.d.ts

@@ -0,0 +1,3 @@
+import { Signal } from '@preact/signals-core';
+export declare function liveQuery<T = any>(sql: string, bind?: any[]): Signal<T[]>;
+export { signal, effect, computed } from '@preact/signals-core';

package/dist/src/reactivity/signal.js

@@ -0,0 +1,31 @@
+import { signal } from '@preact/signals-core';
+import { dash } from '../engine/sqlite.js';
+export function liveQuery(sql, bind) {
+    const data = signal([]);
+    const run = async () => {
+        await dash.ready();
+        try {
+            const result = dash.execute(sql, bind);
+            data.value = result;
+        }
+        catch (e) {
+            console.error('Dash LiveQuery Error:', e);
+        }
+    };
+    // Run immediately
+    run();
+    // Subscribe to database changes
+    // Parse table name naively
+    const match = sql.match(/FROM\s+([a-zA-Z0-9_]+)/i);
+    const table = match ? match[1] : null;
+    if (table) {
+        dash.subscribe(table, () => {
+            run();
+        });
+    }
+    else {
+        console.warn('Dash: Could not identify table for liveQuery', sql);
+    }
+    return data;
+}
+export { signal, effect, computed } from '@preact/signals-core';

package/dist/src/schema/lens.d.ts

@@ -0,0 +1,29 @@
+export type LensOp = {
+    kind: 'rename';
+    source: string;
+    target: string;
+} | {
+    kind: 'hoist';
+    host: string;
+    name: string;
+} | {
+    kind: 'wrap';
+    name: string;
+};
+export interface SchemaLens {
+    from: number;
+    to: number;
+    ops: LensOp[];
+}
+export declare class LensEngine {
+    private lenses;
+    private currentVersion;
+    constructor(currentVersion: number);
+    registerLens(from: number, to: number, ops: LensOp[]): void;
+    private findPath;
+    migrate(data: any, from: number, to?: number): any;
+    private normalizeOps;
+    private invertOp;
+    private applyOp;
+}
+export declare const schema: LensEngine;

package/dist/src/schema/lens.js

@@ -0,0 +1,122 @@
+// Native Bidirectional Lens Implementation
+// Inspired by Project Cambria
+export class LensEngine {
+    lenses = [];
+    currentVersion;
+    constructor(currentVersion) {
+        this.currentVersion = currentVersion;
+    }
+    registerLens(from, to, ops) {
+        this.lenses.push({ from, to, ops });
+    }
+    // Find path from V_start to V_end
+    findPath(from, to) {
+        // BFS to find shortest path
+        const queue = [{ version: from, path: [] }];
+        const visited = new Set([from]);
+        while (queue.length > 0) {
+            const { version, path } = queue.shift();
+            if (version === to)
+                return path;
+            // Find neighbors
+            // Forward lenses
+            const forward = this.lenses.filter(l => l.from === version);
+            for (const lens of forward) {
+                if (!visited.has(lens.to)) {
+                    visited.add(lens.to);
+                    queue.push({ version: lens.to, path: [...path, lens] });
+                }
+            }
+            // Reverse lenses (Implicit)
+            const backward = this.lenses.filter(l => l.to === version);
+            for (const lens of backward) {
+                if (!visited.has(lens.from)) {
+                    visited.add(lens.from);
+                    // Create synthetic reverse lens
+                    const reverseLens = {
+                        from: lens.to,
+                        to: lens.from,
+                        ops: [...lens.ops].reverse() // Ops must be reversed!
+                    };
+                    queue.push({ version: lens.from, path: [...path, reverseLens] });
+                }
+            }
+        }
+        throw new Error(`No translation path found from v${from} to v${to}`);
+    }
+    migrate(data, from, to = this.currentVersion) {
+        if (from === to)
+            return data;
+        const path = this.findPath(from, to);
+        let doc = JSON.parse(JSON.stringify(data)); // Deep clone to avoid mutation
+        for (const step of path) {
+            const isForward = step.from < step.to; // Heuristic: Assuming localized version jumps
+            // Actually we should just apply the ops in the step direction.
+            // But we need to know if the step is a "Forward Lens" or a "Reverse Lens" 
+            // because ops like 'rename' need to swap source/target if reversed.
+            // The path finding creates "synthetic" lenses for reverse steps where from > to.
+            // So we just need to apply 'step.ops' carefully. 
+            // But wait! in findPath, I just reversed the ARRAY of ops.
+            // I ALSO need to invert the OPERATORS themselves.
+            const opsToApply = this.normalizeOps(step);
+            for (const op of opsToApply) {
+                doc = this.applyOp(doc, op);
+            }
+        }
+        return doc;
+    }
+    normalizeOps(step) {
+        // If this lens was registered as from=1, to=2
+        // And we are using it as from=1, to=2. No change.
+        // If we are traversing 2->1.
+        // The findPath constructed a lens { from: 2, to: 1, ops: ops.reverse() }
+        // But the ops inside are still { kind: 'rename', source: 'old', target: 'new' }
+        // We need to invert them to { kind: 'rename', source: 'new', target: 'old' }
+        // We need to know the *registred* direction to know if inversion is needed?
+        // Actually findPath constructs a fresh object. We can check if it exists in this.lenses.
+        const registered = this.lenses.find(l => l.from === step.from && l.to === step.to);
+        if (registered) {
+            return step.ops; // Direct match, use as is
+        }
+        // Must be a reverse step constructed by findPath
+        return step.ops.map(op => this.invertOp(op));
+    }
+    invertOp(op) {
+        switch (op.kind) {
+            case 'rename': return { kind: 'rename', source: op.target, target: op.source };
+            // Invert Hoist: Wrap?
+            // Hoist: host='meta', name='key' (moves doc.meta.key -> doc.key)
+            // Inverse: Wrap (moves doc.key -> doc.meta.key)
+            // Use 'wrap' as simplified inverse of simple hoist
+            case 'hoist': return { kind: 'wrap', name: op.name }; // Simplified
+            case 'wrap': return { kind: 'hoist', host: 'container', name: op.name }; // Naive inverse
+            default: return op;
+        }
+    }
+    applyOp(doc, op) {
+        switch (op.kind) {
+            case 'rename': {
+                if (doc[op.source] !== undefined) {
+                    doc[op.target] = doc[op.source];
+                    delete doc[op.source];
+                }
+                return doc;
+            }
+            case 'hoist': {
+                // Extract property from scalar host? Or object?
+                // Assume simple object flattening: { data: { val: 1 } } -> hoist 'data', 'val' -> { val: 1 }
+                // doc[op.host][op.name] -> doc[op.name]
+                if (doc[op.host] && doc[op.host][op.name] !== undefined) {
+                    doc[op.name] = doc[op.host][op.name];
+                    delete doc[op.host][op.name];
+                    if (Object.keys(doc[op.host]).length === 0)
+                        delete doc[op.host];
+                }
+                return doc;
+            }
+            default: return doc;
+        }
+    }
+}
+export const schema = new LensEngine(1);
+// Default to v1 until configured

package/dist/src/sync/backup.d.ts

@@ -0,0 +1,12 @@
+import * as Y from 'yjs';
+export interface CloudStorageAdapter {
+    upload(name: string, data: Uint8Array): Promise<void>;
+    download(name: string): Promise<Uint8Array | null>;
+}
+export declare function generateKey(): Promise<CryptoKey>;
+export declare function exportKey(key: CryptoKey): Promise<string>;
+export declare function importKey(jwkString: string): Promise<CryptoKey>;
+export declare function encrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+export declare function decrypt(data: Uint8Array, key: CryptoKey): Promise<Uint8Array>;
+export declare function backup(roomName: string, doc: Y.Doc, key: CryptoKey, adapter: CloudStorageAdapter): Promise<void>;
+export declare function restore(roomName: string, doc: Y.Doc, key: CryptoKey, adapter: CloudStorageAdapter): Promise<void>;

package/dist/src/sync/backup.js

@@ -0,0 +1,44 @@
+import * as Y from 'yjs';
+// AES-GCM Encryption
+export async function generateKey() {
+    return await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']);
+}
+export async function exportKey(key) {
+    const exported = await crypto.subtle.exportKey('jwk', key);
+    return JSON.stringify(exported);
+}
+export async function importKey(jwkString) {
+    const jwk = JSON.parse(jwkString);
+    return await crypto.subtle.importKey('jwk', jwk, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt']);
+}
+export async function encrypt(data, key) {
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    // Ensure we have a proper ArrayBuffer (not SharedArrayBuffer) by creating a copy
+    const dataCopy = new Uint8Array(data);
+    const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, dataCopy);
+    // Combine IV and Encrypted Data
+    const combined = new Uint8Array(iv.length + encrypted.byteLength);
+    combined.set(iv);
+    combined.set(new Uint8Array(encrypted), iv.length);
+    return combined;
+}
+export async function decrypt(data, key) {
+    const iv = data.slice(0, 12);
+    const ciphertext = data.slice(12);
+    const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, ciphertext);
+    return new Uint8Array(decrypted);
+}
+export async function backup(roomName, doc, key, adapter) {
+    const state = Y.encodeStateAsUpdate(doc);
+    const encrypted = await encrypt(state, key);
+    await adapter.upload(`backup_${roomName}`, encrypted);
+}
+export async function restore(roomName, doc, key, adapter) {
+    const encrypted = await adapter.download(`backup_${roomName}`);
+    if (!encrypted) {
+        console.warn(`[CloudBackup] No backup found for room ${roomName}`);
+        return;
+    }
+    const state = await decrypt(encrypted, key);
+    Y.applyUpdate(doc, state);
+}

package/dist/src/sync/connection.d.ts

@@ -0,0 +1,20 @@
+import * as Y from 'yjs';
+export interface SyncConnectionConfig {
+    type?: 'webrtc' | 'webtransport';
+    roomName: string;
+    doc: Y.Doc;
+    signalingServers?: string[];
+    password?: string | null;
+    url?: string;
+    awareness?: any;
+}
+export declare class SyncConnection {
+    private provider;
+    roomName: string;
+    constructor(config: SyncConnectionConfig);
+    disconnect(): void;
+    get awareness(): any;
+}
+export declare class WebRTCConnection extends SyncConnection {
+    constructor(config: Omit<SyncConnectionConfig, 'type'>);
+}

package/dist/src/sync/connection.js

@@ -0,0 +1,50 @@
+import { WebrtcProvider } from 'y-webrtc';
+import { HybridProvider } from './hybrid-provider.js';
+export class SyncConnection {
+    provider;
+    roomName;
+    constructor(config) {
+        this.roomName = config.roomName;
+        const type = config.type || 'webrtc'; // Default to WebRTC for backward compatibility
+        if (type === 'webtransport') {
+            if (!config.url) {
+                throw new Error('WebTransport requires a "url" in config');
+            }
+            this.provider = new HybridProvider(config.url, config.roomName, config.doc, { awareness: config.awareness });
+        }
+        else {
+            // Default signaling servers if none provided
+            // Note: In production, users should host their own signaling servers
+            const signaling = config.signalingServers || [
+                'wss://signaling.yjs.dev',
+                'wss://y-webrtc-signaling-eu.herokuapp.com',
+                'wss://y-webrtc-signaling-us.herokuapp.com'
+            ];
+            this.provider = new WebrtcProvider(config.roomName, config.doc, {
+                signaling,
+                password: config.password || undefined,
+                awareness: config.awareness
+            });
+        }
+        this.provider.on('synced', (event) => {
+            console.log(`[${type === 'webtransport' ? 'WebTransport' : 'WebRTC'}] Room: ${this.roomName}, Synced: ${event.synced}`);
+        });
+        // Relay status from provider if available
+        this.provider.on('status', (event) => {
+            // loose typing for event forwarding
+            console.log(`[${type}] Status update:`, event);
+        });
+    }
+    disconnect() {
+        this.provider.destroy();
+    }
+    get awareness() {
+        return this.provider.awareness;
+    }
+}
+// Backward compatibility alias
+export class WebRTCConnection extends SyncConnection {
+    constructor(config) {
+        super({ ...config, type: 'webrtc' });
+    }
+}

package/dist/src/sync/hybrid-provider.d.ts

@@ -0,0 +1,28 @@
+import * as Y from 'yjs';
+import { Observable } from 'lib0/observable';
+import * as awarenessProtocol from 'y-protocols/awareness';
+export declare class HybridProvider extends Observable<string> {
+    private doc;
+    private ws;
+    private wt;
+    private connected;
+    private url;
+    private roomName;
+    awareness: awarenessProtocol.Awareness;
+    private writer;
+    private highFrequencyMode;
+    constructor(url: string, roomName: string, doc: Y.Doc, { awareness }?: {
+        awareness?: awarenessProtocol.Awareness | undefined;
+    });
+    private connect;
+    private connectWebSocket;
+    private getAuthToken;
+    enterHighFrequencyMode(): Promise<void>;
+    private sendSyncStep1;
+    private readLoop;
+    private handleMessage;
+    private send;
+    private onDocUpdate;
+    private onAwarenessUpdate;
+    destroy(): void;
+}

package/dist/src/sync/hybrid-provider.js

@@ -0,0 +1,194 @@
+import { Observable } from 'lib0/observable';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+// @ts-ignore
+import * as syncProtocol from 'y-protocols/sync';
+// @ts-ignore
+import * as awarenessProtocol from 'y-protocols/awareness';
+export class HybridProvider extends Observable {
+    doc;
+    ws = null;
+    wt = null;
+    connected = false;
+    url;
+    roomName;
+    awareness;
+    writer = null;
+    // "High Frequency" mode uses WebTransport for ephemeral data
+    highFrequencyMode = false;
+    constructor(url, roomName, doc, { awareness = new awarenessProtocol.Awareness(doc) } = {}) {
+        super();
+        this.url = url;
+        this.roomName = roomName;
+        this.doc = doc;
+        this.awareness = awareness;
+        this.doc.on('update', this.onDocUpdate.bind(this));
+        this.awareness.on('update', this.onAwarenessUpdate.bind(this));
+        this.connect();
+    }
+    connect() {
+        this.connectWebSocket();
+    }
+    connectWebSocket() {
+        // Protocol: switch http/https to ws/wss
+        // Protocol: switch http/https to ws/wss
+        // 1. Get Token
+        // Ideally await this before connecting, but construction is sync.
+        // We'll make connect async internally or fire-and-forget with token wait.
+        this.getAuthToken().then(token => {
+            const wsUrl = this.url.replace(/^http/, 'ws') + '/sync/' + this.roomName + '?token=' + token;
+            this.ws = new WebSocket(wsUrl);
+            this.ws.binaryType = 'arraybuffer';
+            this.ws.onopen = () => {
+                this.connected = true;
+                this.emit('status', [{ status: 'connected' }]);
+                this.sendSyncStep1();
+            };
+            // ... rest of event handlers
+            this.ws.onmessage = (event) => {
+                this.handleMessage(new Uint8Array(event.data));
+            };
+            this.ws.onclose = () => {
+                this.connected = false;
+                this.ws = null;
+                this.emit('status', [{ status: 'disconnected' }]);
+                // Reconnect logic
+                setTimeout(() => this.connectWebSocket(), 3000);
+            };
+            this.ws.onerror = (err) => {
+                console.error('WebSocket error', err);
+            };
+        });
+    }
+    async getAuthToken() {
+        // Lazy load auth to avoid circular dependency issues if any
+        const { auth } = await import('../auth/manager.js');
+        // For MVP, we assume the Relay allows any DID to connect if they sign it.
+        // In prod, you'd know the Relay's DID.
+        return auth.issueRoomToken("did:web:relay.buley.dev", this.roomName);
+    }
+    async enterHighFrequencyMode() {
+        if (this.highFrequencyMode)
+            return;
+        try {
+            // Connect WebTransport
+            // Just an example URL construction, depends on server routing
+            const wtUrl = this.url + '/sync/' + this.roomName;
+            this.wt = new WebTransport(wtUrl);
+            await this.wt.ready;
+            const stream = await this.wt.createBidirectionalStream();
+            this.writer = stream.writable;
+            this.readLoop(stream.readable);
+            this.highFrequencyMode = true;
+            console.log('Upgraded to WebTransport (High Frequency Mode)');
+        }
+        catch (e) {
+            console.error('Failed to upgrade to WebTransport', e);
+            // Fallback: stay on WebSocket
+        }
+    }
+    sendSyncStep1() {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, 0); // MessageType.Sync
+        syncProtocol.writeSyncStep1(encoder, this.doc);
+        this.send(encoding.toUint8Array(encoder));
+    }
+    async readLoop(readable) {
+        let reader;
+        try {
+            // @ts-ignore
+            reader = readable.getReader({ mode: 'byob' });
+        }
+        catch (e) {
+            reader = readable.getReader();
+        }
+        // Pre-allocate buffer (64KB) to emulate Zero-Copy / WASM Heap view
+        // In a future update, this could be a view into `sqlite3.wasm.memory`.
+        let buffer = new Uint8Array(65536);
+        try {
+            while (true) {
+                let result;
+                if (reader.readAtLeast) {
+                    // BYOB Reader
+                    // We pass the view. The reader detaches it and returns a new view (potentially same backing store).
+                    result = await reader.read(new Uint8Array(buffer.buffer, 0, buffer.byteLength));
+                    if (result.value) {
+                        buffer = result.value; // Update our reference to the valid buffer
+                    }
+                }
+                else {
+                    // Default Reader
+                    result = await reader.read();
+                }
+                if (result.done)
+                    break;
+                if (result.value) {
+                    // Processing: In true zero-copy, we'd pass the offset/length to SQL directly.
+                    // Here we pass the view.
+                    this.handleMessage(result.value);
+                }
+            }
+        }
+        catch (e) {
+            console.error('WebTransport Read loop error', e);
+        }
+        finally {
+            this.highFrequencyMode = false;
+            this.writer = null;
+            this.wt = null;
+        }
+    }
+    handleMessage(buf) {
+        // Simple protocol: First byte is message type (0=Sync, 1=Awareness)
+        // In strict binary mode, we might need a more robust header.
+        // For now assuming Y-protocol encoding.
+        // Note: The Relay DO sends raw messages back.
+        const decoder = decoding.createDecoder(buf);
+        const messageType = decoding.readVarUint(decoder);
+        switch (messageType) {
+            case 0: // Sync
+                syncProtocol.readSyncMessage(decoder, encoding.createEncoder(), this.doc, this);
+                break;
+            case 1: // Awareness
+                awarenessProtocol.applyAwarenessUpdate(this.awareness, decoding.readVarUint8Array(decoder), this);
+                break;
+        }
+    }
+    async send(message) {
+        if (this.writer && this.highFrequencyMode) {
+            // High Priority -> WebTransport
+            const writer = this.writer.getWriter();
+            await writer.write(message);
+            writer.releaseLock();
+        }
+        else if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            // Default -> WebSocket
+            this.ws.send(message);
+        }
+    }
+    onDocUpdate(update, origin) {
+        if (origin === this)
+            return;
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, 0); // MessageType.Sync
+        syncProtocol.writeUpdate(encoder, update);
+        this.send(encoding.toUint8Array(encoder));
+    }
+    onAwarenessUpdate({ added, updated, removed }, origin) {
+        if (origin === this)
+            return;
+        const changedClients = added.concat(updated).concat(removed);
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, 1); // MessageType.Awareness
+        encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, changedClients));
+        this.send(encoding.toUint8Array(encoder));
+    }
+    destroy() {
+        this.doc.off('update', this.onDocUpdate);
+        this.awareness.off('update', this.onAwarenessUpdate);
+        this.ws?.close();
+        this.wt?.close();
+        this.connected = false;
+        super.destroy();
+    }
+}

package/dist/src/sync/provider.d.ts

@@ -0,0 +1,11 @@
+import * as Y from 'yjs';
+export declare class YjsSqliteProvider {
+    private doc;
+    private roomName;
+    whenSynced: Promise<void>;
+    constructor(roomName: string, doc: Y.Doc);
+    private persistUpdate;
+    private loadState;
+    private toBase64;
+    private fromBase64;
+}