@nyte-ai/host 0.0.18 → 0.0.19

package/dist/chunks/{canvas-preview-0nrnbt76.js → canvas-preview-k1yg4fgp.js}

@@ -3,22 +3,61 @@ import {
   recordedUsage2,
   summarizeModels2
 } from "./canvas-preview-srgfpdmf.js";
+import {
+  localDay2
+} from "./canvas-preview-11nadadc.js";
+import {
+  fileScanSchema2,
+  UsageScanCache2,
+  readHistory2,
+  readCacheDocument2,
+  writeCacheDocument2
+} from "./canvas-preview-kp75gb63.js";
 
 // src/usage.ts
-import { Buffer } from "node:buffer";
-import { constants, existsSync } from "node:fs";
-import { lstat, open, opendir, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { lstat, opendir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import process from "node:process";
-import { StringDecoder } from "node:string_decoder";
 import { Type } from "typebox";
+import { Compile } from "typebox/compile";
 import { Value } from "typebox/value";
 import { calculateCost } from "@nyte-ai/ai";
 var tokens = Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var count = Type.Number({ minimum: 0 });
+var modelUsage = Type.Object({
+  input: count,
+  output: count,
+  cacheRead: count,
+  cacheWrite: count,
+  cacheWrite1h: Type.Optional(count),
+  reasoning: Type.Optional(count),
+  totalTokens: count,
+  cost: Type.Object({
+    input: Type.Number(),
+    output: Type.Number(),
+    cacheRead: Type.Number(),
+    cacheWrite: Type.Number(),
+    total: Type.Number()
+  })
+});
+var recordedAt = Type.Union([Type.Number(), Type.Null()]);
+var snapshot = Type.Object({
+  model: Type.String(),
+  usage: modelUsage,
+  costUSD: Type.Optional(Type.Number()),
+  at: recordedAt
+});
+var claudeCodeFileScan = Type.Object({
+  keyed: Type.Array(Type.Tuple([Type.String(), snapshot])),
+  anonymous: Type.Array(snapshot),
+  malformedRecords: Type.Integer({ minimum: 0 })
+});
 var envelope = Type.Object({ type: Type.String() });
 var assistantRecord = Type.Object({
   type: Type.Literal("assistant"),
+  timestamp: Type.Optional(Type.String()),
   requestId: Type.Optional(Type.String()),
   costUSD: Type.Optional(Type.Unknown()),
   message: Type.Object({
@@ -43,38 +82,49 @@ function betterSnapshot(previous, next) {
   const usage = next.usage;
   return usage.totalTokens > previous.usage.totalTokens || usage.totalTokens === previous.usage.totalTokens && (usage.output > previous.usage.output || usage.output === previous.usage.output && previous.costUSD === undefined && next.costUSD !== undefined);
 }
-async function scanClaudeCodeFile(path, signal) {
-  const keyed = new Map;
-  const anonymous = [];
-  let malformedRecords = 0;
-  for await (const line of historyLines(path, signal)) {
-    signal?.throwIfAborted();
-    if (!line.text.trim())
-      continue;
+function parseRecordedAt(value) {
+  if (value === undefined)
+    return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function recordedIn(window, at) {
+  if (at === null)
+    return window.sinceDay === null;
+  const day = localDay2(at);
+  return day <= window.untilDay && (window.sinceDay === null || day >= window.sinceDay);
+}
+var claudeCodeParser = (from) => {
+  const keyed = new Map(from?.keyed);
+  const anonymous = [...from?.anonymous ?? []];
+  let malformedRecords = from?.malformedRecords ?? 0;
+  const line = ({ text, terminated }) => {
+    if (!text.trim())
+      return;
     let value;
     try {
-      value = JSON.parse(line.text);
+      value = JSON.parse(text);
     } catch {
-      if (line.terminated)
+      if (terminated)
         malformedRecords++;
-      continue;
+      return;
     }
     if (!Value.Check(envelope, value)) {
       malformedRecords++;
-      continue;
+      return;
     }
     if (value.type !== "assistant")
-      continue;
+      return;
     if (!Value.Check(assistantRecord, value)) {
       malformedRecords++;
-      continue;
+      return;
     }
     const raw = value.message.usage;
     const cacheWrite = raw.cache_creation_input_tokens ?? 0;
     const cacheWrite1h = raw.cache_creation?.ephemeral_1h_input_tokens;
     if ((cacheWrite1h ?? 0) + (raw.cache_creation?.ephemeral_5m_input_tokens ?? 0) > cacheWrite) {
       malformedRecords++;
-      continue;
+      return;
     }
     const usage = {
       ...emptyModelUsage2(),
@@ -89,40 +139,31 @@ async function scanClaudeCodeFile(path, signal) {
     const snapshot = {
       model: value.message.model,
       usage,
-      costUSD: Value.Check(reportedCost, value.costUSD) ? value.costUSD : undefined
+      at: parseRecordedAt(value.timestamp)
     };
+    if (Value.Check(reportedCost, value.costUSD))
+      snapshot.costUSD = value.costUSD;
     const messageId = value.message.id?.trim() || null;
     const requestId = value.requestId?.trim() || null;
     if (messageId === null && requestId === null) {
       anonymous.push(snapshot);
-      continue;
+      return;
     }
     const identity = JSON.stringify([messageId, requestId]);
     if (betterSnapshot(keyed.get(identity), snapshot))
       keyed.set(identity, snapshot);
-  }
-  return { keyed: [...keyed], anonymous, malformedRecords };
-}
-async function scanCached(path, cache, seen, parse) {
-  seen.add(path);
-  if (cache === undefined)
-    return parse();
+  };
+  return { line, scan: () => ({ keyed: [...keyed], anonymous: [...anonymous], malformedRecords }) };
+};
+async function readHistoryInWindow(path, window, read) {
+  read.seen.add(path);
   const info = await lstat(path);
   if (!info.isFile())
     throw new Error("History is not a regular file.");
-  const hit = cache.get(path);
-  if (hit !== undefined && hit.size === info.size && hit.mtimeMs === info.mtimeMs)
-    return hit.scan;
-  const scan = await parse();
-  cache.set(path, { size: info.size, mtimeMs: info.mtimeMs, scan });
-  return scan;
-}
-function pruneCache(cache, seen) {
-  if (cache === undefined)
+  const opens = window.sinceDay === null ? 0 : new Date(`${window.sinceDay}T00:00:00`).getTime();
+  if (info.mtimeMs < opens)
     return;
-  for (const path of cache.keys())
-    if (!seen.has(path))
-      cache.delete(path);
+  return readHistory2(path, info, read.parser, read.cache, read.signal);
 }
 async function readClaudeCodeUsage2(options) {
   options.signal?.throwIfAborted();
@@ -161,7 +202,14 @@ async function readClaudeCodeUsage2(options) {
           if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
             continue;
           try {
-            const scan = await scanCached(path, options.cache, seen, () => scanClaudeCodeFile(path, options.signal));
+            const scan = await readHistoryInWindow(path, options.window, {
+              parser: claudeCodeParser,
+              cache: options.cache,
+              seen,
+              signal: options.signal
+            });
+            if (scan === undefined)
+              continue;
             malformedRecords += scan.malformedRecords;
             anonymous.push(...scan.anonymous);
             for (const [identity, snapshot] of scan.keyed) {
@@ -181,12 +229,14 @@ async function readClaudeCodeUsage2(options) {
       }
     }
     options.signal?.throwIfAborted();
-    pruneCache(options.cache, seen);
+    options.cache?.keepOnly(seen);
     const catalog = options.models.getModels("anthropic").filter((model) => model.provider === "anthropic");
     const rows = [];
     let unpricedRecords = 0;
     for (const snapshot of [...keyed.values(), ...anonymous]) {
       options.signal?.throwIfAborted();
+      if (!recordedIn(options.window, snapshot.at))
+        continue;
       const usage = { ...snapshot.usage, cost: { ...snapshot.usage.cost } };
       if (snapshot.costUSD !== undefined) {
         usage.cost.total = snapshot.costUSD;
@@ -218,6 +268,19 @@ async function readClaudeCodeUsage2(options) {
     return { kind: "failed", message: "Could not read Claude Code local history." };
   }
 }
+var codexRow = Type.Object({ model: Type.String(), usage: modelUsage, at: recordedAt });
+var codexCursor = Type.Object({
+  model: Type.String(),
+  sawMeta: Type.Boolean(),
+  signature: Type.Optional(Type.String()),
+  forkAnchorMs: Type.Optional(Type.Number())
+});
+var codexFileScan = Type.Object({
+  modern: Type.Array(Type.Tuple([Type.String(), codexRow])),
+  legacy: Type.Array(codexRow),
+  malformedRecords: Type.Integer({ minimum: 0 }),
+  cursor: codexCursor
+});
 var codexTokens = Type.Object({
   input_tokens: Type.Optional(tokens),
   cached_input_tokens: Type.Optional(tokens),
@@ -227,6 +290,7 @@ var codexTokens = Type.Object({
 });
 var usageRecord = Type.Object({
   type: Type.Literal("token_usage_record"),
+  timestamp: Type.Optional(Type.String()),
   payload: Type.Object({
     response_id: Type.Optional(Type.String()),
     usage: codexTokens
@@ -269,12 +333,6 @@ function codexUsage(raw) {
   };
 }
 var FORK_COPY_MAX_GAP_MS = 1000;
-function parseMs(value) {
-  if (value === undefined)
-    return;
-  const parsed = Date.parse(value);
-  return Number.isNaN(parsed) ? undefined : parsed;
-}
 async function readCodexUsage2(options) {
   options.signal?.throwIfAborted();
   const home = resolve(options.homeDir ?? (process.env.CODEX_HOME?.trim() || join(homedir(), ".codex")));
@@ -302,7 +360,14 @@ async function readCodexUsage2(options) {
     for (const root of present) {
       for await (const path of jsonlFiles(root, options.signal)) {
         try {
-          const scan = await scanCached(path, options.cache, seen, () => scanCodexRollout(path, options.signal));
+          const scan = await readHistoryInWindow(path, options.window, {
+            parser: codexParser,
+            cache: options.cache,
+            seen,
+            signal: options.signal
+          });
+          if (scan === undefined)
+            continue;
           malformedRecords += scan.malformedRecords;
           if (scan.modern.length > 0) {
             for (const [id, row] of scan.modern)
@@ -318,12 +383,14 @@ async function readCodexUsage2(options) {
       }
     }
     options.signal?.throwIfAborted();
-    pruneCache(options.cache, seen);
+    options.cache?.keepOnly(seen);
     const catalog = options.models.getModels("openai-codex").filter((model) => model.provider === "openai-codex");
     const rows = [];
     let unpricedRecords = 0;
     for (const row of [...responses.values(), ...legacy]) {
       options.signal?.throwIfAborted();
+      if (!recordedIn(options.window, row.at))
+        continue;
       const usage = { ...row.usage, cost: { ...row.usage.cost } };
       const matches = catalog.filter((model) => model.id === row.model);
       const model = matches.length === 1 ? matches[0] : undefined;
@@ -350,76 +417,81 @@ async function readCodexUsage2(options) {
     return { kind: "failed", message: "Could not read Codex local history." };
   }
 }
-async function scanCodexRollout(path, signal) {
-  const modern = new Map;
-  const legacy = [];
-  let malformedRecords = 0;
-  let model = "";
-  let sawMeta = false;
-  let signature;
-  let forkAnchorMs;
-  for await (const line of historyLines(path, signal)) {
-    signal?.throwIfAborted();
-    if (!line.text.trim())
-      continue;
+var codexParser = (from) => {
+  const modern = new Map(from?.modern);
+  const legacy = [...from?.legacy ?? []];
+  let malformedRecords = from?.malformedRecords ?? 0;
+  const cursor = { ...from?.cursor ?? { model: "", sawMeta: false } };
+  const line = ({ text, terminated }) => {
+    if (!text.trim())
+      return;
     let value;
     try {
-      value = JSON.parse(line.text);
+      value = JSON.parse(text);
     } catch {
-      if (line.terminated)
+      if (terminated)
         malformedRecords++;
-      continue;
+      return;
     }
     if (!Value.Check(envelope, value)) {
       malformedRecords++;
-      continue;
+      return;
     }
     if (Value.Check(turnContext, value)) {
       if (value.payload.model !== undefined)
-        model = value.payload.model;
-      continue;
+        cursor.model = value.payload.model;
+      return;
     }
     if (Value.Check(sessionMeta, value)) {
-      if (sawMeta)
-        continue;
-      sawMeta = true;
+      if (cursor.sawMeta)
+        return;
+      cursor.sawMeta = true;
       const forked = value.payload.forked_from_id !== undefined || value.payload.parent_thread_id !== undefined;
-      if (forked)
-        forkAnchorMs = parseMs(value.timestamp);
-      continue;
+      const anchor = parseRecordedAt(value.timestamp);
+      if (forked && anchor !== null)
+        cursor.forkAnchorMs = anchor;
+      return;
     }
     if (Value.Check(usageRecord, value)) {
       const id = value.payload.response_id;
-      if (id === undefined || model === "")
-        continue;
+      if (id === undefined || cursor.model === "")
+        return;
       const usage = codexUsage(value.payload.usage);
       if (usage.totalTokens > 0 && !modern.has(id))
-        modern.set(id, { model, usage });
-      continue;
+        modern.set(id, { model: cursor.model, usage, at: parseRecordedAt(value.timestamp) });
+      return;
     }
     if (!Value.Check(tokenCount, value))
-      continue;
+      return;
     const last = value.payload.info.last_token_usage;
-    if (last === undefined || model === "")
-      continue;
+    if (last === undefined || cursor.model === "")
+      return;
     const next = JSON.stringify(last);
-    if (next === signature)
-      continue;
-    signature = next;
-    if (forkAnchorMs !== undefined) {
-      const at = parseMs(value.timestamp);
-      if (at !== undefined && at - forkAnchorMs < FORK_COPY_MAX_GAP_MS) {
-        forkAnchorMs = at;
-        continue;
+    if (next === cursor.signature)
+      return;
+    cursor.signature = next;
+    const at = parseRecordedAt(value.timestamp);
+    if (cursor.forkAnchorMs !== undefined) {
+      if (at !== null && at - cursor.forkAnchorMs < FORK_COPY_MAX_GAP_MS) {
+        cursor.forkAnchorMs = at;
+        return;
       }
-      forkAnchorMs = undefined;
+      delete cursor.forkAnchorMs;
     }
     const usage = codexUsage(last);
     if (usage.totalTokens > 0)
-      legacy.push({ model, usage });
-  }
-  return { modern: [...modern], legacy, malformedRecords };
-}
+      legacy.push({ model: cursor.model, usage, at });
+  };
+  return {
+    line,
+    scan: () => ({
+      modern: [...modern],
+      legacy: [...legacy],
+      malformedRecords,
+      cursor: { ...cursor }
+    })
+  };
+};
 async function* jsonlFiles(root, signal) {
   const directories = [root];
   for (const directory of directories) {
@@ -441,37 +513,37 @@ async function* jsonlFiles(root, signal) {
     }
   }
 }
-async function* historyLines(path, signal) {
-  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-  try {
-    const stat = await file.stat();
-    if (!stat.isFile())
-      throw new Error("History is not a regular file.");
-    const buffer = Buffer.alloc(64 * 1024);
-    const decoder = new StringDecoder("utf8");
-    let pending = "";
-    let position = 0;
-    while (position < stat.size) {
-      signal?.throwIfAborted();
-      const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, stat.size - position), position);
-      if (bytesRead === 0)
-        break;
-      position += bytesRead;
-      const lines = `${pending}${decoder.write(buffer.subarray(0, bytesRead))}`.split(`
-`);
-      pending = lines.pop() ?? "";
-      for (const text of lines)
-        yield { text, terminated: true };
-    }
-    pending += decoder.end();
-    if (pending)
-      yield { text: pending, terminated: false };
-  } finally {
-    await file.close();
-  }
-}
 function createUsageScanCaches2() {
-  return { claudeCode: new Map, codex: new Map };
+  return { claudeCode: new UsageScanCache2, codex: new UsageScanCache2 };
+}
+var USAGE_SCAN_CACHE_VERSION = 1;
+var usageScanCacheDocument = Type.Object({
+  version: Type.Literal(USAGE_SCAN_CACHE_VERSION),
+  claudeCode: Type.Array(Type.Tuple([Type.String(), fileScanSchema2(claudeCodeFileScan)])),
+  codex: Type.Array(Type.Tuple([Type.String(), fileScanSchema2(codexFileScan)]))
+});
+var usageScanCacheValidator = Compile(usageScanCacheDocument);
+async function loadUsageScanCaches2(path) {
+  const document = await readCacheDocument2(path, usageScanCacheValidator);
+  if (document === undefined)
+    return createUsageScanCaches2();
+  return {
+    claudeCode: new UsageScanCache2(document.claudeCode),
+    codex: new UsageScanCache2(document.codex)
+  };
+}
+async function saveUsageScanCaches2(path, caches) {
+  if (!caches.claudeCode.changed && !caches.codex.changed)
+    return;
+  const saved = await writeCacheDocument2(path, {
+    version: USAGE_SCAN_CACHE_VERSION,
+    claudeCode: [...caches.claudeCode.entries()],
+    codex: [...caches.codex.entries()]
+  });
+  if (!saved)
+    return;
+  caches.claudeCode.markSaved();
+  caches.codex.markSaved();
 }
 async function readLocalUsage2(options) {
   const failed = (message) => {
@@ -481,11 +553,13 @@ async function readLocalUsage2(options) {
   const [claudeCode, codex] = await Promise.all([
     readClaudeCodeUsage2({
       models: options.models,
+      window: options.window,
       signal: options.signal,
       cache: options.caches?.claudeCode
     }).catch(() => failed("Could not read Claude Code history.")),
     readCodexUsage2({
       models: options.models,
+      window: options.window,
       signal: options.signal,
       cache: options.caches?.codex
     }).catch(() => failed("Could not read Codex history."))
@@ -494,4 +568,4 @@ async function readLocalUsage2(options) {
   return { claudeCode, codex };
 }
 
-export { readClaudeCodeUsage2, readCodexUsage2, createUsageScanCaches2, readLocalUsage2 };
+export { readClaudeCodeUsage2, readCodexUsage2, createUsageScanCaches2, loadUsageScanCaches2, saveUsageScanCaches2, readLocalUsage2 };

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

@@ -0,0 +1,141 @@
+// src/usage-history.ts
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { Type } from "typebox";
+function fileScanSchema2(scan) {
+  return Type.Object({
+    size: Type.Number({ minimum: 0 }),
+    mtimeMs: Type.Number(),
+    position: Type.Number({ minimum: 0 }),
+    committed: scan
+  });
+}
+
+class UsageScanCache2 {
+  #files;
+  #changed = false;
+  constructor(files = []) {
+    this.#files = new Map(files);
+  }
+  keys() {
+    return this.#files.keys();
+  }
+  entries() {
+    return this.#files.entries();
+  }
+  get(path) {
+    return this.#files.get(path);
+  }
+  set(path, scan) {
+    if (this.#files.get(path) === scan)
+      return;
+    this.#files.set(path, scan);
+    this.#changed = true;
+  }
+  keepOnly(seen) {
+    for (const path of this.#files.keys()) {
+      if (seen.has(path))
+        continue;
+      this.#files.delete(path);
+      this.#changed = true;
+    }
+  }
+  get changed() {
+    return this.#changed;
+  }
+  markSaved() {
+    this.#changed = false;
+  }
+}
+async function readHistory2(path, info, parser, cache, signal) {
+  const hit = cache?.get(path);
+  const unchanged = hit !== undefined && hit.size === info.size && hit.mtimeMs === info.mtimeMs;
+  if (unchanged && hit.position === info.size)
+    return hit.committed;
+  const from = unchanged || hit !== undefined && info.size > hit.size ? hit : undefined;
+  const fold = parser(from?.committed);
+  let position = from?.position ?? 0;
+  let unterminated;
+  for await (const line of historyLines(path, position, signal)) {
+    signal?.throwIfAborted();
+    if (!line.terminated) {
+      unterminated = line;
+      continue;
+    }
+    fold.line(line);
+    position = line.end;
+  }
+  const committed = fold.scan();
+  cache?.set(path, unchanged ? hit : { size: info.size, mtimeMs: info.mtimeMs, position, committed });
+  if (unterminated === undefined)
+    return committed;
+  fold.line(unterminated);
+  return fold.scan();
+}
+async function* historyLines(path, start, signal) {
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const stat = await file.stat();
+    if (!stat.isFile())
+      throw new Error("History is not a regular file.");
+    const buffer = Buffer.alloc(64 * 1024);
+    let pending = Buffer.alloc(0);
+    let pendingStart = start;
+    let position = start;
+    while (position < stat.size) {
+      signal?.throwIfAborted();
+      const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, stat.size - position), position);
+      if (bytesRead === 0)
+        break;
+      position += bytesRead;
+      const read = buffer.subarray(0, bytesRead);
+      const chunk = pending.length === 0 ? read : Buffer.concat([pending, read]);
+      let from = 0;
+      for (let newline = chunk.indexOf(10);newline !== -1; newline = chunk.indexOf(10, from)) {
+        yield {
+          text: chunk.toString("utf8", from, newline),
+          terminated: true,
+          end: pendingStart + newline + 1
+        };
+        from = newline + 1;
+      }
+      pendingStart += from;
+      pending = Buffer.from(chunk.subarray(from));
+    }
+    if (pending.length > 0)
+      yield {
+        text: pending.toString("utf8"),
+        terminated: false,
+        end: pendingStart + pending.length
+      };
+  } finally {
+    await file.close();
+  }
+}
+async function readCacheDocument2(path, validator) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    return validator.Check(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+async function writeCacheDocument2(path, document) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(temporary, JSON.stringify(document), { mode: 384 });
+    await rename(temporary, path);
+    return true;
+  } catch {
+    await rm(temporary, { force: true }).catch(() => {
+      return;
+    });
+    return false;
+  }
+}
+
+export { fileScanSchema2, UsageScanCache2, readHistory2, readCacheDocument2, writeCacheDocument2 };

package/dist/chunks/{canvas-preview-ewgspmsd.js → canvas-preview-n2a35zv5.js}

@@ -3,7 +3,7 @@ import {
 } from "./canvas-preview-2zdyh9ny.js";
 import {
   package_default
-} from "./canvas-preview-g3qj3y3k.js";
+} from "./canvas-preview-jeddjex8.js";
 
 // src/deploy/vercel/server/utils/host.ts
 import process from "node:process";

package/dist/chunks/{canvas-preview-h8hshnff.js → canvas-preview-pkzqg96v.js}

@@ -54,7 +54,7 @@ function expand(values, server) {
     value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
       const found = process.env[name];
       if (found === undefined)
-        throw new Error(`${server} needs the environment variable ${name}. Set it where Nyte runs, then restart Nyte (for the CLI, \`nyte service stop\`).`);
+        throw new Error(`${server} needs the environment variable ${name}. Set it where Nyte runs, then restart Nyte.`);
       return found;
     })
   ]));