@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-ehf3vp31.js

@@ -0,0 +1,411 @@
+// src/local/jobs.ts
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { asId, SdkError } from "@nyte-ai/schema";
+import {
+  processEnvironment,
+  closable,
+  dev,
+  readTraceparent,
+  startSpan,
+  tracing
+} from "@nyte-ai/core";
+var OUTPUT_LIMIT = 1024 * 1024;
+var PAUSE_BYTES = 256 * 1024;
+var RESUME_BYTES = 64 * 1024;
+var STOP_GRACE_MS = 2000;
+var CLOSE_GRACE_MS = 2000;
+var QUIET_MS = 300;
+var DONE = { done: true, value: undefined };
+var ESC = "\x1B";
+var BEL = "\x07";
+var PROMPT_MARKER = new RegExp(`${ESC}\\]133;([ABCD])`, "g");
+var loaded;
+function localExec2(root, options) {
+  const readers = new Set;
+  const custom = options?.loadPty;
+  const load = custom === undefined ? loadPty : () => ptyFrom(custom);
+  options?.signal?.addEventListener("abort", () => {
+    for (const close of readers)
+      close();
+  }, { once: true });
+  return async (command, input) => {
+    if (input?.signal?.aborted === true)
+      throw new SdkError("unavailable", "aborted");
+    if (typeof command !== "string" && command.length === 0 && input?.pty === undefined)
+      throw new SdkError("invalid", "An empty command runs only in a pty, as the login shell.");
+    const cwd = input?.cwd === undefined ? root : resolve(root, input.cwd);
+    await processEnvironment();
+    const env = { ...process.env, ...input?.env };
+    const trace = readTraceparent(input?.env?.TRACEPARENT);
+    const spawned = startSpan("pty.spawn", trace, { pty: input?.pty !== undefined });
+    const log = tracedOutput(createOutputLog(OUTPUT_LIMIT), trace);
+    let settle = () => {
+      return;
+    };
+    const ended = new Promise((done) => {
+      settle = done;
+    });
+    let stopping = false;
+    let finished = null;
+    const finish = (code) => {
+      if (finished !== null)
+        return;
+      finished = { kind: "exited", code, reason: stopping ? "terminated" : "exited" };
+      dev("jobs", "exit", { code, reason: finished.reason });
+      log.end(code);
+      settle(finished);
+    };
+    const driver = input?.pty === undefined ? await pipe(command, { cwd, env, protocol: input?.stdio === "protocol" }, log, finish) : await terminal(command, { cwd, env, size: input.pty, shell: options?.shell?.() ?? undefined, load }, log, finish);
+    spawned();
+    dev("jobs", "start", {
+      program: typeof command === "string" ? command.split(/\s/, 1)[0] : command[0] ?? null,
+      args: typeof command === "string" ? null : command.length - 1,
+      pty: driver.pty
+    });
+    let stopped = null;
+    const stop = () => {
+      stopped ??= (async () => {
+        if (finished !== null)
+          return finished;
+        stopping = true;
+        driver.kill(driver.pty ? "SIGHUP" : "SIGTERM");
+        const timer = setTimeout(() => driver.kill("SIGKILL"), STOP_GRACE_MS);
+        try {
+          return await ended;
+        } finally {
+          clearTimeout(timer);
+        }
+      })();
+      return stopped;
+    };
+    input?.signal?.addEventListener("abort", () => void stop(), { once: true });
+    const own = new Set;
+    const close = async () => {
+      for (const detach of own)
+        detach();
+    };
+    const job = {
+      id: asId(crypto.randomUUID()),
+      key: null,
+      write: (bytes) => driver.write(bytes),
+      output: () => closable(() => {
+        const reader = log.reader();
+        const detach = () => {
+          own.delete(detach);
+          readers.delete(detach);
+          reader.close();
+        };
+        own.add(detach);
+        readers.add(detach);
+        return { pull: () => reader.next(), close: detach };
+      }),
+      async resize(size) {
+        if (!driver.pty)
+          return { kind: "not-pty" };
+        return finished === null && driver.resize(size) ? { kind: "resized" } : { kind: "missing" };
+      },
+      idle: async () => finished === null && driver.idle(),
+      stop: async () => ({ kind: "settled", outcome: await stop() }),
+      settled: (request) => waitEnd(ended, request),
+      close,
+      [Symbol.asyncDispose]: close
+    };
+    return job;
+  };
+}
+async function pipe(command, options, log, finish) {
+  const group = process.platform !== "win32";
+  const [file, ...args] = typeof command === "string" ? [command] : command;
+  const settings = {
+    cwd: options.cwd,
+    env: options.env,
+    detached: group,
+    stdio: "pipe",
+    windowsHide: true
+  };
+  const child = typeof command === "string" ? spawn(command, { ...settings, shell: true }) : spawn(file ?? "", args, settings);
+  await new Promise((started, failed) => {
+    child.once("spawn", started);
+    child.once("error", (error) => failed(new SdkError("unavailable", `Cannot start ${file ?? ""}: ${error.message}`)));
+  });
+  child.stdout?.on("data", (chunk) => log.push(chunk));
+  child.stderr?.on("data", (chunk) => log.push(chunk, options.protocol ? "stderr" : undefined));
+  if (options.protocol)
+    log.throttle({
+      pause: () => {
+        child.stdout?.pause();
+        child.stderr?.pause();
+      },
+      resume: () => {
+        child.stdout?.resume();
+        child.stderr?.resume();
+      }
+    });
+  child.stdin?.on("error", () => {
+    return;
+  });
+  child.on("close", (code) => finish(code));
+  child.on("exit", (code) => {
+    setTimeout(() => {
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      finish(code);
+    }, CLOSE_GRACE_MS).unref();
+  });
+  return {
+    pty: false,
+    async write(bytes) {
+      const stdin = child.stdin;
+      if (stdin === null || !stdin.writable)
+        throw new SdkError("unavailable", "The process no longer reads its input.");
+      await new Promise((written) => stdin.write(bytes, () => written()));
+    },
+    resize: () => false,
+    idle: () => false,
+    kill(signal) {
+      try {
+        if (group && child.pid !== undefined)
+          process.kill(-child.pid, signal);
+        else
+          child.kill(signal);
+      } catch {
+        child.kill(signal);
+      }
+    }
+  };
+}
+function terminalEnv(env) {
+  const { ELECTRON_RUN_AS_NODE: _electron, NODE_OPTIONS: _node, ...rest } = env;
+  return { ...rest, TERM: "xterm-256color", COLORTERM: "truecolor", TERM_PROGRAM: "Nyte" };
+}
+async function terminal(command, options, log, finish) {
+  const pty = options.load();
+  if (pty === null)
+    throw new SdkError("unavailable", "Terminals need @lydell/node-pty, which does not load on this platform.");
+  const windows = process.platform === "win32";
+  const shell = options.shell ?? (windows ? process.env.COMSPEC ?? "cmd.exe" : process.env.SHELL ?? "/bin/sh");
+  const [file, ...args] = typeof command === "string" ? windows ? [shell, "/d", "/s", "/c", command] : ["/bin/sh", "-c", command] : command.length === 0 ? windows ? [shell] : [shell, "-l"] : command;
+  let term;
+  try {
+    term = pty.spawn(file ?? shell, args, {
+      name: "xterm-256color",
+      cols: options.size.columns,
+      rows: options.size.rows,
+      cwd: options.cwd,
+      env: terminalEnv(options.env)
+    });
+  } catch (error) {
+    throw new SdkError("unavailable", `Cannot start ${file ?? shell} in a pty: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const encoder = new TextEncoder;
+  let marker = null;
+  let line = "";
+  let quietSince = 0;
+  term.onData((text) => {
+    log.push(encoder.encode(text));
+    quietSince = Date.now();
+    marker = lastMarker(text) ?? marker;
+    const plain = withoutEscapes(text);
+    const broken = plain.lastIndexOf(`
+`);
+    line = (broken < 0 ? line + plain : plain.slice(broken + 1)).slice(-1024);
+    const returned = line.replace(/\r+$/, "").lastIndexOf("\r");
+    if (returned >= 0)
+      line = line.slice(returned + 1);
+  });
+  term.onExit(({ exitCode, signal }) => finish(signal ? null : exitCode));
+  log.throttle({ pause: () => term.pause(), resume: () => term.resume() });
+  return {
+    pty: true,
+    async write(bytes) {
+      term.write(Buffer.from(bytes));
+    },
+    resize(size) {
+      term.resize(size.columns, size.rows);
+      return true;
+    },
+    idle() {
+      if (marker !== null)
+        return marker !== "C";
+      return quietSince > 0 && Date.now() - quietSince >= QUIET_MS && line.trim() !== "";
+    },
+    kill(signal) {
+      try {
+        term.kill(windows ? undefined : signal);
+      } catch {}
+    }
+  };
+}
+function lastMarker(text) {
+  return Array.from(text.matchAll(PROMPT_MARKER), (match) => match[1]).at(-1) ?? null;
+}
+function withoutEscapes(text) {
+  let plain = "";
+  let at = 0;
+  while (at < text.length) {
+    const char = text[at] ?? "";
+    if (char !== ESC) {
+      plain += char;
+      at += 1;
+      continue;
+    }
+    const kind = text[at + 1] ?? "";
+    at += 2;
+    if (kind === "[") {
+      while (at < text.length && !/[@-~]/.test(text[at] ?? ""))
+        at += 1;
+      at += 1;
+    } else if (kind === "]") {
+      while (at < text.length && text[at] !== BEL && !(text[at] === ESC && text[at + 1] === "\\"))
+        at += 1;
+      at += text[at] === BEL ? 1 : 2;
+    }
+  }
+  return plain;
+}
+function loadPty() {
+  if (loaded === undefined)
+    loaded = ptyFrom(() => createRequire(import.meta.url)("@lydell/node-pty"));
+  return loaded;
+}
+function ptyFrom(load) {
+  try {
+    const required = load();
+    return fitsPtyModule(required) ? required : null;
+  } catch {
+    return null;
+  }
+}
+function fitsPtyModule(value) {
+  return typeof value === "object" && value !== null && "spawn" in value && typeof value.spawn === "function";
+}
+function waitEnd(ended, request) {
+  const signal = request?.signal;
+  if (signal === undefined)
+    return ended;
+  if (signal.aborted)
+    return Promise.reject(new SdkError("unavailable", "aborted"));
+  return new Promise((settled, failed) => {
+    const abort = () => failed(new SdkError("unavailable", "aborted"));
+    signal.addEventListener("abort", abort, { once: true });
+    ended.then((end) => {
+      signal.removeEventListener("abort", abort);
+      settled(end);
+    }, failed);
+  });
+}
+function tracedOutput(log, trace) {
+  if (!tracing.enabled)
+    return log;
+  let ended = null;
+  let bytes = 0;
+  return {
+    ...log,
+    push(chunk, stream) {
+      ended ??= startSpan("pty.output", trace);
+      bytes += chunk.byteLength;
+      log.push(chunk, stream);
+    },
+    end(code) {
+      ended?.({ bytes, code });
+      log.end(code);
+    }
+  };
+}
+function createOutputLog(limit) {
+  const state = { chunks: [], first: 0, size: 0, pushed: 0, exit: null };
+  const waiters = new Set;
+  const positions = new Set;
+  let source = null;
+  let paused = false;
+  const behind = () => Math.max(0, ...[...positions].map((position) => state.pushed - position.read));
+  const pace = () => {
+    if (source === null)
+      return;
+    const lag = behind();
+    if (!paused && lag > PAUSE_BYTES) {
+      paused = true;
+      source.pause();
+    } else if (paused && lag < RESUME_BYTES) {
+      paused = false;
+      source.resume();
+    }
+  };
+  const wake = () => {
+    const pending = [...waiters];
+    waiters.clear();
+    for (const resolve of pending)
+      resolve();
+  };
+  return {
+    throttle(next) {
+      source = next;
+    },
+    push(bytes, stream) {
+      state.chunks.push(stream === undefined ? { kind: "bytes", data: bytes } : { kind: "bytes", data: bytes, stream });
+      state.size += bytes.byteLength;
+      state.pushed += bytes.byteLength;
+      while (state.size > limit && state.chunks.length > 1) {
+        state.size -= state.chunks.shift()?.data.byteLength ?? 0;
+        state.first += 1;
+      }
+      pace();
+      wake();
+    },
+    end(code) {
+      state.exit ??= { code };
+      wake();
+    },
+    reader() {
+      let cursor = 0;
+      let done = false;
+      let waiting = null;
+      const position = { read: 0 };
+      positions.add(position);
+      return {
+        async next() {
+          for (;; ) {
+            if (done)
+              return DONE;
+            if (cursor < state.first) {
+              cursor = state.first;
+              position.read = state.pushed - state.size;
+              return { done: false, value: { kind: "gap" } };
+            }
+            const chunk = state.chunks[cursor - state.first];
+            if (chunk !== undefined) {
+              cursor += 1;
+              position.read += chunk.data.byteLength;
+              pace();
+              return { done: false, value: chunk };
+            }
+            if (state.exit !== null) {
+              done = true;
+              return { done: false, value: { kind: "exit", code: state.exit.code } };
+            }
+            await new Promise((woken) => {
+              waiting = woken;
+              waiters.add(woken);
+            });
+            waiting = null;
+          }
+        },
+        close() {
+          done = true;
+          positions.delete(position);
+          pace();
+          const resolve = waiting;
+          waiting = null;
+          if (resolve !== null) {
+            waiters.delete(resolve);
+            resolve();
+          }
+        }
+      };
+    }
+  };
+}
+
+export { localExec2 };