@meshagent/meshagent 0.29.2 → 0.30.0

package/dist/esm/sync-client.js

@@ -1,8 +1,8 @@
 import { EventEmitter } from "./event-emitter";
 import { MeshSchema } from "./schema";
-import { StreamController } from "./stream-controller";
 import { MeshDocument, RoomServerException } from "./room-server-client";
-import { splitMessageHeader, splitMessagePayload, decoder, encoder, RefCount } from "./utils";
+import { BinaryContent, ControlContent, ErrorContent } from "./response";
+import { decoder, encoder, RefCount, unpackMessage } from "./utils";
 import { unregisterDocument, applyBackendChanges } from "./runtime";
 import { Completer } from "./completer";
 function normalizeSyncPath(path) {
@@ -18,98 +18,251 @@ function normalizeSyncPath(path) {
     }
     return normalized;
 }
-;
-export class QueuedSync {
-    constructor({ path, base64 }) {
-        this.path = path;
-        this.base64 = base64;
+function parseSyncOpenStateChunkHeaders(headers) {
+    if (headers["kind"] !== "state" ||
+        typeof headers["path"] !== "string" ||
+        typeof headers["schema"] !== "object" ||
+        headers["schema"] == null) {
+        throw new RoomServerException("unexpected return type from sync.open");
     }
+    return {
+        kind: "state",
+        path: headers["path"],
+        schema: headers["schema"],
+    };
 }
+function parseSyncOpenOutputChunkHeaders(headers) {
+    const kind = headers["kind"];
+    if ((kind !== "state" && kind !== "sync") ||
+        typeof headers["path"] !== "string") {
+        throw new RoomServerException("unexpected return type from sync.open");
+    }
+    return {
+        kind,
+        path: headers["path"],
+    };
+}
+class SyncOpenStreamState {
+    constructor(params) {
+        this.params = params;
+        this._inputQueue = [];
+        this._inputWaiters = [];
+        this._inputClosed = false;
+    }
+    _enqueueChunk(chunk) {
+        const waiter = this._inputWaiters.shift();
+        if (waiter) {
+            waiter(chunk);
+            return;
+        }
+        this._inputQueue.push(chunk);
+    }
+    _nextChunk() {
+        const queued = this._inputQueue.shift();
+        if (queued !== undefined) {
+            return Promise.resolve(queued);
+        }
+        return new Promise((resolve) => {
+            this._inputWaiters.push(resolve);
+        });
+    }
+    async *inputStream() {
+        yield new BinaryContent({
+            data: new Uint8Array(),
+            headers: {
+                kind: "start",
+                path: this.params.path,
+                create: this.params.create,
+                vector: this.params.vector,
+                schema: this.params.schemaJson,
+                schema_path: this.params.schemaPath,
+                initial_json: this.params.initialJson,
+            },
+        });
+        while (true) {
+            const chunk = await this._nextChunk();
+            if (chunk === SyncOpenStreamState.INPUT_STREAM_CLOSE) {
+                return;
+            }
+            yield chunk;
+        }
+    }
+    attachTask(task) {
+        this._task = task
+            .catch((error) => {
+            this._error = error;
+            throw error;
+        })
+            .finally(() => {
+            this.closeInputStream();
+        });
+        void this._task.catch(() => undefined);
+    }
+    closeInputStream() {
+        if (this._inputClosed) {
+            return;
+        }
+        this._inputClosed = true;
+        this._enqueueChunk(SyncOpenStreamState.INPUT_STREAM_CLOSE);
+    }
+    queueSync(data) {
+        if (this._error instanceof Error) {
+            throw this._error;
+        }
+        if (this._error !== undefined) {
+            throw new RoomServerException(`sync stream failed: ${String(this._error)}`);
+        }
+        if (this._inputClosed) {
+            throw new RoomServerException("attempted to sync to a document that is not connected");
+        }
+        this._enqueueChunk(new BinaryContent({
+            data,
+            headers: { kind: "sync" },
+        }));
+    }
+    async wait() {
+        await this._task;
+    }
+}
+SyncOpenStreamState.INPUT_STREAM_CLOSE = Symbol("sync-open-input-close");
 export class SyncClient extends EventEmitter {
     constructor({ room }) {
         super();
         this._connectingDocuments = {};
-        this._changesToSync = new StreamController();
         this._connectedDocuments = {};
+        this._documentStreams = {};
         this.client = room;
-        this.client.protocol.addHandler("room.sync", this._handleSync.bind(this));
         this.client.protocol.addHandler("room.status", this._handleStatus.bind(this));
     }
+    _unexpectedResponseError(operation) {
+        return new RoomServerException(`unexpected return type from sync.${operation}`);
+    }
+    async _invoke(operation, input) {
+        return await this.client.invoke({
+            toolkit: "sync",
+            tool: operation,
+            input,
+        });
+    }
     start({ onDone, onError } = {}) {
         this.client.protocol.start({ onDone, onError });
-        (async () => {
-            for await (const message of this._changesToSync.stream) {
-                await this.client.sendRequest("room.sync", { path: message.path }, encoder.encode(message.base64));
-            }
-        })();
     }
     dispose() {
         super.dispose();
-        this._changesToSync.close();
-    }
-    async _handleSync(protocol, messageId, data, bytes) {
-        const headerStr = splitMessageHeader(bytes || new Uint8Array());
-        const payload = splitMessagePayload(bytes || new Uint8Array());
-        const header = JSON.parse(headerStr);
-        const path = normalizeSyncPath(header["path"]);
-        const isConnecting = this._connectingDocuments[path];
-        if (isConnecting) {
-            await isConnecting;
-        }
-        if (this._connectedDocuments[path]) {
-            const rc = this._connectedDocuments[path];
-            const doc = rc.ref;
+        for (const streamState of Object.values(this._documentStreams)) {
+            streamState.closeInputStream();
+        }
+        this._documentStreams = {};
+        for (const rc of Object.values(this._connectedDocuments)) {
+            unregisterDocument(rc.ref.id);
+        }
+        this._connectedDocuments = {};
+        this._connectingDocuments = {};
+    }
+    _applySyncPayload(rc, payload) {
+        const doc = rc.ref;
+        if (payload.length > 0) {
             const base64 = decoder.decode(payload);
             applyBackendChanges(doc.id, base64);
-            this.emit("synced", { type: "sync", doc });
-            if (!doc.isSynchronized) {
-                doc.setSynchronizedComplete();
-            }
         }
-        else {
-            throw new RoomServerException(`received change for a document that is not connected: ${path}`);
+        this.emit("synced", { type: "sync", doc });
+        if (!doc.isSynchronized) {
+            doc.setSynchronizedComplete();
         }
     }
-    async _handleStatus(protocol, messageId, data, bytes) {
-        const headerStr = splitMessageHeader(bytes || new Uint8Array());
-        const header = JSON.parse(headerStr);
-        this.emit("status", header.status);
+    async _handleStatus(_protocol, _messageId, _type, bytes) {
+        if (!bytes) {
+            return;
+        }
+        const [header] = unpackMessage(bytes);
+        this.emit("status", { type: "status", status: header.status });
     }
     async create(path, json) {
-        path = normalizeSyncPath(path);
-        await this.client.sendRequest("room.create", { path, json });
+        const normalizedPath = normalizeSyncPath(path);
+        await this._invoke("create", {
+            path: normalizedPath,
+            json: json ?? null,
+            schema: null,
+            schema_path: null,
+        });
     }
-    async open(path, { create = true } = {}) {
+    async open(path, { create = true, initialJson, schema, } = {}) {
         path = normalizeSyncPath(path);
         const pending = this._connectingDocuments[path];
         if (pending) {
             await pending;
         }
-        if (this._connectedDocuments[path]) {
-            const rc = this._connectedDocuments[path];
-            rc.count++;
-            return rc.ref;
+        const connected = this._connectedDocuments[path];
+        if (connected) {
+            connected.count++;
+            return connected.ref;
         }
-        const c = new Completer();
-        this._connectingDocuments[path] = c.fut;
+        const connecting = new Completer();
+        this._connectingDocuments[path] = connecting.fut;
+        let streamState;
+        let iterator;
         try {
-            const result = (await this.client.sendRequest("room.connect", { path, create }));
-            const schema = MeshSchema.fromJson(result.json["schema"]);
+            streamState = new SyncOpenStreamState({
+                path,
+                create,
+                vector: null,
+                schemaJson: schema == null ? null : schema.toJson(),
+                schemaPath: null,
+                initialJson: initialJson ?? null,
+            });
+            const responseStream = await this.client.invokeStream({
+                toolkit: "sync",
+                tool: "open",
+                input: streamState.inputStream(),
+            });
+            iterator = responseStream[Symbol.asyncIterator]();
+            const first = await iterator.next();
+            if (first.done || first.value === undefined) {
+                throw new RoomServerException("sync.open stream closed before the initial document state was returned");
+            }
+            const firstChunk = first.value;
+            if (firstChunk instanceof ErrorContent) {
+                throw new RoomServerException(firstChunk.text, firstChunk.code);
+            }
+            if (!(firstChunk instanceof BinaryContent)) {
+                throw this._unexpectedResponseError("open");
+            }
+            const stateHeaders = parseSyncOpenStateChunkHeaders(firstChunk.headers);
+            if (normalizeSyncPath(stateHeaders.path) !== path) {
+                throw new RoomServerException("sync.open stream returned a mismatched path");
+            }
             const doc = new MeshDocument({
-                schema,
-                sendChangesToBackend: (base64Str) => {
-                    this._changesToSync.add({ path, base64: base64Str });
+                schema: MeshSchema.fromJson(stateHeaders.schema),
+                sendChangesToBackend: (base64) => {
+                    try {
+                        streamState?.queueSync(encoder.encode(base64));
+                    }
+                    catch {
+                    }
                 },
             });
             const rc = new RefCount(doc);
             this._connectedDocuments[path] = rc;
+            this._documentStreams[path] = streamState;
+            this._applySyncPayload(rc, firstChunk.data);
+            streamState.attachTask(this._consumeOpenStream({
+                path,
+                rc,
+                iterator,
+                streamState,
+            }));
             this.emit("connected", { type: "connect", doc });
-            c.complete();
+            connecting.complete(rc);
+            await doc.synchronized;
             return doc;
         }
-        catch (err) {
-            c.completeError(err);
-            throw err;
+        catch (error) {
+            streamState?.closeInputStream();
+            if (iterator) {
+                await iterator.return?.();
+            }
+            connecting.completeError(error);
+            throw error;
         }
         finally {
             delete this._connectingDocuments[path];
@@ -117,11 +270,6 @@ export class SyncClient extends EventEmitter {
     }
     async close(path) {
         path = normalizeSyncPath(path);
-        const pending = this._connectingDocuments[path];
-        if (pending) {
-            await pending;
-            await new Promise(resolve => setTimeout(resolve, 50));
-        }
         const rc = this._connectedDocuments[path];
         if (!rc) {
             throw new RoomServerException(`Not connected to ${path}`);
@@ -130,13 +278,64 @@ export class SyncClient extends EventEmitter {
         rc.count--;
         if (rc.count === 0) {
             delete this._connectedDocuments[path];
-            await this.client.sendRequest("room.disconnect", { path });
-            unregisterDocument(doc.id);
+            const streamState = this._documentStreams[path];
+            delete this._documentStreams[path];
+            if (streamState) {
+                streamState.closeInputStream();
+                try {
+                    await streamState.wait();
+                }
+                finally {
+                    unregisterDocument(doc.id);
+                }
+            }
+            else {
+                unregisterDocument(doc.id);
+            }
         }
         this.emit("closed", { type: "close", doc });
     }
     async sync(path, data) {
         path = normalizeSyncPath(path);
-        await this.client.sendRequest("room.sync", { path }, data);
+        if (!this._connectedDocuments[path]) {
+            throw new RoomServerException("attempted to sync to a document that is not connected");
+        }
+        const streamState = this._documentStreams[path];
+        if (!streamState) {
+            throw new RoomServerException("attempted to sync to a document that is not connected");
+        }
+        streamState.queueSync(data);
+    }
+    async _consumeOpenStream(params) {
+        try {
+            while (true) {
+                const next = await params.iterator.next();
+                if (next.done || next.value === undefined) {
+                    return;
+                }
+                const chunk = next.value;
+                if (chunk instanceof ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        return;
+                    }
+                    throw this._unexpectedResponseError("open");
+                }
+                if (!(chunk instanceof BinaryContent)) {
+                    throw this._unexpectedResponseError("open");
+                }
+                const headers = parseSyncOpenOutputChunkHeaders(chunk.headers);
+                if (normalizeSyncPath(headers.path) !== params.path) {
+                    throw new RoomServerException("sync.open stream returned a mismatched path");
+                }
+                this._applySyncPayload(params.rc, chunk.data);
+            }
+        }
+        finally {
+            params.streamState.closeInputStream();
+            await params.iterator.return?.();
+        }
     }
 }

package/dist/node/agent-client.js

@@ -173,38 +173,13 @@ class AgentsClient {
         this.client = room;
     }
     async call(params) {
-        await this.client.sendRequest("agent.call", params);
+        await this.client.call(params);
     }
     async listToolkits(params) {
-        const request = {};
-        if (params?.participantId != null) {
-            request["participant_id"] = params.participantId;
-        }
-        if (params?.participantName != null) {
-            request["participant_name"] = params.participantName;
-        }
-        if (params?.timeout !== undefined) {
-            request["timeout"] = params.timeout;
-        }
-        const result = (await this.client.sendRequest("agent.list_toolkits", request));
-        const tools = result.json["tools"];
-        const toolkits = [];
-        for (const name of Object.keys(tools)) {
-            const data = tools[name];
-            toolkits.push(ToolkitDescription.fromJson(data, { name }));
-        }
-        return toolkits;
+        return await this.client.listToolkits(params);
     }
     async invokeTool(params) {
-        const request = {
-            toolkit: params.toolkit,
-            tool: params.tool,
-            arguments: {
-                type: "json",
-                json: params.arguments,
-            },
-        };
-        return await this.client.sendRequest("agent.invoke_tool", request);
+        return await this.client.invoke(params);
     }
 }
 exports.AgentsClient = AgentsClient;

package/dist/node/agent.js

@@ -93,15 +93,15 @@ class RemoteToolkit extends Toolkit {
     }
     async start({ public_: isPublic = false } = {}) {
         const handler = this._toolCall.bind(this);
-        this.client.protocol.addHandler(`agent.tool_call.${this.name}`, handler);
+        this.client.protocol.addHandler(`room.tool_call.${this.name}`, handler);
         await this._register(isPublic);
     }
     async stop() {
         await this._unregister();
-        this.client.protocol.removeHandler(`agent.tool_call.${this.name}`);
+        this.client.protocol.removeHandler(`room.tool_call.${this.name}`);
     }
     async _register(public_) {
-        const response = await this.client.sendRequest("agent.register_toolkit", {
+        const response = await this.client.sendRequest("room.register_toolkit", {
             name: this.name,
             title: this.title,
             description: this.description,
@@ -114,7 +114,7 @@ class RemoteToolkit extends Toolkit {
     async _unregister() {
         if (!this._registrationId)
             return;
-        await this.client.sendRequest("agent.unregister_toolkit", {
+        await this.client.sendRequest("room.unregister_toolkit", {
             id: this._registrationId,
         });
     }
@@ -144,11 +144,11 @@ class RemoteToolkit extends Toolkit {
                 args = rawArguments ?? {};
             }
             const response = await this.execute(toolName, args);
-            await this.client.protocol.send("agent.tool_call_response", response.pack(), messageId);
+            await this.client.protocol.send("room.tool_call_response", response.pack(), messageId);
         }
         catch (e) {
             const err = new response_1.ErrorContent({ text: String(e) });
-            await this.client.protocol.send("agent.tool_call_response", err.pack(), messageId);
+            await this.client.protocol.send("room.tool_call_response", err.pack(), messageId);
         }
     }
 }

package/dist/node/containers-client.d.ts

@@ -0,0 +1,125 @@
+import { ContainerMountSpec } from "./meshagent-client";
+import { Content } from "./response";
+import { RoomClient } from "./room-client";
+export interface DockerSecret {
+    username: string;
+    password: string;
+    registry: string;
+    email?: string;
+}
+export interface ContainerImage {
+    id: string;
+    tags: string[];
+    size?: number;
+    labels: Record<string, unknown>;
+}
+export interface ContainerParticipantInfo {
+    id: string;
+    name: string;
+}
+export interface RoomContainer {
+    id: string;
+    image: string;
+    name?: string;
+    startedBy: ContainerParticipantInfo;
+    state: string;
+    private: boolean;
+    serviceId?: string;
+}
+export interface ContainerLogsSession {
+    stream: AsyncIterable<string>;
+    result: Promise<void>;
+    cancel(): Promise<void>;
+}
+export declare class ExecSession {
+    readonly command: string;
+    readonly result: Promise<number>;
+    readonly previousOutput: Uint8Array[];
+    readonly output: AsyncIterable<Uint8Array>;
+    private readonly requestId;
+    private readonly containerId;
+    private readonly tty?;
+    private readonly resultCompleter;
+    private readonly outputController;
+    private readonly queuedInput;
+    private inputClosed;
+    private closed;
+    private inputWaiter;
+    private lastResizeWidth?;
+    private lastResizeHeight?;
+    constructor(params: {
+        requestId: string;
+        command: string;
+        containerId: string;
+        tty?: boolean;
+    });
+    inputStream(): AsyncIterable<Content>;
+    write(data: Uint8Array): Promise<void>;
+    resize(params: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    kill(): Promise<void>;
+    close(status: number): void;
+    closeError(error: unknown): void;
+    addOutput(data: Uint8Array): void;
+    get isClosed(): boolean;
+    private queueInput;
+    private closeInputStream;
+}
+export declare class ContainersClient {
+    private readonly room;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    private unexpectedResponseError;
+    private invoke;
+    listImages(): Promise<ContainerImage[]>;
+    pullImage(params: {
+        tag: string;
+        credentials?: DockerSecret[];
+    }): Promise<void>;
+    run(params: {
+        image: string;
+        command?: string;
+        workingDir?: string;
+        env?: Record<string, string>;
+        mountPath?: string;
+        mountSubpath?: string;
+        role?: string;
+        participantName?: string;
+        ports?: Record<number, number> | Record<string, number>;
+        credentials?: DockerSecret[];
+        name?: string;
+        mounts?: ContainerMountSpec;
+        writableRootFs?: boolean;
+        private?: boolean;
+    }): Promise<string>;
+    runService(params: {
+        serviceId: string;
+        env?: Record<string, string>;
+    }): Promise<string>;
+    exec(params: {
+        containerId: string;
+        command: string;
+        tty?: boolean;
+    }): ExecSession;
+    stop(params: {
+        containerId: string;
+        force?: boolean;
+    }): Promise<void>;
+    waitForExit(params: {
+        containerId: string;
+    }): Promise<number>;
+    deleteContainer(params: {
+        containerId: string;
+    }): Promise<void>;
+    logs(params: {
+        containerId: string;
+        follow?: boolean;
+    }): ContainerLogsSession;
+    list(params?: {
+        all?: boolean;
+    }): Promise<RoomContainer[]>;
+}