@nyte-ai/host 0.0.18 → 0.0.19

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) {

package/src/local/files.ts

@@ -167,7 +167,7 @@ export function localFiles(
       if (stats === null) return null;
 
       if (stats.isSymbolicLink()) {
-        const link = await readlink(target);
+        const link = await readLink(target);
 
         return { kind: "symlink", size: stats.size, version: hashVersion(link), target: link };
       }
@@ -218,7 +218,7 @@ export function localFiles(
 
       const current =
         (await currentVersion(target)) ??
-        (link.isSymbolicLink() ? hashVersion(await readlink(target)) : null);
+        (link.isSymbolicLink() ? hashVersion(await readLink(target)) : null);
 
       if (removeOptions?.expect !== undefined && removeOptions.expect !== current)
         return { kind: "stale", current };
@@ -326,6 +326,10 @@ async function currentVersion(path: string): Promise<FileVersion | null> {
   return stats.isDirectory() ? directoryVersion(path) : hashFile(path).catch(missing);
 }
 
+async function readLink(path: string): Promise<string> {
+  return (await readlink(path)).split(sep).join("/");
+}
+
 async function resolveLink(path: string): Promise<string> {
   const link = await lstat(path).catch(missing);
 
@@ -529,7 +533,7 @@ function rejectFailure(code: number | null, stderr: string): void {
 }
 
 function ripgrepPath(path: string): string {
-  return path.replace(/^\.\//, "").split(sep).join("/");
+  return path.split(sep).join("/").replace(/^\.\//, "");
 }
 
 async function* grep(
@@ -586,6 +590,7 @@ async function* grep(
   } finally {
     lines.close();
     child.kill();
+    await closed;
   }
 }
 

package/src/local/git-watch.ts

@@ -1,4 +1,5 @@
-import { isAbsolute, relative, sep } from "node:path";
+import { lstat } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
 import type { Disposer, GitStatus } from "@nyte-ai/schema";
 import type { FeedSink } from "./feed.ts";
 import { createIgnores, watchTree } from "./tree.ts";
@@ -33,7 +34,7 @@ const GIT_STATE = new Set([
   "rebase-apply",
 ]);
 
-/** Returns the status watch `localGit` shares among its watchers: the first subscriber starts it and the last one stops it, and each gets the status at once, then again whenever a change could move it. A recursive `fs.watch` on the workspace hears worktree paths that `.gitignore` and `.git/info/exclude` do not ignore, and, in the git directory and the common directory, only HEAD, the index, branch and remote refs, `packed-refs`, `config` and the merge, cherry-pick, revert and rebase state, so object writes, logs and Nyte's snapshot refs read nothing; the `.git` entry itself appearing or going drops the remembered repository and starts over. Only where `fs.watch` is unavailable does it poll, every 2 s. */
+/** Returns the status watch `localGit` shares among its watchers: the first subscriber starts it and the last one stops it, and each gets the status at once, then again whenever a change could move it. A recursive `fs.watch` on the workspace hears worktree paths that `.gitignore` and `.git/info/exclude` do not ignore, and, in the git directory and the common directory, only HEAD, the index, branch and remote refs, `packed-refs`, `config` and the merge, cherry-pick, revert and rebase state, so object writes, logs and Nyte's snapshot refs read nothing; the `.git` entry itself appearing or going (not a change inside it, which Windows also reports on the folder) drops the remembered repository and starts over. Only where `fs.watch` is unavailable does it poll, every 2 s. */
 export function createWatcher(
   cwd: string,
   read: () => Promise<GitStatus>,
@@ -88,7 +89,10 @@ export function createWatcher(
       );
     };
 
-    void repository().then((repo) => {
+    const gitEntry = async (): Promise<boolean> =>
+      (await lstat(join(cwd, ".git")).catch(() => null)) !== null;
+
+    void Promise.all([repository(), gitEntry()]).then(([repo, hadGit]) => {
       if (stopped) return;
       const insideGitDir = repo === null ? null : pathInside(cwd, repo.gitDir);
       const ignores = repo === null ? null : createIgnores(repo.root);
@@ -99,7 +103,11 @@ export function createWatcher(
         let found: "none" | "status" = "none";
 
         for (const path of paths) {
-          if (path === ".git") return "repository";
+          if (path === ".git") {
+            if ((await gitEntry()) !== hadGit) return "repository";
+
+            continue;
+          }
 
           if (repo === null || ignores === null) continue;
 
@@ -115,7 +123,10 @@ export function createWatcher(
           if (path.endsWith(".gitignore"))
             ignores.forget(`${repo.prefix}${path}`.split("/").slice(0, -1).join("/"));
 
-          if (found === "none" && !(await ignores.ignored(`${repo.prefix}${path}`, false)))
+          if (found !== "none") continue;
+          const directory = (await lstat(join(cwd, path)).catch(() => null))?.isDirectory();
+
+          if (!(await ignores.ignored(`${repo.prefix}${path}`, directory === true)))
             found = "status";
         }
 
@@ -175,7 +186,6 @@ function movesStatus(path: string): boolean {
   return (
     path === "" ||
     GIT_STATE.has(top) ||
-    path === "refs" ||
     path.startsWith("refs/heads/") ||
     path.startsWith("refs/remotes/")
   );

package/src/local/git.ts

@@ -1,5 +1,5 @@
 import { lstat, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { asId, SdkError } from "@nyte-ai/schema";
 import type {
   BlameView,
@@ -101,7 +101,12 @@ export function localGit(env: ExecutionEnv, options?: { readonly git?: string })
 
     return root === undefined || gitDir === undefined
       ? null
-      : { root, gitDir, commonDir: commonDir || gitDir, prefix };
+      : {
+          root: resolve(root),
+          gitDir: resolve(gitDir),
+          commonDir: resolve(commonDir || gitDir),
+          prefix,
+        };
   };
 
   const repository = async (): Promise<Repository | null> => {

package/src/local/github.ts

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import type { ChildProcess } from "node:child_process";
 import { Type } from "typebox";
@@ -17,7 +16,7 @@ import type {
 } from "@nyte-ai/schema";
 import { dev } from "@nyte-ai/core";
 import type { ExecutionEnv, GitHubAccountApi, GitHubApi } from "@nyte-ai/core";
-import { findExecutable, run } from "./command.ts";
+import { findExecutable, killTree, run, spawnCommand } from "./command.ts";
 
 const ENV = {
   GH_PROMPT_DISABLED: "1",
@@ -255,7 +254,7 @@ function startSignIn(file: string, cwd: string, ended: () => void): SignIn {
   let verificationUri: string | undefined;
   let done = false;
 
-  const child: ChildProcess = spawn(
+  const child: ChildProcess = spawnCommand(
     file,
     [
       "auth",
@@ -278,7 +277,7 @@ function startSignIn(file: string, cwd: string, ended: () => void): SignIn {
     child.stdout?.destroy();
     child.stderr?.destroy();
 
-    if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    if (child.exitCode === null && child.signalCode === null) killTree(child, "SIGKILL");
     started.resolve(start);
     ended();
   };