@nyte-ai/host 0.0.18 → 0.0.21

package/dist/src/usage.js

@@ -2,12 +2,22 @@ import {
   readClaudeCodeUsage2,
   readCodexUsage2,
   createUsageScanCaches2,
+  loadUsageScanCaches2,
+  saveUsageScanCaches2,
   readLocalUsage2
-} from "../chunks/canvas-preview-0nrnbt76.js";
+} from "../chunks/canvas-preview-eehzfefa.js";
+import"../chunks/canvas-preview-geg2gckp.js";
+import"../chunks/canvas-preview-kp75gb63.js";
 import"../chunks/canvas-preview-srgfpdmf.js";
+import"../chunks/canvas-preview-mstbvwz3.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
 export {
   createUsageScanCaches2 as createUsageScanCaches,
+  loadUsageScanCaches2 as loadUsageScanCaches,
   readClaudeCodeUsage2 as readClaudeCodeUsage,
   readCodexUsage2 as readCodexUsage,
-  readLocalUsage2 as readLocalUsage
+  readLocalUsage2 as readLocalUsage,
+  saveUsageScanCaches2 as saveUsageScanCaches
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyte-ai/host",
-  "version": "0.0.18",
+  "version": "0.0.21",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -36,6 +36,14 @@
       "types": "./dist/src/identity.d.ts",
       "import": "./dist/src/identity.js"
     },
+    "./images": {
+      "types": "./dist/src/images/node.d.ts",
+      "import": "./dist/src/images/node.js"
+    },
+    "./image-worker": {
+      "types": "./dist/src/images/worker.d.ts",
+      "import": "./dist/src/images/worker.js"
+    },
     "./listen-fetch": {
       "types": "./dist/src/listen-fetch.d.ts",
       "import": "./dist/src/listen-fetch.js"
@@ -88,11 +96,12 @@
   "dependencies": {
     "@earendil-works/pi-mcp": "1.3.0",
     "@lydell/node-pty": "1.2.0-beta.15",
-    "@nyte-ai/ai": "0.0.18",
-    "@nyte-ai/core": "0.0.18",
-    "@nyte-ai/plugin": "0.0.18",
-    "@nyte-ai/protocol": "0.0.18",
-    "@nyte-ai/schema": "0.0.18",
+    "@nyte-ai/ai": "0.0.21",
+    "@nyte-ai/core": "0.0.21",
+    "@nyte-ai/plugin": "0.0.21",
+    "@nyte-ai/protocol": "0.0.21",
+    "@nyte-ai/schema": "0.0.21",
+    "@silvia-odwyer/photon": "0.3.3",
     "fflate": "0.8.3",
     "ignore": "7.0.9",
     "pg": "8.23.0",
@@ -126,10 +135,9 @@
   },
   "scripts": {
     "clean": "rm -rf node_modules .turbo",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p src/deploy/vercel",
+    "typecheck": "tsrs --noEmit && tsrs --noEmit -p src/deploy/vercel",
     "test": "vitest --run",
     "check:store": "node scripts/check-store.ts",
-    "compact:store": "node scripts/compact-store.ts",
     "build:package": "bun ../../scripts/sdk-packages.mjs build host"
   }
 }

package/src/canvas-preview.ts

@@ -27,6 +27,7 @@ import type {
 import { Type } from "typebox";
 import type { TSchema } from "typebox";
 import { Value } from "typebox/value";
+import { killTree } from "./local/command.ts";
 
 const ORIGIN = "https://canvas.preview/";
 
@@ -312,12 +313,12 @@ function stop(child: ChildProcess): Promise<void> {
   if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
 
   return new Promise((resolve) => {
-    const kill = setTimeout(() => child.kill("SIGKILL"), 2000);
+    const kill = setTimeout(() => killTree(child, "SIGKILL"), 2000);
     child.once("exit", () => {
       clearTimeout(kill);
       resolve();
     });
-    child.kill();
+    killTree(child, "SIGTERM");
   });
 }
 
@@ -396,7 +397,7 @@ export function chromiumCanvasPreview(
       }
     } finally {
       await stop(child);
-      await rm(profile, { recursive: true, force: true });
+      await rm(profile, { recursive: true, force: true, maxRetries: 10 });
     }
   };
 }

package/src/images/exif.ts

@@ -0,0 +1,69 @@
+const ORIENTATION_TAG = 0x0112;
+
+export function exifOrientation(bytes: Uint8Array): number {
+  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] === 0x49 && bytes[tiff + 1] === 0x49;
+  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: Uint8Array, view: DataView): number {
+  if (bytes[0] === 0xff && bytes[1] === 0xd8) {
+    for (let offset = 2; offset + 4 <= bytes.length;) {
+      if (bytes[offset] !== 0xff) return -1;
+      const marker = view.getUint8(offset + 1);
+
+      if (marker === 0xff) {
+        offset++;
+        continue;
+      }
+
+      if (marker === 0xe1 && 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: Uint8Array, offset: number): boolean {
+  return ascii(bytes, offset, "Exif") && bytes[offset + 4] === 0 && bytes[offset + 5] === 0;
+}
+
+function ascii(bytes: Uint8Array, offset: number, text: string): boolean {
+  for (let index = 0; index < text.length; index++)
+    if (bytes[offset + index] !== text.charCodeAt(index)) return false;
+
+  return true;
+}

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

@@ -1,21 +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";
-export { StoreOwned } from "./store-owner.ts";

package/src/local/command.ts

@@ -1,7 +1,8 @@
 import { spawn } from "node:child_process";
+import type { ChildProcess, SpawnOptions } from "node:child_process";
 import { constants } from "node:fs";
 import { access, stat } from "node:fs/promises";
-import { delimiter, isAbsolute, join } from "node:path";
+import { delimiter, extname, isAbsolute, join } from "node:path";
 import { SdkError } from "@nyte-ai/schema";
 import { processEnvironment } from "@nyte-ai/core";
 
@@ -25,9 +26,10 @@ export async function run(
   },
 ): Promise<Ran> {
   await processEnvironment();
+  const resolved = process.platform === "win32" ? ((await findExecutable(file)) ?? file) : file;
 
   return new Promise((resolve, reject) => {
-    const child = spawn(file, args, {
+    const child = spawnCommand(resolved, args, {
       cwd: options.cwd,
       env: { ...process.env, ...options.env },
       stdio: ["pipe", "pipe", "pipe"],
@@ -44,7 +46,7 @@ export async function run(
     child.on("error", (error) =>
       reject(new SdkError("unavailable", `Cannot run ${file}: ${error.message}`)),
     );
-    child.stdout.on("data", (chunk: Buffer) => {
+    child.stdout?.on("data", (chunk: Buffer) => {
       if (truncated) return;
       size += chunk.byteLength;
 
@@ -58,8 +60,8 @@ export async function run(
 
       stdout.push(chunk);
     });
-    child.stderr.on("data", (chunk: Buffer) => stderr.push(chunk));
-    child.stdin.on("error", () => undefined);
+    child.stderr?.on("data", (chunk: Buffer) => stderr.push(chunk));
+    child.stdin?.on("error", () => undefined);
     child.on("close", (code) =>
       resolve({
         code,
@@ -68,22 +70,72 @@ export async function run(
         truncated,
       }),
     );
-    child.stdin.end(options.input);
+    child.stdin?.end(options.input);
   });
 }
 
+/** Spawns `file` as `spawn` does, except that on Windows a `.cmd` or `.bat` file runs through `cmd.exe` with its arguments escaped, as Node no longer starts batch files without a shell. */
+export function spawnCommand(
+  file: string,
+  args: readonly string[],
+  options: SpawnOptions,
+): ChildProcess {
+  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,
+  });
+}
+
+/** Ends `child` with `signal`; on Windows, which has no signals, it ends the child's whole process tree with `taskkill /T /F`, as `kill` alone would leave what a batch file or a shell started running. */
+export function killTree(child: ChildProcess, signal: NodeJS.Signals): void {
+  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));
+}
+
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+
+function escapeCommand(command: string): string {
+  return command.replace(CMD_META, "^$1");
+}
+
+function escapeArgument(argument: string, twice: boolean): string {
+  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;
+}
+
 export async function findExecutable(
   name: string,
   directories: readonly string[] = [],
 ): Promise<string | null> {
-  if (isAbsolute(name)) return (await executable(name)) ? name : null;
-  await processEnvironment();
-  const path = (process.env.PATH ?? "").split(delimiter).filter((entry) => entry !== "");
+  const pathext = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter((ext) => ext !== "");
 
   const extensions =
-    process.platform === "win32"
-      ? ["", ...(process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")]
-      : [""];
+    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) {