@nyte-ai/host 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,240 @@
+import {
+  bindConnection2
+} from "./canvas-preview-55s0y68g.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 };

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

@@ -0,0 +1,36 @@
+import {
+  vercelHost2
+} from "./canvas-preview-n2a35zv5.js";
+import {
+  stepFrom2
+} from "./canvas-preview-65xqjw7f.js";
+
+// src/deploy/vercel/server/workflows/drive.ts
+import { sleep } from "workflow";
+import { start } from "workflow/api";
+async function dispatchHead2(target) {
+  await start(driveHead2, [target]);
+}
+async function driveHead2(input) {
+  "use workflow";
+  for (;; ) {
+    const next = stepFrom2(await advanceHead2(input), Date.now());
+    if (next.kind === "stop")
+      return;
+    if (next.kind === "sleep")
+      await sleep(next.ms);
+  }
+}
+async function advanceHead2(input) {
+  "use step";
+  const { host } = await vercelHost2(dispatchHead2);
+  const coverage = await host.execution.cover({ kind: "sessions", sessions: [input.session] });
+  try {
+    await host.server.tick(Date.now());
+    return await host.execution.advance(input);
+  } finally {
+    await coverage.close();
+  }
+}
+
+export { dispatchHead2, driveHead2, advanceHead2 };

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

@@ -0,0 +1,60 @@
+// src/images/exif.ts
+var ORIENTATION_TAG = 274;
+function exifOrientation2(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tiff = tiffStart(bytes, view);
+  if (tiff < 0 || tiff + 8 > bytes.length)
+    return 1;
+  const little = bytes[tiff] === 73 && bytes[tiff + 1] === 73;
+  const directory = tiff + view.getUint32(tiff + 4, little);
+  if (directory + 2 > bytes.length)
+    return 1;
+  const entries = view.getUint16(directory, little);
+  for (let index = 0;index < entries; index++) {
+    const entry = directory + 2 + index * 12;
+    if (entry + 12 > bytes.length)
+      return 1;
+    if (view.getUint16(entry, little) === ORIENTATION_TAG) {
+      const value = view.getUint16(entry + 8, little);
+      return value >= 1 && value <= 8 ? value : 1;
+    }
+  }
+  return 1;
+}
+function tiffStart(bytes, view) {
+  if (bytes[0] === 255 && bytes[1] === 216) {
+    for (let offset = 2;offset + 4 <= bytes.length; ) {
+      if (bytes[offset] !== 255)
+        return -1;
+      const marker = view.getUint8(offset + 1);
+      if (marker === 255) {
+        offset++;
+        continue;
+      }
+      if (marker === 225 && startsExif(bytes, offset + 4))
+        return offset + 10;
+      offset += 2 + view.getUint16(offset + 2);
+    }
+    return -1;
+  }
+  if (ascii(bytes, 0, "RIFF") && ascii(bytes, 8, "WEBP")) {
+    for (let offset = 12;offset + 8 <= bytes.length; ) {
+      const size = view.getUint32(offset + 4, true);
+      if (ascii(bytes, offset, "EXIF"))
+        return startsExif(bytes, offset + 8) ? offset + 14 : offset + 8;
+      offset += 8 + size + size % 2;
+    }
+  }
+  return -1;
+}
+function startsExif(bytes, offset) {
+  return ascii(bytes, offset, "Exif") && bytes[offset + 4] === 0 && bytes[offset + 5] === 0;
+}
+function ascii(bytes, offset, text) {
+  for (let index = 0;index < text.length; index++)
+    if (bytes[offset + index] !== text.charCodeAt(index))
+      return false;
+  return true;
+}
+
+export { exifOrientation2 };

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

@@ -0,0 +1,103 @@
+// src/local/command.ts
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { delimiter, extname, 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();
+  const resolved = process.platform === "win32" ? await findExecutable2(file) ?? file : file;
+  return new Promise((resolve, reject) => {
+    const child = spawnCommand2(resolved, 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);
+  });
+}
+function spawnCommand2(file, args, options) {
+  if (process.platform !== "win32" || !/\.(cmd|bat)$/i.test(file))
+    return spawn(file, args, options);
+  const shim = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i.test(file);
+  const line = [escapeCommand(file), ...args.map((arg) => escapeArgument(arg, shim))].join(" ");
+  return spawn(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", `"${line}"`], {
+    ...options,
+    windowsVerbatimArguments: true
+  });
+}
+function killTree2(child, signal) {
+  if (process.platform !== "win32" || child.pid === undefined) {
+    child.kill(signal);
+    return;
+  }
+  spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+    stdio: "ignore",
+    windowsHide: true
+  }).on("error", () => child.kill(signal));
+}
+var CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+function escapeCommand(command) {
+  return command.replace(CMD_META, "^$1");
+}
+function escapeArgument(argument, twice) {
+  const quoted = `"${argument.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\*)$/, "$1$1")}"`;
+  const escaped = quoted.replace(CMD_META, "^$1");
+  return twice ? escaped.replace(CMD_META, "^$1") : escaped;
+}
+async function findExecutable2(name, directories = []) {
+  const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter((ext) => ext !== "");
+  const extensions = process.platform !== "win32" ? [""] : extname(name) === "" ? pathext : ["", ...pathext];
+  if (isAbsolute(name)) {
+    for (const extension of extensions)
+      if (await executable(`${name}${extension}`))
+        return `${name}${extension}`;
+    return null;
+  }
+  await processEnvironment();
+  const path = (process.env.PATH ?? "").split(delimiter).filter((entry) => entry !== "");
+  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, spawnCommand2, killTree2, findExecutable2 };