@ricsam/r5d-worker 0.0.110 → 0.0.112

package/dist/mjs/command-launcher.mjs

@@ -0,0 +1,316 @@
+import { spawn } from "node:child_process";
+class CommandLauncherUnavailableError extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "CommandLauncherUnavailableError";
+  }
+}
+class CommandLaunchCancelledError extends Error {
+  constructor() {
+    super("Command cancelled before it started");
+    this.name = "CommandLaunchCancelledError";
+  }
+}
+function parseCommandLauncher(configuration) {
+  if (configuration === void 0) return void 0;
+  let argv;
+  try {
+    argv = JSON.parse(configuration);
+  } catch {
+    throw new Error("R5D_WORKER_COMMAND_LAUNCHER must be a JSON argv array");
+  }
+  if (!Array.isArray(argv) || argv.length === 0 || argv.some((part) => typeof part !== "string" || part.includes("\0")) || !argv[0])
+    throw new Error("R5D_WORKER_COMMAND_LAUNCHER must be a nonempty JSON argv array without NUL characters");
+  return argv;
+}
+function commandLauncherEnvironment(source = process.env) {
+  const result = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (/^(PATH|HOME|USER|LOGNAME|TMP|TMPDIR|TEMP|SHELL|SYSTEMROOT|COMSPEC|PATHEXT|LANG|LC_[A-Z_]+)$/i.test(key)) result[key] = value;
+  }
+  return result;
+}
+class WorkerCommandLauncher {
+  constructor(options = {}) {
+    this.options = options;
+    this.mode = options.argv ? "external" : "direct";
+    if (!options.argv) {
+      this.exited = Promise.resolve();
+      return;
+    }
+    this.child = spawn(options.argv[0], options.argv.slice(1), {
+      env: options.env ?? commandLauncherEnvironment(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.exited = new Promise((resolve) => {
+      this.child.once("close", (code, signal) => {
+        if (!this.closing) this.fail(new Error(`Configured command launcher exited (${signal ?? code ?? "unknown"})`));
+        resolve();
+      });
+    });
+    this.child.once("error", (error) => this.fail(error));
+    this.child.stdin.on("error", (error) => {
+      if (!this.closing) this.fail(error);
+    });
+    let buffered = "";
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (data) => {
+      buffered += data;
+      if (Buffer.byteLength(buffered) > 1024 * 1024) {
+        this.fail(new Error("Command launcher response exceeded the protocol limit"));
+        return;
+      }
+      while (buffered.includes("\n")) {
+        const newline = buffered.indexOf("\n");
+        const line = buffered.slice(0, newline);
+        buffered = buffered.slice(newline + 1);
+        try {
+          this.receive(JSON.parse(line));
+        } catch (error) {
+          this.fail(error instanceof Error ? error : new Error(String(error)));
+          return;
+        }
+      }
+    });
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (data) => options.onStderr?.(data));
+  }
+  options;
+  mode;
+  child;
+  pending = /* @__PURE__ */ new Map();
+  launches = /* @__PURE__ */ new Map();
+  exited;
+  failure;
+  closing = false;
+  initialized = false;
+  closePromise;
+  sequence = 0;
+  async initialize() {
+    this.assertHealthy();
+    if (this.initialized) return;
+    if (this.child) {
+      try {
+        await this.rpc("initialize");
+      } catch (error) {
+        this.fail(error instanceof Error ? error : new Error(String(error)));
+        await this.close();
+        throw error;
+      }
+    }
+    this.initialized = true;
+  }
+  get activeIds() {
+    return [...this.launches.keys()];
+  }
+  async acquire(request) {
+    this.assertHealthy();
+    if (!this.initialized) throw new Error("Command launcher is not initialized");
+    request.assertAdmission();
+    if (this.launches.has(request.id)) throw new Error(`Duplicate command launch identity: ${request.id}`);
+    let rejectAdmission;
+    const cancellation = new Promise((_resolve, reject) => {
+      rejectAdmission = reject;
+    });
+    void cancellation.catch(() => {
+    });
+    const record = { request, revoked: false, released: false, rejectAdmission };
+    this.launches.set(request.id, record);
+    let prefix = [];
+    let admissionTimer;
+    try {
+      if (this.child) {
+        const { assertAdmission: _assertAdmission, ...fields } = request;
+        const acquisition = this.rpc("acquire", fields, this.options.acquisitionTimeoutMs ?? 9e4).then(async (result) => {
+          if (record.revoked) {
+            await this.releaseRecord(record);
+            throw new CommandLaunchCancelledError();
+          }
+          if (!Array.isArray(result.argvPrefix) || result.argvPrefix.some((part) => typeof part !== "string" || part.includes("\0")))
+            throw this.fail(new Error("Command launcher acquire returned an invalid argvPrefix"));
+          return result.argvPrefix;
+        });
+        admissionTimer = setInterval(() => {
+          try {
+            request.assertAdmission();
+          } catch (error) {
+            record.revoked = true;
+            record.rejectAdmission(error);
+            void this.cancel(request.id).catch(() => {
+            });
+          }
+        }, 100);
+        prefix = await Promise.race([acquisition, cancellation]);
+      }
+      request.assertAdmission();
+      this.assertHealthy();
+      if (record.revoked) throw new CommandLaunchCancelledError();
+    } catch (error) {
+      if (!this.failure && !this.closing) await this.releaseRecord(record);
+      throw error;
+    } finally {
+      if (admissionTimer) clearInterval(admissionTimer);
+    }
+    return {
+      wrap: (argv) => {
+        this.assertHealthy();
+        request.assertAdmission();
+        if (record.revoked) throw new CommandLaunchCancelledError();
+        if (record.released) throw new Error("Command launch lease is already released");
+        if (!argv.length) throw new Error("Command argv must not be empty");
+        return [...prefix, ...argv];
+      },
+      cancel: () => this.cancel(request.id),
+      diagnose: async () => {
+        this.assertHealthy();
+        if (!this.child) return void 0;
+        try {
+          const result = await this.rpc("diagnose", { id: request.id });
+          if (result.message !== void 0 && typeof result.message !== "string")
+            throw new Error("Command launcher returned an invalid diagnostic");
+          return result.message;
+        } catch (error) {
+          throw this.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+      },
+      release: () => this.releaseRecord(record)
+    };
+  }
+  async cancel(id) {
+    const record = this.launches.get(id);
+    if (!record || record.released) return;
+    record.revoked = true;
+    record.rejectAdmission(new CommandLaunchCancelledError());
+    if (this.child) {
+      try {
+        await this.rpc("cancel", { id });
+      } catch (error) {
+        throw this.fail(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+  async cancelSession(sessionId) {
+    await this.cancelMatching((_id, ownerSessionId) => ownerSessionId === sessionId);
+  }
+  async cancelMatching(matches) {
+    const results = await Promise.allSettled(
+      [...this.launches].filter(([id, record]) => matches(id, record.request.sessionId)).map(([id]) => this.cancel(id))
+    );
+    const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (errors.length) throw new AggregateError(errors, "Command launcher cancellation was incomplete");
+  }
+  close() {
+    return this.closePromise ??= (async () => {
+      this.closing = true;
+      for (const record of this.launches.values()) {
+        record.revoked = true;
+        record.rejectAdmission(new CommandLaunchCancelledError());
+      }
+      this.rejectPending(new CommandLauncherUnavailableError("Command launcher is shutting down"));
+      this.child?.stdin.end();
+      const exited = await this.waitForExit(6e3);
+      if (!exited) {
+        this.child?.kill("SIGKILL");
+        await this.waitForExit(1e3);
+      }
+    })();
+  }
+  async waitForExit(timeoutMs) {
+    let timer;
+    try {
+      return await Promise.race([
+        this.exited.then(() => true),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(false), timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  releaseRecord(record) {
+    return record.release ??= (async () => {
+      record.revoked = true;
+      if (this.child) {
+        try {
+          await this.rpc("release", { id: record.request.id });
+        } catch (error) {
+          throw this.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      record.released = true;
+      this.launches.delete(record.request.id);
+    })();
+  }
+  assertHealthy() {
+    if (this.failure) throw this.failure;
+    if (this.closing) throw new CommandLauncherUnavailableError("Command launcher is shutting down");
+  }
+  rpc(method, fields = {}, timeoutMs = this.options.requestTimeoutMs ?? 1e4) {
+    try {
+      this.assertHealthy();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const requestId = String(++this.sequence);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => this.fail(new Error(`Command launcher ${method} request timed out`)), timeoutMs);
+      this.pending.set(requestId, { resolve, reject, timer });
+      this.child.stdin.write(`${JSON.stringify({ requestId, method, ...fields })}
+`, (error) => {
+        if (error) this.fail(error);
+      });
+    });
+  }
+  receive(value) {
+    if (!value || typeof value !== "object") throw new Error("Invalid command launcher response");
+    const response = value;
+    if (typeof response.requestId !== "string") throw new Error("Command launcher response is missing requestId");
+    const request = this.pending.get(response.requestId);
+    if (!request) throw new Error("Command launcher returned an unknown requestId");
+    this.pending.delete(response.requestId);
+    clearTimeout(request.timer);
+    if (typeof response.error === "string") {
+      request.reject(new Error(response.error));
+      return;
+    }
+    if (!response.result || typeof response.result !== "object" || Array.isArray(response.result)) {
+      const error = new Error("Command launcher response is missing result");
+      request.reject(error);
+      throw error;
+    }
+    request.resolve(response.result);
+  }
+  rejectPending(error) {
+    for (const request of this.pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+    this.pending.clear();
+  }
+  fail(error) {
+    if (this.failure || this.closing) return this.failure ?? error;
+    this.failure = new CommandLauncherUnavailableError(`Command launcher unavailable: ${error.message}`, error);
+    for (const record of this.launches.values()) {
+      record.revoked = true;
+      record.rejectAdmission(this.failure);
+    }
+    this.rejectPending(this.failure);
+    this.child?.kill("SIGTERM");
+    this.options.onFailure?.(this.failure, this.activeIds);
+    return this.failure;
+  }
+}
+async function createWorkerCommandLauncher(options = {}) {
+  const launcher = new WorkerCommandLauncher({ ...options, argv: parseCommandLauncher(options.configuration) });
+  await launcher.initialize();
+  return launcher;
+}
+export {
+  CommandLaunchCancelledError,
+  CommandLauncherUnavailableError,
+  WorkerCommandLauncher,
+  commandLauncherEnvironment,
+  createWorkerCommandLauncher,
+  parseCommandLauncher
+};

package/dist/mjs/inline-output.mjs

@@ -0,0 +1,37 @@
+const WORKER_INLINE_OUTPUT_MAX_BYTES = 8 * 1024 * 1024;
+async function collectWorkerInlineOutput(stream, maxBytes = WORKER_INLINE_OUTPUT_MAX_BYTES, signal) {
+  if (!stream) return "";
+  signal?.throwIfAborted();
+  const reader = stream.getReader();
+  const abort = () => {
+    void reader.cancel().catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  const decoder = new TextDecoder();
+  const parts = [];
+  let bytes = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      signal?.throwIfAborted();
+      if (next.done) break;
+      bytes += next.value.byteLength;
+      if (bytes > maxBytes) {
+        void reader.cancel().catch(() => {
+        });
+        throw new Error(`Inline command output exceeded ${maxBytes} bytes. Use streaming execution for large output.`);
+      }
+      parts.push(decoder.decode(next.value, { stream: true }));
+    }
+    parts.push(decoder.decode());
+    return parts.join("");
+  } finally {
+    signal?.removeEventListener("abort", abort);
+    reader.releaseLock();
+  }
+}
+export {
+  WORKER_INLINE_OUTPUT_MAX_BYTES,
+  collectWorkerInlineOutput
+};