@meshagent/meshagent 0.35.6 → 0.35.8

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

@@ -4,14 +4,25 @@ import { RoomClient } from "./room-client";
 export interface DockerSecret {
     username: string;
     password: string;
-    registry: string;
+    registry?: string | null;
     email?: string;
 }
 export interface ContainerImage {
     id: string;
     tags: string[];
     size?: number;
-    labels: Record<string, unknown>;
+    labels: Record<string, string>;
+}
+export interface ImportedImage {
+    resolvedRef: string;
+    refs: string[];
+}
+export type BuildJobStatus = "queued" | "running" | "failed" | "cancelled" | "succeeded";
+export interface BuildJob {
+    id: string;
+    tag: string;
+    status: BuildJobStatus;
+    exitCode?: number;
 }
 export interface ContainerParticipantInfo {
     id: string;
@@ -31,16 +42,24 @@ export interface ContainerLogsSession {
     result: Promise<void>;
     cancel(): Promise<void>;
 }
+export interface BuildLogsSession {
+    stream: AsyncIterable<string>;
+    result: Promise<number | null>;
+    cancel(): Promise<void>;
+}
 export declare class ExecSession {
     readonly command: string;
     readonly result: Promise<number>;
     readonly previousOutput: Uint8Array[];
+    readonly previousError: Uint8Array[];
     readonly output: AsyncIterable<Uint8Array>;
+    readonly stderr: AsyncIterable<Uint8Array>;
     private readonly requestId;
     private readonly containerId;
     private readonly tty?;
     private readonly resultCompleter;
     private readonly outputController;
+    private readonly errorController;
     private readonly queuedInput;
     private inputClosed;
     private closed;
@@ -64,6 +83,7 @@ export declare class ExecSession {
     close(status: number): void;
     closeError(error: unknown): void;
     addOutput(data: Uint8Array): void;
+    addError(data: Uint8Array): void;
     get isClosed(): boolean;
     private queueInput;
     private closeInputStream;
@@ -76,10 +96,32 @@ export declare class ContainersClient {
     private unexpectedResponseError;
     private invoke;
     listImages(): Promise<ContainerImage[]>;
+    deleteImage(params: {
+        image: string;
+    }): Promise<void>;
     pullImage(params: {
         tag: string;
         credentials?: DockerSecret[];
     }): Promise<void>;
+    pushImage(params: {
+        tag: string;
+        credentials?: DockerSecret[];
+        private?: boolean;
+    }): Promise<string>;
+    load(params: {
+        archivePath: string;
+    }): Promise<ImportedImage>;
+    loadImage(params: {
+        mounts: ContainerMountSpec[];
+        archivePath: string;
+        private?: boolean;
+    }): Promise<string>;
+    saveImage(params: {
+        tag: string;
+        mounts: ContainerMountSpec[];
+        archivePath: string;
+        private?: boolean;
+    }): Promise<string>;
     run(params: {
         image: string;
         command?: string;
@@ -96,6 +138,37 @@ export declare class ContainersClient {
         writableRootFs?: boolean;
         private?: boolean;
     }): Promise<string>;
+    startBuild(params: {
+        tag: string;
+        mounts: ContainerMountSpec[];
+        contextPath: string;
+        dockerfilePath?: string;
+        private?: boolean;
+        credentials?: DockerSecret[];
+        contextArchivePath?: string;
+        contextArchiveRef?: string;
+        contextArchiveMountPath?: string;
+        contextArchiveArch?: string;
+    }): Promise<string>;
+    build(params: {
+        tag: string;
+        mounts: ContainerMountSpec[];
+        contextPath: string;
+        dockerfilePath?: string;
+        private?: boolean;
+        credentials?: DockerSecret[];
+        contextArchivePath?: string;
+        contextArchiveRef?: string;
+        contextArchiveMountPath?: string;
+        contextArchiveArch?: string;
+    }): Promise<string>;
+    listBuilds(): Promise<BuildJob[]>;
+    cancelBuild(params: {
+        buildId: string;
+    }): Promise<void>;
+    deleteBuild(params: {
+        buildId: string;
+    }): Promise<void>;
     runService(params: {
         serviceId: string;
         env?: Record<string, string>;
@@ -119,6 +192,10 @@ export declare class ContainersClient {
         containerId: string;
         follow?: boolean;
     }): ContainerLogsSession;
+    getBuildLogs(params: {
+        buildId: string;
+        follow?: boolean;
+    }): BuildLogsSession;
     list(params?: {
         all?: boolean;
     }): Promise<RoomContainer[]>;

package/dist/node/containers-client.js

@@ -20,11 +20,14 @@ function toPortPairs(values) {
 }
 function toCredentials(values) {
     return values.map((entry) => ({
-        registry: entry.registry,
+        registry: entry.registry ?? null,
         username: entry.username,
         password: entry.password,
     }));
 }
+function toMountList(values) {
+    return values.map((entry) => entry);
+}
 function readStringField(data, field, operation) {
     const value = data[field];
     if (typeof value !== "string") {
@@ -32,29 +35,126 @@ function readStringField(data, field, operation) {
     }
     return value;
 }
-function decodeJsonStatus(data) {
-    const text = new TextDecoder().decode(data);
+function readIntegerField(data, field, operation) {
+    const value = data[field];
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return value;
+}
+function readOptionalIntegerField(data, field, operation) {
+    const value = data[field];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return value;
+}
+function decodeUtf8(data, operation) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(data);
+    }
+    catch {
+        throw new room_server_client_1.RoomServerException(`containers.${operation} returned invalid UTF-8 data`);
+    }
+}
+function decodeJsonStatus(data, operation) {
+    const text = decodeUtf8(data, operation);
     let parsed;
     try {
         parsed = JSON.parse(text);
     }
     catch {
-        throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+        throw new room_server_client_1.RoomServerException(`containers.${operation} returned an invalid status payload`);
     }
     if (!isRecord(parsed)) {
-        throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+        throw new room_server_client_1.RoomServerException(`containers.${operation} returned an invalid status payload`);
     }
     const status = parsed["status"];
     if (typeof status !== "number" || !Number.isInteger(status)) {
-        throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+        throw new room_server_client_1.RoomServerException(`containers.${operation} returned an invalid status payload`);
     }
     return status;
 }
+function normalizeImageLabels(labelsRaw, operation) {
+    if (Array.isArray(labelsRaw)) {
+        const labels = {};
+        for (const entry of labelsRaw) {
+            if (!isRecord(entry)) {
+                throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            const key = entry["key"];
+            const value = entry["value"];
+            if (typeof key !== "string" || typeof value !== "string") {
+                throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            labels[key] = value;
+        }
+        return labels;
+    }
+    if (isRecord(labelsRaw)) {
+        const labels = {};
+        for (const [key, value] of Object.entries(labelsRaw)) {
+            if (typeof value !== "string") {
+                throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            labels[key] = value;
+        }
+        return labels;
+    }
+    if (labelsRaw === undefined || labelsRaw === null) {
+        return {};
+    }
+    throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+}
+function parseImportedImage(data, operation) {
+    const resolvedRef = data["resolved_ref"];
+    const refsRaw = data["refs"];
+    if (typeof resolvedRef !== "string" || !Array.isArray(refsRaw) || refsRaw.some((entry) => typeof entry !== "string")) {
+        throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return {
+        resolvedRef,
+        refs: refsRaw,
+    };
+}
+function parseBuildJob(data, operation) {
+    const id = readStringField(data, "id", operation);
+    const tag = readStringField(data, "tag", operation);
+    const status = readStringField(data, "status", operation);
+    if (!["queued", "running", "failed", "cancelled", "succeeded"].includes(status)) {
+        throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+    }
+    return {
+        id,
+        tag,
+        status: status,
+        exitCode: readOptionalIntegerField(data, "exit_code", operation),
+    };
+}
+function buildRequestPayload(params) {
+    return {
+        tag: params.tag,
+        mounts: toMountList(params.mounts),
+        context_path: params.contextPath,
+        dockerfile_path: params.dockerfilePath ?? null,
+        private: params.private ?? false,
+        credentials: toCredentials(params.credentials ?? []),
+        context_archive_path: params.contextArchivePath ?? null,
+        context_archive_ref: params.contextArchiveRef ?? null,
+        context_archive_mount_path: params.contextArchiveMountPath ?? null,
+        context_archive_arch: params.contextArchiveArch ?? null,
+    };
+}
 class ExecSession {
     constructor(params) {
         this.previousOutput = [];
+        this.previousError = [];
         this.resultCompleter = new completer_1.Completer();
         this.outputController = new stream_controller_1.StreamController();
+        this.errorController = new stream_controller_1.StreamController();
         this.queuedInput = [];
         this.inputClosed = false;
         this.closed = false;
@@ -65,6 +165,7 @@ class ExecSession {
         this.tty = params.tty;
         this.result = this.resultCompleter.fut;
         this.output = this.outputController.stream;
+        this.stderr = this.errorController.stream;
     }
     async *inputStream() {
         yield new response_1.BinaryContent({
@@ -119,6 +220,7 @@ class ExecSession {
         this.closed = true;
         this.closeInputStream();
         this.outputController.close();
+        this.errorController.close();
     }
     closeError(error) {
         if (!this.resultCompleter.completed) {
@@ -127,11 +229,16 @@ class ExecSession {
         this.closed = true;
         this.closeInputStream();
         this.outputController.close();
+        this.errorController.close();
     }
     addOutput(data) {
         this.previousOutput.push(data);
         this.outputController.add(data);
     }
+    addError(data) {
+        this.previousError.push(data);
+        this.errorController.add(data);
+    }
     get isClosed() {
         return this.closed;
     }
@@ -175,7 +282,7 @@ class ContainersClient {
     }
     async listImages() {
         const output = await this.invoke("list_images", {});
-        if (!(output instanceof response_1.JsonContent)) {
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
             throw this.unexpectedResponseError("list_images");
         }
         const imagesRaw = output.json["images"];
@@ -199,17 +306,65 @@ class ContainersClient {
                 id,
                 tags: normalizedTags,
                 size: typeof size === "number" ? size : undefined,
-                labels: isRecord(labelsRaw) ? labelsRaw : {},
+                labels: normalizeImageLabels(labelsRaw, "list_images"),
             });
         }
         return images;
     }
+    async deleteImage(params) {
+        await this.invoke("delete_image", {
+            image: params.image,
+        });
+    }
     async pullImage(params) {
         await this.invoke("pull_image", {
             tag: params.tag,
             credentials: toCredentials(params.credentials ?? []),
         });
     }
+    async pushImage(params) {
+        const output = await this.invoke("push_image", {
+            tag: params.tag,
+            credentials: toCredentials(params.credentials ?? []),
+            private: params.private ?? false,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("push_image");
+        }
+        return readStringField(output.json, "container_id", "push_image");
+    }
+    async load(params) {
+        const output = await this.invoke("load", {
+            archive_path: params.archivePath,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("load");
+        }
+        return parseImportedImage(output.json, "load");
+    }
+    async loadImage(params) {
+        const output = await this.invoke("load_image", {
+            mounts: toMountList(params.mounts),
+            archive_path: params.archivePath,
+            private: params.private ?? false,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("load_image");
+        }
+        return readStringField(output.json, "container_id", "load_image");
+    }
+    async saveImage(params) {
+        const output = await this.invoke("save_image", {
+            tag: params.tag,
+            mounts: toMountList(params.mounts),
+            archive_path: params.archivePath,
+            private: params.private ?? false,
+        });
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("save_image");
+        }
+        return readStringField(output.json, "container_id", "save_image");
+    }
     async run(params) {
         const output = await this.invoke("run", {
             image: params.image,
@@ -232,6 +387,46 @@ class ContainersClient {
         }
         return readStringField(output.json, "container_id", "run");
     }
+    async startBuild(params) {
+        const output = await this.invoke("start_build", buildRequestPayload(params));
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("start_build");
+        }
+        return readStringField(output.json, "build_id", "start_build");
+    }
+    async build(params) {
+        const output = await this.invoke("build", buildRequestPayload(params));
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("build");
+        }
+        return readStringField(output.json, "build_id", "build");
+    }
+    async listBuilds() {
+        const output = await this.invoke("list_builds", {});
+        if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("list_builds");
+        }
+        const buildsRaw = output.json["builds"];
+        if (!Array.isArray(buildsRaw)) {
+            throw this.unexpectedResponseError("list_builds");
+        }
+        return buildsRaw.map((entry) => {
+            if (!isRecord(entry)) {
+                throw this.unexpectedResponseError("list_builds");
+            }
+            return parseBuildJob(entry, "list_builds");
+        });
+    }
+    async cancelBuild(params) {
+        await this.invoke("cancel_build", {
+            build_id: params.buildId,
+        });
+    }
+    async deleteBuild(params) {
+        await this.invoke("delete_build", {
+            build_id: params.buildId,
+        });
+    }
     async runService(params) {
         const output = await this.invoke("run_service", {
             service_id: params.serviceId,
@@ -261,6 +456,12 @@ class ContainersClient {
                 if (chunk instanceof response_1.ErrorContent) {
                     throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
                 }
+                if (chunk instanceof response_1.ControlContent) {
+                    if (chunk.method === "close") {
+                        break;
+                    }
+                    throw this.unexpectedResponseError("exec");
+                }
                 if (!(chunk instanceof response_1.BinaryContent)) {
                     throw this.unexpectedResponseError("exec");
                 }
@@ -272,8 +473,12 @@ class ContainersClient {
                     session.addOutput(chunk.data);
                     continue;
                 }
+                if (channel === 2) {
+                    session.addError(chunk.data);
+                    continue;
+                }
                 if (channel === 3) {
-                    session.close(decodeJsonStatus(chunk.data));
+                    session.close(decodeJsonStatus(chunk.data, "exec"));
                     return;
                 }
             }
@@ -287,7 +492,7 @@ class ContainersClient {
     async stop(params) {
         await this.invoke("stop_container", {
             container_id: params.containerId,
-            force: params.force ?? true,
+            force: params.force ?? false,
         });
     }
     async waitForExit(params) {
@@ -297,11 +502,7 @@ class ContainersClient {
         if (!(output instanceof response_1.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;
+        return readIntegerField(output.json, "exit_code", "wait_for_exit");
     }
     async deleteContainer(params) {
         await this.invoke("delete_container", {
@@ -342,13 +543,20 @@ class ContainersClient {
             input: inputStream(),
         })
             .then(async (stream) => {
-            const decoder = new TextDecoder();
             for await (const chunk of stream) {
                 if (chunk instanceof response_1.ErrorContent) {
                     throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
                 }
                 if (chunk instanceof response_1.ControlContent) {
-                    continue;
+                    if (chunk.method === "close") {
+                        closeInputStream();
+                        streamController.close();
+                        if (!result.completed) {
+                            result.complete();
+                        }
+                        return;
+                    }
+                    throw this.unexpectedResponseError("logs");
                 }
                 if (!(chunk instanceof response_1.BinaryContent)) {
                     throw this.unexpectedResponseError("logs");
@@ -360,11 +568,125 @@ class ContainersClient {
                 if (channel !== 1) {
                     continue;
                 }
-                streamController.add(decoder.decode(chunk.data));
+                streamController.add(decodeUtf8(chunk.data, "logs"));
+            }
+            closeInputStream();
+            streamController.close();
+            if (!result.completed) {
+                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);
+            },
+        };
+    }
+    getBuildLogs(params) {
+        const requestId = (0, uuid_1.v4)();
+        const closeInput = new completer_1.Completer();
+        const streamController = new stream_controller_1.StreamController();
+        const result = new completer_1.Completer();
+        let inputClosed = false;
+        const closeInputStream = () => {
+            if (inputClosed) {
+                return;
+            }
+            inputClosed = true;
+            if (!closeInput.completed) {
+                closeInput.complete();
+            }
+        };
+        const inputStream = async function* () {
+            yield new response_1.BinaryContent({
+                data: new Uint8Array(0),
+                headers: {
+                    kind: "start",
+                    request_id: requestId,
+                    build_id: params.buildId,
+                    follow: params.follow ?? true,
+                },
+            });
+            await closeInput.fut;
+        };
+        this.room
+            .invokeStream({
+            toolkit: "containers",
+            tool: "get_build_logs",
+            input: inputStream(),
+        })
+            .then(async (stream) => {
+            for await (const chunk of stream) {
+                if (chunk instanceof response_1.ErrorContent) {
+                    throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof response_1.ControlContent) {
+                    if (chunk.method === "close") {
+                        closeInputStream();
+                        streamController.close();
+                        if (!result.completed) {
+                            result.complete(null);
+                        }
+                        return;
+                    }
+                    throw this.unexpectedResponseError("get_build_logs");
+                }
+                if (!(chunk instanceof response_1.BinaryContent)) {
+                    throw this.unexpectedResponseError("get_build_logs");
+                }
+                const channel = chunk.headers["channel"];
+                if (typeof channel !== "number") {
+                    throw new room_server_client_1.RoomServerException("containers.get_build_logs returned a chunk without a valid channel");
+                }
+                if (channel === 1) {
+                    streamController.add(decodeUtf8(chunk.data, "get_build_logs"));
+                    continue;
+                }
+                if (channel === 3) {
+                    closeInputStream();
+                    streamController.close();
+                    if (!result.completed) {
+                        result.complete(decodeJsonStatus(chunk.data, "get_build_logs"));
+                    }
+                    return;
+                }
             }
             closeInputStream();
             streamController.close();
-            result.complete();
+            if (!result.completed) {
+                result.complete(null);
+            }
         })
             .catch((error) => {
             closeInputStream();