@meshagent/meshagent 0.39.7 → 0.39.9

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.39.9]
+- Added streaming `watchTable` support to the TypeScript DatasetsClient to receive dataset table change events with versioning metadata.
+
+## [0.39.8]
+- TypeScript API: `RoomContainer` now includes a required `ports: number[]` field (and validation) in container listings
+- TypeScript API: `ContainerSpec` now supports optional fields `private`, `on_demand`, and `writable_root_fs`
+- React developer-console package: refactored view switching to use strongly-typed tab configs and reorganized the console UI into grouped primary/resource/terminal tab groups
+- React developer-console package: updated console layouts to wire the developer terminal/container/image/logs/metrics/traces panes into the new tab/view structure
+- Build tooling: developer-console package `build:types` now runs declaration-path rewrite as part of type generation
+
 ## [0.39.7]
 - Updated Meshagent JS/TS package manifests so inter-package dependencies are aligned to the new Meshagent version (`@meshagent/*` packages now depend on the updated `^0.39.6` versions).
 

package/dist/browser/datasets-client.d.ts

@@ -123,6 +123,16 @@ export type DatasetSqlCancelStatus = "cancelled" | "cancelling" | "not_cancellab
 export interface DatasetSqlCancelResult {
     status: DatasetSqlCancelStatus;
 }
+export interface DatasetWatchEvent {
+    kind: "data" | "ready";
+    phase?: string;
+    table?: Table;
+    version?: number;
+    changeType?: string;
+    beginVersion?: number;
+    endVersion?: number;
+    watchEvent?: string;
+}
 export declare abstract class DatasetValueEncoder {
     abstract encodeDatasetValue(): unknown;
 }
@@ -368,6 +378,12 @@ export declare class DatasetsClient {
         branch?: string;
         version?: number;
     }): AsyncIterable<Table>;
+    watchTable({ table, namespace, branch, pollIntervalSeconds }: {
+        table: string;
+        namespace?: string[];
+        branch?: string;
+        pollIntervalSeconds?: number;
+    }): AsyncIterable<DatasetWatchEvent>;
     count({ table, text, vector, where, namespace, branch, version }: {
         table: string;
         text?: string;

package/dist/browser/datasets-client.js

@@ -444,6 +444,18 @@ function tableBranchFromJson(value) {
         manifestSize: value.manifest_size ?? null,
     };
 }
+function optionalDatasetInt(value) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+    }
+    if (typeof value === "string" && /^-?\d+$/.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    return undefined;
+}
+function optionalDatasetString(value) {
+    return typeof value === "string" ? value : undefined;
+}
 class DatasetWriteInputStream {
     constructor(start, chunks) {
         this.start = start;
@@ -1130,6 +1142,63 @@ class DatasetsClient {
             version: version ?? null,
         });
     }
+    async *watchTable({ table, namespace, branch, pollIntervalSeconds = 0.5 }) {
+        const input = new DatasetArrowReadInputStream({
+            kind: "start",
+            table,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+            poll_interval_seconds: pollIntervalSeconds,
+        });
+        const response = await this.invokeStream("watch_table", input.stream());
+        input.requestNext();
+        try {
+            for await (const chunk of response) {
+                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") {
+                        return;
+                    }
+                    throw this._unexpectedResponseError("watch_table");
+                }
+                if (chunk instanceof response_1.BinaryContent) {
+                    if (chunk.headers.kind !== "data") {
+                        throw this._unexpectedResponseError("watch_table");
+                    }
+                    yield {
+                        kind: "data",
+                        phase: optionalDatasetString(chunk.headers.phase),
+                        table: tableFromIPCBytes(chunk.data),
+                        version: optionalDatasetInt(chunk.headers.version),
+                        changeType: optionalDatasetString(chunk.headers.change_type),
+                        beginVersion: optionalDatasetInt(chunk.headers.begin_version),
+                        endVersion: optionalDatasetInt(chunk.headers.end_version),
+                        watchEvent: optionalDatasetString(chunk.headers.watch_event),
+                    };
+                    input.requestNext();
+                    continue;
+                }
+                if (chunk instanceof response_1.JsonContent) {
+                    if (chunk.json.kind !== "ready") {
+                        throw this._unexpectedResponseError("watch_table");
+                    }
+                    yield {
+                        kind: "ready",
+                        phase: optionalDatasetString(chunk.json.phase),
+                        version: optionalDatasetInt(chunk.json.version),
+                    };
+                    input.requestNext();
+                    continue;
+                }
+                throw this._unexpectedResponseError("watch_table");
+            }
+        }
+        finally {
+            input.close();
+        }
+    }
     async count({ table, text, vector, where, namespace, branch, version }) {
         const response = await this.invoke("count", {
             table,

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

@@ -123,6 +123,16 @@ export type DatasetSqlCancelStatus = "cancelled" | "cancelling" | "not_cancellab
 export interface DatasetSqlCancelResult {
     status: DatasetSqlCancelStatus;
 }
+export interface DatasetWatchEvent {
+    kind: "data" | "ready";
+    phase?: string;
+    table?: Table;
+    version?: number;
+    changeType?: string;
+    beginVersion?: number;
+    endVersion?: number;
+    watchEvent?: string;
+}
 export declare abstract class DatasetValueEncoder {
     abstract encodeDatasetValue(): unknown;
 }
@@ -368,6 +378,12 @@ export declare class DatasetsClient {
         branch?: string;
         version?: number;
     }): AsyncIterable<Table>;
+    watchTable({ table, namespace, branch, pollIntervalSeconds }: {
+        table: string;
+        namespace?: string[];
+        branch?: string;
+        pollIntervalSeconds?: number;
+    }): AsyncIterable<DatasetWatchEvent>;
     count({ table, text, vector, where, namespace, branch, version }: {
         table: string;
         text?: string;

package/dist/esm/datasets-client.js

@@ -444,6 +444,18 @@ function tableBranchFromJson(value) {
         manifestSize: value.manifest_size ?? null,
     };
 }
+function optionalDatasetInt(value) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+    }
+    if (typeof value === "string" && /^-?\d+$/.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    return undefined;
+}
+function optionalDatasetString(value) {
+    return typeof value === "string" ? value : undefined;
+}
 class DatasetWriteInputStream {
     constructor(start, chunks) {
         this.start = start;
@@ -1130,6 +1142,63 @@ class DatasetsClient {
             version: version ?? null,
         });
     }
+    async *watchTable({ table, namespace, branch, pollIntervalSeconds = 0.5 }) {
+        const input = new DatasetArrowReadInputStream({
+            kind: "start",
+            table,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+            poll_interval_seconds: pollIntervalSeconds,
+        });
+        const response = await this.invokeStream("watch_table", input.stream());
+        input.requestNext();
+        try {
+            for await (const chunk of response) {
+                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") {
+                        return;
+                    }
+                    throw this._unexpectedResponseError("watch_table");
+                }
+                if (chunk instanceof response_1.BinaryContent) {
+                    if (chunk.headers.kind !== "data") {
+                        throw this._unexpectedResponseError("watch_table");
+                    }
+                    yield {
+                        kind: "data",
+                        phase: optionalDatasetString(chunk.headers.phase),
+                        table: tableFromIPCBytes(chunk.data),
+                        version: optionalDatasetInt(chunk.headers.version),
+                        changeType: optionalDatasetString(chunk.headers.change_type),
+                        beginVersion: optionalDatasetInt(chunk.headers.begin_version),
+                        endVersion: optionalDatasetInt(chunk.headers.end_version),
+                        watchEvent: optionalDatasetString(chunk.headers.watch_event),
+                    };
+                    input.requestNext();
+                    continue;
+                }
+                if (chunk instanceof response_1.JsonContent) {
+                    if (chunk.json.kind !== "ready") {
+                        throw this._unexpectedResponseError("watch_table");
+                    }
+                    yield {
+                        kind: "ready",
+                        phase: optionalDatasetString(chunk.json.phase),
+                        version: optionalDatasetInt(chunk.json.version),
+                    };
+                    input.requestNext();
+                    continue;
+                }
+                throw this._unexpectedResponseError("watch_table");
+            }
+        }
+        finally {
+            input.close();
+        }
+    }
     async count({ table, text, vector, where, namespace, branch, version }) {
         const response = await this.invoke("count", {
             table,

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

@@ -123,6 +123,16 @@ export type DatasetSqlCancelStatus = "cancelled" | "cancelling" | "not_cancellab
 export interface DatasetSqlCancelResult {
     status: DatasetSqlCancelStatus;
 }
+export interface DatasetWatchEvent {
+    kind: "data" | "ready";
+    phase?: string;
+    table?: Table;
+    version?: number;
+    changeType?: string;
+    beginVersion?: number;
+    endVersion?: number;
+    watchEvent?: string;
+}
 export declare abstract class DatasetValueEncoder {
     abstract encodeDatasetValue(): unknown;
 }
@@ -368,6 +378,12 @@ export declare class DatasetsClient {
         branch?: string;
         version?: number;
     }): AsyncIterable<Table>;
+    watchTable({ table, namespace, branch, pollIntervalSeconds }: {
+        table: string;
+        namespace?: string[];
+        branch?: string;
+        pollIntervalSeconds?: number;
+    }): AsyncIterable<DatasetWatchEvent>;
     count({ table, text, vector, where, namespace, branch, version }: {
         table: string;
         text?: string;

package/dist/node/datasets-client.js

@@ -444,6 +444,18 @@ function tableBranchFromJson(value) {
         manifestSize: value.manifest_size ?? null,
     };
 }
+function optionalDatasetInt(value) {
+    if (typeof value === "number" && Number.isInteger(value)) {
+        return value;
+    }
+    if (typeof value === "string" && /^-?\d+$/.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    return undefined;
+}
+function optionalDatasetString(value) {
+    return typeof value === "string" ? value : undefined;
+}
 class DatasetWriteInputStream {
     constructor(start, chunks) {
         this.start = start;
@@ -1130,6 +1142,63 @@ class DatasetsClient {
             version: version ?? null,
         });
     }
+    async *watchTable({ table, namespace, branch, pollIntervalSeconds = 0.5 }) {
+        const input = new DatasetArrowReadInputStream({
+            kind: "start",
+            table,
+            namespace: namespace ?? null,
+            branch: branch ?? null,
+            poll_interval_seconds: pollIntervalSeconds,
+        });
+        const response = await this.invokeStream("watch_table", input.stream());
+        input.requestNext();
+        try {
+            for await (const chunk of response) {
+                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") {
+                        return;
+                    }
+                    throw this._unexpectedResponseError("watch_table");
+                }
+                if (chunk instanceof response_1.BinaryContent) {
+                    if (chunk.headers.kind !== "data") {
+                        throw this._unexpectedResponseError("watch_table");
+                    }
+                    yield {
+                        kind: "data",
+                        phase: optionalDatasetString(chunk.headers.phase),
+                        table: tableFromIPCBytes(chunk.data),
+                        version: optionalDatasetInt(chunk.headers.version),
+                        changeType: optionalDatasetString(chunk.headers.change_type),
+                        beginVersion: optionalDatasetInt(chunk.headers.begin_version),
+                        endVersion: optionalDatasetInt(chunk.headers.end_version),
+                        watchEvent: optionalDatasetString(chunk.headers.watch_event),
+                    };
+                    input.requestNext();
+                    continue;
+                }
+                if (chunk instanceof response_1.JsonContent) {
+                    if (chunk.json.kind !== "ready") {
+                        throw this._unexpectedResponseError("watch_table");
+                    }
+                    yield {
+                        kind: "ready",
+                        phase: optionalDatasetString(chunk.json.phase),
+                        version: optionalDatasetInt(chunk.json.version),
+                    };
+                    input.requestNext();
+                    continue;
+                }
+                throw this._unexpectedResponseError("watch_table");
+            }
+        }
+        finally {
+            input.close();
+        }
+    }
     async count({ table, text, vector, where, namespace, branch, version }) {
         const response = await this.invoke("count", {
             table,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.39.7",
+    "version": "0.39.9",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {