@nosana/node 1.1.22 → 1.1.23

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nosana/node",
-    "version": "1.1.22",
+    "version": "1.1.23",
     "description": "",
     "bin": {
         "nosana-node": "./dist/src/index.js"

package/dist/src/NodeManager/node/utils/extractLogsAndResultsFromLogBuffer.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import type { OperationResults, Log } from '@nosana/sdk';
-export declare function extractLogsAndResultsFromLogBuffer(logBuffer: Buffer, operationResults: OperationResults | undefined, expiryTimeout?: number): {
+export declare function extractLogsAndResultsFromLogBuffer(logBuffer: Buffer, operationResults: OperationResults | undefined): {
     logs: Log[];
     results: {} | undefined;
 };

package/dist/src/NodeManager/node/utils/extractLogsAndResultsFromLogBuffer.js

@@ -1,34 +1,14 @@
-import { parseBuffer } from '../../provider/utils/parseBuffer.js';
+import { parseLogFrames } from '../../provider/utils/parseBuffer.js';
 import { createResultsObject, extractResultFromLog, } from './extractResultsFromLogs.js';
-export function extractLogsAndResultsFromLogBuffer(logBuffer, operationResults, expiryTimeout = 180) {
-    const logs = [];
+export function extractLogsAndResultsFromLogBuffer(logBuffer, operationResults) {
     const results = operationResults
         ? createResultsObject(operationResults)
         : undefined;
-    let index = 0, running = true;
-    const timer = setTimeout(() => {
-        running = false;
-        logs.push({
-            type: 'nodeerr',
-            log: 'Took too long to retrive all logs',
-            timestamp: new Date().toISOString(),
-        });
-    }, expiryTimeout);
-    while (index < logBuffer.length && running) {
-        const log = parseBuffer(logBuffer, index);
-        logs.push(log);
-        if (results && operationResults) {
+    const { logs } = parseLogFrames(logBuffer);
+    if (results && operationResults) {
+        for (const log of logs) {
             extractResultFromLog(results, log, operationResults);
         }
-        if (logs.length >= 25000) {
-            running = false;
-            logs.push({
-                type: 'nodeerr',
-                log: 'Found too many logs...',
-                timestamp: new Date().toISOString(),
-            });
-        }
     }
-    clearTimeout(timer);
     return { logs, results };
 }

package/dist/src/NodeManager/provider/ContainerStateManager.d.ts

@@ -11,6 +11,7 @@ export declare class ContainerStateManager {
     private state;
     private exitedCheckCount;
     private lastLogTimestamp;
+    private logRemainder;
     private readonly EXITED_CHECKS_REQUIRED;
     private currentLogStream;
     private currentStatsStream;
@@ -20,6 +21,19 @@ export declare class ContainerStateManager {
     startMonitoring(): Promise<void>;
     private attachLogStream;
     waitForExit(): Promise<void>;
+    /**
+     * Wait for the followed log stream to finish delivering its final buffered
+     * frames after the container has exited.
+     *
+     * `container.wait()` (which drives `waitForExit`) and the log stream are
+     * independent connections, so when `wait()` reports the exit the stream may
+     * still be flushing the last lines (e.g. an op's final result line). Reading
+     * logs or tearing the stream down at that point loses them. The stream's
+     * `close` handler nulls `currentLogStream`, and it won't re-attach once the
+     * container has exited, so a null stream means the flush is complete. Bounded
+     * so a stream that never closes can't stall completion.
+     */
+    waitForLogsDrained(timeoutMs?: number): Promise<void>;
     stopMonitoring(): void;
     private readonly STATS_INTERVAL_MS;
     private attachStatsStream;

package/dist/src/NodeManager/provider/ContainerStateManager.js

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
 import { createInterface } from 'readline';
-import { parseBuffer } from './utils/parseBuffer.js';
+import { parseLogFrames } from './utils/parseBuffer.js';
 import { parseDockerStat } from './utils/parseDockerStat.js';
 import { liveAbortSignal } from '../utils/liveAbortSignal.js';
 function destroyStream(stream) {
@@ -20,6 +20,7 @@ export class ContainerStateManager {
         this.state = 'starting';
         this.exitedCheckCount = 0;
         this.lastLogTimestamp = 0; // Unix timestamp in seconds from actual container logs
+        this.logRemainder = Buffer.alloc(0); // trailing partial frame between chunks
         this.EXITED_CHECKS_REQUIRED = 3; // Require 3 consecutive checks before confirming exit
         this.currentLogStream = null;
         this.currentStatsStream = null;
@@ -78,6 +79,9 @@ export class ContainerStateManager {
         // container we're tearing down. Mirrors `attachStatsStream`.
         if (this.controller.signal.aborted)
             return;
+        // Any partial frame buffered from a previous stream can never be completed
+        // by this freshly re-attached stream, so start clean.
+        this.logRemainder = Buffer.alloc(0);
         try {
             this.currentLogStream = await this.container.logs({
                 stdout: true,
@@ -88,11 +92,18 @@ export class ContainerStateManager {
                 abortSignal: liveAbortSignal(this.controller.signal),
             });
             this.currentLogStream.on('data', (data) => {
-                const { log, type, timestamp } = parseBuffer(data);
-                if (!log)
-                    return;
-                this.lastLogTimestamp = Math.floor(new Date(timestamp).getTime() / 1000);
-                this.emitter.emit('log', log, type, 'container', timestamp);
+                // A single 'data' event can carry several multiplexed frames (Docker
+                // coalesces output, especially the final flush at container exit) and
+                // can split one frame across events. Decode every complete frame and
+                // carry any partial trailing frame over to the next chunk.
+                const { logs, rest } = parseLogFrames(Buffer.concat([this.logRemainder, data]));
+                this.logRemainder = rest;
+                for (const { log, type, timestamp } of logs) {
+                    if (!log)
+                        continue;
+                    this.lastLogTimestamp = Math.floor(new Date(timestamp).getTime() / 1000);
+                    this.emitter.emit('log', log, type, 'container', timestamp);
+                }
             });
             this.currentLogStream.on('close', () => {
                 this.currentLogStream = null;
@@ -125,6 +136,26 @@ export class ContainerStateManager {
             }, 500);
         });
     }
+    /**
+     * Wait for the followed log stream to finish delivering its final buffered
+     * frames after the container has exited.
+     *
+     * `container.wait()` (which drives `waitForExit`) and the log stream are
+     * independent connections, so when `wait()` reports the exit the stream may
+     * still be flushing the last lines (e.g. an op's final result line). Reading
+     * logs or tearing the stream down at that point loses them. The stream's
+     * `close` handler nulls `currentLogStream`, and it won't re-attach once the
+     * container has exited, so a null stream means the flush is complete. Bounded
+     * so a stream that never closes can't stall completion.
+     */
+    async waitForLogsDrained(timeoutMs = 3000) {
+        const deadline = Date.now() + timeoutMs;
+        while (this.currentLogStream !== null) {
+            if (this.controller.signal.aborted || Date.now() >= deadline)
+                return;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
     stopMonitoring() {
         if (this.pollingInterval) {
             clearInterval(this.pollingInterval);

package/dist/src/NodeManager/provider/Provider.js

@@ -266,6 +266,10 @@ export class Provider {
                     emitter.emit('healthcheck:startup:success');
                 }
                 await stateManager.waitForExit();
+                // `wait()` reporting the exit and the log stream finishing its final
+                // flush are independent; drain the stream before results are read off
+                // the logs so the last line (e.g. the op's result) isn't lost.
+                await stateManager.waitForLogsDrained();
             }
             const info = await promiseTimeoutWrapper(container.inspect({
                 abortSignal: liveAbortSignal(controller.signal),

package/dist/src/NodeManager/provider/utils/parseBuffer.d.ts

@@ -1,4 +1,17 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { Log } from '@nosana/sdk';
+/**
+ * Demultiplex every complete Docker log frame contained in `buffer`.
+ *
+ * A non-TTY container log stream is a sequence of frames, each an 8-byte header
+ * (stream type + big-endian payload length) followed by the payload. The stream
+ * layer may pack several frames into one read *and* split a single frame across
+ * reads, so a caller following a live stream must feed the returned `rest` (an
+ * incomplete trailing frame, if any) back in alongside the next chunk.
+ */
+export declare function parseLogFrames(buffer: Buffer): {
+    logs: Log[];
+    rest: Buffer;
+};
 export declare function parseBuffer(buffer: Buffer, index?: number): Log;

package/dist/src/NodeManager/provider/utils/parseBuffer.js

@@ -1,4 +1,27 @@
 const TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})\s/;
+const DOCKER_LOG_HEADER_BYTES = 8;
+/**
+ * Demultiplex every complete Docker log frame contained in `buffer`.
+ *
+ * A non-TTY container log stream is a sequence of frames, each an 8-byte header
+ * (stream type + big-endian payload length) followed by the payload. The stream
+ * layer may pack several frames into one read *and* split a single frame across
+ * reads, so a caller following a live stream must feed the returned `rest` (an
+ * incomplete trailing frame, if any) back in alongside the next chunk.
+ */
+export function parseLogFrames(buffer) {
+    const logs = [];
+    let index = 0;
+    while (index + DOCKER_LOG_HEADER_BYTES <= buffer.length) {
+        const chunkLength = buffer.readUInt32BE(index + 4);
+        const end = index + DOCKER_LOG_HEADER_BYTES + chunkLength;
+        if (end > buffer.length)
+            break; // frame has not fully arrived yet
+        logs.push(parseBuffer(buffer, index));
+        index = end;
+    }
+    return { logs, rest: buffer.subarray(index) };
+}
 export function parseBuffer(buffer, index = 0) {
     const head = buffer.subarray(index, (index += 8));
     const chunkType = head.readUInt8(0);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.22",
+  "version": "1.1.23",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@nosana/node",
-      "version": "1.1.22",
+      "version": "1.1.23",
       "license": "ISC",
       "dependencies": {
         "@coral-xyz/anchor": "^0.28.1-beta.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.22",
+  "version": "1.1.23",
   "description": "",
   "bin": {
     "nosana-node": "./dist/src/index.js"