@meshagent/meshagent 0.35.6 → 0.35.8

package/dist/esm/containers-client.js

@@ -17,11 +17,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") {
@@ -29,29 +32,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 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 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 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 RoomServerException("containers.exec returned an invalid status payload");
+        throw new RoomServerException(`containers.${operation} returned an invalid status payload`);
     }
     if (!isRecord(parsed)) {
-        throw new RoomServerException("containers.exec returned an invalid status payload");
+        throw new RoomServerException(`containers.${operation} 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");
+        throw new 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 RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            const key = entry["key"];
+            const value = entry["value"];
+            if (typeof key !== "string" || typeof value !== "string") {
+                throw new 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 RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            labels[key] = value;
+        }
+        return labels;
+    }
+    if (labelsRaw === undefined || labelsRaw === null) {
+        return {};
+    }
+    throw new 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 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 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,
+    };
+}
 export class ExecSession {
     constructor(params) {
         this.previousOutput = [];
+        this.previousError = [];
         this.resultCompleter = new Completer();
         this.outputController = new StreamController();
+        this.errorController = new StreamController();
         this.queuedInput = [];
         this.inputClosed = false;
         this.closed = false;
@@ -62,6 +162,7 @@ export 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 BinaryContent({
@@ -116,6 +217,7 @@ export class ExecSession {
         this.closed = true;
         this.closeInputStream();
         this.outputController.close();
+        this.errorController.close();
     }
     closeError(error) {
         if (!this.resultCompleter.completed) {
@@ -124,11 +226,16 @@ export 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;
     }
@@ -171,7 +278,7 @@ export class ContainersClient {
     }
     async listImages() {
         const output = await this.invoke("list_images", {});
-        if (!(output instanceof JsonContent)) {
+        if (!(output instanceof JsonContent) || !isRecord(output.json)) {
             throw this.unexpectedResponseError("list_images");
         }
         const imagesRaw = output.json["images"];
@@ -195,17 +302,65 @@ export 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 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 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 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 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,
@@ -228,6 +383,46 @@ export class ContainersClient {
         }
         return readStringField(output.json, "container_id", "run");
     }
+    async startBuild(params) {
+        const output = await this.invoke("start_build", buildRequestPayload(params));
+        if (!(output instanceof 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 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 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,
@@ -257,6 +452,12 @@ export class ContainersClient {
                 if (chunk instanceof ErrorContent) {
                     throw new RoomServerException(chunk.text, chunk.code);
                 }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        break;
+                    }
+                    throw this.unexpectedResponseError("exec");
+                }
                 if (!(chunk instanceof BinaryContent)) {
                     throw this.unexpectedResponseError("exec");
                 }
@@ -268,8 +469,12 @@ export 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;
                 }
             }
@@ -283,7 +488,7 @@ export 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) {
@@ -293,11 +498,7 @@ export class ContainersClient {
         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;
+        return readIntegerField(output.json, "exit_code", "wait_for_exit");
     }
     async deleteContainer(params) {
         await this.invoke("delete_container", {
@@ -338,13 +539,20 @@ export class ContainersClient {
             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.method === "close") {
+                        closeInputStream();
+                        streamController.close();
+                        if (!result.completed) {
+                            result.complete();
+                        }
+                        return;
+                    }
+                    throw this.unexpectedResponseError("logs");
                 }
                 if (!(chunk instanceof BinaryContent)) {
                     throw this.unexpectedResponseError("logs");
@@ -356,11 +564,125 @@ export 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 = 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,
+                    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 ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        closeInputStream();
+                        streamController.close();
+                        if (!result.completed) {
+                            result.complete(null);
+                        }
+                        return;
+                    }
+                    throw this.unexpectedResponseError("get_build_logs");
+                }
+                if (!(chunk instanceof BinaryContent)) {
+                    throw this.unexpectedResponseError("get_build_logs");
+                }
+                const channel = chunk.headers["channel"];
+                if (typeof channel !== "number") {
+                    throw new 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();