@meshagent/meshagent 0.35.5 → 0.35.7

package/dist/browser/storage-client.js

@@ -1,11 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageClient = exports.FileHandle = void 0;
+exports.StorageClient = exports.StorageEntry = exports.FileHandle = void 0;
 const room_event_1 = require("./room-event");
 const response_1 = require("./response");
 const utils_1 = require("./utils");
 const event_emitter_1 = require("./event-emitter");
 const room_server_client_1 = require("./room-server-client");
+const _DEFAULT_UPLOAD_MIME_TYPE = "application/octet-stream";
+const _UPLOAD_MIME_TYPES_BY_SUFFIX = new Map([
+    [".tar.gz", "application/x-tar"],
+    [".tgz", "application/x-tar"],
+]);
+const _UPLOAD_MIME_TYPES_BY_EXTENSION = new Map([
+    [".bin", "application/octet-stream"],
+    [".css", "text/css"],
+    [".csv", "text/csv"],
+    [".gif", "image/gif"],
+    [".gz", "application/gzip"],
+    [".htm", "text/html"],
+    [".html", "text/html"],
+    [".jpeg", "image/jpeg"],
+    [".jpg", "image/jpeg"],
+    [".js", "text/javascript"],
+    [".json", "application/json"],
+    [".md", "text/markdown"],
+    [".mp3", "audio/mpeg"],
+    [".mp4", "video/mp4"],
+    [".pdf", "application/pdf"],
+    [".png", "image/png"],
+    [".svg", "image/svg+xml"],
+    [".tar", "application/x-tar"],
+    [".txt", "text/plain"],
+    [".ts", "text/typescript"],
+    [".tsx", "text/tsx"],
+    [".wasm", "application/wasm"],
+    [".webp", "image/webp"],
+    [".xml", "application/xml"],
+    [".yaml", "application/yaml"],
+    [".yml", "application/yaml"],
+    [".zip", "application/zip"],
+]);
+function _unexpectedStorageResponseError(operation) {
+    return new room_server_client_1.RoomServerException(`unexpected return type from storage.${operation}`);
+}
+function _parseStorageTimestamp(value, operation) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        throw _unexpectedStorageResponseError(operation);
+    }
+    const timestamp = new Date(value);
+    if (Number.isNaN(timestamp.getTime())) {
+        throw _unexpectedStorageResponseError(operation);
+    }
+    return timestamp;
+}
 class FileHandle {
     constructor({ id }) {
         this.id = id;
@@ -13,10 +63,12 @@ class FileHandle {
 }
 exports.FileHandle = FileHandle;
 class StorageEntry {
-    constructor({ name, isFolder, size = null }) {
+    constructor({ name, isFolder, size = null, createdAt = null, updatedAt = null }) {
         this.name = name;
         this.isFolder = isFolder;
         this.size = size;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
     }
     nameWithoutExtension() {
         const segments = this.name
@@ -27,6 +79,7 @@ class StorageEntry {
             .replace(/\.[^/.]+$/, "");
     }
 }
+exports.StorageEntry = StorageEntry;
 class StorageClient extends event_emitter_1.EventEmitter {
     constructor({ room }) {
         super();
@@ -36,18 +89,32 @@ class StorageClient extends event_emitter_1.EventEmitter {
     }
     async _handleFileUpdated(protocol, messageId, type, bytes) {
         const [data, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
-        const event = new room_event_1.FileUpdatedEvent({ path: data["path"] });
+        const event = new room_event_1.FileUpdatedEvent({ path: data["path"], participantId: data["participant_id"] });
         this.client.emit(event);
         this.emit('file.updated', event);
     }
     async _handleFileDeleted(protocol, messageId, type, bytes) {
         const [data, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
-        const event = new room_event_1.FileDeletedEvent({ path: data["path"] });
+        const event = new room_event_1.FileDeletedEvent({ path: data["path"], participantId: data["participant_id"] });
         this.client.emit(event);
         this.emit('file.deleted', event);
     }
     _unexpectedResponseError(operation) {
-        return new room_server_client_1.RoomServerException(`unexpected return type from storage.${operation}`);
+        return _unexpectedStorageResponseError(operation);
+    }
+    _storageEntry(operation, value) {
+        if (typeof value["name"] !== "string" ||
+            typeof value["is_folder"] !== "boolean" ||
+            (value["size"] != null && typeof value["size"] !== "number")) {
+            throw this._unexpectedResponseError(operation);
+        }
+        return new StorageEntry({
+            name: value["name"],
+            isFolder: value["is_folder"],
+            size: typeof value["size"] === "number" ? value["size"] : null,
+            createdAt: _parseStorageTimestamp(value["created_at"], operation),
+            updatedAt: _parseStorageTimestamp(value["updated_at"], operation),
+        });
     }
     async _invoke(operation, input, callerContext) {
         return await this.client.invoke({
@@ -59,22 +126,26 @@ class StorageClient extends event_emitter_1.EventEmitter {
     }
     async list(path) {
         const response = await this._invoke("list", { path });
-        if (!(response instanceof response_1.JsonContent)) {
+        if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json["files"])) {
             throw this._unexpectedResponseError("list");
         }
         const files = response.json["files"];
-        const entries = files.map((f) => {
-            return new StorageEntry({
-                name: f["name"],
-                isFolder: f["is_folder"],
-                size: typeof f["size"] === "number" ? f["size"] : null,
-            });
-        });
+        const entries = files.map((f) => this._storageEntry("list", f));
         entries.sort((a, b) => a.name.localeCompare(b.name));
         return entries;
     }
-    async delete(path) {
-        await this._invoke("delete", { path, recursive: null });
+    async stat(path) {
+        const response = await this._invoke("stat", { path });
+        if (!(response instanceof response_1.JsonContent) || typeof response.json["exists"] !== "boolean") {
+            throw this._unexpectedResponseError("stat");
+        }
+        if (!response.json["exists"]) {
+            return null;
+        }
+        return this._storageEntry("stat", response.json);
+    }
+    async delete(path, { recursive = null, } = {}) {
+        await this._invoke("delete", { path, recursive });
     }
     async exists(path) {
         const result = await this._invoke("exists", { path });
@@ -91,6 +162,22 @@ class StorageClient extends event_emitter_1.EventEmitter {
         const lastSegment = segments.length > 0 ? segments[segments.length - 1] : undefined;
         return lastSegment ?? path;
     }
+    _defaultUploadMimeType(name, mimeType) {
+        if (typeof mimeType === "string" && mimeType.length > 0) {
+            return mimeType;
+        }
+        const lowerName = name.toLowerCase();
+        for (const [suffix, contentType] of _UPLOAD_MIME_TYPES_BY_SUFFIX.entries()) {
+            if (lowerName.endsWith(suffix)) {
+                return contentType;
+            }
+        }
+        const lastDot = lowerName.lastIndexOf(".");
+        if (lastDot >= 0) {
+            return _UPLOAD_MIME_TYPES_BY_EXTENSION.get(lowerName.slice(lastDot)) ?? _DEFAULT_UPLOAD_MIME_TYPE;
+        }
+        return _DEFAULT_UPLOAD_MIME_TYPE;
+    }
     async upload(path, bytes, { overwrite = false, name, mimeType = null, } = {}) {
         async function* singleChunk() {
             yield bytes;
@@ -104,6 +191,7 @@ class StorageClient extends event_emitter_1.EventEmitter {
     }
     async uploadStream(path, chunks, { overwrite = false, chunkSize = 64 * 1024, size = null, name, mimeType = null, } = {}) {
         const resolvedName = this._defaultUploadName(path, name);
+        const resolvedMimeType = this._defaultUploadMimeType(resolvedName, mimeType);
         const input = new _StorageUploadInputStream({
             path,
             overwrite,
@@ -111,7 +199,7 @@ class StorageClient extends event_emitter_1.EventEmitter {
             chunkSize,
             size,
             name: resolvedName,
-            mimeType,
+            mimeType: resolvedMimeType,
         });
         const response = await this.client.invokeStream({
             toolkit: "storage",
@@ -135,7 +223,10 @@ class StorageClient extends event_emitter_1.EventEmitter {
                 if (chunk.headers["kind"] !== "pull") {
                     throw this._unexpectedResponseError("upload");
                 }
-                input.requestNext();
+                const rawChunkSize = chunk.headers["chunk_size"];
+                input.requestNext(typeof rawChunkSize === "number" && rawChunkSize > 0
+                    ? rawChunkSize
+                    : null);
             }
         }
         finally {
@@ -326,7 +417,7 @@ class _StorageDownloadInputStream {
 class _StorageUploadInputStream {
     constructor({ path, overwrite, chunks, chunkSize, size, name, mimeType, }) {
         this.closed = false;
-        this.pendingPulls = 0;
+        this.pendingPulls = [];
         this.waitingResolver = null;
         this.pendingChunk = new Uint8Array(0);
         this.pendingOffset = 0;
@@ -339,11 +430,11 @@ class _StorageUploadInputStream {
         this.name = name;
         this.mimeType = mimeType;
     }
-    requestNext() {
+    requestNext(chunkSize = null) {
         if (this.closed) {
             return;
         }
-        this.pendingPulls += 1;
+        this.pendingPulls.push(chunkSize);
         if (this.waitingResolver) {
             const resolver = this.waitingResolver;
             this.waitingResolver = null;
@@ -361,21 +452,26 @@ class _StorageUploadInputStream {
             resolver();
         }
     }
-    async nextChunk() {
-        while (true) {
+    async nextChunk(requestedChunkSize) {
+        const parts = [];
+        let totalLength = 0;
+        while (totalLength < requestedChunkSize) {
             if (this.pendingOffset < this.pendingChunk.length) {
                 const start = this.pendingOffset;
-                const end = Math.min(start + this.chunkSize, this.pendingChunk.length);
+                const end = Math.min(start + (requestedChunkSize - totalLength), this.pendingChunk.length);
+                const part = this.pendingChunk.slice(start, end);
                 this.pendingOffset = end;
-                return this.pendingChunk.slice(start, end);
+                parts.push(part);
+                totalLength += part.length;
+                continue;
             }
             if (this.sourceExhausted) {
-                return null;
+                break;
             }
             const next = await this.source.next();
             if (next.done) {
                 this.sourceExhausted = true;
-                return null;
+                break;
             }
             if (next.value.length === 0) {
                 continue;
@@ -383,6 +479,19 @@ class _StorageUploadInputStream {
             this.pendingChunk = next.value;
             this.pendingOffset = 0;
         }
+        if (totalLength === 0) {
+            return null;
+        }
+        if (parts.length === 1) {
+            return parts[0];
+        }
+        const combined = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const part of parts) {
+            combined.set(part, offset);
+            offset += part.length;
+        }
+        return combined;
     }
     async *stream() {
         yield new response_1.BinaryContent({
@@ -397,7 +506,7 @@ class _StorageUploadInputStream {
             },
         });
         while (!this.closed) {
-            if (this.pendingPulls === 0) {
+            if (this.pendingPulls.length === 0) {
                 await new Promise((resolve) => {
                     this.waitingResolver = resolve;
                 });
@@ -405,11 +514,13 @@ class _StorageUploadInputStream {
             if (this.closed) {
                 return;
             }
-            if (this.pendingPulls === 0) {
+            if (this.pendingPulls.length === 0) {
                 continue;
             }
-            this.pendingPulls -= 1;
-            const chunk = await this.nextChunk();
+            const requestedChunkSize = this.pendingPulls.shift();
+            const chunk = await this.nextChunk(typeof requestedChunkSize === "number" && requestedChunkSize > 0
+                ? requestedChunkSize
+                : this.chunkSize);
             if (chunk == null) {
                 return;
             }

package/dist/esm/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[]>;