@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/src/shell-env.js

@@ -0,0 +1,108 @@
+// src/shell-env.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { holdProcessEnvironment } from "@nyte-ai/core/server";
+var TIMEOUT_MS = 1e4;
+var OUTPUT_LIMIT = 64 * 1024;
+var SHELL_LOCAL = new Set(["PWD", "OLDPWD", "SHLVL", "_"]);
+var shared;
+function completeShellEnvironment() {
+  if (shared === undefined) {
+    shared = createShellEnvironmentRepair();
+    holdProcessEnvironment(shared());
+  }
+  return shared();
+}
+function createShellEnvironmentRepair({
+  env = process.env,
+  platform = process.platform,
+  timeoutMs = TIMEOUT_MS
+} = {}) {
+  let attempt;
+  return () => {
+    attempt ??= repairShellEnvironment({ env, platform, timeoutMs });
+    return attempt;
+  };
+}
+async function repairShellEnvironment({
+  env,
+  platform,
+  timeoutMs
+}) {
+  const shell = env.SHELL || "/bin/sh";
+  if (platform === "win32" || !isAbsolute(shell))
+    return;
+  const inheritedPath = env.PATH;
+  const loaded = await readLoginShellEnvironment({ shell, env, timeoutMs });
+  if (loaded === undefined)
+    return;
+  for (const [name, value] of loaded) {
+    if (name !== "PATH" && !SHELL_LOCAL.has(name))
+      env[name] = value;
+  }
+  const path = loaded.get("PATH");
+  if (path === undefined || path === "")
+    return;
+  env.PATH = inheritedPath ? `${path}:${inheritedPath}` : path;
+}
+function readLoginShellEnvironment({
+  shell,
+  env,
+  timeoutMs
+}) {
+  return new Promise((resolve) => {
+    const marker = `nyte-env-${randomUUID()}`;
+    const fence = `\x00${marker}\x00`;
+    const printFence = `printf '\\000${marker}\\000'`;
+    const child = spawn(shell, ["-ilc", `${printFence}; /usr/bin/env -0; ${printFence}`], {
+      env,
+      detached: true,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (loaded) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      child.stdout.destroy();
+      child.kill("SIGKILL");
+      resolve(loaded);
+    };
+    const timer = setTimeout(() => finish(undefined), timeoutMs);
+    child.on("error", () => finish(undefined));
+    child.stdout.on("error", () => finish(undefined));
+    child.stdout.on("data", (chunk) => {
+      bytes += chunk.byteLength;
+      if (bytes > OUTPUT_LIMIT) {
+        finish(undefined);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.on("close", (code) => {
+      const [, fenced, ...after] = Buffer.concat(chunks).toString("utf8").split(fence);
+      if (code !== 0 || fenced === undefined || after.length === 0) {
+        finish(undefined);
+        return;
+      }
+      finish(parseEnvironment(fenced));
+    });
+  });
+}
+function parseEnvironment(output) {
+  const loaded = new Map;
+  for (const entry of output.split("\x00")) {
+    const [name = "", ...value] = entry.split("=");
+    if (name !== "" && value.length > 0)
+      loaded.set(name, value.join("="));
+  }
+  return loaded;
+}
+export {
+  completeShellEnvironment,
+  createShellEnvironmentRepair
+};

package/dist/src/sqlite-workers.d.ts

@@ -0,0 +1,6 @@
+import type { DatabaseSync, SQLInputValue } from "node:sqlite";
+export declare function sqliteWorkers(database: DatabaseSync, path: string): {
+    check: () => void;
+    read(sql: string, params: readonly SQLInputValue[]): Promise<readonly Record<string, string | number | bigint | null>[] | undefined>;
+    close(): Promise<void>;
+};

package/dist/src/sqlite-workers.js

@@ -0,0 +1,6 @@
+import {
+  sqliteWorkers2
+} from "../chunks/canvas-preview-zaaj99wd.js";
+export {
+  sqliteWorkers2 as sqliteWorkers
+};

package/dist/src/sqlite.d.ts

@@ -0,0 +1,8 @@
+import type { Store } from "@nyte-ai/core";
+/** The local store's file: `NYTE_DB` when set, so a source run keeps its own chats, else `.nyte/nyte.db` under `home`. */
+export declare function storePath(home: string): string;
+export declare function sqliteStore(input: {
+    readonly path: string;
+} | {
+    readonly memory: true;
+}): Store;

package/dist/src/sqlite.js

@@ -0,0 +1,11 @@
+import {
+  storePath2,
+  sqliteStore2
+} from "../chunks/canvas-preview-tnqe7k0b.js";
+import"../chunks/canvas-preview-zaaj99wd.js";
+import"../chunks/canvas-preview-0cmbkp2j.js";
+import"../chunks/canvas-preview-69fkk9yn.js";
+export {
+  sqliteStore2 as sqliteStore,
+  storePath2 as storePath
+};

package/dist/src/store-rows.d.ts

@@ -0,0 +1,13 @@
+import type { ByteReader, Ref, Revision, SessionEvent } from "@nyte-ai/schema";
+import type { LoggedRow, StoredObject, StoredRecord } from "@nyte-ai/core/store";
+export declare function prefixEnd(prefix: string): string | null;
+export declare function mintRevision(): Revision;
+export declare function decodeEvent(seq: number, at: number, text: string): SessionEvent;
+export declare function parseNumber(value: unknown): number;
+export declare function parseText(value: unknown): string | null;
+export declare function parseRef(row: Readonly<Record<string, unknown>>): Ref;
+export declare function parseStoredRecord(row: Readonly<Record<string, unknown>>): StoredRecord;
+export declare function parseStoredObject(row: Readonly<Record<string, unknown>>): StoredObject;
+export declare function loggedRow(row: Readonly<Record<string, unknown>>): LoggedRow;
+export declare function collect(bytes: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+export declare function memoryReader(bytes: Uint8Array): ByteReader;

package/dist/src/store-rows.js

@@ -0,0 +1,26 @@
+import {
+  prefixEnd2,
+  mintRevision2,
+  decodeEvent2,
+  parseNumber2,
+  parseText2,
+  parseRef2,
+  parseStoredRecord2,
+  parseStoredObject2,
+  loggedRow2,
+  collect2,
+  memoryReader2
+} from "../chunks/canvas-preview-69fkk9yn.js";
+export {
+  collect2 as collect,
+  decodeEvent2 as decodeEvent,
+  loggedRow2 as loggedRow,
+  memoryReader2 as memoryReader,
+  mintRevision2 as mintRevision,
+  parseNumber2 as parseNumber,
+  parseRef2 as parseRef,
+  parseStoredObject2 as parseStoredObject,
+  parseStoredRecord2 as parseStoredRecord,
+  parseText2 as parseText,
+  prefixEnd2 as prefixEnd
+};

package/dist/src/store-usage.d.ts

@@ -0,0 +1,25 @@
+import type { SessionId, Usage } from "@nyte-ai/schema";
+import type { UsageReport, UsageSubject, UsageWindow } from "./usage-types.ts";
+export interface UsageRecord {
+    readonly at: number;
+    readonly subject: UsageSubject;
+    readonly usage: Usage;
+}
+export interface SessionUsage {
+    readonly sessionId: SessionId;
+    readonly name: string | undefined;
+    readonly records: readonly UsageRecord[];
+    readonly lastActivityAt?: number;
+}
+export interface StoreRead {
+    readonly workspacePath: string | null;
+    readonly sessions: readonly SessionUsage[];
+    readonly failure: {
+        readonly message: string;
+    } | null;
+}
+export declare const USAGE_EVENTS = "SELECT session, seq, at, event FROM log WHERE json_extract(event, '$.kind') = 'request' OR (json_extract(event, '$.kind') = 'run' AND json_extract(event, '$.change') = 'started') ORDER BY session, seq";
+export declare function localDay(at: number): string;
+export declare function shiftDay(day: string, delta: number): string;
+export declare function projectUsageReport(stores: readonly StoreRead[], window: UsageWindow, readAt: number): UsageReport;
+export declare function readNyteUsage(home: string, window: UsageWindow): UsageReport;

package/dist/src/store-usage.js

@@ -0,0 +1,19 @@
+import {
+  USAGE_EVENTS2,
+  localDay2,
+  shiftDay2,
+  projectUsageReport2,
+  readNyteUsage2
+} from "../chunks/canvas-preview-11nadadc.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 {
+  USAGE_EVENTS2 as USAGE_EVENTS,
+  localDay2 as localDay,
+  projectUsageReport2 as projectUsageReport,
+  readNyteUsage2 as readNyteUsage,
+  shiftDay2 as shiftDay
+};

package/dist/src/usage-history.d.ts

@@ -0,0 +1,54 @@
+import type { Stats } from "node:fs";
+import { Type, type TSchema } from "typebox";
+export interface HistoryLine {
+    readonly text: string;
+    /** False for a last line without its newline: its writer may still be appending it. */
+    readonly terminated: boolean;
+}
+export interface HistoryFold<Scan> {
+    line(line: HistoryLine): void;
+    scan(): Scan;
+}
+/** Folds a history file's lines into a scan. `scan()` returns a copy, so folding goes on without changing it. */
+export type HistoryParser<Scan> = (from: Scan | undefined) => HistoryFold<Scan>;
+export interface FileScan<Scan> {
+    readonly size: number;
+    readonly mtimeMs: number;
+    /** The byte after the last newline, where a grown file resumes. */
+    readonly position: number;
+    /** The scan of every line up to `position`. */
+    readonly committed: Scan;
+}
+export declare function fileScanSchema<Scan extends TSchema>(scan: Scan): Type.TObject<{
+    size: Type.TNumber;
+    mtimeMs: Type.TNumber;
+    position: Type.TNumber;
+    committed: Scan;
+}>;
+/** Scans keyed by path. A scan answers while its file keeps the size and mtime it was read at. */
+export declare class UsageScanCache<Scan> {
+    #private;
+    constructor(files?: Iterable<readonly [string, FileScan<Scan>]>);
+    keys(): IterableIterator<string>;
+    entries(): IterableIterator<[string, FileScan<Scan>]>;
+    get(path: string): FileScan<Scan> | undefined;
+    set(path: string, scan: FileScan<Scan>): void;
+    /** Forgets every file a read did not reach. */
+    keepOnly(seen: ReadonlySet<string>): void;
+    /** Whether a scan was added or forgotten since the last {@link markSaved}. */
+    get changed(): boolean;
+    markSaved(): void;
+}
+/**
+ * Reads a history file through `cache`. An unchanged file answers from the cache without being
+ * opened, and a file that only grew is read from its last newline on; any other change rereads it.
+ * A last line without its newline is folded into the answer but not the cache, since its writer may
+ * still be appending it: the next read starts from that line again.
+ */
+export declare function readHistory<Scan>(path: string, info: Stats, parser: HistoryParser<Scan>, cache: UsageScanCache<Scan> | undefined, signal: AbortSignal | undefined): Promise<Scan>;
+/** Reads a cache document written by {@link writeCacheDocument}; a missing, torn or outdated one reads as `undefined`. */
+export declare function readCacheDocument<Document>(path: string, validator: {
+    Check(value: unknown): value is Document;
+}): Promise<Document | undefined>;
+/** Replaces the cache document whole, so a reader never sees half of one. Resolves whether the write landed. */
+export declare function writeCacheDocument<Document>(path: string, document: Document): Promise<boolean>;

package/dist/src/usage-history.js

@@ -0,0 +1,14 @@
+import {
+  fileScanSchema2,
+  UsageScanCache2,
+  readHistory2,
+  readCacheDocument2,
+  writeCacheDocument2
+} from "../chunks/canvas-preview-kp75gb63.js";
+export {
+  UsageScanCache2 as UsageScanCache,
+  fileScanSchema2 as fileScanSchema,
+  readCacheDocument2 as readCacheDocument,
+  readHistory2 as readHistory,
+  writeCacheDocument2 as writeCacheDocument
+};

package/dist/src/usage-scan.d.ts

@@ -0,0 +1,24 @@
+import type { UsageScan, UsageScanReader, UsageScanRequest } from "./usage-service.ts";
+export interface UsageWorkerRequest extends UsageScanRequest {
+    readonly id: number;
+    readonly home: string;
+}
+export type UsageWorkerReply = {
+    readonly id: number;
+    readonly scan: UsageScan;
+} | {
+    readonly id: number;
+    readonly error: string;
+};
+export declare class UsageScanWorker implements UsageScanReader {
+    private readonly home;
+    private readonly entry;
+    private worker;
+    private nextId;
+    private readonly pending;
+    constructor(home: string, entry: string | URL);
+    scan(request: UsageScanRequest): Promise<UsageScan>;
+    close(): Promise<void>;
+    private spawn;
+    private fail;
+}

package/dist/src/usage-scan.js

@@ -0,0 +1,65 @@
+// src/usage-scan.ts
+import { Worker } from "node:worker_threads";
+
+class UsageScanWorker {
+  home;
+  entry;
+  worker;
+  nextId = 1;
+  pending = new Map;
+  constructor(home, entry) {
+    this.home = home;
+    this.entry = entry;
+  }
+  async scan(request) {
+    const worker = this.spawn();
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      try {
+        worker.postMessage({ id, home: this.home, ...request });
+      } catch (cause) {
+        this.pending.delete(id);
+        reject(cause);
+      }
+    });
+  }
+  async close() {
+    const worker = this.worker;
+    if (worker === undefined)
+      return;
+    this.fail(worker, new Error("Usage worker closed."));
+    await worker.terminate();
+  }
+  spawn() {
+    if (this.worker !== undefined)
+      return this.worker;
+    const worker = new Worker(this.entry);
+    worker.unref();
+    worker.on("message", (reply) => {
+      const request = this.pending.get(reply.id);
+      this.pending.delete(reply.id);
+      if ("scan" in reply)
+        request?.resolve(reply.scan);
+      else
+        request?.reject(new Error(reply.error));
+    });
+    worker.on("error", (cause) => this.fail(worker, cause));
+    worker.on("exit", (code) => {
+      this.fail(worker, new Error(`Usage worker exited with code ${String(code)}.`));
+    });
+    this.worker = worker;
+    return worker;
+  }
+  fail(worker, cause) {
+    if (this.worker !== worker)
+      return;
+    this.worker = undefined;
+    for (const request of this.pending.values())
+      request.reject(cause);
+    this.pending.clear();
+  }
+}
+export {
+  UsageScanWorker
+};

package/dist/src/usage-service.d.ts

@@ -0,0 +1,23 @@
+import type { Models } from "@nyte-ai/ai";
+import type { Api, Model } from "@nyte-ai/schema/model";
+import type { UsageSnapshot, UsageWindow } from "./usage-types.ts";
+export interface UsageScanRequest {
+    readonly window: UsageWindow;
+    readonly catalog?: readonly Model<Api>[];
+}
+export type UsageScan = UsageSnapshot;
+export interface UsageScanReader {
+    scan(request: UsageScanRequest): Promise<UsageScan>;
+    close(): Promise<void>;
+}
+export declare function catalogForUsage(models: Pick<Models, "getModels">): readonly Model<Api>[];
+export declare class UsageScanner implements UsageScanReader {
+    private readonly home;
+    private readonly cachePath;
+    private caches;
+    private readonly models;
+    private readonly scans;
+    constructor(home: string);
+    scan(request: UsageScanRequest): Promise<UsageScan>;
+    close(): Promise<void>;
+}

package/dist/src/usage-service.js

@@ -0,0 +1,16 @@
+import {
+  catalogForUsage2,
+  UsageScanner2
+} from "../chunks/canvas-preview-fxa0rfb0.js";
+import"../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 {
+  UsageScanner2 as UsageScanner,
+  catalogForUsage2 as catalogForUsage
+};

package/dist/src/usage-summary.d.ts

@@ -0,0 +1,9 @@
+import type { Usage } from "@nyte-ai/schema";
+import type { Usage as ModelUsageCounts } from "@nyte-ai/schema/model";
+import type { ModelUsage, UsageSummary } from "./usage-types.ts";
+export declare function emptyModelUsage(): ModelUsageCounts;
+export declare function recordedUsage(usage: ModelUsageCounts): Usage;
+export declare function emptyUsageSummary(): UsageSummary;
+export declare function summarizeModels(rows: readonly ModelUsage[]): UsageSummary;
+export declare function cacheSavings(usage: Usage): number;
+export declare function usageTokens(usage: Usage): number;

package/dist/src/usage-summary.js

@@ -0,0 +1,16 @@
+import {
+  emptyModelUsage2,
+  recordedUsage2,
+  emptyUsageSummary2,
+  summarizeModels2,
+  cacheSavings2,
+  usageTokens2
+} from "../chunks/canvas-preview-srgfpdmf.js";
+export {
+  cacheSavings2 as cacheSavings,
+  emptyModelUsage2 as emptyModelUsage,
+  emptyUsageSummary2 as emptyUsageSummary,
+  recordedUsage2 as recordedUsage,
+  summarizeModels2 as summarizeModels,
+  usageTokens2 as usageTokens
+};

package/dist/src/usage-types.d.ts

@@ -0,0 +1,86 @@
+import type { SessionId, Usage } from "@nyte-ai/schema";
+export interface UsageWindow {
+    readonly sinceDay: string | null;
+    readonly untilDay: string;
+}
+export interface UsageTotals {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly reasoning: number;
+    readonly tokens: number;
+    readonly cost: number;
+    readonly cacheSavings: number;
+}
+export type UsageSubject = {
+    readonly kind: "model";
+    readonly provider: string;
+    readonly model: string;
+} | {
+    readonly kind: "tool";
+} | {
+    readonly kind: "compaction";
+};
+export interface UsageEntry {
+    readonly day: string;
+    readonly workspacePath: string | null;
+    readonly sessionId: SessionId;
+    readonly subject: UsageSubject;
+    readonly totals: UsageTotals;
+}
+export interface UsageSession {
+    readonly sessionId: SessionId;
+    readonly name?: string;
+    readonly workspacePath: string | null;
+    readonly lastActivityAt: number;
+}
+export interface UsageSource {
+    readonly workspacePath: string | null;
+    readonly status: "ok" | "failed";
+    readonly sessions: number;
+    readonly message: string | null;
+}
+export interface UsageReport {
+    readonly readAt: number;
+    readonly sinceDay: string;
+    readonly untilDay: string;
+    readonly entries: readonly UsageEntry[];
+    readonly sessions: readonly UsageSession[];
+    readonly sources: readonly UsageSource[];
+    readonly previous?: {
+        readonly cost: number;
+        readonly tokens: number;
+    };
+    readonly earliestDay?: string;
+}
+export interface ModelUsage {
+    readonly provider: string;
+    readonly model: string;
+    readonly turns: number;
+    readonly usage: Usage;
+}
+export interface UsageSummary {
+    readonly models: readonly ModelUsage[];
+    readonly compaction: Usage;
+    readonly tools: Usage;
+    readonly total: Usage;
+    readonly cacheSavings: number;
+}
+export type LocalHistoryUsage = {
+    readonly kind: "missing";
+} | {
+    readonly kind: "failed";
+    readonly message: string;
+} | {
+    readonly kind: "ready";
+    readonly summary: UsageSummary;
+    readonly unpricedRecords: number;
+    readonly malformedRecords: number;
+    readonly unreadableFiles: number;
+};
+export interface UsageSnapshot extends UsageReport {
+    readonly nyteError: string | null;
+    readonly claudeCode: LocalHistoryUsage;
+    readonly codex: LocalHistoryUsage;
+}

package/dist/src/usage-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/usage-worker.js

@@ -0,0 +1,29 @@
+import"../chunks/canvas-preview-69fkk9yn.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-fxa0rfb0.js";
+
+// src/usage-worker.ts
+import { parentPort } from "node:worker_threads";
+var port = parentPort;
+if (port === null)
+  throw new Error("The usage worker must run on a worker thread.");
+var scanner;
+port.on("message", (request) => {
+  scanner ??= new UsageScanner2(request.home);
+  scanner.scan(request).then((scan) => {
+    port.postMessage({ id: request.id, scan });
+  }, (cause) => {
+    port.postMessage({
+      id: request.id,
+      error: cause instanceof Error ? cause.message : String(cause)
+    });
+  });
+});