@nyte-ai/host 0.0.18 → 0.0.19

package/dist/src/usage-worker.js

@@ -1,10 +1,14 @@
-import"../chunks/canvas-preview-srgfpdmf.js";
 import"../chunks/canvas-preview-69fkk9yn.js";
-import"../chunks/canvas-preview-5hxat7hh.js";
-import"../chunks/canvas-preview-0nrnbt76.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-tnqe7k0b.js";
+import"../chunks/canvas-preview-srgfpdmf.js";
+import"../chunks/canvas-preview-11nadadc.js";
+import"../chunks/canvas-preview-kp75gb63.js";
+import"../chunks/canvas-preview-k1yg4fgp.js";
 import {
   UsageScanner2
-} from "../chunks/canvas-preview-1ta3avah.js";
+} from "../chunks/canvas-preview-fxa0rfb0.js";
 
 // src/usage-worker.ts
 import { parentPort } from "node:worker_threads";

package/dist/src/usage.d.ts

@@ -1,29 +1,83 @@
+import { Type, type Static } from "typebox";
 import { type Models } from "@nyte-ai/ai";
-import type { LocalHistoryUsage } from "./usage-types.ts";
-import type { Usage } from "@nyte-ai/schema/model";
+import { UsageScanCache } from "./usage-history.ts";
+import type { LocalHistoryUsage, UsageWindow } from "./usage-types.ts";
 export interface ClaudeCodeUsageOptions {
     readonly models: Pick<Models, "getModels">;
+    readonly window: UsageWindow;
     readonly configDir?: string;
     readonly signal?: AbortSignal;
     readonly cache?: UsageScanCache<ClaudeCodeFileScan>;
 }
-export type UsageScanCache<T> = Map<string, FileScan<T>>;
-export interface FileScan<T> {
-    readonly size: number;
-    readonly mtimeMs: number;
-    readonly scan: T;
-}
-export interface ClaudeCodeFileScan {
-    readonly keyed: readonly (readonly [string, Snapshot])[];
-    readonly anonymous: readonly Snapshot[];
-    readonly malformedRecords: number;
-}
 export type ClaudeCodeUsage = LocalHistoryUsage;
-export interface Snapshot {
-    readonly model: string;
-    readonly usage: Usage;
-    readonly costUSD: number | undefined;
-}
+declare const snapshot: Type.TObject<{
+    model: Type.TString;
+    usage: Type.TObject<{
+        input: Type.TNumber;
+        output: Type.TNumber;
+        cacheRead: Type.TNumber;
+        cacheWrite: Type.TNumber;
+        cacheWrite1h: Type.TOptional<Type.TNumber>;
+        reasoning: Type.TOptional<Type.TNumber>;
+        totalTokens: Type.TNumber;
+        cost: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            total: Type.TNumber;
+        }>;
+    }>;
+    costUSD: Type.TOptional<Type.TNumber>;
+    at: Type.TUnion<[Type.TNumber, Type.TNull]>;
+}>;
+export type Snapshot = Static<typeof snapshot>;
+declare const claudeCodeFileScan: Type.TObject<{
+    keyed: Type.TArray<Type.TTuple<[Type.TString, Type.TObject<{
+        model: Type.TString;
+        usage: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            cacheWrite1h: Type.TOptional<Type.TNumber>;
+            reasoning: Type.TOptional<Type.TNumber>;
+            totalTokens: Type.TNumber;
+            cost: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                total: Type.TNumber;
+            }>;
+        }>;
+        costUSD: Type.TOptional<Type.TNumber>;
+        at: Type.TUnion<[Type.TNumber, Type.TNull]>;
+    }>]>>;
+    anonymous: Type.TArray<Type.TObject<{
+        model: Type.TString;
+        usage: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            cacheWrite1h: Type.TOptional<Type.TNumber>;
+            reasoning: Type.TOptional<Type.TNumber>;
+            totalTokens: Type.TNumber;
+            cost: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                total: Type.TNumber;
+            }>;
+        }>;
+        costUSD: Type.TOptional<Type.TNumber>;
+        at: Type.TUnion<[Type.TNumber, Type.TNull]>;
+    }>>;
+    malformedRecords: Type.TInteger;
+}>;
+export type ClaudeCodeFileScan = Static<typeof claudeCodeFileScan>;
 /**
  * Reads Claude Code's local usage under `<configDir>/projects`. The configured root may be a
  * symlink (as may a system ancestor such as macOS `/tmp`), but links below it are skipped, to
@@ -35,19 +89,82 @@ export declare function readClaudeCodeUsage(options: ClaudeCodeUsageOptions): Pr
 export type CodexUsage = LocalHistoryUsage;
 export interface CodexUsageOptions {
     readonly models: Pick<Models, "getModels">;
+    readonly window: UsageWindow;
     readonly homeDir?: string;
     readonly signal?: AbortSignal;
     readonly cache?: UsageScanCache<CodexFileScan>;
 }
-export interface CodexFileScan {
-    readonly modern: readonly (readonly [string, CodexRow])[];
-    readonly legacy: readonly CodexRow[];
-    readonly malformedRecords: number;
-}
-export interface CodexRow {
-    readonly model: string;
-    readonly usage: Usage;
-}
+declare const codexRow: Type.TObject<{
+    model: Type.TString;
+    usage: Type.TObject<{
+        input: Type.TNumber;
+        output: Type.TNumber;
+        cacheRead: Type.TNumber;
+        cacheWrite: Type.TNumber;
+        cacheWrite1h: Type.TOptional<Type.TNumber>;
+        reasoning: Type.TOptional<Type.TNumber>;
+        totalTokens: Type.TNumber;
+        cost: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            total: Type.TNumber;
+        }>;
+    }>;
+    at: Type.TUnion<[Type.TNumber, Type.TNull]>;
+}>;
+export type CodexRow = Static<typeof codexRow>;
+declare const codexFileScan: Type.TObject<{
+    modern: Type.TArray<Type.TTuple<[Type.TString, Type.TObject<{
+        model: Type.TString;
+        usage: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            cacheWrite1h: Type.TOptional<Type.TNumber>;
+            reasoning: Type.TOptional<Type.TNumber>;
+            totalTokens: Type.TNumber;
+            cost: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                total: Type.TNumber;
+            }>;
+        }>;
+        at: Type.TUnion<[Type.TNumber, Type.TNull]>;
+    }>]>>;
+    legacy: Type.TArray<Type.TObject<{
+        model: Type.TString;
+        usage: Type.TObject<{
+            input: Type.TNumber;
+            output: Type.TNumber;
+            cacheRead: Type.TNumber;
+            cacheWrite: Type.TNumber;
+            cacheWrite1h: Type.TOptional<Type.TNumber>;
+            reasoning: Type.TOptional<Type.TNumber>;
+            totalTokens: Type.TNumber;
+            cost: Type.TObject<{
+                input: Type.TNumber;
+                output: Type.TNumber;
+                cacheRead: Type.TNumber;
+                cacheWrite: Type.TNumber;
+                total: Type.TNumber;
+            }>;
+        }>;
+        at: Type.TUnion<[Type.TNumber, Type.TNull]>;
+    }>>;
+    malformedRecords: Type.TInteger;
+    cursor: Type.TObject<{
+        model: Type.TString;
+        sawMeta: Type.TBoolean;
+        signature: Type.TOptional<Type.TString>;
+        forkAnchorMs: Type.TOptional<Type.TNumber>;
+    }>;
+}>;
+export type CodexFileScan = Static<typeof codexFileScan>;
 /**
  * Reads Codex's local usage from `sessions` and `archived_sessions` (where the legacy format
  * lives). A `response_id` is unique across files, so one map dedups a forked rollout's repeated
@@ -61,12 +178,18 @@ export interface UsageScanCaches {
     readonly codex: UsageScanCache<CodexFileScan>;
 }
 export declare function createUsageScanCaches(): UsageScanCaches;
+/** Restores the scans {@link saveUsageScanCaches} wrote to `path`; each still answers only while its file is unchanged. */
+export declare function loadUsageScanCaches(path: string): Promise<UsageScanCaches>;
+/** Writes `caches` to `path` when a read changed them since they were last saved; a failed write is tried again on the next save. */
+export declare function saveUsageScanCaches(path: string, caches: UsageScanCaches): Promise<void>;
 export interface LocalUsage {
     readonly claudeCode: LocalHistoryUsage;
     readonly codex: LocalHistoryUsage;
 }
 export declare function readLocalUsage(options: {
     readonly models: Pick<Models, "getModels">;
+    readonly window: UsageWindow;
     readonly signal?: AbortSignal;
     readonly caches?: UsageScanCaches;
 }): Promise<LocalUsage>;
+export {};

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-k1yg4fgp.js";
+import"../chunks/canvas-preview-11nadadc.js";
+import"../chunks/canvas-preview-kp75gb63.js";
 import"../chunks/canvas-preview-srgfpdmf.js";
+import"../chunks/canvas-preview-tnqe7k0b.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.19",
   "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.19",
+    "@nyte-ai/core": "0.0.19",
+    "@nyte-ai/plugin": "0.0.19",
+    "@nyte-ai/protocol": "0.0.19",
+    "@nyte-ai/schema": "0.0.19",
+    "@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);
+  }
+}