@rool-dev/sdk 0.11.15 → 0.12.0-dev.2daa829

package/dist/space.js

@@ -1,188 +1,537 @@
+import { EventEmitter } from './event-emitter.js';
 import { SpaceSubscriptionManager } from './subscription.js';
-import { SpaceOperations } from './space-session.js';
-import { RoolWebDAV } from './webdav.js';
-import { machinePath } from './path.js';
-/**
- * A space is a container for objects, schema, metadata, and conversations.
- *
- * RoolSpace owns the real-time SSE subscription for the space and exposes
- * space-level object, schema, metadata, and AI operations.
- *
- * Call close() when done to stop the subscription.
- */
-export class RoolSpace extends SpaceOperations {
-    _memberCount;
+import { ConversationHandle, generateEntityId } from './space-session.js';
+import { RoolWebDAV, WebDAVError } from './webdav.js';
+import { isObjectPath, machinePath, machineUri } from './path.js';
+const GET_OBJECTS_CHUNK_SIZE = 500;
+function objectPath(input) {
+    const path = machinePath(input);
+    if (!isObjectPath(path)) {
+        throw new Error(`Object path must be /space/<collection>/<name>.json without dotfiles: ${input}`);
+    }
+    return path;
+}
+function collectionPath(name) {
+    return machinePath(`/space/${name}`);
+}
+function schemaPath(name) {
+    return `${collectionPath(name)}/.schema.json`;
+}
+function objectFromBody(path, body) {
+    return { path, body };
+}
+function jsonObject(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be a JSON object`);
+    }
+    return value;
+}
+function patchBody(current, patch) {
+    const next = { ...current };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null || value === undefined)
+            delete next[key];
+        else
+            next[key] = value;
+    }
+    return next;
+}
+function collectionDef(input, options) {
+    const base = Array.isArray(input)
+        ? { fields: input }
+        : { fields: input.fields, schemaOrgType: input.schemaOrgType };
+    const schemaOrgType = options?.schemaOrgType ?? base.schemaOrgType;
+    return schemaOrgType ? { fields: base.fields, schemaOrgType } : { fields: base.fields };
+}
+function attachmentBody(file) {
+    if (isFile(file)) {
+        return {
+            filename: safeAttachmentFilename(file.name, file.type),
+            contentType: file.type || 'application/octet-stream',
+            body: file,
+        };
+    }
+    if (isBlob(file)) {
+        const contentType = file.type || 'application/octet-stream';
+        return {
+            filename: safeAttachmentFilename('attachment', contentType),
+            contentType,
+            body: file,
+        };
+    }
+    return {
+        filename: safeAttachmentFilename(file.filename ?? 'attachment', file.contentType),
+        contentType: file.contentType,
+        body: base64Body(file.data),
+    };
+}
+function isFile(value) {
+    return typeof File !== 'undefined' && value instanceof File;
+}
+function isBlob(value) {
+    return typeof Blob !== 'undefined' && value instanceof Blob;
+}
+function safeAttachmentFilename(name, contentType) {
+    const fallback = `attachment.${extensionForContentType(contentType)}`;
+    const leaf = name.split(/[/\\]/).pop() || fallback;
+    const cleaned = leaf.replace(/[\x00-\x1f\x7f]/g, '').replace(/\s+/g, '_');
+    return cleaned.replace(/[^A-Za-z0-9._-]/g, '_').replace(/^\.+$/, '') || fallback;
+}
+function extensionForContentType(contentType) {
+    if (contentType === 'image/png')
+        return 'png';
+    if (contentType === 'image/jpeg')
+        return 'jpg';
+    if (contentType === 'image/gif')
+        return 'gif';
+    if (contentType === 'image/webp')
+        return 'webp';
+    if (contentType === 'image/svg+xml')
+        return 'svg';
+    if (contentType === 'application/pdf')
+        return 'pdf';
+    if (contentType === 'text/markdown')
+        return 'md';
+    if (contentType === 'text/plain')
+        return 'txt';
+    if (contentType === 'text/csv')
+        return 'csv';
+    if (contentType === 'text/html')
+        return 'html';
+    if (contentType === 'application/json')
+        return 'json';
+    if (contentType === 'application/xml')
+        return 'xml';
+    return 'bin';
+}
+function base64Body(data) {
+    const clean = data.includes(',') ? data.slice(data.indexOf(',') + 1) : data;
+    if (typeof Buffer !== 'undefined') {
+        const buffer = Buffer.from(clean, 'base64');
+        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    }
+    const binary = atob(clean);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes.buffer;
+}
+/** An imperative API handle for one open space. */
+export class RoolSpace extends EventEmitter {
+    _id;
+    _openSpaceResult;
+    _connectionState = 'reconnecting';
+    _closed = false;
+    _graphqlClient;
+    _restClient;
+    _webdav;
+    _logger;
     authManager;
     router;
     _route;
     onCloseCallback;
     clientInfo;
-    // Subscription
     subscriptionManager = null;
-    _resyncing = false;
-    _resyncPending = false;
-    _resyncTimer = null;
-    _subscriptionReady = null;
     constructor(config) {
-        let self;
-        const webdav = new RoolWebDAV({
+        super();
+        this._id = config.id;
+        this._openSpaceResult = config.openSpaceResult;
+        this._graphqlClient = config.graphqlClient;
+        this._restClient = config.restClient;
+        this._logger = config.logger;
+        this._emitterLogger = config.logger;
+        this.authManager = config.authManager;
+        this.router = config.router;
+        this._route = config.initialRoute;
+        this.onCloseCallback = config.onClose;
+        this.clientInfo = config.clientInfo;
+        this._webdav = new RoolWebDAV({
             webdavUrl: config.initialRoute.server,
             spaceId: config.id,
             authManager: config.authManager,
             clientInfo: config.clientInfo,
             onRefused: async () => {
-                await self.reroute();
-                return self._route.server;
+                await this.reroute();
+                return this._route.server;
             },
         });
-        super({
-            id: config.id,
-            name: config.name,
-            role: config.role,
-            userId: config.userId,
-            conversationMeta: config.fullData.conversationMeta,
-            graphqlClient: config.graphqlClient,
-            restClient: config.restClient,
-            webdav,
-            logger: config.logger,
-            onClose: () => { },
-        });
-        this.clientInfo = config.clientInfo;
-        self = this;
-        this._memberCount = config.memberCount;
-        this.authManager = config.authManager;
-        this.router = config.router;
-        this._route = config.initialRoute;
-        this.onCloseCallback = config.onClose;
         this._graphqlClient.setOnRefused(() => this.reroute());
         this._restClient.setOnRefused(async () => {
             await this.reroute();
             return this._route.server;
         });
-        // Start subscription
         this.startSubscription();
     }
     get id() { return this._id; }
-    get name() { return this._name; }
-    get role() { return this._role; }
-    get userId() { return this._userId; }
-    get spaceId() { return this._id; }
-    get spaceName() { return this._name; }
-    get isReadOnly() { return this._role === 'viewer'; }
-    get memberCount() { return this._memberCount; }
+    get name() { return this._openSpaceResult.name; }
+    get role() { return this._openSpaceResult.role; }
+    get isReadOnly() { return this.role === 'viewer'; }
+    get memberCount() { return this._openSpaceResult.memberCount; }
+    get openSpaceResult() { return this._openSpaceResult; }
+    get connectionState() { return this._connectionState; }
     get route() { return this._route; }
-    /** WebDAV client for this space's user-visible files and object filesystem. */
-    get webdav() {
-        return this._webdav;
-    }
-    /** Return file-storage quota usage for this space. */
-    async getStorageUsage() {
-        return this.webdav.getStorageUsage();
-    }
-    /** Fetch a user-visible file path through the current space. */
-    async fetchPath(path, options) {
-        const canonical = machinePath(path);
-        if (!canonical.startsWith('/rool-drive/'))
-            throw new Error('Path is not a fetchable file');
-        return this.webdav.get(canonical, options);
-    }
-    /** Lightweight conversation roster (no interaction bodies). */
-    get conversations() { return this._conversationMeta; }
-    startSubscription() {
-        let firstProbe = true;
-        this.subscriptionManager = new SpaceSubscriptionManager({
-            getGraphqlUrl: async () => {
-                if (firstProbe) {
-                    firstProbe = false;
-                    return this._graphqlClient.graphqlUrl;
-                }
-                return this.reroute();
-            },
-            authManager: this.authManager,
-            logger: this._logger,
-            clientInfo: this.clientInfo,
-            spaceId: this._id,
-            onEvent: (event) => this.handleSpaceEvent(event),
-            onConnectionStateChanged: (state) => {
-                this.emit('connectionStateChanged', state);
-            },
-            onError: (error) => {
-                this._logger.error(`[RoolSpace] Space ${this._id} subscription error:`, error);
-            },
-        });
-        this._subscriptionReady = this.subscriptionManager.subscribe();
-        // .catch prevents a rejection here from crashing Node before the caller awaits it.
-        this._subscriptionReady.catch(() => { });
+    get webdav() { return this._webdav; }
+    async refresh() {
+        this._openSpaceResult = await this._graphqlClient.openSpace(this._id);
+        return this._openSpaceResult;
     }
-    async reroute() {
-        const route = await this.router.resolve(this._id);
-        this._route = route;
-        this._webdav.setWebDAVUrl(route.server);
-        this._restClient.setApiUrl(route.server);
-        const url = `${route.server.replace(/\/+$/, '')}/graphql`;
-        this._graphqlClient.setGraphqlUrl(url);
-        return url;
+    async listConversations() {
+        return (await this.refresh()).conversationMeta;
     }
-    /** Get a handle for a conversation in this space. */
     conversation(conversationId) {
         if (!conversationId || conversationId.length > 32 || !/^[a-zA-Z0-9_-]+$/.test(conversationId)) {
             throw new Error('conversationId must be 1–32 characters containing only alphanumeric characters, hyphens, and underscores');
         }
-        return super.conversation(conversationId);
+        return new ConversationHandle(this, conversationId);
+    }
+    async getConversation(conversationId) {
+        return this._graphqlClient.getConversation(this._id, conversationId);
+    }
+    async deleteConversation(conversationId) {
+        await this._graphqlClient.deleteConversation(this._id, conversationId);
+    }
+    async createConversation(agent, visibility) {
+        return this._graphqlClient.createConversation(this._id, agent, visibility);
+    }
+    async listAgents() {
+        return this._graphqlClient.listAgents(this._id);
+    }
+    async deleteAgent(agent) {
+        await this._graphqlClient.deleteAgent(this._id, agent);
+    }
+    async canUndo() {
+        return (await this._graphqlClient.checkpointStatus(this._id)).canUndo;
+    }
+    async canRedo() {
+        return (await this._graphqlClient.checkpointStatus(this._id)).canRedo;
+    }
+    async undo() {
+        return (await this._graphqlClient.undo(this._id)).success;
+    }
+    async redo() {
+        return (await this._graphqlClient.redo(this._id)).success;
+    }
+    davHeaders(interactionId) {
+        const headers = new Headers();
+        if (interactionId)
+            headers.set('X-Rool-Interaction-Id', interactionId);
+        return headers;
+    }
+    async readObject(path) {
+        const canonical = objectPath(path);
+        try {
+            const response = await this._webdav.get(canonical);
+            const body = jsonObject(await response.json(), `Object ${canonical}`);
+            return { object: objectFromBody(canonical, body), etag: response.headers.get('ETag') };
+        }
+        catch (error) {
+            if (error instanceof WebDAVError && error.status === 404)
+                return undefined;
+            if (error instanceof SyntaxError)
+                throw new Error(`Object ${canonical} did not contain valid JSON`);
+            throw error;
+        }
+    }
+    /** Get an object JSON file by machine path. Fetches from the server on each call. */
+    async getObject(path) {
+        return (await this.readObject(path))?.object;
+    }
+    /** Get object JSON files by machine path in bulk. Duplicate paths are fetched once. */
+    async getObjects(paths) {
+        const canonical = [];
+        const seen = new Set();
+        for (const path of paths) {
+            const normalized = objectPath(path);
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            canonical.push(normalized);
+        }
+        const result = { objects: [], missing: [] };
+        for (let i = 0; i < canonical.length; i += GET_OBJECTS_CHUNK_SIZE) {
+            const chunk = canonical.slice(i, i + GET_OBJECTS_CHUNK_SIZE);
+            const partial = await this._restClient.getObjects(this._id, chunk);
+            result.objects.push(...partial.objects);
+            result.missing.push(...partial.missing);
+        }
+        return result;
+    }
+    /** Create or replace an object JSON file. */
+    async putObject(path, body) {
+        const canonical = objectPath(path);
+        const optimistic = objectFromBody(canonical, body);
+        try {
+            const interactionId = generateEntityId();
+            await this._webdav.put(canonical, JSON.stringify(body), {
+                contentType: 'application/json',
+                headers: this.davHeaders(interactionId),
+            });
+            const fresh = await this.getObject(canonical) ?? optimistic;
+            return { object: fresh, message: `Put ${canonical}` };
+        }
+        catch (error) {
+            this._logger.error('[RoolSpace] Failed to put object:', error);
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    /** Patch an existing object JSON file. */
+    async patchObject(path, options) {
+        const canonical = objectPath(path);
+        const data = options.data ?? {};
+        const current = await this.readObject(canonical);
+        if (!current)
+            throw new Error(`Object ${canonical} not found`);
+        const body = patchBody(current.object.body, data);
+        const optimistic = objectFromBody(canonical, body);
+        try {
+            const interactionId = generateEntityId();
+            await this._webdav.put(canonical, JSON.stringify(body), {
+                contentType: 'application/json',
+                ifMatch: current.etag ?? undefined,
+                headers: this.davHeaders(interactionId),
+            });
+            const fresh = await this.getObject(canonical) ?? optimistic;
+            return { object: fresh, message: `Patched ${canonical}` };
+        }
+        catch (error) {
+            this._logger.error('[RoolSpace] Failed to patch object:', error);
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    /** Move (rename/relocate) an object. */
+    async moveObject(from, to, options) {
+        const fromPath = objectPath(from);
+        const toPath = objectPath(to);
+        const optimistic = objectFromBody(toPath, options?.body ?? {});
+        try {
+            const interactionId = generateEntityId();
+            await this._webdav.move(fromPath, toPath, {
+                headers: this.davHeaders(interactionId),
+            });
+            if (options?.body) {
+                await this._webdav.put(toPath, JSON.stringify(options.body), {
+                    contentType: 'application/json',
+                    headers: this.davHeaders(interactionId),
+                });
+            }
+            const fresh = await this.getObject(toPath) ?? optimistic;
+            return { object: fresh, message: `Moved ${fromPath} to ${toPath}` };
+        }
+        catch (error) {
+            this._logger.error('[RoolSpace] Failed to move object:', error);
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    /** Delete object JSON files by path. */
+    async deleteObjects(paths) {
+        if (paths.length === 0)
+            return;
+        const canonical = paths.map(objectPath);
+        try {
+            const interactionId = generateEntityId();
+            for (const path of canonical) {
+                await this._webdav.delete(path, {
+                    headers: this.davHeaders(interactionId),
+                });
+            }
+        }
+        catch (error) {
+            this._logger.error('[RoolSpace] Failed to delete paths:', error);
+            this.emit('syncError', error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
     }
     /**
-     * Rename this space.
+     * Read space metadata from `/space/.meta.json`. Returns `{}` when the space has
+     * no metadata file yet. Stateless — callers (e.g. a reactive wrapper) cache and
+     * re-fetch this on their own schedule, typically when a file-tree sync reports
+     * the node changed.
      */
-    async rename(newName) {
-        await this._graphqlClient.renameSpace(this._id, newName);
-        this._name = newName;
+    async readMeta() {
+        try {
+            const response = await this._webdav.get('/space/.meta.json');
+            return jsonObject(await response.json(), 'space meta');
+        }
+        catch (error) {
+            if (error instanceof WebDAVError && error.status === 404)
+                return {};
+            throw error;
+        }
     }
     /**
-     * Delete this space permanently. Cannot be undone.
+     * Write the full metadata blob to `/space/.meta.json`, attributed to a
+     * conversation. Callers compose the blob (e.g. read-merge-write) — this does no
+     * merging.
      */
-    async delete() {
-        await this._graphqlClient.deleteSpace(this._id);
+    async writeMeta(meta) {
+        await this._webdav.put('/space/.meta.json', JSON.stringify(meta), {
+            contentType: 'application/json',
+            headers: this.davHeaders(generateEntityId()),
+        });
     }
     /**
-     * List users with access to this space.
+     * Read the collection schema: one `/space/<name>/.schema.json` per collection
+     * directory under `/space`. Returns `{}` for a space with no collections.
+     * Stateless — reactive callers re-fetch when a `.schema.json` node changes.
      */
-    async listUsers() {
-        return this._graphqlClient.listSpaceUsers(this._id);
+    async readSchema() {
+        const listing = await this._webdav.propfind('/space', { depth: '1', props: ['resourcetype'] });
+        const collections = listing.responses
+            .filter((r) => r.isCollection && r.path !== '/space')
+            .map((r) => r.path.split('/').pop());
+        const entries = await Promise.all(collections.map(async (name) => {
+            try {
+                const response = await this._webdav.get(`/space/${name}/.schema.json`);
+                return [name, jsonObject(await response.json(), `schema ${name}`)];
+            }
+            catch (error) {
+                if (error instanceof WebDAVError && error.status === 404)
+                    return null;
+                throw error;
+            }
+        }));
+        const schema = {};
+        for (const entry of entries)
+            if (entry)
+                schema[entry[0]] = entry[1];
+        return schema;
+    }
+    /** Create a new collection (MKCOL + schema JSON). */
+    async createCollection(name, fields, options) {
+        const def = collectionDef(fields, options);
+        await this._webdav.mkcol(collectionPath(name), { headers: this.davHeaders(generateEntityId()) });
+        await this._webdav.put(schemaPath(name), JSON.stringify(def), {
+            contentType: 'application/json',
+            headers: this.davHeaders(generateEntityId()),
+        });
+        return def;
+    }
+    /** Alter an existing collection's schema JSON. */
+    async alterCollection(name, fields, options) {
+        const def = collectionDef(fields, options);
+        await this._webdav.put(schemaPath(name), JSON.stringify(def), {
+            contentType: 'application/json',
+            headers: this.davHeaders(generateEntityId()),
+        });
+        return def;
+    }
+    /** Drop a collection (DELETE). */
+    async dropCollection(name) {
+        await this._webdav.delete(collectionPath(name), { collection: true, headers: this.davHeaders(generateEntityId()) });
+    }
+    /** @internal */
+    async _updateConversation(conversationId, options) {
+        await this._graphqlClient.updateConversation(this._id, conversationId, options);
+    }
+    /** @internal */
+    async _prompt(prompt, conversationId, options) {
+        const { attachments, signal, interactionId = generateEntityId(), parentInteractionId = null, ...rest } = options ?? {};
+        let attachmentRefs;
+        if (attachments?.length) {
+            attachmentRefs = await Promise.all(attachments.map(async (attachment) => {
+                const path = typeof attachment === 'string' ? machinePath(attachment) : await this.uploadAttachment(attachment, conversationId);
+                return machineUri(path);
+            }));
+        }
+        let onAbort;
+        if (signal) {
+            if (signal.aborted) {
+                this.stopConversation(conversationId).catch(() => { });
+            }
+            else {
+                onAbort = () => {
+                    this.stopConversation(conversationId).catch(() => { });
+                };
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+        }
+        let result;
+        try {
+            result = await this._graphqlClient.prompt(this._id, prompt, conversationId, {
+                ...rest,
+                attachmentRefs,
+                interactionId,
+                parentInteractionId,
+            });
+        }
+        finally {
+            if (onAbort)
+                signal.removeEventListener('abort', onAbort);
+        }
+        const objects = [];
+        const fetched = await Promise.all(result.modifiedObjectPaths.map((path) => this.getObject(path)));
+        for (const object of fetched) {
+            if (object)
+                objects.push(object);
+        }
+        return {
+            message: result.message,
+            objects,
+            creditsUsed: result.creditsUsed,
+        };
     }
     /**
-     * Change an existing member's role. New members join via invites.
+     * Stop whatever is running in a conversation. A conversation processes one
+     * run at a time, so no interaction handle is needed.
+     *
+     * Returns whether anything was actually running.
      */
-    async setUserRole(userId, role) {
-        return this._graphqlClient.setSpaceUserRole(this._id, userId, role);
+    async stopConversation(conversationId) {
+        return this._graphqlClient.stopConversation(this._id, conversationId);
     }
     /**
-     * Remove a user from this space.
+     * Fetch an external URL via the server proxy, bypassing CORS restrictions.
      */
+    async fetch(url, init) {
+        return this._restClient.proxyFetch(this._id, url, init);
+    }
+    async uploadAttachment(file, conversationId) {
+        const attachment = attachmentBody(file);
+        const path = `/rool-drive/attachments/${conversationId}/${attachment.filename}`;
+        // createParents avoids racing MKCOLs when multiple attachments upload concurrently.
+        await this._webdav.put(path, attachment.body, {
+            contentType: attachment.contentType,
+            createParents: true,
+        });
+        return path;
+    }
+    async getStorageUsage() {
+        return this._webdav.getStorageUsage();
+    }
+    async fetchPath(path, options) {
+        const canonical = machinePath(path);
+        if (!canonical.startsWith('/rool-drive/'))
+            throw new Error('Path is not a fetchable file');
+        return this._webdav.get(canonical, options);
+    }
+    async rename(newName) {
+        await this._graphqlClient.renameSpace(this._id, newName);
+        this._openSpaceResult = { ...this._openSpaceResult, name: newName };
+    }
+    async delete() {
+        await this._graphqlClient.deleteSpace(this._id);
+    }
+    async listUsers() {
+        return this._graphqlClient.listSpaceUsers(this._id);
+    }
+    async setUserRole(userId, role) {
+        await this._graphqlClient.setSpaceUserRole(this._id, userId, role);
+    }
     async removeUser(userId) {
-        return this._graphqlClient.removeSpaceUser(this._id, userId);
+        await this._graphqlClient.removeSpaceUser(this._id, userId);
     }
-    /**
-     * Mint an invite link for this space. Requires owner or admin role.
-     * With `email` set, the invite is single-use, guarded to that address,
-     * and sent to it by mail. The returned `url` contains the secret token
-     * and is only available here.
-     */
     async createInvite(role, options) {
         return this._graphqlClient.createSpaceInvite(this._id, role, options);
     }
-    /**
-     * List this space's currently redeemable invites. Requires owner or admin role.
-     */
     async listInvites() {
         return this._graphqlClient.listSpaceInvites(this._id);
     }
-    /**
-     * Revoke an invite so its link stops working. Requires owner or admin role.
-     */
     async revokeInvite(inviteId) {
         return this._graphqlClient.revokeSpaceInvite(this._id, inviteId);
     }
-    // Targets the owning shard
     async exportArchive() {
         const tokens = await this.authManager.getTokens();
         if (!tokens)
@@ -204,45 +553,53 @@ export class RoolSpace extends SpaceOperations {
         }
         return response.blob();
     }
-    /**
-     * Refresh space data from the server.
-     * Updates name, role, conversation list, and all cached data.
-     */
-    async refresh() {
-        const data = await this._graphqlClient.openSpaceFull(this._id);
-        this.applyFullData(data);
-    }
-    /**
-     * Close the space subscription.
-     */
     close() {
+        if (this._closed)
+            return;
         this._closed = true;
-        if (this._resyncTimer) {
-            clearTimeout(this._resyncTimer);
-            this._resyncTimer = null;
-        }
-        // Stop subscription
-        if (this.subscriptionManager) {
-            this.subscriptionManager.destroy();
-            this.subscriptionManager = null;
-            this._subscriptionReady = null;
-        }
+        this.subscriptionManager?.destroy();
+        this.subscriptionManager = null;
         this.removeAllListeners();
         this.onCloseCallback();
     }
-    /**
-     * Handle a space event from the SSE subscription.
-     *
-     * Only a reconnect resyncs conversation history (we may have missed
-     * `conversation_updated` events while disconnected). File changes are not a
-     * conversation signal — they just notify file/WebDAV consumers to sync, which
-     * the reactive file tree does at path granularity via `sync-collection`.
-     */
+    startSubscription() {
+        let firstProbe = true;
+        this.subscriptionManager = new SpaceSubscriptionManager({
+            getGraphqlUrl: async () => {
+                if (firstProbe) {
+                    firstProbe = false;
+                    return this._graphqlClient.graphqlUrl;
+                }
+                return this.reroute();
+            },
+            authManager: this.authManager,
+            logger: this._logger,
+            clientInfo: this.clientInfo,
+            spaceId: this._id,
+            onEvent: (event) => this.handleSpaceEvent(event),
+            onConnectionStateChanged: (state) => {
+                this._connectionState = state;
+                this.emit('connectionStateChanged', state);
+            },
+            onError: (error) => this._logger.error(`[RoolSpace] Space ${this._id} subscription error:`, error),
+        });
+        void this.subscriptionManager.subscribe().catch((error) => {
+            if (!this._closed)
+                this._logger.error(`[RoolSpace] Space ${this._id} subscription failed:`, error);
+        });
+    }
+    async reroute() {
+        const route = await this.router.resolve(this._id);
+        this._route = route;
+        this._webdav.setWebDAVUrl(route.server);
+        this._restClient.setApiUrl(route.server);
+        const url = `${route.server.replace(/\/+$/, '')}/graphql`;
+        this._graphqlClient.setGraphqlUrl(url);
+        return url;
+    }
     handleSpaceEvent(event) {
-        if (event.type === 'connected') {
-            this.handleResync();
+        if (this._closed || event.type === 'connected')
             return;
-        }
         if (event.type === 'space_files_changed') {
             this.emit('filesChanged', { spaceId: event.spaceId, source: event.source, timestamp: event.timestamp });
             return;
@@ -251,63 +608,14 @@ export class RoolSpace extends SpaceOperations {
             this.emit('filesReset', { spaceId: event.spaceId, source: event.source, timestamp: event.timestamp });
             return;
         }
-        this._handleEvent(event);
-    }
-    // Reconnect resync: refetch conversation history and apply it. Retries until it
-    // lands — a single failure used to leave the client empty until reload.
-    // Single-flight: an event arriving mid-resync sets _resyncPending so we re-run
-    // once afterward, ensuring the final state reflects the latest server state.
-    handleResync() {
-        if (this._resyncing) {
-            this._resyncPending = true;
+        if (event.type !== 'conversation_updated' || !event.conversationId)
             return;
-        }
-        this._resyncing = true;
-        this._resyncWithRetry(0);
-    }
-    _resyncWithRetry(attempt) {
-        this._resyncTimer = null;
-        if (this._closed) {
-            this._resyncing = false;
-            return;
-        }
-        void this._graphqlClient.openSpaceFull(this._id).then((result) => {
-            if (this._closed) {
-                this._resyncing = false;
-                return;
-            }
-            this.applyFullData(result);
-            this._logger.info(`[RoolSpace] Space ${this._id} resync complete`);
-            this._finishResync();
-        }).catch((error) => {
-            if (this._closed) {
-                this._resyncing = false;
-                return;
-            }
-            const ms = Math.min(1000 * 2 ** attempt, 30000);
-            this._logger.error(`[RoolSpace] Space ${this._id} resync failed (attempt ${attempt + 1}), retrying in ${ms}ms:`, error);
-            this._resyncTimer = setTimeout(() => this._resyncWithRetry(attempt + 1), ms);
+        this.emit('conversationUpdated', {
+            conversationId: event.conversationId,
+            conversation: event.conversation ?? null,
+            source: event.source === 'agent' ? 'remote_agent' : 'remote_user',
+            timestamp: event.timestamp,
         });
     }
-    // Clear in-flight flag; if an event arrived mid-resync, run one more pass.
-    _finishResync() {
-        this._resyncing = false;
-        if (this._resyncPending && !this._closed) {
-            this._resyncPending = false;
-            this.handleResync();
-        }
-    }
-    /**
-     * Apply resynced space data from the server (reconnect). Refetches the
-     * conversation roster and reloads any live conversation handles — we may have
-     * missed SSE updates while disconnected.
-     */
-    applyFullData(data) {
-        this._name = data.name;
-        this._role = data.role;
-        this._memberCount = data.memberCount;
-        this._conversationMeta = data.conversationMeta;
-        this.emit('reset', { source: 'system' });
-    }
 }
 //# sourceMappingURL=space.js.map