firedrill-run 3.0.2 → 3.0.3

package/dist/assembly.json

@@ -1,7 +1,7 @@
 {
   "schema": "firedrill.cli-assembly.v1",
   "package": "firedrill-run",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "entry": "cli/src/main.js",
   "helpers": [
     "cli/runtime/source_snapshot.py",

package/dist/cli/src/request-input.js

@@ -2,13 +2,88 @@ import { constants } from 'node:fs';
 import { lstat, open } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { CliError } from './http.js';
+/** Consume a pipe once without leaving an abort waiting for another byte. */
+async function stdinInput(signal, maximumBytes) {
+    signal.throwIfAborted();
+    const input = process.stdin;
+    if (input.isTTY || input.readableEncoding !== null) {
+        throw new CliError('request_stdin_invalid', 'Pipe one UTF-8 JSON object into --file -. Nothing was submitted.', 2);
+    }
+    const chunks = await new Promise((accept, reject) => {
+        const collected = [];
+        let size = 0;
+        let settled = false;
+        const invalid = () => new CliError('request_stdin_invalid', 'Standard input must contain one JSON object within transport capacity. Nothing was submitted.', 2);
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            input.pause();
+            input.removeListener('data', data);
+            input.removeListener('end', end);
+            input.removeListener('error', failed);
+            input.removeListener('close', closed);
+            signal.removeEventListener('abort', aborted);
+            if (error !== undefined)
+                reject(error);
+            else
+                accept(collected);
+        };
+        const data = (chunk) => {
+            if (!Buffer.isBuffer(chunk)) {
+                finish(invalid());
+                return;
+            }
+            size += chunk.length;
+            if (size > maximumBytes) {
+                finish(invalid());
+                return;
+            }
+            collected.push(Buffer.from(chunk));
+        };
+        const end = () => finish();
+        const failed = () => finish(invalid());
+        const closed = () => { if (!input.readableEnded)
+            finish(invalid()); };
+        const aborted = () => finish(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+        input.on('data', data);
+        input.once('end', end);
+        input.once('error', failed);
+        input.once('close', closed);
+        signal.addEventListener('abort', aborted, { once: true });
+        // EOF or cancellation can precede listener installation. Never wait for an
+        // event that has already happened, including an idle pipe on cancellation.
+        if (signal.aborted)
+            aborted();
+        else if (input.readableEnded)
+            end();
+        else if (input.destroyed)
+            failed();
+        else
+            input.resume();
+    });
+    signal.throwIfAborted();
+    try {
+        const raw = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error();
+        return raw;
+    }
+    catch {
+        throw new CliError('request_stdin_invalid', 'Standard input is not a UTF-8 JSON object. Nothing was submitted.', 2);
+    }
+}
 /** Read one bounded, unchanged JSON object without rewriting number literals. */
 export async function requestInput(path, signal, maximumBytes = 8 * 1024 * 1024) {
+    signal.throwIfAborted();
     if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 2 || maximumBytes > 8 * 1024 * 1024) {
         throw new CliError('request_capacity_invalid', 'Choose a supported request capacity.', 2);
     }
     if (!path)
         return '{}';
+    if (path === '-')
+        return stdinInput(signal, maximumBytes);
     const before = await lstat(resolve(path));
     if (!before.isFile() || before.isSymbolicLink() || before.size > maximumBytes) {
         throw new CliError('request_file_invalid', 'Choose a regular JSON file within transport capacity.', 2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firedrill-run",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "Local AI agent simulations with cloud-hosted worlds and tools",
   "type": "module",
   "bin": {