@nyte-ai/host 0.0.0-stage → 0.0.18

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,16 @@
+import {
+  USAGE_EVENTS2,
+  localDay2,
+  shiftDay2,
+  projectUsageReport2,
+  readNyteUsage2
+} from "../chunks/canvas-preview-5hxat7hh.js";
+import"../chunks/canvas-preview-srgfpdmf.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-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,22 @@
+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 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,12 @@
+import {
+  catalogForUsage2,
+  UsageScanner2
+} from "../chunks/canvas-preview-1ta3avah.js";
+import"../chunks/canvas-preview-0nrnbt76.js";
+import"../chunks/canvas-preview-5hxat7hh.js";
+import"../chunks/canvas-preview-srgfpdmf.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,25 @@
+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 {
+  UsageScanner2
+} from "../chunks/canvas-preview-1ta3avah.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)
+    });
+  });
+});

package/dist/src/usage.d.ts

@@ -0,0 +1,72 @@
+import { type Models } from "@nyte-ai/ai";
+import type { LocalHistoryUsage } from "./usage-types.ts";
+import type { Usage } from "@nyte-ai/schema/model";
+export interface ClaudeCodeUsageOptions {
+    readonly models: Pick<Models, "getModels">;
+    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;
+}
+/**
+ * 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
+ * avoid loops and duplicate history. Every read prices cached snapshots again on a copy, since
+ * the catalog can change between reads while a transcript does not; a snapshot that records its
+ * own cost keeps that total, with no invented breakdown.
+ */
+export declare function readClaudeCodeUsage(options: ClaudeCodeUsageOptions): Promise<ClaudeCodeUsage>;
+export type CodexUsage = LocalHistoryUsage;
+export interface CodexUsageOptions {
+    readonly models: Pick<Models, "getModels">;
+    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;
+}
+/**
+ * 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
+ * parent responses as well as repeats within a file; a file with modern records counts only
+ * those, since the legacy event is written beside them. Rows are priced on a copy against the
+ * `openai-codex` catalog, the ChatGPT-backend model ids Codex writes.
+ */
+export declare function readCodexUsage(options: CodexUsageOptions): Promise<CodexUsage>;
+export interface UsageScanCaches {
+    readonly claudeCode: UsageScanCache<ClaudeCodeFileScan>;
+    readonly codex: UsageScanCache<CodexFileScan>;
+}
+export declare function createUsageScanCaches(): UsageScanCaches;
+export interface LocalUsage {
+    readonly claudeCode: LocalHistoryUsage;
+    readonly codex: LocalHistoryUsage;
+}
+export declare function readLocalUsage(options: {
+    readonly models: Pick<Models, "getModels">;
+    readonly signal?: AbortSignal;
+    readonly caches?: UsageScanCaches;
+}): Promise<LocalUsage>;

package/dist/src/usage.js

@@ -0,0 +1,13 @@
+import {
+  readClaudeCodeUsage2,
+  readCodexUsage2,
+  createUsageScanCaches2,
+  readLocalUsage2
+} from "../chunks/canvas-preview-0nrnbt76.js";
+import"../chunks/canvas-preview-srgfpdmf.js";
+export {
+  createUsageScanCaches2 as createUsageScanCaches,
+  readClaudeCodeUsage2 as readClaudeCodeUsage,
+  readCodexUsage2 as readCodexUsage,
+  readLocalUsage2 as readLocalUsage
+};

package/package.json

@@ -1,6 +1,135 @@
 {
   "name": "@nyte-ai/host",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.18",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/interfaces-lab/nyte.git",
+    "directory": "packages/host"
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./canvas-preview": {
+      "types": "./dist/src/canvas-preview.d.ts",
+      "import": "./dist/src/canvas-preview.js"
+    },
+    "./credentials": {
+      "types": "./dist/src/credentials.d.ts",
+      "import": "./dist/src/credentials.js"
+    },
+    "./durable-object": {
+      "types": "./dist/src/durable-object.d.ts",
+      "import": "./dist/src/durable-object.js"
+    },
+    "./identity": {
+      "types": "./dist/src/identity.d.ts",
+      "import": "./dist/src/identity.js"
+    },
+    "./listen-fetch": {
+      "types": "./dist/src/listen-fetch.d.ts",
+      "import": "./dist/src/listen-fetch.js"
+    },
+    "./providers": {
+      "types": "./dist/src/providers.d.ts",
+      "import": "./dist/src/providers.js"
+    },
+    "./secrets": {
+      "types": "./dist/src/secrets.d.ts",
+      "import": "./dist/src/secrets.js"
+    },
+    "./shell-env": {
+      "types": "./dist/src/shell-env.d.ts",
+      "import": "./dist/src/shell-env.js"
+    },
+    "./usage": {
+      "types": "./dist/src/usage.d.ts",
+      "import": "./dist/src/usage.js"
+    },
+    "./store-usage": {
+      "types": "./dist/src/store-usage.d.ts",
+      "import": "./dist/src/store-usage.js"
+    },
+    "./usage-service": {
+      "types": "./dist/src/usage-service.d.ts",
+      "import": "./dist/src/usage-service.js"
+    },
+    "./usage-scan": {
+      "types": "./dist/src/usage-scan.d.ts",
+      "import": "./dist/src/usage-scan.js"
+    },
+    "./usage-worker": {
+      "types": "./dist/src/usage-worker.d.ts",
+      "import": "./dist/src/usage-worker.js"
+    },
+    "./deploy/cloudflare": {
+      "types": "./dist/src/deploy/cloudflare/worker.d.ts",
+      "import": "./dist/src/deploy/cloudflare/worker.js"
+    },
+    "./deploy/vercel": {
+      "types": "./dist/src/deploy/vercel/nitro.config.d.ts",
+      "import": "./dist/src/deploy/vercel/nitro.config.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "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",
+    "fflate": "0.8.3",
+    "ignore": "7.0.9",
+    "pg": "8.23.0",
+    "typebox": "1.3.36"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "0.5.8",
+    "@nyte-ai/canvas": "0.0.0",
+    "@types/node": "^26.6.5",
+    "@types/pg": "8.23.1",
+    "fast-check": "4.10.2",
+    "nitro": "3.0.260903-beta",
+    "typescript": "6.0.3",
+    "vitest": "^5.0.5",
+    "workflow": "4.8.8"
+  },
+  "peerDependencies": {
+    "nitro": "3.0.260903-beta",
+    "workflow": "4.8.8"
+  },
+  "peerDependenciesMeta": {
+    "nitro": {
+      "optional": true
+    },
+    "workflow": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=26.4.0"
+  },
+  "scripts": {
+    "clean": "rm -rf node_modules .turbo",
+    "typecheck": "tsgo --noEmit && tsgo --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"
+  }
 }