@rool-dev/extension 0.3.7-dev.2ccb343 → 0.3.7-dev.d9f341e

package/dist/reactive.svelte.js

@@ -1,10 +1,17 @@
 /**
- * Reactive Svelte wrapper around Channel (bridge client).
+ * Extension channel — bridge client with Svelte 5 reactivity.
  *
- * Mirrors the @rool-dev/svelte ReactiveChannel API: same $state properties,
- * same methods, same reactive primitives (object(), watch()).
- * The underlying transport is the postMessage bridge, not the SDK.
+ * Handles the postMessage bridge to the host and provides reactive $state
+ * properties, matching the @rool-dev/svelte ReactiveChannel API.
  */
+import { isBridgeMessage } from './protocol.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+let _nextId = 0;
+function nextRequestId() {
+    return `req-${++_nextId}-${Date.now().toString(36)}`;
+}
 // ---------------------------------------------------------------------------
 // ReactiveWatch
 // ---------------------------------------------------------------------------
@@ -160,128 +167,324 @@ class ReactiveObjectImpl {
 // ReactiveChannel
 // ---------------------------------------------------------------------------
 class ReactiveChannelImpl {
-    #channel;
+    _pending = new Map();
+    _listeners = new Map();
+    _schema;
+    _metadata;
+    #unsubscribers = [];
     #closed = false;
+    // Metadata from handshake
+    channelId;
+    spaceId;
+    spaceName;
+    role;
+    linkAccess;
+    userId;
+    /** Current user info (id, name, email). */
+    user;
     // Reactive state
     interactions = $state([]);
     objectIds = $state([]);
     collections = $state([]);
     conversations = $state([]);
-    #unsubscribers = [];
-    constructor(channel) {
-        this.#channel = channel;
+    constructor(init) {
+        this.channelId = init.channelId;
+        this.spaceId = init.spaceId;
+        this.spaceName = init.spaceName;
+        this.role = init.role;
+        this.linkAccess = init.linkAccess;
+        this.userId = init.userId;
+        this.user = init.user;
+        this._schema = init.schema;
+        this._metadata = init.metadata;
+        window.addEventListener('message', this._onMessage);
         // Load initial data
-        channel.getInteractions().then((list) => { this.interactions = list; });
-        channel.getObjectIds().then((ids) => { this.objectIds = ids; });
-        channel.getConversations().then((list) => { this.conversations = list; });
-        this.collections = Object.keys(channel.getSchema());
+        this.getInteractions().then((list) => { this.interactions = list; });
+        this._call('getObjectIds').then((ids) => { this.objectIds = ids; });
+        this.getConversations().then((list) => { this.conversations = list; });
+        this.collections = Object.keys(this._schema);
         // Subscribe to channel updates → refresh interactions
         const onChannelUpdated = () => {
-            channel.getInteractions().then((list) => { this.interactions = list; });
+            this.getInteractions().then((list) => { this.interactions = list; });
         };
-        channel.on('channelUpdated', onChannelUpdated);
-        this.#unsubscribers.push(() => channel.off('channelUpdated', onChannelUpdated));
+        this.on('channelUpdated', onChannelUpdated);
+        this.#unsubscribers.push(() => this.off('channelUpdated', onChannelUpdated));
         // Subscribe to conversation updates → refresh conversations
         const onConversationUpdated = () => {
-            channel.getConversations().then((list) => { this.conversations = list; });
+            this.getConversations().then((list) => { this.conversations = list; });
         };
-        channel.on('conversationUpdated', onConversationUpdated);
-        this.#unsubscribers.push(() => channel.off('conversationUpdated', onConversationUpdated));
+        this.on('conversationUpdated', onConversationUpdated);
+        this.#unsubscribers.push(() => this.off('conversationUpdated', onConversationUpdated));
         // Subscribe to object events → refresh objectIds
         const refreshObjectIds = () => {
-            channel.getObjectIds().then((ids) => { this.objectIds = ids; });
+            this._call('getObjectIds').then((ids) => { this.objectIds = ids; });
         };
-        channel.on('objectCreated', refreshObjectIds);
-        this.#unsubscribers.push(() => channel.off('objectCreated', refreshObjectIds));
-        channel.on('objectDeleted', refreshObjectIds);
-        this.#unsubscribers.push(() => channel.off('objectDeleted', refreshObjectIds));
+        this.on('objectCreated', refreshObjectIds);
+        this.#unsubscribers.push(() => this.off('objectCreated', refreshObjectIds));
+        this.on('objectDeleted', refreshObjectIds);
+        this.#unsubscribers.push(() => this.off('objectDeleted', refreshObjectIds));
         // Subscribe to schema updates → refresh collections
         const onSchemaUpdated = () => {
-            this.collections = Object.keys(channel.getSchema());
+            this.collections = Object.keys(this._schema);
         };
-        channel.on('schemaUpdated', onSchemaUpdated);
-        this.#unsubscribers.push(() => channel.off('schemaUpdated', onSchemaUpdated));
+        this.on('schemaUpdated', onSchemaUpdated);
+        this.#unsubscribers.push(() => this.off('schemaUpdated', onSchemaUpdated));
         // Full resets
         const onReset = () => {
-            channel.getInteractions().then((list) => { this.interactions = list; });
-            channel.getObjectIds().then((ids) => { this.objectIds = ids; });
-            channel.getConversations().then((list) => { this.conversations = list; });
-            this.collections = Object.keys(channel.getSchema());
+            this.getInteractions().then((list) => { this.interactions = list; });
+            this._call('getObjectIds').then((ids) => { this.objectIds = ids; });
+            this.getConversations().then((list) => { this.conversations = list; });
+            this.collections = Object.keys(this._schema);
         };
-        channel.on('reset', onReset);
-        this.#unsubscribers.push(() => channel.off('reset', onReset));
+        this.on('reset', onReset);
+        this.#unsubscribers.push(() => this.off('reset', onReset));
+    }
+    get isReadOnly() {
+        return this.role === 'viewer';
+    }
+    // ---------------------------------------------------------------------------
+    // Event emitter
+    // ---------------------------------------------------------------------------
+    on(event, callback) {
+        let set = this._listeners.get(event);
+        if (!set) {
+            set = new Set();
+            this._listeners.set(event, set);
+        }
+        set.add(callback);
+    }
+    off(event, callback) {
+        this._listeners.get(event)?.delete(callback);
+    }
+    _emit(event, data) {
+        const set = this._listeners.get(event);
+        if (set) {
+            for (const cb of set) {
+                try {
+                    cb(data);
+                }
+                catch (e) {
+                    console.error(`[Channel] Error in ${event} listener:`, e);
+                }
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // postMessage transport
+    // ---------------------------------------------------------------------------
+    _call(method, ...args) {
+        return this._callScoped(method, args);
+    }
+    /**
+     * Send a bridge request, optionally scoped to a conversation.
+     * @internal
+     */
+    _callScoped(method, args, conversationId) {
+        return new Promise((resolve, reject) => {
+            const id = nextRequestId();
+            this._pending.set(id, { resolve, reject });
+            const msg = { type: 'rool:request', id, method, args };
+            if (conversationId !== undefined)
+                msg.conversationId = conversationId;
+            window.parent.postMessage(msg, '*');
+        });
     }
-    // Proxied properties
-    get channelId() { return this.#channel.channelId; }
-    get spaceId() { return this.#channel.spaceId; }
-    get spaceName() { return this.#channel.spaceName; }
-    get role() { return this.#channel.role; }
-    get linkAccess() { return this.#channel.linkAccess; }
-    get userId() { return this.#channel.userId; }
-    get isReadOnly() { return this.#channel.isReadOnly; }
+    _onMessage = (event) => {
+        if (!isBridgeMessage(event.data))
+            return;
+        if (event.data.type === 'rool:response') {
+            const msg = event.data;
+            const pending = this._pending.get(msg.id);
+            if (pending) {
+                this._pending.delete(msg.id);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+            return;
+        }
+        if (event.data.type === 'rool:event') {
+            const msg = event.data;
+            // Update local caches before emitting so listeners see fresh data
+            if (msg.name === 'metadataUpdated') {
+                const payload = msg.data;
+                this._metadata = payload.metadata;
+            }
+            else if (msg.name === 'schemaUpdated') {
+                const payload = msg.data;
+                this._schema = payload.schema;
+            }
+            else if (msg.name === 'reset') {
+                // Full reload happened on the host — refresh cached schema and metadata
+                Promise.all([
+                    this._call('getSchema'),
+                    this._call('getAllMetadata'),
+                ]).then(([schema, metadata]) => {
+                    this._schema = schema;
+                    this._metadata = metadata;
+                });
+            }
+            this._emit(msg.name, msg.data);
+            return;
+        }
+    };
+    // ---------------------------------------------------------------------------
     // Object operations
-    getObject(objectId) { return this.#channel.getObject(objectId); }
-    stat(objectId) { return this.#channel.stat(objectId); }
-    findObjects(options) { return this.#channel.findObjects(options); }
-    getObjectIds(options) { return this.#channel.getObjectIds(options); }
-    createObject(options) { return this.#channel.createObject(options); }
-    updateObject(objectId, options) { return this.#channel.updateObject(objectId, options); }
-    deleteObjects(objectIds) { return this.#channel.deleteObjects(objectIds); }
-    // AI
-    prompt(text, options) { return this.#channel.prompt(text, options); }
-    // Undo/redo
-    checkpoint(label) { return this.#channel.checkpoint(label); }
-    canUndo() { return this.#channel.canUndo(); }
-    canRedo() { return this.#channel.canRedo(); }
-    undo() { return this.#channel.undo(); }
-    redo() { return this.#channel.redo(); }
-    clearHistory() { return this.#channel.clearHistory(); }
-    // Metadata
-    setMetadata(key, value) { return this.#channel.setMetadata(key, value); }
-    getMetadata(key) { return this.#channel.getMetadata(key); }
-    getAllMetadata() { return this.#channel.getAllMetadata(); }
-    // History
-    getInteractions() { return this.#channel.getInteractions(); }
-    getTree() { return this.#channel.getTree(); }
-    getActiveLeafId() { return this.#channel.getActiveLeafId(); }
-    setActiveLeaf(interactionId) { return this.#channel.setActiveLeaf(interactionId); }
-    getSystemInstruction() { return this.#channel.getSystemInstruction(); }
-    setSystemInstruction(instruction) { return this.#channel.setSystemInstruction(instruction); }
-    getConversations() { return this.#channel.getConversations(); }
-    deleteConversation(conversationId) { return this.#channel.deleteConversation(conversationId); }
-    renameConversation(name) { return this.#channel.renameConversation(name); }
+    // ---------------------------------------------------------------------------
+    async getObject(objectId) {
+        return this._call('getObject', objectId);
+    }
+    async stat(objectId) {
+        return this._call('stat', objectId);
+    }
+    async findObjects(options) {
+        return this._call('findObjects', options);
+    }
+    async getObjectIds(options) {
+        return this._call('getObjectIds', options);
+    }
+    async createObject(options) {
+        return this._call('createObject', options);
+    }
+    async updateObject(objectId, options) {
+        return this._call('updateObject', objectId, options);
+    }
+    async deleteObjects(objectIds) {
+        await this._call('deleteObjects', objectIds);
+    }
+    // ---------------------------------------------------------------------------
     // Schema
-    getSchema() { return this.#channel.getSchema(); }
-    createCollection(name, fields) { return this.#channel.createCollection(name, fields); }
-    alterCollection(name, fields) { return this.#channel.alterCollection(name, fields); }
-    dropCollection(name) { return this.#channel.dropCollection(name); }
+    // ---------------------------------------------------------------------------
+    getSchema() {
+        return this._schema;
+    }
+    async createCollection(name, fields) {
+        const result = await this._call('createCollection', name, fields);
+        this._schema[name] = result;
+        return result;
+    }
+    async alterCollection(name, fields) {
+        const result = await this._call('alterCollection', name, fields);
+        this._schema[name] = result;
+        return result;
+    }
+    async dropCollection(name) {
+        await this._call('dropCollection', name);
+        delete this._schema[name];
+    }
+    // ---------------------------------------------------------------------------
+    // Interactions & system instruction
+    // ---------------------------------------------------------------------------
+    async getInteractions() {
+        return this._call('getInteractions');
+    }
+    async getTree() {
+        return this._call('getTree');
+    }
+    async getActiveLeafId() {
+        return this._call('getActiveLeafId');
+    }
+    async setActiveLeaf(interactionId) {
+        await this._call('setActiveLeaf', interactionId);
+    }
+    async getSystemInstruction() {
+        return this._call('getSystemInstruction');
+    }
+    async setSystemInstruction(instruction) {
+        await this._call('setSystemInstruction', instruction);
+    }
+    async getConversations() {
+        return this._call('getConversations');
+    }
+    async deleteConversation(conversationId) {
+        await this._call('deleteConversation', conversationId);
+    }
+    async renameConversation(name) {
+        await this._call('renameConversation', name);
+    }
+    // ---------------------------------------------------------------------------
     // Conversations
+    // ---------------------------------------------------------------------------
+    /**
+     * Get a reactive handle for a specific conversation within this channel.
+     * Scopes AI and mutation operations to that conversation's interaction history.
+     * Conversations are auto-created on first interaction.
+     */
     conversation(conversationId) {
         if (this.#closed)
             throw new Error('Cannot create reactive conversation: channel is closed');
-        return new ReactiveConversationHandleImpl(this.#channel, conversationId);
+        return new ReactiveConversationHandleImpl(this, conversationId);
+    }
+    // ---------------------------------------------------------------------------
+    // Metadata
+    // ---------------------------------------------------------------------------
+    async setMetadata(key, value) {
+        await this._call('setMetadata', key, value);
+        this._metadata[key] = value;
     }
-    // Events
-    on(...args) { return this.#channel.on(...args); }
-    off(...args) { return this.#channel.off(...args); }
+    getMetadata(key) {
+        return this._metadata[key];
+    }
+    getAllMetadata() {
+        return { ...this._metadata };
+    }
+    // ---------------------------------------------------------------------------
+    // AI
+    // ---------------------------------------------------------------------------
+    async prompt(text, options) {
+        return this._call('prompt', text, options);
+    }
+    // ---------------------------------------------------------------------------
+    // Undo/redo
+    // ---------------------------------------------------------------------------
+    async checkpoint(label) {
+        return this._call('checkpoint', label);
+    }
+    async canUndo() {
+        return this._call('canUndo');
+    }
+    async canRedo() {
+        return this._call('canRedo');
+    }
+    async undo() {
+        return this._call('undo');
+    }
+    async redo() {
+        return this._call('redo');
+    }
+    async clearHistory() {
+        await this._call('clearHistory');
+    }
+    // ---------------------------------------------------------------------------
     // Reactive primitives
+    // ---------------------------------------------------------------------------
     object(objectId) {
         if (this.#closed)
             throw new Error('Cannot create reactive object: channel is closed');
-        return new ReactiveObjectImpl(this.#channel, objectId);
+        return new ReactiveObjectImpl(this, objectId);
     }
     watch(options) {
         if (this.#closed)
             throw new Error('Cannot create reactive watch: channel is closed');
-        return new ReactiveWatchImpl(this.#channel, options);
+        return new ReactiveWatchImpl(this, options);
     }
+    // ---------------------------------------------------------------------------
     // Cleanup
+    // ---------------------------------------------------------------------------
     destroy() {
         this.#closed = true;
         for (const unsub of this.#unsubscribers)
             unsub();
         this.#unsubscribers.length = 0;
-        this.#channel.destroy();
+        window.removeEventListener('message', this._onMessage);
+        for (const { reject } of this._pending.values()) {
+            reject(new Error('Channel destroyed'));
+        }
+        this._pending.clear();
+        this._listeners.clear();
     }
 }
 // ---------------------------------------------------------------------------
@@ -289,59 +492,91 @@ class ReactiveChannelImpl {
 // ---------------------------------------------------------------------------
 /**
  * A reactive conversation handle for the extension bridge.
- * Wraps ConversationHandle with $state interactions that auto-update
- * when the conversation changes via SSE events.
+ * Scopes AI and mutation operations to a specific conversation's
+ * interaction history, while sharing the channel's bridge connection.
  *
  * Call `close()` when done to stop listening for updates.
  */
 class ReactiveConversationHandleImpl {
-    #handle;
+    #channel;
     #conversationId;
     #unsubscribers = [];
     // Reactive state
     interactions = $state([]);
     constructor(channel, conversationId) {
+        this.#channel = channel;
         this.#conversationId = conversationId;
-        this.#handle = channel.conversation(conversationId);
         // Initial load
-        this.#handle.getInteractions().then((list) => { this.interactions = list; });
+        this.getInteractions().then((list) => { this.interactions = list; });
         // Listen for updates to this conversation
         const onConversationUpdated = ({ conversationId: cid }) => {
             if (cid === this.#conversationId) {
-                this.#handle.getInteractions().then((list) => { this.interactions = list; });
+                this.getInteractions().then((list) => { this.interactions = list; });
             }
         };
         channel.on('conversationUpdated', onConversationUpdated);
         this.#unsubscribers.push(() => channel.off('conversationUpdated', onConversationUpdated));
         // Handle full resets
         const onReset = () => {
-            this.#handle.getInteractions().then((list) => { this.interactions = list; });
+            this.getInteractions().then((list) => { this.interactions = list; });
         };
         channel.on('reset', onReset);
         this.#unsubscribers.push(() => channel.off('reset', onReset));
     }
     get conversationId() { return this.#conversationId; }
     // Conversation history
-    getInteractions() { return this.#handle.getInteractions(); }
-    getTree() { return this.#handle.getTree(); }
-    getActiveLeafId() { return this.#handle.getActiveLeafId(); }
-    setActiveLeaf(interactionId) { return this.#handle.setActiveLeaf(interactionId); }
-    getSystemInstruction() { return this.#handle.getSystemInstruction(); }
-    setSystemInstruction(instruction) { return this.#handle.setSystemInstruction(instruction); }
-    rename(name) { return this.#handle.rename(name); }
+    async getInteractions() {
+        return this.#channel._callScoped('getInteractions', [], this.#conversationId);
+    }
+    async getTree() {
+        return this.#channel._callScoped('getTree', [], this.#conversationId);
+    }
+    async getActiveLeafId() {
+        return this.#channel._callScoped('getActiveLeafId', [], this.#conversationId);
+    }
+    async setActiveLeaf(interactionId) {
+        await this.#channel._callScoped('setActiveLeaf', [interactionId], this.#conversationId);
+    }
+    async getSystemInstruction() {
+        return this.#channel._callScoped('getSystemInstruction', [], this.#conversationId);
+    }
+    async setSystemInstruction(instruction) {
+        await this.#channel._callScoped('setSystemInstruction', [instruction], this.#conversationId);
+    }
+    async rename(name) {
+        await this.#channel._callScoped('renameConversation', [name], this.#conversationId);
+    }
     // Object operations
-    findObjects(options) { return this.#handle.findObjects(options); }
-    createObject(options) { return this.#handle.createObject(options); }
-    updateObject(objectId, options) { return this.#handle.updateObject(objectId, options); }
-    deleteObjects(objectIds) { return this.#handle.deleteObjects(objectIds); }
+    async findObjects(options) {
+        return this.#channel._callScoped('findObjects', [options], this.#conversationId);
+    }
+    async createObject(options) {
+        return this.#channel._callScoped('createObject', [options], this.#conversationId);
+    }
+    async updateObject(objectId, options) {
+        return this.#channel._callScoped('updateObject', [objectId, options], this.#conversationId);
+    }
+    async deleteObjects(objectIds) {
+        await this.#channel._callScoped('deleteObjects', [objectIds], this.#conversationId);
+    }
     // AI
-    prompt(text, options) { return this.#handle.prompt(text, options); }
+    async prompt(text, options) {
+        return this.#channel._callScoped('prompt', [text, options], this.#conversationId);
+    }
     // Schema
-    createCollection(name, fields) { return this.#handle.createCollection(name, fields); }
-    alterCollection(name, fields) { return this.#handle.alterCollection(name, fields); }
-    dropCollection(name) { return this.#handle.dropCollection(name); }
+    async createCollection(name, fields) {
+        return this.#channel._callScoped('createCollection', [name, fields], this.#conversationId);
+    }
+    async alterCollection(name, fields) {
+        return this.#channel._callScoped('alterCollection', [name, fields], this.#conversationId);
+    }
+    async dropCollection(name) {
+        await this.#channel._callScoped('dropCollection', [name], this.#conversationId);
+    }
     // Metadata
-    setMetadata(key, value) { return this.#handle.setMetadata(key, value); }
+    async setMetadata(key, value) {
+        await this.#channel._callScoped('setMetadata', [key, value], this.#conversationId);
+    }
     /**
      * Stop listening for updates and clean up.
      */
@@ -352,17 +587,47 @@ class ReactiveConversationHandleImpl {
     }
 }
 // ---------------------------------------------------------------------------
-// initExtension (reactive version)
+// initExtension
 // ---------------------------------------------------------------------------
-import { initExtension as initBridge } from './client.js';
 /**
  * Initialize the extension and return a reactive channel.
  *
  * Sends `rool:ready` to the host, waits for the handshake, and returns
  * a reactive channel with $state properties (interactions, objectIds)
  * and reactive primitives (object(), watch()).
+ *
+ * If the extension is opened directly (not in an iframe), redirects to the Rool
+ * console with `?openExtension={extensionId}` so the user can install or navigate to it.
+ *
+ * @param timeout - How long to wait for the handshake (ms). Default: 10000.
  */
-export async function initExtension(timeout) {
-    const bridge = await initBridge(timeout);
-    return new ReactiveChannelImpl(bridge);
+export function initExtension(timeout = 10000) {
+    // Deep link: if not in an iframe, redirect to the Rool console
+    if (window.self === window.top) {
+        const host = window.location.hostname;
+        const dot = host.indexOf('.');
+        if (dot > 0) {
+            const extensionId = host.slice(0, dot);
+            const domain = host.slice(dot + 1);
+            window.location.href = `https://${domain}/?openExtension=${extensionId}`;
+        }
+        // Never resolve — the redirect will unload the page
+        return new Promise(() => { });
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            window.removeEventListener('message', onMessage);
+            reject(new Error('Extension handshake timed out — is this running inside a Rool host?'));
+        }, timeout);
+        function onMessage(event) {
+            if (!isBridgeMessage(event.data) || event.data.type !== 'rool:init')
+                return;
+            clearTimeout(timer);
+            window.removeEventListener('message', onMessage);
+            resolve(new ReactiveChannelImpl(event.data));
+        }
+        window.addEventListener('message', onMessage);
+        // Signal to the host that we're ready
+        window.parent.postMessage({ type: 'rool:ready' }, '*');
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rool-dev/extension",
-  "version": "0.3.7-dev.2ccb343",
+  "version": "0.3.7-dev.d9f341e",
   "description": "Svelte-first extension SDK for Rool — reactive channel over iframe bridge",
   "type": "module",
   "svelte": "./dist/index.js",
@@ -57,7 +57,7 @@
     "archiver": "^7.0.1",
     "tailwindcss": "^4.2.2",
     "vite": "^8.0.0",
-    "@rool-dev/sdk": "0.3.7-dev.2ccb343"
+    "@rool-dev/sdk": "0.3.7-dev.d9f341e"
   },
   "devDependencies": {
     "@sveltejs/package": "^2.5.7",