@nyte-ai/host 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,398 @@
+import {
+  run2,
+  spawnCommand2,
+  killTree2,
+  findExecutable2
+} from "./canvas-preview-bxnqt8cd.js";
+
+// src/local/jobs.ts
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { basename, 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 DONE = { done: true, value: undefined };
+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 () => driver.pty && (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 windows = process.platform === "win32";
+  const [file, ...args] = typeof command === "string" ? [command] : command;
+  const settings = {
+    cwd: options.cwd,
+    env: options.env,
+    detached: !windows,
+    stdio: "pipe",
+    windowsHide: true
+  };
+  const child = typeof command === "string" ? spawn(command, { ...settings, shell: true }) : spawnCommand2(windows ? await findExecutable2(file ?? "") ?? file ?? "" : 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;
+  });
+  let killed = false;
+  child.on("close", (code) => finish(killed ? null : code));
+  child.on("exit", (code) => {
+    setTimeout(() => {
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      finish(killed ? null : 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) {
+      if (windows) {
+        killed = true;
+        killTree2(child, signal);
+        return;
+      }
+      try {
+        if (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;
+  term.onData((text) => log.push(encoder.encode(text)));
+  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;
+    },
+    async idle() {
+      if (typeof command === "string" || command.length !== 0)
+        return false;
+      const result = await run2(windows ? "powershell.exe" : "ps", windows ? [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Get-CimInstance Win32_Process -Filter "ParentProcessId = ${term.pid} AND Name != 'conhost.exe' AND Name != 'OpenConsole.exe'" | Select-Object -ExpandProperty ProcessId`
+      ] : ["-A", "-o", "pid=,ppid=,stat=,comm="], { cwd: options.cwd, timeoutMs: 1500 });
+      if (result.code !== 0)
+        throw new SdkError("unavailable", "Cannot inspect terminal processes");
+      const processes = result.stdout.toString("utf8").trim();
+      if (windows)
+        return processes === "";
+      return !processes.split(`
+`).some((line) => {
+        const [pid, parent, state, ...name] = line.trim().split(/\s+/);
+        if (state?.startsWith("Z"))
+          return false;
+        if (Number(parent) === term.pid)
+          return true;
+        return Number(pid) === term.pid && basename(name.join(" ")).replace(/^-/, "") !== basename(shell);
+      });
+    },
+    kill(signal) {
+      try {
+        term.kill(windows ? undefined : signal);
+      } catch {}
+    }
+  };
+}
+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 };

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

@@ -0,0 +1,272 @@
+import {
+  createHandler2
+} from "./canvas-preview-aq5j4p25.js";
+
+// src/listen-fetch.ts
+import { SdkError } from "@nyte-ai/schema";
+import { serial } from "@nyte-ai/schema/serial";
+import { dev } from "@nyte-ai/core";
+import { TOKEN, TOKEN_AUTHORITY } from "@nyte-ai/core/server";
+import {
+  HOST_HEADER,
+  OPERATIONS_HEADER,
+  asSdkError,
+  encodeError,
+  errorStatus,
+  operationsDigest
+} from "@nyte-ai/protocol";
+var encoder = new TextEncoder;
+async function listenFetch2(host, options) {
+  const { auth } = options;
+  if (auth.kind === "token" && auth.token.length < 16)
+    throw new SdkError("invalid", "A listener token needs at least 16 characters.");
+  const { server } = host;
+  const operations = await operationsDigest();
+  const cache = new Map;
+  const devices = new Map;
+  const streams = new Map;
+  const flights = new WeakMap;
+  let generation = new AbortController;
+  let closing = null;
+  let principalsRevision = null;
+  const rechecks = serial();
+  const drop = (key, entry, reason) => {
+    if (cache.get(key) === entry)
+      cache.delete(key);
+    entry.dispose();
+    for (const [digest, device] of devices)
+      if (device.principal === entry.principal)
+        devices.delete(digest);
+    const open = streams.get(entry.principal);
+    streams.delete(entry.principal);
+    for (const flight of open ?? [])
+      flight.controller.abort(reason);
+    entry.connection.close();
+  };
+  const land = (flight) => {
+    for (const [principal, open] of streams)
+      if (open.delete(flight) && open.size === 0)
+        streams.delete(principal);
+  };
+  const connectionFor = (flight, principal, authority, token) => {
+    const key = JSON.stringify([principal, [...authority].sort()]);
+    const entry = cache.get(key) ?? admit(key, principal, authority, token);
+    flight.principal = principal;
+    const open = streams.get(principal) ?? new Set;
+    open.add(flight);
+    streams.set(principal, open);
+    return entry.connection;
+  };
+  const admit = (key, principal, authority, token) => {
+    const connection = server.connect({
+      principal,
+      authority,
+      credential: { kind: "token", token },
+      origin: null
+    });
+    const entry = { connection, principal, dispose: () => {
+      return;
+    } };
+    const admitted = server.connections.register(principal, () => drop(key, entry, new SdkError("unauthenticated", "The principal was revoked.")));
+    if (admitted.kind === "revoked")
+      throw new SdkError("unauthenticated", "The principal was revoked.");
+    entry.dispose = admitted.dispose;
+    cache.set(key, entry);
+    return entry;
+  };
+  const reread = async (token, digest) => {
+    const found = await server.authenticate(token);
+    if (found === null) {
+      const known = devices.get(digest);
+      devices.delete(digest);
+      if (known !== undefined)
+        server.connections.revoke(known.principal);
+      return null;
+    }
+    return { ...found, token };
+  };
+  const findDevice = async (token) => {
+    const digest = hex(await sha256(token));
+    const device = devices.get(digest) ?? await reread(token, digest);
+    return device === null ? null : { digest, device };
+  };
+  const recheck = async () => {
+    if (devices.size === 0)
+      return;
+    const revision = await server.principalsRevision();
+    if (revision === principalsRevision)
+      return;
+    principalsRevision = revision;
+    await Promise.all([...devices].map(([digest, known]) => reread(known.token, digest)));
+  };
+  const externalCommit = () => {
+    rechecks.run(recheck).catch((error) => dev("listen", "device re-check failed", { error: String(error) }));
+  };
+  const unwatchCommits = server.onExternalCommit(externalCommit);
+  const isListenerToken = auth.kind === "token" ? (token) => sameSecret(token, auth.token) : async () => false;
+  const fallback = auth.kind === "custom" ? async (request) => {
+    const verdict = await auth.authorize(request);
+    if ("deny" in verdict)
+      throw verdict.deny === "forbidden" ? new SdkError("denied", "This principal may not call the host.") : new SdkError("unauthenticated", "The request is not authorized.");
+    return verdict;
+  } : async (_request, token) => {
+    throw new SdkError("unauthenticated", token === undefined ? "Send Authorization: Bearer <token>." : "The token is not accepted.");
+  };
+  const authenticate = async (request, flight) => {
+    const header = request.headers.get("Authorization") ?? "";
+    const pairing = /^Pairing\s+(\S+)\s*$/i.exec(header)?.[1];
+    if (pairing !== undefined) {
+      const redeemed = await server.redeem(pairing);
+      if (redeemed === null)
+        throw new SdkError("unauthenticated", "The pairing code is unknown or has expired.");
+      const digest = hex(await sha256(redeemed.token));
+      const { principal, authority, token } = redeemed;
+      const connection = connectionFor(flight, principal, authority, token);
+      devices.set(digest, { principal, authority, token });
+      return { connection, authority, headers: { "X-Nyte-Credential": token } };
+    }
+    const token = /^Bearer\s+(\S+)\s*$/i.exec(header)?.[1];
+    if (token !== undefined) {
+      if (await isListenerToken(token))
+        return {
+          connection: connectionFor(flight, TOKEN, TOKEN_AUTHORITY, token),
+          authority: TOKEN_AUTHORITY
+        };
+      const remembered = await findDevice(token);
+      if (remembered !== null) {
+        const { digest, device } = remembered;
+        const connection = connectionFor(flight, device.principal, device.authority, token);
+        devices.set(digest, device);
+        return { connection, authority: device.authority };
+      }
+    }
+    const verdict = await fallback(request, token);
+    return {
+      connection: connectionFor(flight, verdict.principal, verdict.authority, ""),
+      authority: verdict.authority
+    };
+  };
+  const handler = createHandler2({
+    server,
+    origins: options.origins,
+    maxBodyBytes: options.maxBodyBytes,
+    connection: (request) => {
+      const flight = flights.get(request);
+      if (flight === undefined)
+        throw new Error("The listener did not register this request.");
+      return authenticate(request, flight);
+    }
+  });
+  const cors = (request) => {
+    const origin = request.headers.get("Origin");
+    return origin !== null && (options.origins ?? []).includes(origin) ? {
+      "Access-Control-Allow-Origin": origin,
+      "Access-Control-Expose-Headers": `${HOST_HEADER}, ${OPERATIONS_HEADER}`,
+      Vary: "Origin"
+    } : {};
+  };
+  const serve = async (request, trace) => {
+    if (closing !== null)
+      return failure(new SdkError("unavailable", "This listener is closed."), {});
+    const early = await options.before?.(request);
+    if (early !== undefined)
+      return early;
+    const url = new URL(request.url);
+    if (request.method === "GET" && url.pathname === "/.nyte/identity") {
+      const nonce = url.searchParams.get("nonce");
+      if (options.identity === undefined || nonce === null || nonce === "")
+        return failure(new SdkError("unknown", "This host answers no identity challenge."), cors(request));
+      return json({ ...await options.identity.sign(nonce), hostId: server.hostId }, cors(request));
+    }
+    if (request.method === "GET" && url.pathname === "/.nyte/describe") {
+      if (options.describe === undefined)
+        return failure(new SdkError("unknown", "This host describes nothing."), cors(request));
+      return json(await options.describe(), cors(request));
+    }
+    const controller = new AbortController;
+    const forwarded = new Request(request, {
+      signal: AbortSignal.any([request.signal, generation.signal, controller.signal])
+    });
+    const flight = { request: forwarded, controller, principal: null };
+    flights.set(forwarded, flight);
+    const response = await handler(forwarded);
+    trace.principal = flight.principal;
+    return landing(response, () => land(flight));
+  };
+  const fetch = async (request) => {
+    const started = Date.now();
+    const trace = { principal: null };
+    const response = await serve(request, trace).catch((error) => failure(asSdkError(error), cors(request)));
+    dev("listen", "request", {
+      method: request.method,
+      path: new URL(request.url).pathname,
+      status: response.status,
+      principal: trace.principal === null ? "none" : trace.principal === TOKEN ? "token" : "principal",
+      ms: Date.now() - started
+    });
+    return withHost(response, server.hostId, operations);
+  };
+  const execution = options.execution ?? { kind: "run", coverage: { kind: "all" } };
+  const coverage = execution.kind === "admit-only" || server.execution.kind === "dispatch" ? null : server.execution.kind === "admit-only" ? server.drive(execution.coverage) : await host.execution.cover(execution.coverage);
+  const disconnectClients = () => {
+    for (const [key, entry] of cache)
+      drop(key, entry, new SdkError("unavailable", "The host disconnected its clients."));
+    devices.clear();
+    generation.abort(new SdkError("unavailable", "The host disconnected its clients."));
+    generation = new AbortController;
+  };
+  const close = () => {
+    closing ??= (async () => {
+      unwatchCommits();
+      disconnectClients();
+      await coverage?.close();
+    })();
+    return closing;
+  };
+  return { address: null, fetch, disconnectClients, close, [Symbol.asyncDispose]: close };
+}
+function landing(response, done) {
+  if (response.body === null) {
+    done();
+    return response;
+  }
+  const settles = { flush: done, cancel: done };
+  return new Response(response.body.pipeThrough(new TransformStream(settles)), { status: response.status, statusText: response.statusText, headers: response.headers });
+}
+function withHost(response, hostId, operations) {
+  const headers = new Headers(response.headers);
+  headers.set(HOST_HEADER, hostId);
+  headers.set(OPERATIONS_HEADER, operations);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function json(value, headers) {
+  return new Response(JSON.stringify(value), {
+    status: 200,
+    headers: { ...headers, "Content-Type": "application/json" }
+  });
+}
+function failure(error, headers) {
+  return new Response(JSON.stringify(encodeError(error)), {
+    status: errorStatus[error.code],
+    headers: { ...headers, "Content-Type": "application/json" }
+  });
+}
+async function sha256(text) {
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(text)));
+}
+function hex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sameSecret(given, expected) {
+  const [left, right] = await Promise.all([sha256(given), sha256(expected)]);
+  let difference = left.length ^ right.length;
+  for (let index = 0;index < left.length; index += 1)
+    difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+  return difference === 0;
+}
+
+export { listenFetch2 };