@meshagent/meshagent 0.29.4 → 0.30.1

package/dist/esm/containers-client.js

@@ -0,0 +1,453 @@
+import { v4 as uuidv4 } from "uuid";
+import { Completer } from "./completer";
+import { BinaryContent, ControlContent, ErrorContent, JsonContent } from "./response";
+import { RoomServerException } from "./room-server-client";
+import { StreamController } from "./stream-controller";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStringMapList(values) {
+    return Object.entries(values).map(([key, value]) => ({ key, value }));
+}
+function toPortPairs(values) {
+    return Object.entries(values).map(([containerPort, hostPort]) => ({
+        container_port: Number(containerPort),
+        host_port: hostPort,
+    }));
+}
+function toCredentials(values) {
+    return values.map((entry) => ({
+        registry: entry.registry,
+        username: entry.username,
+        password: entry.password,
+    }));
+}
+function readStringField(data, field, operation) {
+    const value = data[field];
+    if (typeof value !== "string") {
+        throw new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return value;
+}
+function decodeJsonStatus(data) {
+    const text = new TextDecoder().decode(data);
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new RoomServerException("containers.exec returned an invalid status payload");
+    }
+    if (!isRecord(parsed)) {
+        throw new RoomServerException("containers.exec returned an invalid status payload");
+    }
+    const status = parsed["status"];
+    if (typeof status !== "number" || !Number.isInteger(status)) {
+        throw new RoomServerException("containers.exec returned an invalid status payload");
+    }
+    return status;
+}
+export class ExecSession {
+    constructor(params) {
+        this.previousOutput = [];
+        this.resultCompleter = new Completer();
+        this.outputController = new StreamController();
+        this.queuedInput = [];
+        this.inputClosed = false;
+        this.closed = false;
+        this.inputWaiter = null;
+        this.requestId = params.requestId;
+        this.command = params.command;
+        this.containerId = params.containerId;
+        this.tty = params.tty;
+        this.result = this.resultCompleter.fut;
+        this.output = this.outputController.stream;
+    }
+    async *inputStream() {
+        yield new BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+                kind: "start",
+                request_id: this.requestId,
+                container_id: this.containerId,
+                command: this.command,
+                tty: this.tty,
+            },
+        });
+        while (true) {
+            while (this.queuedInput.length > 0) {
+                const chunk = this.queuedInput.shift();
+                if (chunk) {
+                    yield chunk;
+                }
+            }
+            if (this.inputClosed) {
+                return;
+            }
+            this.inputWaiter = new Completer();
+            await this.inputWaiter.fut;
+            this.inputWaiter = null;
+        }
+    }
+    async write(data) {
+        this.queueInput({ channel: 1, data });
+    }
+    async resize(params) {
+        if (this.lastResizeWidth === params.width && this.lastResizeHeight === params.height) {
+            return;
+        }
+        this.lastResizeWidth = params.width;
+        this.lastResizeHeight = params.height;
+        this.queueInput({ channel: 4, width: params.width, height: params.height });
+    }
+    async stop() {
+        this.closeInputStream();
+    }
+    async kill() {
+        if (this.inputClosed) {
+            return;
+        }
+        this.queueInput({ channel: 5 });
+    }
+    close(status) {
+        if (!this.resultCompleter.completed) {
+            this.resultCompleter.complete(status);
+        }
+        this.closed = true;
+        this.closeInputStream();
+        this.outputController.close();
+    }
+    closeError(error) {
+        if (!this.resultCompleter.completed) {
+            this.resultCompleter.completeError(error);
+        }
+        this.closed = true;
+        this.closeInputStream();
+        this.outputController.close();
+    }
+    addOutput(data) {
+        this.previousOutput.push(data);
+        this.outputController.add(data);
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    queueInput(params) {
+        if (this.inputClosed) {
+            throw new RoomServerException("container exec session is already closed");
+        }
+        this.queuedInput.push(new BinaryContent({
+            data: params.data ?? new Uint8Array(0),
+            headers: {
+                kind: "input",
+                channel: params.channel,
+                width: params.width,
+                height: params.height,
+            },
+        }));
+        this.inputWaiter?.complete();
+    }
+    closeInputStream() {
+        if (this.inputClosed) {
+            return;
+        }
+        this.inputClosed = true;
+        this.inputWaiter?.complete();
+    }
+}
+export class ContainersClient {
+    constructor({ room }) {
+        this.room = room;
+    }
+    unexpectedResponseError(operation) {
+        return new RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    async invoke(operation, input) {
+        return await this.room.invoke({
+            toolkit: "containers",
+            tool: operation,
+            input,
+        });
+    }
+    async listImages() {
+        const output = await this.invoke("list_images", {});
+        if (!(output instanceof JsonContent)) {
+            throw this.unexpectedResponseError("list_images");
+        }
+        const imagesRaw = output.json["images"];
+        if (!Array.isArray(imagesRaw)) {
+            throw this.unexpectedResponseError("list_images");
+        }
+        const images = [];
+        for (const entry of imagesRaw) {
+            if (!isRecord(entry)) {
+                throw this.unexpectedResponseError("list_images");
+            }
+            const id = entry["id"];
+            const tags = entry["tags"];
+            const labelsRaw = entry["labels"];
+            if (typeof id !== "string" || !Array.isArray(tags)) {
+                throw this.unexpectedResponseError("list_images");
+            }
+            const normalizedTags = tags.filter((tag) => typeof tag === "string");
+            const size = entry["size"];
+            images.push({
+                id,
+                tags: normalizedTags,
+                size: typeof size === "number" ? size : undefined,
+                labels: isRecord(labelsRaw) ? labelsRaw : {},
+            });
+        }
+        return images;
+    }
+    async pullImage(params) {
+        await this.invoke("pull_image", {
+            tag: params.tag,
+            credentials: toCredentials(params.credentials ?? []),
+        });
+    }
+    async run(params) {
+        const output = await this.invoke("run", {
+            image: params.image,
+            command: params.command,
+            working_dir: params.workingDir,
+            env: toStringMapList(params.env ?? {}),
+            mount_path: params.mountPath,
+            mount_subpath: params.mountSubpath,
+            role: params.role,
+            participant_name: params.participantName,
+            ports: toPortPairs(params.ports ?? {}),
+            credentials: toCredentials(params.credentials ?? []),
+            name: params.name,
+            mounts: params.mounts,
+            writable_root_fs: params.writableRootFs,
+            private: params.private,
+        });
+        if (!(output instanceof JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("run");
+        }
+        return readStringField(output.json, "container_id", "run");
+    }
+    async runService(params) {
+        const output = await this.invoke("run_service", {
+            service_id: params.serviceId,
+            env: toStringMapList(params.env ?? {}),
+        });
+        if (!(output instanceof JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("run_service");
+        }
+        return readStringField(output.json, "container_id", "run_service");
+    }
+    exec(params) {
+        const requestId = uuidv4();
+        const session = new ExecSession({
+            requestId,
+            command: params.command,
+            containerId: params.containerId,
+            tty: params.tty,
+        });
+        this.room
+            .invokeStream({
+            toolkit: "containers",
+            tool: "exec",
+            input: session.inputStream(),
+        })
+            .then(async (stream) => {
+            for await (const chunk of stream) {
+                if (chunk instanceof ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (!(chunk instanceof BinaryContent)) {
+                    throw this.unexpectedResponseError("exec");
+                }
+                const channel = chunk.headers["channel"];
+                if (typeof channel !== "number") {
+                    throw new RoomServerException("containers.exec returned a chunk without a valid channel");
+                }
+                if (channel === 1) {
+                    session.addOutput(chunk.data);
+                    continue;
+                }
+                if (channel === 3) {
+                    session.close(decodeJsonStatus(chunk.data));
+                    return;
+                }
+            }
+            throw new RoomServerException("containers.exec stream closed before a status was returned");
+        })
+            .catch((error) => {
+            session.closeError(error);
+        });
+        return session;
+    }
+    async stop(params) {
+        await this.invoke("stop_container", {
+            container_id: params.containerId,
+            force: params.force ?? true,
+        });
+    }
+    async waitForExit(params) {
+        const output = await this.invoke("wait_for_exit", {
+            container_id: params.containerId,
+        });
+        if (!(output instanceof JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("wait_for_exit");
+        }
+        const exitCode = output.json["exit_code"];
+        if (typeof exitCode !== "number" || !Number.isInteger(exitCode)) {
+            throw this.unexpectedResponseError("wait_for_exit");
+        }
+        return exitCode;
+    }
+    async deleteContainer(params) {
+        await this.invoke("delete_container", {
+            container_id: params.containerId,
+        });
+    }
+    logs(params) {
+        const requestId = uuidv4();
+        const closeInput = new Completer();
+        const streamController = new StreamController();
+        const result = new Completer();
+        let inputClosed = false;
+        const closeInputStream = () => {
+            if (inputClosed) {
+                return;
+            }
+            inputClosed = true;
+            if (!closeInput.completed) {
+                closeInput.complete();
+            }
+        };
+        const inputStream = async function* () {
+            yield new BinaryContent({
+                data: new Uint8Array(0),
+                headers: {
+                    kind: "start",
+                    request_id: requestId,
+                    container_id: params.containerId,
+                    follow: params.follow ?? false,
+                },
+            });
+            await closeInput.fut;
+        };
+        this.room
+            .invokeStream({
+            toolkit: "containers",
+            tool: "logs",
+            input: inputStream(),
+        })
+            .then(async (stream) => {
+            const decoder = new TextDecoder();
+            for await (const chunk of stream) {
+                if (chunk instanceof ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof ControlContent) {
+                    continue;
+                }
+                if (!(chunk instanceof BinaryContent)) {
+                    throw this.unexpectedResponseError("logs");
+                }
+                const channel = chunk.headers["channel"];
+                if (typeof channel !== "number") {
+                    throw new RoomServerException("containers.logs returned a chunk without a valid channel");
+                }
+                if (channel !== 1) {
+                    continue;
+                }
+                streamController.add(decoder.decode(chunk.data));
+            }
+            closeInputStream();
+            streamController.close();
+            result.complete();
+        })
+            .catch((error) => {
+            closeInputStream();
+            streamController.close();
+            if (!result.completed) {
+                result.completeError(error);
+            }
+        });
+        const outputStream = {
+            [Symbol.asyncIterator]() {
+                const it = streamController.stream[Symbol.asyncIterator]();
+                return {
+                    async next() {
+                        return await it.next();
+                    },
+                    async return(value) {
+                        closeInputStream();
+                        return await it.return?.(value) ?? { done: true, value };
+                    },
+                    async throw(e) {
+                        closeInputStream();
+                        if (it.throw) {
+                            return await it.throw(e);
+                        }
+                        throw e;
+                    },
+                };
+            },
+        };
+        return {
+            stream: outputStream,
+            result: result.fut,
+            cancel: async () => {
+                closeInputStream();
+                await result.fut.catch(() => undefined);
+            },
+        };
+    }
+    async list(params) {
+        const output = await this.invoke("list_containers", {
+            all: params?.all,
+        });
+        if (!(output instanceof JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("list");
+        }
+        const containersRaw = output.json["containers"];
+        if (!Array.isArray(containersRaw)) {
+            throw this.unexpectedResponseError("list");
+        }
+        const items = [];
+        for (const entry of containersRaw) {
+            if (!isRecord(entry)) {
+                throw this.unexpectedResponseError("list");
+            }
+            const startedByRaw = entry["started_by"];
+            if (!isRecord(startedByRaw)) {
+                throw this.unexpectedResponseError("list");
+            }
+            const id = entry["id"];
+            const image = entry["image"];
+            const state = entry["state"];
+            const privateFlag = entry["private"];
+            const startedById = startedByRaw["id"];
+            const startedByName = startedByRaw["name"];
+            if (typeof id !== "string" ||
+                typeof image !== "string" ||
+                typeof state !== "string" ||
+                typeof privateFlag !== "boolean" ||
+                typeof startedById !== "string" ||
+                typeof startedByName !== "string") {
+                throw this.unexpectedResponseError("list");
+            }
+            const nameRaw = entry["name"];
+            const serviceIdRaw = entry["service_id"];
+            items.push({
+                id,
+                image,
+                name: typeof nameRaw === "string" ? nameRaw : undefined,
+                startedBy: {
+                    id: startedById,
+                    name: startedByName,
+                },
+                state,
+                private: privateFlag,
+                serviceId: typeof serviceIdRaw === "string" ? serviceIdRaw : undefined,
+            });
+        }
+        return items;
+    }
+}

package/dist/esm/database-client.d.ts

@@ -1,5 +1,5 @@
-import { RoomClient } from "./room-client";
 import { DataType } from "./data-types";
+import { RoomClient } from "./room-client";
 export type CreateMode = "create" | "overwrite" | "create_if_not_exists";
 export interface TableRef {
     name: string;
@@ -11,6 +11,11 @@ export declare class DatabaseClient {
     constructor({ room }: {
         room: RoomClient;
     });
+    private _unexpectedResponseError;
+    private invoke;
+    private invokeStream;
+    private drainWriteStream;
+    private streamRows;
     listTables(): Promise<string[]>;
     private createTable;
     createTableWithSchema({ name, schema, data, mode }: {
@@ -24,6 +29,12 @@ export declare class DatabaseClient {
         data?: Array<Record<string, any>>;
         mode?: CreateMode;
     }): Promise<void>;
+    createTableFromDataStream({ name, chunks, schema, mode }: {
+        name: string;
+        chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+        schema?: Record<string, DataType>;
+        mode?: CreateMode;
+    }): Promise<void>;
     dropTable({ name, ignoreMissing }: {
         name: string;
         ignoreMissing?: boolean;
@@ -40,6 +51,10 @@ export declare class DatabaseClient {
         table: string;
         records: Array<Record<string, any>>;
     }): Promise<void>;
+    insertStream({ table, chunks }: {
+        table: string;
+        chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+    }): Promise<void>;
     update({ table, where, values, valuesSql }: {
         table: string;
         where: string;
@@ -53,13 +68,23 @@ export declare class DatabaseClient {
     merge({ table, on, records }: {
         table: string;
         on: string;
-        records: any;
+        records: Array<Record<string, any>>;
+    }): Promise<void>;
+    mergeStream({ table, on, chunks }: {
+        table: string;
+        on: string;
+        chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
     }): Promise<void>;
     sql({ query, tables, params }: {
         query: string;
         tables: TableRef[];
         params?: Record<string, any>;
     }): Promise<Array<Record<string, any>>>;
+    sqlStream({ query, tables, params }: {
+        query: string;
+        tables: TableRef[];
+        params?: Record<string, any>;
+    }): AsyncIterable<Array<Record<string, any>>>;
     search({ table, text, vector, where, limit, select }: {
         table: string;
         text?: string;
@@ -68,20 +93,31 @@ export declare class DatabaseClient {
         limit?: number;
         select?: string[];
     }): Promise<Array<Record<string, any>>>;
+    searchStream({ table, text, vector, where, limit, select }: {
+        table: string;
+        text?: string;
+        vector?: number[];
+        where?: string | Record<string, any>;
+        limit?: number;
+        select?: string[];
+    }): AsyncIterable<Array<Record<string, any>>>;
     optimize(table: string): Promise<void>;
-    createVectorIndex({ table, column }: {
+    createVectorIndex({ table, column, replace }: {
         table: string;
         column: string;
+        replace?: boolean;
     }): Promise<void>;
-    createScalarIndex({ table, column }: {
+    createScalarIndex({ table, column, replace }: {
         table: string;
         column: string;
+        replace?: boolean;
     }): Promise<void>;
-    createFullTextSearchIndex({ table, column }: {
+    createFullTextSearchIndex({ table, column, replace }: {
         table: string;
         column: string;
+        replace?: boolean;
     }): Promise<void>;
     listIndexes({ table }: {
         table: string;
-    }): Promise<Record<string, any>>;
+    }): Promise<Array<Record<string, any>>>;
 }