@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-98aj5p34.js

@@ -0,0 +1,176 @@
+import {
+  listenFetch2
+} from "./canvas-preview-76fwvd6e.js";
+
+// src/listen.ts
+import { createServer } from "node:http";
+import { SdkError } from "@nyte-ai/schema";
+import { encodeError, errorStatus } from "@nyte-ai/protocol";
+async function listen2(host, options) {
+  const inner = await listenFetch2(host, { ...options, transport: { kind: "fetch" } });
+  if (options.transport.kind === "fetch")
+    return inner;
+  const responses = new Set;
+  const bound = await bind(options.transport, (request) => inner.fetch(request), responses).catch(async (error) => {
+    await inner.close();
+    throw new SdkError("unavailable", `Cannot listen: ${error instanceof Error ? error.message : String(error)}`);
+  });
+  const disconnectClients = () => {
+    inner.disconnectClients();
+    for (const response of responses)
+      response.destroy();
+  };
+  let closing = null;
+  const close = () => {
+    closing ??= (async () => {
+      disconnectClients();
+      await inner.close();
+      await new Promise((done) => {
+        bound.server.close(() => done());
+        bound.server.closeAllConnections();
+      });
+    })();
+    return closing;
+  };
+  return {
+    address: bound.address,
+    fetch: (request) => inner.fetch(request),
+    disconnectClients,
+    close,
+    [Symbol.asyncDispose]: close
+  };
+}
+async function bind(transport, fetch, responses) {
+  let origin = "http://127.0.0.1";
+  const server = createServer({ noDelay: true }, (incoming, outgoing) => {
+    respond(incoming, outgoing, origin, fetch, responses);
+  });
+  await new Promise((listening, failed) => {
+    server.once("error", failed);
+    server.listen(transport.port ?? 0, transport.hostname ?? "127.0.0.1", () => {
+      server.off("error", failed);
+      listening();
+    });
+  });
+  const info = server.address();
+  if (info === null || typeof info === "string") {
+    server.close();
+    throw new Error("the socket has no address");
+  }
+  const hostname = info.address.includes(":") ? `[${info.address}]` : info.address;
+  origin = `http://${hostname}:${info.port}`;
+  return { server, address: origin };
+}
+async function respond(incoming, outgoing, origin, fetch, responses) {
+  const controller = new AbortController;
+  responses.add(outgoing);
+  outgoing.on("close", () => {
+    responses.delete(outgoing);
+    if (!outgoing.writableFinished)
+      controller.abort();
+  });
+  let request;
+  try {
+    request = readRequest(incoming, origin, controller.signal);
+  } catch (error) {
+    await write(failure(new SdkError("invalid", error instanceof Error ? error.message : String(error))), outgoing);
+    return;
+  }
+  await write(await fetch(request), outgoing);
+}
+function readRequest(incoming, origin, signal) {
+  const headers = new Headers;
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    if (name.startsWith(":") || value === undefined)
+      continue;
+    if (Array.isArray(value))
+      for (const each of value)
+        headers.append(name, each);
+    else
+      headers.set(name, value);
+  }
+  const host = incoming.headers.host;
+  const url = new URL(incoming.url ?? "/", host === undefined ? origin : `http://${host}`);
+  const method = incoming.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? {} : { body: streamBody(incoming), duplex: "half" };
+  return new Request(url.href, { method, headers, signal, ...body });
+}
+function streamBody(incoming) {
+  return new ReadableStream({
+    start(controller) {
+      incoming.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        if ((controller.desiredSize ?? 0) <= 0)
+          incoming.pause();
+      });
+      incoming.on("end", () => controller.close());
+      incoming.on("error", (error) => controller.error(error));
+    },
+    pull() {
+      incoming.resume();
+    },
+    cancel() {
+      incoming.destroy();
+    }
+  });
+}
+async function write(response, outgoing) {
+  if (outgoing.destroyed) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    return;
+  }
+  const headers = {};
+  response.headers.forEach((value, name) => {
+    headers[name] = value;
+  });
+  const cookies = response.headers.getSetCookie();
+  if (cookies.length > 0)
+    headers["set-cookie"] = cookies;
+  outgoing.writeHead(response.status, headers);
+  outgoing.flushHeaders();
+  if (response.body === null) {
+    outgoing.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  const cancel = () => {
+    reader.cancel().catch(() => {
+      return;
+    });
+  };
+  outgoing.on("close", cancel);
+  try {
+    for (;; ) {
+      const read = await reader.read();
+      if (read.done)
+        break;
+      if (!outgoing.write(read.value))
+        await new Promise((drained) => {
+          const done = () => {
+            outgoing.off("drain", done);
+            outgoing.off("close", done);
+            drained();
+          };
+          outgoing.on("drain", done);
+          outgoing.on("close", done);
+        });
+      if (outgoing.destroyed)
+        return;
+    }
+    outgoing.end();
+  } catch {
+    outgoing.destroy();
+  } finally {
+    outgoing.off("close", cancel);
+  }
+}
+function failure(error) {
+  return new Response(JSON.stringify(encodeError(error)), {
+    status: errorStatus[error.code],
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+export { listen2 };

package/dist/chunks/canvas-preview-9aqczacs.js

@@ -0,0 +1,73 @@
+// src/local/legacy-trust.ts
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { envelope, trustRef } from "@nyte-ai/core/store";
+import { SdkError } from "@nyte-ai/schema";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var MIGRATION = "host/migrations/legacy-folder-trust-v1";
+var WorkspacesFile = Type.Record(Type.String(), Type.Object({ trusted: Type.Boolean() }));
+var TrustFile = Type.Record(Type.String(), Type.Literal(true));
+async function importLegacyTrust2(connection, home) {
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    if (await connection.refs.get(MIGRATION) !== null)
+      return;
+    const folders = await legacyFolders(home);
+    const updates = [];
+    for (const path of folders) {
+      const target = { kind: "local", path };
+      const name = await trustRef(target);
+      if (await connection.refs.get(name) !== null)
+        continue;
+      updates.push({
+        name,
+        expect: "absent",
+        target: await connection.objects.put(envelope("trust", { target, trusted: true }, Date.now()))
+      });
+    }
+    updates.push({
+      name: MIGRATION,
+      expect: "absent",
+      target: await connection.objects.put({ imported: folders })
+    });
+    if ((await connection.refs.set(updates)).kind === "set")
+      return;
+  }
+  throw new SdkError("unavailable", "Folder trust changed while Nyte was importing it.");
+}
+async function legacyFolders(home) {
+  const [workspaces, nyte, uji] = await Promise.all([
+    readJson(join(home, ".nyte", "workspaces.json")),
+    readJson(join(home, ".nyte", "trust.json")),
+    readJson(join(home, ".uji", "trust.json"))
+  ]);
+  const granted = [
+    ...Value.Check(WorkspacesFile, workspaces) ? Object.entries(workspaces).flatMap(([path, row]) => row.trusted ? [path] : []) : [],
+    ...[nyte, uji].flatMap((file) => Value.Check(TrustFile, file) ? Object.keys(file) : [])
+  ];
+  const ownHome = await realpath(home).catch(() => home);
+  const found = await Promise.all(granted.map(canonicalFolder));
+  return [
+    ...new Set(found.flatMap((path) => path === null || path === ownHome || ownHome.startsWith(`${path}/`) || path === "/" ? [] : [path]))
+  ];
+}
+async function canonicalFolder(path) {
+  if (!isAbsolute(path))
+    return null;
+  const real = await realpath(path).catch(() => null);
+  if (real === null || (await stat(real).catch(() => null))?.isDirectory() !== true)
+    return null;
+  return real.replace(/\/+$/u, "");
+}
+async function readJson(path) {
+  const text = await readFile(path, "utf8").catch(() => null);
+  if (text === null)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+export { importLegacyTrust2 };

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

@@ -0,0 +1,72 @@
+import {
+  parseNumber2,
+  parseText2
+} from "./canvas-preview-69fkk9yn.js";
+
+// src/store-owner.ts
+import { resolve } from "node:path";
+import process from "node:process";
+import { DatabaseSync } from "node:sqlite";
+import { SdkError } from "@nyte-ai/schema";
+import { STORE_VERSION } from "@nyte-ai/core/store";
+var CONTEND_MS = 1000;
+var SQLITE_BUSY = 5;
+var claims = new Map;
+
+class StoreOwned2 extends SdkError {
+  constructor(message) {
+    super("unavailable", message);
+  }
+}
+function claimStore2(path) {
+  const key = resolve(path);
+  const claim = claims.get(key) ?? { lock: lockStore(key), holders: 0 };
+  claims.set(key, claim);
+  claim.holders += 1;
+  let released = false;
+  return () => {
+    if (released)
+      return;
+    released = true;
+    claim.holders -= 1;
+    if (claim.holders > 0)
+      return;
+    claims.delete(key);
+    claim.lock.close();
+  };
+}
+function lockStore(path) {
+  const lock = new DatabaseSync(`${path}.owner`, { timeout: CONTEND_MS });
+  try {
+    reserve(lock, path);
+    lock.exec("CREATE TABLE IF NOT EXISTS owner (id INTEGER PRIMARY KEY CHECK (id = 1), pid INTEGER NOT NULL, program TEXT NOT NULL, store INTEGER NOT NULL)");
+    lock.prepare("INSERT OR REPLACE INTO owner (id, pid, program, store) VALUES (1, ?, ?, ?)").run(process.pid, process.execPath, STORE_VERSION);
+    lock.exec("COMMIT");
+    reserve(lock, path);
+  } catch (cause) {
+    lock.close();
+    throw cause;
+  }
+  return lock;
+}
+function reserve(lock, path) {
+  try {
+    lock.exec("BEGIN IMMEDIATE");
+  } catch (cause) {
+    if (!(cause instanceof Error && ("errcode" in cause) && cause.errcode === SQLITE_BUSY))
+      throw cause;
+    throw new StoreOwned2(`${describeOwner(lock)} has ${path} open. Nyte opens a store in one process at a time; quit that one and try again.`);
+  }
+}
+function describeOwner(lock) {
+  try {
+    const row = lock.prepare("SELECT pid, program, store FROM owner WHERE id = 1").get();
+    if (row === undefined)
+      return "Another Nyte process";
+    return `Another Nyte process (pid ${String(parseNumber2(row.pid))}, ${parseText2(row.program)}, store version ${String(parseNumber2(row.store))})`;
+  } catch {
+    return "Another Nyte process";
+  }
+}
+
+export { StoreOwned2, claimStore2 };

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

@@ -0,0 +1,68 @@
+// src/local/command.ts
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
+import { SdkError } from "@nyte-ai/schema";
+import { processEnvironment } from "@nyte-ai/core";
+async function run2(file, args, options) {
+  await processEnvironment();
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      timeout: options.timeoutMs
+    });
+    const stdout = [];
+    const stderr = [];
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    let size = 0;
+    let truncated = false;
+    child.on("error", (error) => reject(new SdkError("unavailable", `Cannot run ${file}: ${error.message}`)));
+    child.stdout.on("data", (chunk) => {
+      if (truncated)
+        return;
+      size += chunk.byteLength;
+      if (size > limit) {
+        truncated = true;
+        stdout.push(chunk.subarray(0, chunk.byteLength - (size - limit)));
+        child.kill("SIGKILL");
+        return;
+      }
+      stdout.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.stdin.on("error", () => {
+      return;
+    });
+    child.on("close", (code) => resolve({
+      code,
+      stdout: Buffer.concat(stdout),
+      stderr: Buffer.concat(stderr).toString("utf8"),
+      truncated
+    }));
+    child.stdin.end(options.input);
+  });
+}
+async function findExecutable2(name, directories = []) {
+  if (isAbsolute(name))
+    return await executable(name) ? name : null;
+  await processEnvironment();
+  const path = (process.env.PATH ?? "").split(delimiter).filter((entry) => entry !== "");
+  const extensions = process.platform === "win32" ? ["", ...(process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
+  for (const directory of [...directories, ...path])
+    for (const extension of extensions) {
+      const candidate = join(directory, `${name}${extension}`);
+      if (await executable(candidate))
+        return candidate;
+    }
+  return null;
+}
+async function executable(path) {
+  const found = await stat(path).catch(() => null);
+  return found !== null && found.isFile() && await access(path, constants.X_OK).then(() => true, () => false);
+}
+
+export { run2, findExecutable2 };

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

@@ -0,0 +1,240 @@
+import {
+  bindConnection2
+} from "./canvas-preview-m02v4yy6.js";
+import {
+  createStreamChannels2
+} from "./canvas-preview-rp4x6y1h.js";
+
+// src/serve/handler.ts
+import { Type } from "typebox";
+import { compile, isJsonObject, OPERATIONS, SdkError } from "@nyte-ai/schema";
+import {
+  CANCEL_PATH,
+  CHANNEL_HEADER,
+  CHANNEL_PATH,
+  HOST_HEADER,
+  INPUT_HEADER,
+  STREAM_HEADER,
+  abortable,
+  answersBytes,
+  answersOnce,
+  asSdkError,
+  decodeInput,
+  encodeError,
+  encodeOutput,
+  errorStatus,
+  mapped,
+  namesOperation,
+  octetStream,
+  outputFrames,
+  parseJson,
+  readInputHeader,
+  sseFrames
+} from "@nyte-ai/protocol";
+var MAX_BODY_BYTES = 8 * 1024 * 1024;
+var UPLOADS = new Set([
+  "files.write",
+  "job.write",
+  "files.upload"
+]);
+var ALLOWED_HEADERS = `Authorization, Content-Type, ${INPUT_HEADER}, ${CHANNEL_HEADER}, ${STREAM_HEADER}`;
+var EXPOSED_HEADERS = `X-Nyte-Version, X-Nyte-Mime, X-Nyte-Credential, ${HOST_HEADER}, ${CHANNEL_HEADER}`;
+var tooLarge = new WeakSet;
+var cancellations = compile(Type.Object({ channel: Type.String(), stream: Type.String() }));
+function createHandler2(options) {
+  const limit = options.maxBodyBytes ?? MAX_BODY_BYTES;
+  const bindings = new WeakMap;
+  const channels = createStreamChannels2();
+  const bind = (connection) => {
+    const known = bindings.get(connection);
+    if (known !== undefined)
+      return known;
+    const created = bindConnection2(connection, options);
+    bindings.set(connection, created);
+    return created;
+  };
+  return async (request) => {
+    const cors = corsHeaders(request, options.origins);
+    if (cors === null)
+      return errorResponse(new SdkError("denied", "This origin may not call the host."), {});
+    if (request.method === "OPTIONS")
+      return new Response(null, {
+        status: 204,
+        headers: {
+          ...cors,
+          "Access-Control-Allow-Methods": "POST",
+          "Access-Control-Allow-Headers": ALLOWED_HEADERS,
+          "Access-Control-Max-Age": "600"
+        }
+      });
+    try {
+      const path = new URL(request.url).pathname.slice(1);
+      const name = request.method === "POST" && (path === CHANNEL_PATH || path === CANCEL_PATH) ? path : readOperation(request);
+      const authenticated = await options.connection(request);
+      if (name === CHANNEL_PATH) {
+        const value = await readBody(request, limit);
+        const deflate = isJsonObject(value) && value.deflate === true;
+        return withHeaders(channels.open(authenticated.connection, request.signal, deflate), {
+          ...cors,
+          ...authenticated.headers
+        });
+      }
+      if (name === CANCEL_PATH) {
+        const value = await readBody(request, limit);
+        if (!cancellations.Check(value))
+          throw new SdkError("invalid", "A stream cancellation needs its channel and stream.");
+        channels.cancel(authenticated.connection, value.channel, value.stream);
+        return withHeaders(new Response(null, { status: 204 }), {
+          ...cors,
+          ...authenticated.headers
+        });
+      }
+      const needed = OPERATIONS[name].authority;
+      if (!authenticated.authority.has(needed))
+        throw new SdkError("denied", `${name} needs ${needed} authority.`);
+      const binding = bind(authenticated.connection);
+      let response;
+      const channel = request.headers.get(CHANNEL_HEADER);
+      const stream = request.headers.get(STREAM_HEADER);
+      if (channel !== null || stream !== null) {
+        if (channel === null || stream === null)
+          throw new SdkError("invalid", "A shared stream needs its channel and identifier.");
+        const value = await readBody(request, limit);
+        response = await channels.start(authenticated.connection, channel, stream, request.signal, (signal) => answer(binding, name, value, request, signal));
+      } else
+        response = await serve(binding, name, request, limit);
+      return withHeaders(response, { ...cors, ...authenticated.headers });
+    } catch (error) {
+      return errorResponse(asSdkError(error), cors);
+    }
+  };
+}
+async function serve(binding, name, request, limit) {
+  if (UPLOADS.has(name) && answersOnce(name)) {
+    const body = limited(request, limit);
+    return json(await call(binding, name, readInputHeader(request) ?? {}, { body, signal: request.signal }));
+  }
+  return answer(binding, name, await readBody(request, limit), request, request.signal);
+}
+async function answer(binding, name, value, request, signal) {
+  const context = { body: null, signal };
+  if (answersOnce(name))
+    return json(await call(binding, name, value, context));
+  if (name === "job.output")
+    return new Response(outputFrames(abortable(await binding["job.output"](decodeInput(name, value), context), signal)), { status: 200, headers: { "Content-Type": "application/octet-stream" } });
+  if (answersBytes(name))
+    return octetStream(await bytes(binding, name, value, context), request.signal);
+  return new Response(sseFrames(ending(await frames(binding, name, value, context), signal)), {
+    status: 200,
+    headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" }
+  });
+}
+async function call(binding, name, value, request) {
+  return encodeOutput(name, await binding[name](decodeInput(name, value), request));
+}
+async function bytes(binding, name, value, request) {
+  return binding[name](decodeInput(name, value), request);
+}
+async function frames(binding, name, value, request) {
+  return mapped(await binding[name](decodeInput(name, value), request), (frame) => encodeOutput(name, frame));
+}
+function ending(source, signal) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iterator = abortable(source, signal)[Symbol.asyncIterator]();
+      return {
+        async next() {
+          const next = await iterator.next();
+          if (next.done === true && signal.reason instanceof SdkError)
+            throw signal.reason;
+          return next;
+        },
+        async return() {
+          await iterator.return?.();
+          return { done: true, value: undefined };
+        }
+      };
+    }
+  };
+}
+async function readBody(request, limit) {
+  const stream = limited(request, limit);
+  if (stream === null)
+    return {};
+  const chunks = [];
+  const reader = stream.getReader();
+  for (;; ) {
+    const read = await reader.read();
+    if (read.done)
+      break;
+    chunks.push(read.value);
+  }
+  const decoder = new TextDecoder;
+  const text = chunks.map((chunk) => decoder.decode(chunk, { stream: true })).join("") + decoder.decode();
+  return text.trim() === "" ? {} : parseJson(text);
+}
+function limited(request, limit) {
+  const declared = Number(request.headers.get("Content-Length") ?? "0");
+  if (declared > limit)
+    throw largerThan(limit);
+  if (request.body === null)
+    return null;
+  let total = 0;
+  return request.body.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      total += chunk.byteLength;
+      if (total > limit)
+        controller.error(largerThan(limit));
+      else
+        controller.enqueue(chunk);
+    }
+  }), { signal: request.signal });
+}
+function largerThan(limit) {
+  const error = new SdkError("invalid", `The body is larger than ${limit} bytes.`);
+  tooLarge.add(error);
+  return error;
+}
+function corsHeaders(request, origins) {
+  const origin = request.headers.get("Origin");
+  if (origin === null || origin === new URL(request.url).origin)
+    return {};
+  if (!(origins ?? []).includes(origin))
+    return null;
+  return {
+    "Access-Control-Allow-Origin": origin,
+    "Access-Control-Expose-Headers": EXPOSED_HEADERS,
+    Vary: "Origin"
+  };
+}
+function readOperation(request) {
+  const path = new URL(request.url).pathname;
+  const name = path.slice(1);
+  if (request.method !== "POST" || !namesOperation(name))
+    throw new SdkError("unknown", `No operation answers ${request.method} ${path}.`);
+  return name;
+}
+function json(value) {
+  return new Response(JSON.stringify(value), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function errorResponse(failure, headers) {
+  return new Response(JSON.stringify(encodeError(failure)), {
+    status: tooLarge.has(failure) ? 413 : errorStatus[failure.code],
+    headers: { ...headers, "Content-Type": "application/json" }
+  });
+}
+function withHeaders(response, headers) {
+  const merged = new Headers(response.headers);
+  for (const [key, value] of Object.entries(headers))
+    merged.set(key, value);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: merged
+  });
+}
+
+export { createHandler2 };