@nyte-ai/host 0.0.0-stage → 0.0.19

package/src/images/node.ts

@@ -0,0 +1,163 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import type { ImageLimits, ImageProcessor, PreparedImage } from "@nyte-ai/core";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { photonImages } from "./photon.ts";
+
+export interface NodeImagesOptions {
+  readonly worker?: string | URL;
+  readonly wasm?: string;
+}
+
+export interface PrepareRequest {
+  readonly id: number;
+  readonly bytes: Uint8Array;
+  readonly mimeType: string;
+  readonly limits: ImageLimits;
+}
+
+const size = Type.Object({ width: Type.Number(), height: Type.Number() });
+
+export const prepareReply = Type.Union([
+  Type.Object({ id: Type.Integer(), result: Type.Null() }),
+  Type.Object({
+    id: Type.Integer(),
+    result: Type.Object({
+      data: Type.String(),
+      mimeType: Type.String(),
+      resized: Type.Optional(Type.Object({ from: size, to: size })),
+    }),
+  }),
+  Type.Object({ id: Type.Integer(), error: Type.String() }),
+]);
+
+const IDLE_MS = 30_000;
+
+export function nodeImages(options: NodeImagesOptions = {}): ImageProcessor {
+  const worker =
+    options.worker ??
+    new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
+
+  let wasm: Promise<Uint8Array> | undefined;
+
+  const loadWasm = (): Promise<Uint8Array> =>
+    (wasm ??= readFile(options.wasm ?? resolvePhotonWasmPath()));
+
+  let thread: PhotonThread | undefined;
+  let inProcess: ImageProcessor | undefined;
+
+  return {
+    async prepare(bytes, mimeType, limits) {
+      if (inProcess !== undefined) return inProcess.prepare(bytes, mimeType, limits);
+      const module = await loadWasm();
+
+      try {
+        thread ??= new PhotonThread(worker, module, (ended) => {
+          if (thread === ended) thread = undefined;
+        });
+
+        return await thread.prepare(bytes, mimeType, limits);
+      } catch (cause) {
+        if (!(cause instanceof WorkerUnavailable)) throw cause;
+        inProcess ??= photonImages(module);
+
+        return inProcess.prepare(bytes, mimeType, limits);
+      }
+    },
+  };
+}
+
+export function resolvePhotonWasmPath(): string {
+  return fileURLToPath(import.meta.resolve("@silvia-odwyer/photon/photon_rs_bg.wasm"));
+}
+
+class WorkerUnavailable extends Error {}
+
+class PhotonThread {
+  readonly #worker: Worker;
+  readonly #pending = new Map<number, PromiseWithResolvers<PreparedImage | undefined>>();
+  readonly #onExit: (ended: PhotonThread) => void;
+  #nextId = 0;
+  #idle: ReturnType<typeof setTimeout> | undefined;
+  #started = false;
+
+  constructor(entry: string | URL, wasm: Uint8Array, onExit: (ended: PhotonThread) => void) {
+    this.#onExit = onExit;
+
+    try {
+      this.#worker = new Worker(entry, { workerData: wasm });
+    } catch (cause) {
+      throw new WorkerUnavailable("The image worker cannot start", { cause });
+    }
+
+    this.#worker.on("message", (reply: unknown) => {
+      if (!Value.Check(prepareReply, reply)) {
+        this.#fail(new Error("Malformed image worker reply"));
+        void this.#worker.terminate();
+
+        return;
+      }
+
+      this.#started = true;
+      const request = this.#pending.get(reply.id);
+
+      if (request === undefined) return;
+      this.#pending.delete(reply.id);
+
+      if ("error" in reply) request.reject(new Error(reply.error));
+      else request.resolve(reply.result ?? undefined);
+      this.#settled();
+    });
+
+    this.#worker.on("error", (cause) => this.#fail(cause));
+
+    this.#worker.on("exit", (code) =>
+      this.#fail(new Error(`The image worker exited with code ${String(code)}`)),
+    );
+  }
+
+  prepare(
+    bytes: Uint8Array,
+    mimeType: string,
+    limits: ImageLimits,
+  ): Promise<PreparedImage | undefined> {
+    const id = this.#nextId++;
+    const request = Promise.withResolvers<PreparedImage | undefined>();
+    this.#pending.set(id, request);
+    clearTimeout(this.#idle);
+    this.#idle = undefined;
+    this.#worker.ref();
+    const copy = bytes.slice();
+
+    this.#worker.postMessage({ id, bytes: copy, mimeType, limits } satisfies PrepareRequest, [
+      copy.buffer,
+    ]);
+
+    return request.promise;
+  }
+
+  #settled(): void {
+    if (this.#pending.size > 0) return;
+    this.#worker.unref();
+
+    this.#idle = setTimeout(() => {
+      this.#onExit(this);
+      void this.#worker.terminate();
+    }, IDLE_MS);
+
+    this.#idle.unref();
+  }
+
+  #fail(cause: unknown): void {
+    const failure = this.#started
+      ? cause
+      : new WorkerUnavailable("The image worker cannot start", { cause });
+
+    for (const request of this.#pending.values()) request.reject(failure);
+    this.#pending.clear();
+    clearTimeout(this.#idle);
+    this.#onExit(this);
+  }
+}

package/src/images/photon.ts

@@ -0,0 +1,141 @@
+import {
+  PhotonImage,
+  SamplingFilter,
+  fliph,
+  flipv,
+  initSync,
+  resize,
+} from "@silvia-odwyer/photon/photon_rs.js";
+import type { SyncInitInput } from "@silvia-odwyer/photon/photon_rs.js";
+import type { ImageLimits, ImageProcessor, PreparedImage } from "@nyte-ai/core";
+import { exifOrientation } from "./exif.ts";
+
+const INLINE_IMAGE_TYPES: ReadonlySet<string> = new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+]);
+
+const JPEG_QUALITIES = [80, 70, 55, 40];
+
+export function photonImages(wasm: SyncInitInput): ImageProcessor {
+  initSync({ module: wasm });
+
+  return {
+    prepare: (bytes, mimeType, limits) => Promise.resolve(prepare(bytes, mimeType, limits)),
+  };
+}
+
+function prepare(
+  bytes: Uint8Array,
+  mimeType: string,
+  limits: ImageLimits,
+): PreparedImage | undefined {
+  const orientation = exifOrientation(bytes);
+  let image: PhotonImage | undefined;
+
+  try {
+    image = PhotonImage.new_from_byteslice(bytes);
+
+    if (
+      INLINE_IMAGE_TYPES.has(mimeType) &&
+      orientation === 1 &&
+      image.get_width() <= limits.maxWidth &&
+      image.get_height() <= limits.maxHeight &&
+      base64Length(bytes.byteLength) <= limits.maxBase64Bytes
+    )
+      return { data: bytes.toBase64(), mimeType };
+
+    if (orientation >= 5) {
+      const upright = transposed(image, orientation);
+      image.free();
+      image = undefined;
+      image = new PhotonImage(upright.pixels, upright.width, upright.height);
+    } else if (orientation !== 1) {
+      if (orientation !== 4) fliph(image);
+
+      if (orientation !== 2) flipv(image);
+    }
+
+    const width = image.get_width();
+    const height = image.get_height();
+    const scale = Math.min(1, limits.maxWidth / width, limits.maxHeight / height);
+
+    let target = {
+      width: Math.max(1, Math.round(width * scale)),
+      height: Math.max(1, Math.round(height * scale)),
+    };
+
+    for (;;) {
+      const encoded = encodeWithin(image, target, limits.maxBase64Bytes, mimeType === "image/jpeg");
+
+      if (encoded !== undefined)
+        return target.width === width && target.height === height
+          ? encoded
+          : { ...encoded, resized: { from: { width, height }, to: target } };
+
+      if (target.width === 1 && target.height === 1) return undefined;
+      target = {
+        width: Math.max(1, Math.floor(target.width * 0.75)),
+        height: Math.max(1, Math.floor(target.height * 0.75)),
+      };
+    }
+  } catch {
+    return undefined;
+  } finally {
+    image?.free();
+  }
+}
+
+function encodeWithin(
+  image: PhotonImage,
+  size: { readonly width: number; readonly height: number },
+  maxBase64Bytes: number,
+  jpegFirst: boolean,
+): { readonly data: string; readonly mimeType: string } | undefined {
+  const same = size.width === image.get_width() && size.height === image.get_height();
+  const scaled = same ? image : resize(image, size.width, size.height, SamplingFilter.Lanczos3);
+
+  try {
+    const png = { mimeType: "image/png", encode: () => scaled.get_bytes() };
+
+    const jpegs = JPEG_QUALITIES.map((quality) => ({
+      mimeType: "image/jpeg",
+      encode: () => scaled.get_bytes_jpeg(quality),
+    }));
+
+    for (const candidate of jpegFirst ? [...jpegs, png] : [png, ...jpegs]) {
+      const encoded = candidate.encode();
+
+      if (base64Length(encoded.byteLength) <= maxBase64Bytes)
+        return { data: encoded.toBase64(), mimeType: candidate.mimeType };
+    }
+
+    return undefined;
+  } finally {
+    if (!same) scaled.free();
+  }
+}
+
+function transposed(image: PhotonImage, orientation: number) {
+  const width = image.get_width();
+  const height = image.get_height();
+  const source = image.get_raw_pixels();
+  const pixels = new Uint8Array(source.length);
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const outX = orientation === 5 || orientation === 8 ? y : height - 1 - y;
+      const outY = orientation === 5 || orientation === 6 ? x : width - 1 - x;
+      const from = (y * width + x) * 4;
+      pixels.set(source.subarray(from, from + 4), (outY * height + outX) * 4);
+    }
+  }
+
+  return { pixels, width: height, height: width };
+}
+
+function base64Length(byteLength: number): number {
+  return Math.ceil(byteLength / 3) * 4;
+}

package/src/images/worker.ts

@@ -0,0 +1,29 @@
+import { parentPort, workerData } from "node:worker_threads";
+import type { Static } from "typebox";
+import type { PrepareRequest, prepareReply } from "./node.ts";
+import { photonImages } from "./photon.ts";
+
+const port = parentPort;
+
+if (port === null) throw new Error("The image worker needs a parent thread");
+
+const wasm: unknown = workerData;
+
+if (!(wasm instanceof Uint8Array)) throw new Error("The image worker needs Photon's WebAssembly");
+
+const images = photonImages(wasm);
+
+port.on("message", (request: PrepareRequest) => {
+  void images.prepare(request.bytes, request.mimeType, request.limits).then(
+    (result) =>
+      port.postMessage({
+        id: request.id,
+        result: result ?? null,
+      } satisfies Static<typeof prepareReply>),
+    (cause: unknown) =>
+      port.postMessage({
+        id: request.id,
+        error: cause instanceof Error ? cause.message : String(cause),
+      } satisfies Static<typeof prepareReply>),
+  );
+});

package/src/index.ts

@@ -0,0 +1,39 @@
+export * from "./credentials.ts";
+
+export * from "./identity.ts";
+
+export { identitySigner } from "./identity-key.ts";
+
+export * from "./listen.ts";
+
+export * from "./listen-fetch.ts";
+
+export * from "./local/files.ts";
+
+export * from "./local/git.ts";
+
+export * from "./local/github.ts";
+
+export * from "./local/identity.ts";
+
+export * from "./local/jobs.ts";
+
+export * from "./local/provider.ts";
+
+export { createMcpHub } from "./mcp/hub.ts";
+
+export type { McpConnector } from "./mcp/connect.ts";
+
+export * from "./local/snapshots.ts";
+
+export * from "./local/worktrees.ts";
+
+export * from "./open.ts";
+
+export * from "./plugins/loader.ts";
+
+export * from "./postgres.ts";
+
+export * from "./secrets.ts";
+
+export * from "./sqlite.ts";

package/src/key-file.ts

@@ -0,0 +1,53 @@
+import { link, mkdir, open, readFile, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+import { SdkError } from "@nyte-ai/schema";
+import { readErrorCode } from "./local/tree.ts";
+
+export async function readKeyFile(path: string, name: string): Promise<Uint8Array> {
+  const bytes = await readFile(path)
+    .then(
+      (stored) => new Uint8Array(stored),
+      (error: unknown) => {
+        if (readErrorCode(error) === "ENOENT") return mintKeyFile(path);
+
+        throw error;
+      },
+    )
+    .catch((error: unknown) => {
+      throw new SdkError(
+        "unavailable",
+        `The ${name} at ${path} cannot be read: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    });
+
+  if (bytes.length !== 32)
+    throw new SdkError("invalid", `The ${name} at ${path} is ${bytes.length} bytes, not 32.`);
+
+  return bytes;
+}
+
+async function mintKeyFile(path: string): Promise<Uint8Array> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  const temp = `${path}.${crypto.randomUUID()}`;
+  const file = await open(temp, "wx", 0o600);
+
+  try {
+    await file.writeFile(bytes);
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+
+  try {
+    await link(temp, path);
+
+    return bytes;
+  } catch (error) {
+    if (readErrorCode(error) !== "EEXIST") throw error;
+
+    return new Uint8Array(await readFile(path));
+  } finally {
+    await unlink(temp).catch(() => undefined);
+  }
+}