@nyte-ai/host 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,518 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  run2
+} from "./canvas-preview-azg56359.js";
+import {
+  PATCH_LIMIT2,
+  textEntry2,
+  readPatches2,
+  lineStat2,
+  parseNumstat2,
+  parseNameStatus2
+} from "./canvas-preview-tjhabynd.js";
+import {
+  decodeText2
+} from "./canvas-preview-kn7kvbfj.js";
+import {
+  WALK_LIMIT2,
+  walkTree2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/local/snapshots.ts
+import { createHash, randomUUID } from "node:crypto";
+import {
+  copyFile,
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  readlink,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { asId, SdkError } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+var GENERATION_NAME = /^g(\d{6})$/;
+var NOTHING_KEPT = { id: "", root: [], last: null };
+var ENV = {
+  GIT_OPTIONAL_LOCKS: "0",
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_LITERAL_PATHSPECS: "1",
+  LC_ALL: "C"
+};
+var CONFIG = ["-c", "core.quotepath=off", "-c", "color.ui=false", "-c", "diff.noprefix=false"];
+var DIFF = [
+  "--no-color",
+  "--no-ext-diff",
+  "--no-textconv",
+  "--src-prefix=a/",
+  "--dst-prefix=b/",
+  "-M"
+];
+var BEFORE_KEPT = 1000;
+var KEPT_REF = "refs/nyte/kept";
+var LEGACY_REFS = "refs/nyte/snapshots/";
+var GENERATION = 1000;
+var KEEP_TRIES = 3;
+var CHUNK = 64 * 1024;
+function localSnapshots2(env, options) {
+  const binary = options.git ?? "git";
+  const befores = new Map;
+  const stamps = new Map;
+  const fresh = [];
+  let repositoryLookup;
+  let emptyTree;
+  let keeping;
+  let kept = null;
+  const keptTrees = new Set;
+  const git = (cwd, args, extra) => run2(binary, [...CONFIG, ...args], {
+    cwd,
+    env: { ...ENV, ...extra?.env },
+    input: extra?.input,
+    limit: extra?.limit
+  });
+  const findRepository = async () => {
+    const ran = await git(env.cwd, [
+      "rev-parse",
+      "--show-toplevel",
+      "--absolute-git-dir",
+      "--show-prefix"
+    ]).catch(() => null);
+    if (ran === null || ran.code !== 0)
+      return null;
+    const [root, gitDir, prefix = ""] = ran.stdout.toString("utf8").split(`
+`);
+    return root === undefined || gitDir === undefined ? null : { root, gitDir, prefix };
+  };
+  const repository = () => {
+    repositoryLookup ??= findRepository();
+    return repositoryLookup;
+  };
+  const checked = async (ran) => {
+    if (ran.code !== 0)
+      throw new SdkError("unavailable", ran.stderr.trim() || "git failed");
+    return ran.stdout.toString("utf8").trim();
+  };
+  const gitSnapshot = async (repo) => {
+    const write = async (seeded) => {
+      const index = join(tmpdir(), `nyte-index-${randomUUID()}`);
+      try {
+        if (seeded)
+          await copyFile(join(repo.gitDir, "index"), index).catch(() => {
+            return;
+          });
+        const indexEnv = { GIT_INDEX_FILE: index };
+        await checked(await git(env.cwd, ["add", "-A", "--", "."], { env: indexEnv }));
+        return await git(repo.root, repo.prefix === "" ? ["write-tree"] : ["write-tree", `--prefix=${repo.prefix}`], { env: indexEnv });
+      } finally {
+        await rm(index, { force: true });
+      }
+    };
+    const first = await write(true);
+    const tree = await checked(first.code === 0 ? first : await write(false));
+    const id = asId(`git:${tree}`);
+    if (fresh.includes(tree) || keptTrees.has(tree))
+      return id;
+    fresh.push(tree);
+    keeping ??= keepTrees(repo).finally(() => {
+      keeping = undefined;
+    });
+    return id;
+  };
+  const keepTrees = async (repo) => {
+    for (let tries = 0;fresh.length > 0 && tries < KEEP_TRIES; tries += 1) {
+      const taken = fresh.splice(0);
+      let landed = false;
+      try {
+        landed = await rewriteKept(repo, taken);
+      } catch (error) {
+        dev("snapshots", "keep failed", { error: String(error) });
+      }
+      if (!landed)
+        fresh.unshift(...taken);
+    }
+  };
+  const rewriteKept = async (repo, taken) => {
+    const listed = await checked(await git(repo.root, ["for-each-ref", "--format=%(objectname) %(refname)", "refs/nyte/"]));
+    const refs = listed.split(`
+`).filter((line) => line !== "").map((line) => {
+      const [id = "", name = ""] = line.split(" ");
+      return { id, name };
+    });
+    const current = refs.find((ref) => ref.name === KEPT_REF)?.id ?? null;
+    const legacy = refs.filter((ref) => ref.name.startsWith(LEGACY_REFS));
+    const known = current === null ? NOTHING_KEPT : await readKept(repo, current);
+    const open = known.last !== null && known.last.trees.length < GENERATION ? known.last : null;
+    const openTrees = open?.trees ?? [];
+    const adding = [...new Set([...legacy.map((ref) => ref.id), ...taken])].filter((tree) => !keptTrees.has(tree) && !openTrees.includes(tree));
+    if (adding.length === 0 && legacy.length === 0)
+      return true;
+    const filled = [...openTrees, ...adding];
+    const first = open?.number ?? (known.last === null ? 0 : known.last.number + 1);
+    const generations = await Promise.all(Array.from({ length: Math.ceil(filled.length / GENERATION) }, async (_, index) => {
+      const trees = filled.slice(index * GENERATION, (index + 1) * GENERATION);
+      return {
+        number: first + index,
+        trees,
+        tree: await mktree(repo, trees.map((tree) => ({ tree, name: tree })))
+      };
+    }));
+    const root = [
+      ...known.root.filter((entry) => entry.name !== open?.name),
+      ...generations.map((generation) => ({
+        tree: generation.tree,
+        name: generationName(generation.number)
+      }))
+    ];
+    const next = await mktree(repo, root);
+    const commands = [
+      current === null ? `create ${KEPT_REF} ${next}` : `update ${KEPT_REF} ${next} ${current}`,
+      ...legacy.map((ref) => `delete ${ref.name} ${ref.id}`)
+    ];
+    const updated = await git(repo.root, ["update-ref", "--stdin"], {
+      input: `${commands.join(`
+`)}
+`
+    });
+    if (updated.code !== 0) {
+      kept = null;
+      return false;
+    }
+    const newest = generations.at(-1);
+    kept = {
+      id: next,
+      root,
+      last: newest === undefined ? known.last : {
+        name: generationName(newest.number),
+        number: newest.number,
+        trees: newest.trees
+      }
+    };
+    for (const tree of filled)
+      keptTrees.add(tree);
+    return true;
+  };
+  const mktree = async (repo, entries) => checked(await git(repo.root, ["mktree"], {
+    input: entries.map((entry) => `040000 tree ${entry.tree}	${entry.name}
+`).join("")
+  }));
+  const readTree = async (repo, id) => {
+    const listed = await checked(await git(repo.root, ["ls-tree", id]));
+    return listed.split(`
+`).flatMap((line) => {
+      const [mode = "", type = "", rest = ""] = line.split(" ");
+      const [tree = "", name = ""] = rest.split("\t");
+      return mode === "040000" && type === "tree" ? [{ tree, name }] : [];
+    });
+  };
+  const readKept = async (repo, id) => {
+    if (kept?.id === id)
+      return kept;
+    const root = await readTree(repo, id);
+    const last = root.flatMap((entry) => {
+      const number = GENERATION_NAME.exec(entry.name)?.[1];
+      return number === undefined ? [] : [{ ...entry, number: Number(number) }];
+    }).toSorted((left, right) => left.number - right.number).at(-1);
+    if (last === undefined)
+      return { id, root, last: null };
+    const trees = (await readTree(repo, last.tree)).map((entry) => entry.tree);
+    for (const tree of trees)
+      keptTrees.add(tree);
+    return { id, root, last: { name: last.name, number: last.number, trees } };
+  };
+  const walkSnapshot = async () => {
+    const manifest = {};
+    let incomplete = false;
+    for await (const frame of walkTree2(env.cwd, {
+      ignored: "exclude",
+      limit: options.limit ?? WALK_LIMIT2
+    })) {
+      if (frame.kind === "incomplete")
+        incomplete = true;
+      if (frame.kind !== "entries")
+        continue;
+      for (const entry of frame.entries) {
+        if (entry.kind === "directory")
+          continue;
+        const hash = await storeEntry(options.store, join(env.cwd, entry.path), entry.kind, stamps).catch(() => null);
+        if (hash !== null)
+          manifest[entry.path] = hash;
+      }
+    }
+    const text = JSON.stringify({
+      incomplete,
+      files: Object.fromEntries(Object.entries(manifest).sort(([left], [right]) => left < right ? -1 : 1))
+    });
+    const id = sha2562(text);
+    await keep(join(options.store, "trees", `${id}.json`), text);
+    return asId(`tree:${id}`);
+  };
+  const take = async () => {
+    const started = Date.now();
+    const repo = await repository();
+    const id = await (repo === null ? walkSnapshot() : gitSnapshot(repo));
+    dev("snapshots", "take", { kind: repo === null ? "tree" : "git", ms: Date.now() - started });
+    return id;
+  };
+  const pair = async (from, to) => {
+    const kinds = new Set([from, to].flatMap((id) => id === "" ? [] : id.split(":", 1)));
+    if (kinds.size > 1)
+      throw new SdkError("invalid", `Snapshots ${from} and ${to} are of two kinds.`);
+    if (kinds.has("tree") || kinds.size === 0)
+      return {
+        kind: "tree",
+        from: await readWalkedTree(options.store, from),
+        to: await readWalkedTree(options.store, to)
+      };
+    const repo = await repository();
+    if (repo === null)
+      throw new SdkError("unavailable", `${env.cwd} is no longer in a git repository.`);
+    const empty = from === "" || to === "" ? await (emptyTree ??= git(repo.root, ["hash-object", "-t", "tree", "--stdin"], {
+      input: ""
+    }).then(checked)) : "";
+    const tree = (id) => id === "" ? empty : id.slice("git:".length);
+    return { kind: "git", repo, from: tree(from), to: tree(to) };
+  };
+  const changed = async (from, to) => {
+    if (from === to)
+      return [];
+    const compared = await pair(from, to);
+    if (compared.kind === "git") {
+      const [names, numstat] = await Promise.all([
+        git(compared.repo.root, [
+          "diff-tree",
+          "-r",
+          "-z",
+          "-M",
+          "--name-status",
+          compared.from,
+          compared.to
+        ]),
+        git(compared.repo.root, [
+          "diff-tree",
+          "-r",
+          "-z",
+          "-M",
+          "--numstat",
+          compared.from,
+          compared.to
+        ])
+      ]);
+      const stats = parseNumstat2(await checked(numstat));
+      return parseNameStatus2(await checked(names)).map((file) => ({
+        ...file,
+        stat: stats.get(file.path) ?? { kind: "unknown" }
+      }));
+    }
+    const { files, incomplete } = compareTrees(compared.from, compared.to);
+    return Promise.all(files.map(async (file) => ({
+      ...file,
+      stat: incomplete.has(file.path) ? { kind: "unknown" } : await manifestStat(options.store, compared.from.files, compared.to.files, file)
+    })));
+  };
+  return {
+    before(run) {
+      const known = befores.get(run);
+      if (known !== undefined)
+        return known;
+      const taken = take();
+      befores.set(run, taken);
+      taken.catch(() => befores.delete(run));
+      for (const old of befores.keys()) {
+        if (befores.size <= BEFORE_KEPT)
+          break;
+        befores.delete(old);
+      }
+      return taken;
+    },
+    after: () => take(),
+    async diff(from, to) {
+      const started = Date.now();
+      const files = await changed(from, to);
+      dev("snapshots", "diff", { entries: files.length, ms: Date.now() - started });
+      return { revision: to, files };
+    },
+    async patches(from, to, paths, diff) {
+      const compared = await pair(from, to);
+      const reported = new Map((await changed(from, to)).map((file) => [file.path, file]));
+      const wanted = [...new Set(paths)].flatMap((path) => {
+        const file = reported.get(path);
+        return file === undefined ? [] : [file];
+      });
+      if (wanted.length === 0)
+        return [];
+      if (compared.kind === "tree") {
+        const { incomplete } = compareTrees(compared.from, compared.to);
+        return Promise.all(wanted.map(async (file) => incomplete.has(file.path) ? {
+          path: file.path,
+          status: file.status,
+          digest: "",
+          kind: "failed",
+          reason: "incomplete"
+        } : manifestEntry(options.store, compared.from.files, compared.to.files, file, diff)));
+      }
+      return readPatches2(wanted, (files, limit) => git(compared.repo.root, [
+        "diff",
+        ...DIFF,
+        "-U3",
+        ...diff?.ignoreWhitespace === true ? ["--ignore-all-space"] : [],
+        compared.from,
+        compared.to,
+        "--",
+        ...files.flatMap((file) => file.from === undefined ? [file.path] : [file.from, file.path])
+      ], { limit }), (file) => sha2562(`${to}\x00${file.path}`));
+    }
+  };
+}
+async function storeEntry(store, path, kind, stamps) {
+  const stats = await lstat(path);
+  const stamp = `${kind}:${stats.size}:${stats.mtimeMs}:${stats.ino}`;
+  const known = stamps.get(path);
+  if (known?.stamp === stamp)
+    return known.hash;
+  if (kind === "symlink") {
+    const target = new TextEncoder().encode(await readlink(path));
+    const hash = sha2562(target);
+    await keep(join(store, "objects", hash), target);
+    stamps.set(path, { stamp, hash });
+    return hash;
+  }
+  if (stats.size > PATCH_LIMIT2) {
+    const hash = await hashFile(path);
+    stamps.set(path, { stamp, hash });
+    return hash;
+  }
+  const bytes = await readFile(path);
+  const hash = sha2562(bytes);
+  await keep(join(store, "objects", hash), bytes);
+  stamps.set(path, { stamp, hash });
+  return hash;
+}
+async function hashFile(path) {
+  const hash = createHash("sha256");
+  const handle = await open(path, "r");
+  try {
+    const buffer = new Uint8Array(CHUNK);
+    for (;; ) {
+      const { bytesRead } = await handle.read(buffer, 0, CHUNK, null);
+      if (bytesRead === 0)
+        break;
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+  } finally {
+    await handle.close();
+  }
+  return hash.digest("hex");
+}
+async function keep(path, contents) {
+  if (await lstat(path).then(() => true, () => false))
+    return;
+  await mkdir(join(path, ".."), { recursive: true });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, contents);
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+async function readWalkedTree(store, id) {
+  if (id === "")
+    return { files: {}, incomplete: false };
+  if (!id.startsWith("tree:"))
+    throw new SdkError("invalid", `${id} is not a walked snapshot.`);
+  const text = await readFile(join(store, "trees", `${id.slice("tree:".length)}.json`), "utf8").catch(() => null);
+  if (text === null)
+    throw new SdkError("unknown", `No snapshot ${id} is stored.`);
+  const value = JSON.parse(text);
+  if (typeof value !== "object" || value === null || !("files" in value) || typeof value.files !== "object" || value.files === null || Array.isArray(value.files))
+    throw new SdkError("internal", `Snapshot ${id} is malformed.`);
+  return {
+    incomplete: "incomplete" in value && value.incomplete === true,
+    files: Object.fromEntries(Object.entries(value.files).flatMap(([path, hash]) => typeof hash === "string" ? [[path, hash]] : []))
+  };
+}
+function compareTrees(before, after) {
+  const from = before.files;
+  const to = after.files;
+  const gone = Object.keys(from).filter((path) => !(path in to));
+  const fresh = Object.keys(to).filter((path) => !(path in from));
+  const incomplete = new Set([
+    ...after.incomplete ? gone : [],
+    ...before.incomplete ? fresh : []
+  ]);
+  const deleted = after.incomplete ? [] : gone;
+  const added = before.incomplete ? [] : fresh;
+  const moved = new Map;
+  const byHash = new Map;
+  for (const path of deleted)
+    byHash.set(from[path] ?? "", [...byHash.get(from[path] ?? "") ?? [], path]);
+  for (const path of added) {
+    const source = byHash.get(to[path] ?? "")?.shift();
+    if (source !== undefined)
+      moved.set(path, source);
+  }
+  const sources = new Set(moved.values());
+  const files = [
+    ...deleted.filter((path) => !sources.has(path)).map((path) => ({ path, status: "deleted" })),
+    ...added.map((path) => {
+      const source = moved.get(path);
+      return source === undefined ? { path, status: "added" } : { path, status: "renamed", from: source };
+    }),
+    ...Object.keys(to).filter((path) => (path in from) && from[path] !== to[path]).map((path) => ({ path, status: "modified" })),
+    ...[...incomplete].map((path) => ({ path, status: "modified" }))
+  ];
+  return {
+    files: files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0),
+    incomplete
+  };
+}
+async function sideText(store, hash) {
+  if (hash === undefined)
+    return null;
+  const bytes = await readFile(join(store, "objects", hash)).catch(() => {
+    return;
+  });
+  return bytes === undefined ? undefined : decodeText2(bytes) ?? undefined;
+}
+async function stored(store, hash) {
+  if (hash === undefined)
+    return "absent";
+  const bytes = await readFile(join(store, "objects", hash)).catch(() => {
+    return;
+  });
+  if (bytes === undefined)
+    return "missing";
+  return decodeText2(bytes) === null ? "binary" : "text";
+}
+async function manifestStat(store, from, to, file) {
+  const before = from[file.from ?? file.path];
+  const after = to[file.path];
+  const kinds = await Promise.all([stored(store, before), stored(store, after)]);
+  if (kinds.includes("missing"))
+    return { kind: "unknown" };
+  if (kinds.includes("binary"))
+    return { kind: "binary" };
+  return lineStat2(await sideText(store, before) ?? "", await sideText(store, after) ?? "");
+}
+async function manifestEntry(store, from, to, file, diff) {
+  const before = from[file.from ?? file.path];
+  const after = to[file.path];
+  const kinds = await Promise.all([stored(store, before), stored(store, after)]);
+  const digest = sha2562(`${before ?? ""}\x00${after ?? ""}`);
+  if (kinds.includes("missing"))
+    return { path: file.path, status: file.status, digest, kind: "too-large", limit: PATCH_LIMIT2 };
+  if (kinds.includes("binary"))
+    return { path: file.path, status: file.status, digest, kind: "binary" };
+  return textEntry2(file.path, file.status, await sideText(store, before) ?? null, await sideText(store, after) ?? null, diff);
+}
+function generationName(number) {
+  return `g${String(number).padStart(6, "0")}`;
+}
+
+export { localSnapshots2 };

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

@@ -0,0 +1,23 @@
+import {
+  readKeyFile2
+} from "./canvas-preview-wg80rbc2.js";
+
+// src/secrets.ts
+import { join } from "node:path";
+function defaultSecrets2(home) {
+  const path = join(home, ".nyte", "secret.key");
+  let key = null;
+  return {
+    key: () => {
+      const known = key ?? readKeyFile2(path, "secrets key");
+      key = known;
+      known.catch(() => {
+        if (key === known)
+          key = null;
+      });
+      return known;
+    }
+  };
+}
+
+export { defaultSecrets2 };

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

@@ -0,0 +1,60 @@
+// src/usage-summary.ts
+import { addUsage } from "@nyte-ai/core/server";
+function emptyModelUsage2() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+function recordedUsage2(usage) {
+  return {
+    input: usage.input,
+    output: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+    reasoning: usage.reasoning ?? null,
+    total: usage.totalTokens,
+    cost: { ...usage.cost }
+  };
+}
+function emptyUsageSummary2() {
+  return {
+    models: [],
+    compaction: recordedUsage2(emptyModelUsage2()),
+    tools: recordedUsage2(emptyModelUsage2()),
+    total: recordedUsage2(emptyModelUsage2()),
+    cacheSavings: 0
+  };
+}
+function summarizeModels2(rows) {
+  const models = new Map;
+  let total = recordedUsage2(emptyModelUsage2());
+  let savings = 0;
+  for (const row of rows) {
+    savings += cacheSavings2(row.usage);
+    const key = JSON.stringify([row.provider, row.model]);
+    const previous = models.get(key);
+    models.set(key, previous === undefined ? row : { ...row, turns: previous.turns + row.turns, usage: addUsage(previous.usage, row.usage) });
+    total = addUsage(total, row.usage);
+  }
+  return {
+    ...emptyUsageSummary2(),
+    models: [...models.values()].toSorted((left, right) => right.usage.cost.total - left.usage.cost.total || right.usage.total - left.usage.total || left.model.localeCompare(right.model) || left.provider.localeCompare(right.provider)),
+    total,
+    cacheSavings: savings
+  };
+}
+function cacheSavings2(usage) {
+  if (usage.input === 0)
+    return 0;
+  return usage.cacheRead * (usage.cost.input / usage.input) - usage.cost.cacheRead;
+}
+function usageTokens2(usage) {
+  return usage.total || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+
+export { emptyModelUsage2, recordedUsage2, emptyUsageSummary2, summarizeModels2, cacheSavings2, usageTokens2 };