@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/chunks/canvas-preview-0cmbkp2j.js

@@ -0,0 +1,65 @@
+import {
+  parseText2,
+  parseRef2
+} from "./canvas-preview-69fkk9yn.js";
+
+// src/session-index.ts
+import { projectSessionIndex, sessionIndexRef } from "@nyte-ai/core/store";
+import { asId } from "@nyte-ai/schema";
+function sessionIndexChanges2(name, object, revision) {
+  const ref = sessionIndexRef(name);
+  if (ref === null)
+    return [];
+  const entry = projectSessionIndex(name, object);
+  if (ref.kind === "session") {
+    return entry?.kind === "session" ? [
+      {
+        text: "INSERT INTO session_index (name, session, parent, sort_at, version) VALUES (?, ?, ?, ?, ?) ON CONFLICT (name) DO UPDATE SET session = excluded.session, parent = excluded.parent, sort_at = excluded.sort_at, version = excluded.version",
+        values: [name, entry.session, entry.parent, -entry.at, revision]
+      }
+    ] : [{ text: "DELETE FROM session_index WHERE name = ?", values: [name] }];
+  }
+  return entry !== null && entry.kind !== "session" ? [
+    {
+      text: "INSERT INTO pending_work (name, session, kind) VALUES (?, ?, ?) ON CONFLICT (name) DO UPDATE SET session = excluded.session, kind = excluded.kind",
+      values: [name, entry.session, entry.kind]
+    }
+  ] : [{ text: "DELETE FROM pending_work WHERE name = ?", values: [name] }];
+}
+function sqlSessionIndex2(read) {
+  return {
+    async list({ parents, after, limit }) {
+      const conditions = [];
+      const values = [];
+      if (parents.kind === "roots")
+        conditions.push("s.parent IS NULL");
+      if (parents.kind === "children") {
+        conditions.push("s.parent = ?");
+        values.push(parents.session);
+      }
+      if (after !== undefined) {
+        conditions.push("(s.sort_at, s.session) > (?, ?)");
+        values.push(-after.at, after.id);
+      }
+      values.push(limit);
+      return (await read(`SELECT r.name, r.target, r.revision, s.version FROM session_index s JOIN refs r ON r.name = s.name${conditions.length === 0 ? "" : ` WHERE ${conditions.join(" AND ")}`} ORDER BY s.sort_at, s.session LIMIT ?`, values)).map((row) => ({
+        ref: parseRef2(row),
+        version: asId(parseText2(row.version) ?? "")
+      }));
+    },
+    async work({ after, limit }) {
+      return (await read(`SELECT r.name, r.target, r.revision FROM (SELECT DISTINCT session FROM pending_work${after === undefined ? "" : " WHERE session > ?"}) p JOIN session_index s ON s.session = p.session JOIN refs r ON r.name = s.name ORDER BY p.session LIMIT ?`, after === undefined ? [limit] : [after, limit])).map(parseRef2);
+    },
+    async pending({ kind, sessions }) {
+      if (sessions?.length === 0)
+        return [];
+      return (await read(`SELECT r.name, r.target, r.revision FROM pending_work p JOIN refs r ON r.name = p.name WHERE p.kind = ?${sessions === undefined ? "" : ` AND p.session IN (${sessions.map(() => "?").join(", ")})`} ORDER BY p.name`, [kind, ...sessions ?? []])).map(parseRef2);
+    }
+  };
+}
+function postgresSessionIndexQuery2(text) {
+  let parameter = 0;
+  return text.replaceAll("?", () => `$${++parameter}`);
+}
+
+export { sessionIndexChanges2, sqlSessionIndex2, postgresSessionIndexQuery2 };

package/dist/chunks/canvas-preview-0nq75h9k.js

@@ -0,0 +1,7 @@
+// src/hash.ts
+import { createHash } from "node:crypto";
+function sha2562(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+
+export { sha2562 };

package/dist/chunks/canvas-preview-11nadadc.js

@@ -0,0 +1,241 @@
+import {
+  decodeEvent2,
+  parseNumber2,
+  parseText2
+} from "./canvas-preview-69fkk9yn.js";
+import {
+  storePath2
+} from "./canvas-preview-tnqe7k0b.js";
+import {
+  cacheSavings2,
+  usageTokens2
+} from "./canvas-preview-srgfpdmf.js";
+
+// src/store-usage.ts
+import { existsSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import {
+  decodeObject,
+  decodeSessionRecord,
+  decodeWorkspaceRecord,
+  parseSessionRef
+} from "@nyte-ai/core/store";
+var EMPTY_TOTALS = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  reasoning: 0,
+  tokens: 0,
+  cost: 0,
+  cacheSavings: 0
+};
+function add(totals, usage) {
+  return {
+    input: totals.input + usage.input,
+    output: totals.output + usage.output,
+    cacheRead: totals.cacheRead + usage.cacheRead,
+    cacheWrite: totals.cacheWrite + usage.cacheWrite,
+    reasoning: totals.reasoning + (usage.reasoning ?? 0),
+    tokens: totals.tokens + usageTokens2(usage),
+    cost: totals.cost + usage.cost.total,
+    cacheSavings: totals.cacheSavings + cacheSavings2(usage)
+  };
+}
+var USAGE_EVENTS2 = "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";
+function localDay2(at) {
+  const date = new Date(at);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${String(date.getFullYear())}-${month}-${day}`;
+}
+function shiftDay2(day, delta) {
+  const date = new Date(`${day}T00:00:00`);
+  date.setDate(date.getDate() + delta);
+  return localDay2(date.getTime());
+}
+function priorWindow(sinceDay, untilDay) {
+  if (sinceDay === null)
+    return;
+  const priorUntil = shiftDay2(sinceDay, -1);
+  const span = (Date.parse(`${untilDay}T00:00:00Z`) - Date.parse(`${sinceDay}T00:00:00Z`)) / 86400000 + 1;
+  return { sinceDay: shiftDay2(priorUntil, -(span - 1)), untilDay: priorUntil };
+}
+function projectUsageReport2(stores, window, readAt) {
+  const requestedSince = window.sinceDay;
+  const untilDay = window.untilDay;
+  const prior = priorWindow(requestedSince, untilDay);
+  const cells = new Map;
+  const sessions = new Map;
+  const sources = [];
+  let priorCost = 0;
+  let priorTokens = 0;
+  let sawPrior = false;
+  let earliestDay;
+  for (const store of stores) {
+    sources.push({
+      workspacePath: store.workspacePath,
+      status: store.failure === null ? "ok" : "failed",
+      sessions: store.sessions.length,
+      message: store.failure?.message ?? null
+    });
+    for (const session of store.sessions) {
+      let lastActivityAt = 0;
+      let spentInWindow = false;
+      for (const spend of session.records) {
+        const { usage } = spend;
+        const amounts = [
+          usage.total,
+          usage.input,
+          usage.output,
+          usage.cacheRead,
+          usage.cacheWrite,
+          usage.cost.total
+        ];
+        if (!amounts.some((amount) => amount > 0))
+          continue;
+        const day = localDay2(spend.at);
+        if (earliestDay === undefined || day < earliestDay)
+          earliestDay = day;
+        if (prior !== undefined && day >= prior.sinceDay && day <= prior.untilDay) {
+          sawPrior = true;
+          priorCost += spend.usage.cost.total;
+          priorTokens += usageTokens2(spend.usage);
+        }
+        if (day > untilDay)
+          continue;
+        if (requestedSince !== null && day < requestedSince)
+          continue;
+        const key = JSON.stringify([day, store.workspacePath, session.sessionId, spend.subject]);
+        const cell = cells.get(key);
+        if (cell === undefined) {
+          cells.set(key, {
+            entry: {
+              day,
+              workspacePath: store.workspacePath,
+              sessionId: session.sessionId,
+              subject: spend.subject
+            },
+            totals: add(EMPTY_TOTALS, spend.usage)
+          });
+        } else {
+          cell.totals = add(cell.totals, spend.usage);
+        }
+        spentInWindow = true;
+        lastActivityAt = Math.max(lastActivityAt, spend.at);
+      }
+      if (spentInWindow) {
+        sessions.set(session.sessionId, {
+          sessionId: session.sessionId,
+          name: session.name,
+          workspacePath: store.workspacePath,
+          lastActivityAt: session.lastActivityAt ?? lastActivityAt
+        });
+      }
+    }
+  }
+  return {
+    readAt,
+    sinceDay: requestedSince ?? earliestDay ?? untilDay,
+    untilDay,
+    entries: [...cells.values()].map((cell) => ({ ...cell.entry, totals: cell.totals })).toSorted((left, right) => left.day.localeCompare(right.day)),
+    sessions: [...sessions.values()],
+    sources,
+    previous: sawPrior ? { cost: priorCost, tokens: priorTokens } : undefined,
+    earliestDay
+  };
+}
+function readNyteUsage2(home, window) {
+  const readAt = Date.now();
+  const path = storePath2(home);
+  if (!existsSync(path))
+    return projectUsageReport2([], window, readAt);
+  let database;
+  try {
+    database = new DatabaseSync(path, { readOnly: true, timeout: 5000 });
+    database.exec("BEGIN");
+    const workspaces = new Map;
+    const sessions = new Map;
+    const refs = database.prepare("SELECT refs.name, objects.body FROM refs JOIN objects ON objects.id = refs.target WHERE refs.name LIKE 'workspaces/%' OR (refs.name LIKE 'sessions/%' AND instr(substr(refs.name, 10), '/') = 0)").all();
+    for (const row of refs) {
+      const name = parseText2(row.name);
+      const body = parseText2(row.body);
+      if (name === null || body === null || !name.startsWith("workspaces/"))
+        continue;
+      const workspace = decodeWorkspaceRecord(decodeObject(body));
+      if (workspace !== null)
+        workspaces.set(workspace.id, workspace.target.kind === "local" && "path" in workspace.target ? parseText2(workspace.target.path) : null);
+    }
+    for (const row of refs) {
+      const name = parseText2(row.name);
+      const body = parseText2(row.body);
+      if (name === null || body === null || name.split("/").length !== 2)
+        continue;
+      const id = parseSessionRef(name);
+      if (id === null)
+        continue;
+      const session = decodeSessionRecord(decodeObject(body));
+      if (session === null)
+        throw new Error(`Cannot read session ${id}.`);
+      sessions.set(id, {
+        workspacePath: workspaces.get(session.workspace) ?? null,
+        name: session.name ?? undefined,
+        lastActivityAt: session.lastActivityAt,
+        records: []
+      });
+    }
+    const models = new Map;
+    for (const row of database.prepare(USAGE_EVENTS2).iterate()) {
+      const session = parseSessionRef(`sessions/${parseText2(row.session) ?? ""}`);
+      if (session === null)
+        throw new Error("Cannot read usage session.");
+      const event = decodeEvent2(parseNumber2(row.seq), parseNumber2(row.at), parseText2(row.event) ?? "");
+      let heads = models.get(session);
+      if (heads === undefined) {
+        heads = new Map;
+        models.set(session, heads);
+      }
+      if (event.kind === "run" && event.change === "started")
+        heads.set(event.head, event.view.configuration.model);
+      if (event.kind !== "request")
+        continue;
+      const model = heads.get(event.head);
+      const subject = event.step === "compaction" || event.step === "summary" ? { kind: "compaction" } : event.step === "plugin" ? { kind: "tool" } : {
+        kind: "model",
+        provider: model?.provider ?? "unknown",
+        model: model?.id ?? "unknown"
+      };
+      let info = sessions.get(session);
+      if (info === undefined) {
+        info = { workspacePath: null, name: undefined, lastActivityAt: undefined, records: [] };
+        sessions.set(session, info);
+      }
+      info.records.push({ at: event.at, subject, usage: event.usage });
+    }
+    database.exec("COMMIT");
+    const stores = new Map;
+    for (const [sessionId, info] of sessions) {
+      const group = stores.get(info.workspacePath) ?? [];
+      group.push({
+        sessionId,
+        name: info.name,
+        records: info.records,
+        lastActivityAt: info.lastActivityAt
+      });
+      stores.set(info.workspacePath, group);
+    }
+    return projectUsageReport2([...stores].map(([workspacePath, sessions]) => ({ workspacePath, sessions, failure: null })), window, readAt);
+  } catch (cause) {
+    return projectUsageReport2([
+      {
+        workspacePath: null,
+        sessions: [],
+        failure: { message: cause instanceof Error ? cause.message : String(cause) }
+      }
+    ], window, readAt);
+  } finally {
+    database?.close();
+  }
+}
+
+export { USAGE_EVENTS2, localDay2, shiftDay2, projectUsageReport2, readNyteUsage2 };

package/dist/chunks/canvas-preview-1sq7z9jq.js

@@ -0,0 +1,17 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+
+// src/local/identity.ts
+import { realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { asId } from "@nyte-ai/schema";
+async function folderIdentity2(path) {
+  const real = await realpath(path).catch(() => null);
+  if (real === null)
+    return asId(sha2562(resolve(path)));
+  const stats = await stat(real, { bigint: true }).catch(() => null);
+  return asId(sha2562(stats === null || stats.ino === 0n || stats.birthtimeNs === 0n ? real : `${stats.birthtimeNs}:${stats.ino}`));
+}
+
+export { folderIdentity2 };

package/dist/chunks/canvas-preview-2jwbe14k.js

@@ -0,0 +1,130 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  run2
+} from "./canvas-preview-bxnqt8cd.js";
+
+// src/local/worktrees.ts
+import { randomUUID } from "node:crypto";
+import { copyFile, mkdir, realpath, rm, stat } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { SdkError } from "@nyte-ai/schema";
+var ENV = { GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" };
+function gitCommand(binary = "git") {
+  return async (cwd, args, env) => {
+    const ran = await run2(binary, ["-c", "core.quotepath=off", ...args], {
+      cwd,
+      env: { ...ENV, ...env }
+    });
+    if (ran.code !== 0)
+      throw new SdkError("unavailable", ran.stderr.trim() || `git ${args[0] ?? ""} failed.`);
+    return ran.stdout.toString("utf8");
+  };
+}
+async function listWorktrees2(cwd, options) {
+  const out = await gitCommand(options?.git)(cwd, ["worktree", "list", "--porcelain", "-z"]);
+  return out.split("\x00\x00").flatMap((record) => {
+    const fields = record.split("\x00");
+    const path = fields.find((field) => field.startsWith("worktree "))?.slice(9);
+    const branch = fields.find((field) => field.startsWith("branch refs/heads/"))?.slice(18);
+    return path === undefined ? [] : [{ path: resolve(path), branch: branch ?? null }];
+  });
+}
+async function addWorktree2(cwd, input, options) {
+  await gitCommand(options?.git)(cwd, input.from === undefined ? ["worktree", "add", input.path, input.branch] : ["worktree", "add", "-b", input.branch, input.path, input.from]);
+}
+async function hasBranch2(cwd, name, options) {
+  return gitCommand(options?.git)(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]).then(() => true).catch(() => false);
+}
+function localWorktrees2(options) {
+  const git = gitCommand(options?.git);
+  const folders = join(options?.home ?? homedir(), ".nyte", "worktrees");
+  const commitAt = (cwd, revision) => git(cwd, ["rev-parse", "--verify", "--quiet", `${revision}^{commit}`]).then((out) => out.trim(), () => null);
+  const workingTree = async (repo) => {
+    const index = join(tmpdir(), `nyte-worktree-index-${randomUUID()}`);
+    const indexEnv = { GIT_INDEX_FILE: index };
+    try {
+      await copyFile(join(repo.gitDir, "index"), index).catch(() => {
+        return;
+      });
+      await git(repo.root, ["add", "-A", "--", "."], indexEnv);
+      return (await git(repo.root, ["write-tree"], indexEnv)).trim();
+    } finally {
+      await rm(index, { force: true });
+    }
+  };
+  return {
+    async create(env, input) {
+      const repo = await readRepository(git, env.cwd);
+      if (repo === null)
+        throw new SdkError("unavailable", `${env.cwd} is not in a git repository, so it cannot have a worktree.`);
+      const head = await commitAt(repo.root, "HEAD");
+      if (head === null)
+        throw new SdkError("unavailable", `${repo.root} has no commits yet, so a worktree has nothing to branch from.`);
+      const slug = worktreeSlug(input.name, input.title);
+      const branch = `nyte/${slug}`;
+      const below = (root) => ({
+        kind: "local",
+        path: resolve(root, repo.prefix)
+      });
+      const listed = (await listWorktrees2(repo.root, options)).find((worktree) => worktree.branch === branch);
+      if (listed !== undefined)
+        return {
+          target: below(listed.path),
+          branch,
+          base: await commitAt(repo.root, `refs/heads/${branch}`) ?? head
+        };
+      const folder = join(folders, basename(repo.root), slug);
+      const branched = await hasBranch2(repo.root, branch, options);
+      const base = branched ? await commitAt(repo.root, `refs/heads/${branch}`) ?? head : head;
+      const tree = await workingTree(repo);
+      await mkdir(dirname(folder), { recursive: true });
+      await addWorktree2(repo.root, branched ? { path: folder, branch } : { path: folder, branch, from: head }, options);
+      if (tree !== (await git(folder, ["rev-parse", "HEAD^{tree}"])).trim()) {
+        await git(folder, ["read-tree", "-m", "-u", "HEAD", tree]);
+        await git(folder, ["reset", "-q"]);
+      }
+      return { target: below(await realpath(folder)), branch, base };
+    },
+    async remove(worktree) {
+      const path = "path" in worktree.target ? worktree.target.path : null;
+      if (path === null || await stat(path).catch(() => null) === null)
+        return { folder: "removed", branch: "kept" };
+      const [root = path, common = ""] = (await git(path, [
+        "rev-parse",
+        "--show-toplevel",
+        "--path-format=absolute",
+        "--git-common-dir"
+      ])).split(`
+`);
+      const status = await git(root, ["status", "--porcelain", "--ignored", "-z"]);
+      if (status.split("\x00").some((entry) => entry !== "" && !(entry.startsWith("!! ") && entry.endsWith("/"))))
+        return { folder: "kept", branch: "kept" };
+      await git(common, ["worktree", "remove", root]);
+      if (await commitAt(common, `refs/heads/${worktree.branch}`) !== worktree.base)
+        return { folder: "removed", branch: "kept" };
+      await git(common, ["branch", "-D", worktree.branch]);
+      return { folder: "removed", branch: "deleted" };
+    }
+  };
+}
+async function readRepository(git, cwd) {
+  const out = await git(cwd, [
+    "rev-parse",
+    "--show-toplevel",
+    "--absolute-git-dir",
+    "--show-prefix"
+  ]).catch(() => null);
+  const [root, gitDir, prefix = ""] = out?.split(`
+`) ?? [];
+  return root === undefined || gitDir === undefined || root === "" ? null : { root: resolve(root), gitDir: resolve(gitDir), prefix };
+}
+function worktreeSlug(name, title) {
+  const words = (title ?? "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").slice(0, 40).replace(/^-+|-+$/gu, "");
+  const key = sha2562(name).slice(0, 8);
+  return words === "" ? key : `${words}-${key}`;
+}
+
+export { listWorktrees2, addWorktree2, hasBranch2, localWorktrees2 };

package/dist/chunks/canvas-preview-2zdyh9ny.js

@@ -0,0 +1,26 @@
+// src/deploy/vercel/server/utils/repair.ts
+import { createHash, timingSafeEqual } from "node:crypto";
+import { SdkError } from "@nyte-ai/schema";
+import { encodeError, errorStatus } from "@nyte-ai/protocol";
+async function answerRepair2(request, secret, repair) {
+  if (request.method !== "GET" || new URL(request.url).pathname !== "/.nyte/repair")
+    return;
+  if (secret === undefined || secret === "")
+    return failure(new SdkError("unknown", "This deployment sets no CRON_SECRET."));
+  const given = /^Bearer\s+(\S+)\s*$/i.exec(request.headers.get("Authorization") ?? "")?.[1] ?? "";
+  if (!timingSafeEqual(digest(given), digest(secret)))
+    return failure(new SdkError("unauthenticated", "Send Authorization: Bearer <CRON_SECRET>."));
+  await repair();
+  return new Response(null, { status: 204 });
+}
+function digest(text) {
+  return createHash("sha256").update(text).digest();
+}
+function failure(error) {
+  return new Response(JSON.stringify(encodeError(error)), {
+    status: errorStatus[error.code],
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+export { answerRepair2 };

package/dist/chunks/canvas-preview-31w7xm8z.js

@@ -0,0 +1,34 @@
+// src/identity.ts
+import { SdkError } from "@nyte-ai/schema";
+var PKCS8_PREFIX = Uint8Array.fromHex("302e020100300506032b657004220420");
+var encoder = new TextEncoder;
+async function seedSigner2(id, seed) {
+  const { signing, publicKey } = await identityKeys(seed);
+  return {
+    id,
+    async sign(nonce) {
+      const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", signing, encoder.encode(`nyte/identity
+${id}
+${nonce}`)));
+      return {
+        hostId: id,
+        nonce,
+        signature: signature.toBase64({ alphabet: "base64url", omitPadding: true }),
+        publicKey
+      };
+    }
+  };
+}
+async function identityKeys(seed) {
+  if (seed.length !== 32)
+    throw new SdkError("invalid", `The identity seed is ${seed.length} bytes, not 32.`);
+  const pkcs8 = new Uint8Array([...PKCS8_PREFIX, ...seed]);
+  const readable = await crypto.subtle.importKey("pkcs8", pkcs8, "Ed25519", true, ["sign"]);
+  const { x } = await crypto.subtle.exportKey("jwk", readable);
+  if (x === undefined)
+    throw new SdkError("internal", "The identity key has no public half.");
+  const signing = await crypto.subtle.importKey("pkcs8", pkcs8, "Ed25519", false, ["sign"]);
+  return { signing, publicKey: x };
+}
+
+export { seedSigner2 };