@nyte-ai/host 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,374 @@
+import {
+  prefixEnd2,
+  mintRevision2,
+  decodeEvent2,
+  parseNumber2,
+  parseText2,
+  parseRef2,
+  parseStoredRecord2,
+  parseStoredObject2,
+  loggedRow2,
+  collect2,
+  memoryReader2
+} from "./canvas-preview-69fkk9yn.js";
+import {
+  sqliteWorkers2
+} from "./canvas-preview-zaaj99wd.js";
+import {
+  sessionIndexChanges2,
+  sqlSessionIndex2
+} from "./canvas-preview-0cmbkp2j.js";
+
+// src/sqlite.ts
+import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { DatabaseSync } from "node:sqlite";
+import { asSeq } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+import {
+  admits,
+  fenceNames,
+  assertStoreVersion,
+  blobId,
+  decodeObject,
+  collectSessionEvents,
+  migrateStore,
+  objectId,
+  sessionIndexRef,
+  parseSessionRef
+} from "@nyte-ai/core/store";
+var BUSY_TIMEOUT_MS = 5000;
+var BACKUPS_KEPT = 3;
+var PUT_BODY = "INSERT INTO objects (id, body) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET body = excluded.body WHERE objects.body IS NULL";
+function storePath2(home) {
+  return process.env["NYTE_DB"] ?? join(home, ".nyte", "nyte.db");
+}
+function sqliteStore2(input) {
+  let database = null;
+  let opening = null;
+  let closing = null;
+  let workers = null;
+  const open = async () => {
+    let created;
+    try {
+      created = new DatabaseSync("path" in input ? input.path : ":memory:", {
+        timeout: BUSY_TIMEOUT_MS
+      });
+      if ("path" in input)
+        created.exec("PRAGMA journal_mode = WAL");
+      created.exec("PRAGMA synchronous = NORMAL");
+      created.exec("PRAGMA checkpoint_fullfsync = ON");
+      created.exec("PRAGMA journal_size_limit = 33554432");
+      await migrateStore(sqliteTarget(created, "path" in input ? input.path : null));
+      created.exec("PRAGMA optimize = 0x10012");
+    } catch (error) {
+      created?.close();
+      throw error;
+    }
+    database = created;
+    workers = "path" in input ? sqliteWorkers2(created, input.path) : null;
+    return connect(created, workers);
+  };
+  const connection = () => {
+    if (closing !== null)
+      return closing.then(connection);
+    opening ??= open().catch((error) => {
+      opening = null;
+      throw error;
+    });
+    return opening;
+  };
+  return {
+    open: connection,
+    close() {
+      closing ??= (async () => {
+        await opening?.catch(() => {
+          return;
+        });
+        await workers?.close();
+        database?.close();
+        workers = null;
+        database = null;
+        opening = null;
+      })().finally(() => {
+        closing = null;
+      });
+      return closing;
+    }
+  };
+}
+function hasTable(database, name) {
+  return database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) !== undefined;
+}
+function storedVersion(database) {
+  if (!hasTable(database, "store_meta"))
+    return 0;
+  const row = database.prepare("SELECT version FROM store_meta WHERE id = 1").get();
+  return row === undefined ? 0 : parseNumber2(row.version);
+}
+function sqliteTarget(database, path) {
+  const target = {
+    dialect: "sqlite",
+    async stamp() {
+      return {
+        version: storedVersion(database),
+        empty: !hasTable(database, "refs") || database.prepare("SELECT 1 FROM refs LIMIT 1").get() === undefined
+      };
+    },
+    async records() {
+      return database.prepare("SELECT refs.name, refs.target, refs.revision, objects.body FROM refs JOIN objects ON objects.id = refs.target WHERE objects.body IS NOT NULL").all().map(parseStoredRecord2);
+    },
+    async* objects(kind) {
+      yield* database.prepare("SELECT id, body FROM objects WHERE body IS NOT NULL AND instr(body, ?) > 0").all(`"kind":${JSON.stringify(kind)}`).map(parseStoredObject2);
+    },
+    async* logs() {
+      if (!hasTable(database, "log"))
+        return;
+      const read = database.prepare("SELECT seq, event FROM log WHERE session = ? ORDER BY seq");
+      for (const row of database.prepare("SELECT DISTINCT session FROM log").all()) {
+        const session = parseText2(row.session);
+        if (session !== null)
+          yield { session, events: read.all(session).map(loggedRow2) };
+      }
+    },
+    async commit(change) {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        if (storedVersion(database) !== change.from) {
+          database.exec("ROLLBACK");
+          return "moved";
+        }
+        for (const statement of change.sql)
+          database.exec(statement);
+        const putBody = database.prepare(PUT_BODY);
+        const repoint = database.prepare("UPDATE refs SET target = ?, revision = ? WHERE name = ? AND revision = ?");
+        for (const moved of change.repoints) {
+          write(database, putBody, moved.id, moved.body);
+          if (Number(repoint.run(moved.id, mintRevision2(), moved.name, moved.expect).changes) === 0) {
+            database.exec("ROLLBACK");
+            return "conflict";
+          }
+          updateSessionIndex(database, moved.name, moved.id, mintRevision2());
+        }
+        const create = database.prepare("INSERT INTO refs (name, target, revision) VALUES (?, ?, ?) ON CONFLICT (name) DO NOTHING");
+        for (const created of change.creates) {
+          write(database, putBody, created.target, created.body);
+          const revision = mintRevision2();
+          if (Number(create.run(created.name, created.target, revision).changes) > 0)
+            updateSessionIndex(database, created.name, created.target, revision);
+        }
+        const relog = database.prepare("UPDATE log SET event = ? WHERE session = ? AND seq = ? AND event = ?");
+        for (const row of change.relogs) {
+          if (Number(relog.run(row.event, row.session, row.seq, row.expect).changes) === 0) {
+            database.exec("ROLLBACK");
+            return "conflict";
+          }
+        }
+        if (change.reindexSessions)
+          for (const row of database.prepare("SELECT name, target, revision FROM refs").all()) {
+            const ref = parseRef2(row);
+            updateSessionIndex(database, ref.name, ref.target, ref.revision);
+          }
+        database.prepare("INSERT INTO store_meta (id, version) VALUES (1, ?) ON CONFLICT (id) DO UPDATE SET version = excluded.version").run(change.to);
+        database.exec("COMMIT");
+        return "committed";
+      } catch (error) {
+        if (database.isTransaction)
+          database.exec("ROLLBACK");
+        throw error;
+      }
+    }
+  };
+  if (path === null)
+    return target;
+  return {
+    ...target,
+    backup: async (from, to, names, log) => backup(database, path, from, to, names, log)
+  };
+}
+function backup(database, path, from, to, names, log) {
+  const folder = join(dirname(path), "backups");
+  mkdirSync(folder, { recursive: true, mode: 448 });
+  const at = new Date().toISOString().replaceAll(":", "-");
+  const read = database.prepare("SELECT name, target, revision FROM refs WHERE name = ?");
+  const rows = names.flatMap((name) => {
+    const row = read.get(name);
+    return row === undefined ? [] : [parseRef2(row)];
+  });
+  writeFileSync(join(folder, `store-${at}-${process.pid}-${crypto.randomUUID()}-v${from}-v${to}.json`), JSON.stringify({
+    refs: rows,
+    log: log.map((row) => ({ session: row.session, seq: row.seq, event: row.expect }))
+  }), { mode: 384 });
+  const copies = readdirSync(folder).filter((file) => /^store-.+-v\d+-v\d+\.(?:db|json)$/u.test(file)).sort();
+  for (const file of copies.slice(0, -BACKUPS_KEPT))
+    rmSync(join(folder, file), { force: true });
+}
+function connect(database, workers) {
+  const putBody = database.prepare(PUT_BODY);
+  const putBytes = database.prepare("INSERT INTO objects (id, bytes) VALUES (?, ?) ON CONFLICT (id) DO UPDATE SET bytes = excluded.bytes WHERE objects.bytes IS NULL");
+  const getBody = database.prepare("SELECT body FROM objects WHERE id = ?");
+  const getBytes = database.prepare("SELECT bytes FROM objects WHERE id = ?");
+  const getRef = database.prepare("SELECT name, target, revision FROM refs WHERE name = ?");
+  const listFrom = database.prepare("SELECT name, target, revision FROM refs WHERE name >= ? ORDER BY name");
+  const listRange = database.prepare("SELECT name, target, revision FROM refs WHERE name >= ? AND name < ? ORDER BY name");
+  const putRef = database.prepare("INSERT INTO refs (name, target, revision) VALUES (?, ?, ?) ON CONFLICT (name) DO UPDATE SET target = excluded.target, revision = excluded.revision");
+  const deleteRef = database.prepare("DELETE FROM refs WHERE name = ?");
+  const audit = auditing(database);
+  const append = database.prepare("INSERT INTO log (session, seq, at, event) VALUES (?, ?, ?, ?)");
+  const readLog = database.prepare("SELECT seq, at, event FROM log WHERE session = ? AND seq > ? ORDER BY seq LIMIT ?");
+  const readTail = database.prepare("SELECT MAX(seq) AS tail FROM log WHERE session = ?");
+  const readCheckpoint = database.prepare("SELECT seq, body FROM fold_checkpoints WHERE session = ?");
+  const writeCheckpoint = database.prepare("INSERT INTO fold_checkpoints (session, seq, body) VALUES (?, ?, ?) ON CONFLICT (session) DO UPDATE SET seq = excluded.seq, body = excluded.body WHERE excluded.seq >= fold_checkpoints.seq");
+  const readGap = database.prepare("SELECT COUNT(*) AS events, COALESCE(SUM(LENGTH(CAST(event AS BLOB))), 0) AS bytes FROM log WHERE session = ? AND seq > ?");
+  const readVersion = database.prepare("SELECT version FROM store_meta WHERE id = 1");
+  const readDataVersion = database.prepare("PRAGMA data_version");
+  const read = async (statement, ...params) => await workers?.read(statement.sourceSQL, params) ?? statement.all(...params);
+  const tail = (session) => {
+    const row = readTail.get(session);
+    return asSeq(row?.tail === null || row?.tail === undefined ? 0 : parseNumber2(row.tail));
+  };
+  const ref = (name) => {
+    const row = getRef.get(name);
+    return row === undefined ? null : parseRef2(row);
+  };
+  return {
+    commitMark: async () => parseNumber2(readDataVersion.get()?.data_version),
+    sessions: sqlSessionIndex2(async (text, values) => await workers?.read(text, values) ?? database.prepare(text).all(...values)),
+    objects: {
+      async put(object) {
+        const id = await objectId(object);
+        write(database, putBody, id, JSON.stringify(object));
+        workers?.check();
+        return id;
+      },
+      async get(id) {
+        const body = parseText2(getBody.get(id)?.body);
+        return body === null ? null : decodeObject(body);
+      },
+      async putBlob(bytes) {
+        const joined = await collect2(bytes);
+        const id = await blobId(joined);
+        write(database, putBytes, id, joined);
+        workers?.check();
+        return id;
+      },
+      async blob(id) {
+        const bytes = getBytes.get(id)?.bytes;
+        return bytes instanceof Uint8Array ? memoryReader2(bytes) : null;
+      }
+    },
+    refs: {
+      get: async (name) => ref(name),
+      async list(prefix) {
+        const end = prefixEnd2(prefix);
+        const rows = end === null ? await read(listFrom, prefix) : await read(listRange, prefix, end);
+        return rows.map(parseRef2);
+      },
+      async set(updates) {
+        const logged = collectSessionEvents(updates);
+        const waiting = performance.now();
+        database.exec("BEGIN IMMEDIATE");
+        const acquired = performance.now();
+        try {
+          assertStoreVersion(parseNumber2(readVersion.get()?.version ?? 0));
+          const before = new Map;
+          for (const update of updates)
+            if (!before.has(update.name))
+              before.set(update.name, ref(update.name) ?? undefined);
+          const fenced = fenceNames(updates).find((name) => ref(name) === null);
+          if (fenced !== undefined) {
+            database.exec("ROLLBACK");
+            return { kind: "fenced", name: fenced };
+          }
+          const stale = updates.find((update) => !admits(update, before.get(update.name)));
+          if (stale !== undefined) {
+            database.exec("ROLLBACK");
+            return {
+              kind: "stale",
+              name: stale.name,
+              revision: before.get(stale.name)?.revision ?? null
+            };
+          }
+          const touched = new Map;
+          const current = new Map([...before].map(([name, row]) => [name, row?.revision ?? null]));
+          const revisions = updates.map((update) => {
+            const revision = mintRevision2();
+            if (update.target === null)
+              deleteRef.run(update.name);
+            else
+              putRef.run(update.name, update.target, revision);
+            audit?.run(Date.now(), process.pid, fenceNames([update]).find((name) => name.startsWith("processes/")) ?? null, update.name, current.get(update.name) ?? null, update.target === null ? null : revision, update.target);
+            current.set(update.name, update.target === null ? null : revision);
+            updateSessionIndex(database, update.name, update.target, revision);
+            const session = parseSessionRef(update.name);
+            if (session !== null)
+              touched.set(session, revision);
+            return revision;
+          });
+          for (const [session, version] of touched)
+            database.prepare("UPDATE session_index SET version = ? WHERE session = ?").run(version, session);
+          const at = Date.now();
+          const tails = new Map;
+          const appended = logged.map(({ session, event }) => {
+            const seq = (tails.get(session) ?? tail(session)) + 1;
+            tails.set(session, seq);
+            write(database, append, session, seq, at, JSON.stringify(event));
+            return asSeq(seq);
+          });
+          database.exec("COMMIT");
+          workers?.check();
+          return { kind: "set", logged: appended, at, revisions };
+        } catch (error) {
+          if (database.isTransaction)
+            database.exec("ROLLBACK");
+          throw error;
+        } finally {
+          dev("sqlite", "transaction", {
+            connection: "writer",
+            lockWaitMs: acquired - waiting,
+            executionMs: performance.now() - acquired
+          });
+        }
+      },
+      async log(session, after, limit) {
+        return (await read(readLog, session, after, limit)).map((row) => decodeEvent2(parseNumber2(row.seq), parseNumber2(row.at), parseText2(row.event) ?? ""));
+      },
+      tail: async (session) => tail(session)
+    },
+    checkpoints: {
+      async read(session) {
+        const [row] = await read(readCheckpoint, session);
+        const body = parseText2(row?.body);
+        return row === undefined || body === null ? null : { seq: asSeq(parseNumber2(row.seq)), body };
+      },
+      async write(session, checkpoint) {
+        write(database, writeCheckpoint, session, checkpoint.seq, checkpoint.body);
+        workers?.check();
+      },
+      async gap(session, after) {
+        const [row] = await read(readGap, session, after);
+        return { events: parseNumber2(row?.events ?? 0), bytes: parseNumber2(row?.bytes ?? 0) };
+      }
+    }
+  };
+}
+function auditing(database) {
+  if (process.env.NYTE_STORE_AUDIT !== "1")
+    return null;
+  database.exec("CREATE TABLE IF NOT EXISTS store_audit (id INTEGER PRIMARY KEY, at INTEGER NOT NULL, pid INTEGER NOT NULL, writer TEXT, name TEXT NOT NULL, before TEXT, after TEXT, target TEXT)");
+  return database.prepare("INSERT INTO store_audit (at, pid, writer, name, before, after, target) VALUES (?, ?, ?, ?, ?, ?, ?)");
+}
+function updateSessionIndex(database, name, target, revision) {
+  if (sessionIndexRef(name) === null)
+    return;
+  const body = target === null ? null : parseText2(database.prepare("SELECT body FROM objects WHERE id = ?").get(target)?.body);
+  for (const change of sessionIndexChanges2(name, body === null ? null : decodeObject(body), revision))
+    database.prepare(change.text).run(...change.values);
+}
+function write(database, statement, ...params) {
+  const size = params.reduce((total, value) => total + (typeof value === "string" ? value.length : ArrayBuffer.isView(value) ? value.byteLength : 0), 0);
+  return (size > 64 * 1024 ? database.prepare(statement.sourceSQL) : statement).run(...params);
+}
+
+export { storePath2, sqliteStore2 };

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

@@ -0,0 +1,189 @@
+// src/mcp/tools.ts
+import { createHash } from "node:crypto";
+import { McpClient } from "@earendil-works/pi-mcp";
+import { followedTrace, startSpan, traceparent } from "@nyte-ai/core";
+import { isJson, isJsonObject } from "@nyte-ai/schema";
+import { Errors, Meta } from "typebox/schema";
+var NAME_LIMIT = 64;
+var RESULT_CHARS = 32000;
+var HEAD_CHARS = 8000;
+var CALL_LIMIT_MS = 10 * 60000;
+var DRAFT_2020_12 = Meta["https://json-schema.org/draft/2020-12/schema"];
+var DRAFTS = new Map(Object.entries(Meta).filter(([uri]) => !uri.includes("draft-03")).map(([uri, meta]) => [draftKey(uri), meta]));
+function toolExposure2(entry, tool) {
+  const exact = entry.toolExposure.find(([pattern]) => pattern === tool);
+  if (exact !== undefined)
+    return exact[1];
+  const matched = entry.toolExposure.find(([pattern]) => globMatches(pattern, tool));
+  return matched?.[1] ?? entry.exposure;
+}
+function checkToolSchemas2(server, tools) {
+  const usable = [];
+  const issues = [];
+  for (const tool of tools) {
+    const problem = findSchemaProblem(tool.inputSchema);
+    if (problem === null) {
+      usable.push(tool);
+      continue;
+    }
+    issues.push({
+      severity: "error",
+      path: ["mcpServers", server, "tools", tool.name, "inputSchema"],
+      message: `${server} lists ${tool.name} with an input schema that is not valid JSON Schema (${problem}), so sessions do not get the tool.`
+    });
+  }
+  return { usable, issues };
+}
+function findSchemaProblem(schema) {
+  if (schema["type"] !== "object")
+    return 'its type is not "object"';
+  const declared = schema["$schema"];
+  const named = typeof declared === "string" ? DRAFTS.get(draftKey(declared)) : undefined;
+  const drafts = named === undefined ? [...DRAFTS.values()] : [named];
+  if (drafts.some((meta) => Errors(Meta, meta, schema)[0]))
+    return null;
+  const [, errors] = Errors(Meta, named ?? DRAFT_2020_12, schema);
+  const first = new Map;
+  for (const error of errors)
+    if (!first.has(error.instancePath))
+      first.set(error.instancePath, `${error.instancePath || "/"} ${error.message}`);
+  return [...first.values()].slice(0, 3).join("; ");
+}
+function draftKey(uri) {
+  return uri.replace(/^https?:\/\//, "").replace(/#$/, "");
+}
+
+class TracingMcpClient2 extends McpClient {
+  request(method, params, options) {
+    const traceparent = options !== undefined && "traceparent" in options && typeof options.traceparent === "string" ? options.traceparent : null;
+    return super.request(method, traceparent === null || params?._meta !== undefined ? params : { ...params, _meta: { traceparent } }, options);
+  }
+}
+function bridgeTools2(entry, tools, call) {
+  const names = tools.map((tool) => toolName(entry.name, tool.name));
+  const counts = Map.groupBy(names, (name) => name);
+  return tools.map((tool, index) => {
+    const name = names[index];
+    const unique = (counts.get(name)?.length ?? 0) > 1 ? hashed(name, tool.name) : name;
+    return bridge(entry, tool, call, unique);
+  });
+}
+function toolName(server, tool) {
+  const name = `mcp__${server}__${tool}`.replace(/[^A-Za-z0-9_]/g, "_");
+  return name.length > NAME_LIMIT ? hashed(name, tool) : name;
+}
+function hashed(name, tool) {
+  const suffix = createHash("sha256").update(tool).digest("hex").slice(0, 8);
+  return `${name.slice(0, NAME_LIMIT - suffix.length - 1)}_${suffix}`;
+}
+function globMatches(pattern, value) {
+  if (!pattern.includes("*"))
+    return false;
+  const source = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`).test(value);
+}
+function bridge(entry, tool, call, name) {
+  const output = tool.outputSchema;
+  const definition = {
+    name,
+    namespace: `mcp/${entry.name}`,
+    description: tool.description ?? tool.title ?? tool.name,
+    parameters: passthrough(tool.inputSchema),
+    exposure: toolExposure2(entry, tool.name),
+    class: () => ({ kind: "custom", label: `${entry.name}: ${tool.title ?? tool.name}` }),
+    effects: tool.annotations?.readOnlyHint === true ? "none" : "workspace",
+    replay: tool.annotations?.readOnlyHint === true || tool.annotations?.idempotentHint === true ? "safe" : "never",
+    async execute(args, invocation) {
+      const limitMs = Math.max(entry.timeoutMs, CALL_LIMIT_MS);
+      const limit = AbortSignal.timeout(limitMs);
+      let result;
+      const trace = followedTrace(invocation.session.id);
+      const ended = startSpan("mcp.call", trace, {
+        session: invocation.session.id,
+        server: entry.name,
+        tool: tool.name
+      });
+      try {
+        result = await call(tool.name, args, {
+          signal: AbortSignal.any([invocation.signal, limit]),
+          timeoutMs: entry.timeoutMs,
+          onProgress: (update) => invocation.progress(toolProgress(update)),
+          traceparent: trace === null ? undefined : traceparent(trace)
+        });
+      } catch (error) {
+        ended({ failed: true });
+        if (!limit.aborted || invocation.signal.aborted)
+          throw error;
+        throw new Error(`${tool.name} was still running after ${limitMs / 60000} minutes, so it was cancelled.`, { cause: error });
+      }
+      ended({ failed: result.isError === true });
+      const content = await readToolContent(result, invocation.env, tool.name);
+      if (result.isError === true)
+        throw new Error(content.flatMap((item) => item.kind === "text" ? [item.text] : []).join(`
+`) || `${tool.name} failed.`);
+      const structured = result.structuredContent;
+      if (output === undefined || !isJson(structured) || JSON.stringify(structured).length > RESULT_CHARS)
+        return { content };
+      return { content, output: structured };
+    }
+  };
+  return output === undefined ? definition : { ...definition, output: passthrough(output) };
+}
+function toolProgress(update) {
+  const step = update.total === undefined ? `${update.progress}` : `${update.progress} of ${update.total}`;
+  const text = update.message ?? step;
+  return update.total === undefined || update.total <= 0 ? { text } : { text, fraction: Math.min(1, update.progress / update.total) };
+}
+async function readToolContent(result, env, tool) {
+  const content = [];
+  for (const block of result.content) {
+    if (block.type === "text")
+      content.push({ kind: "text", text: block.text });
+    else if (block.type === "image")
+      content.push({
+        kind: "file",
+        blob: await env.files.upload(once(Uint8Array.fromBase64(block.data))),
+        mime: block.mimeType
+      });
+    else
+      content.push({ kind: "text", text: JSON.stringify(block) });
+  }
+  const text = content.flatMap((item) => item.kind === "text" ? [item.text] : []).join(`
+`);
+  if (text.length <= RESULT_CHARS)
+    return content;
+  const name = `${tool}.txt`;
+  const elided = (text.length - RESULT_CHARS).toLocaleString("en-US");
+  return [
+    {
+      kind: "text",
+      text: `${text.slice(0, HEAD_CHARS)}
+
+[${elided} characters cut from the middle; the whole result is attached as ${name}.]
+
+${text.slice(HEAD_CHARS - RESULT_CHARS)}`
+    },
+    {
+      kind: "file",
+      blob: await env.files.upload(once(new TextEncoder().encode(text))),
+      mime: "text/plain",
+      name
+    },
+    ...content.filter((item) => item.kind === "file")
+  ];
+}
+function passthrough(json) {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "mcp",
+      validate: (value) => isJson(value) && isJsonObject(value) ? { value } : { issues: [{ message: "Expected a JSON object." }] },
+      jsonSchema: { input: () => json, output: () => json }
+    }
+  };
+}
+async function* once(bytes) {
+  yield bytes;
+}
+
+export { toolExposure2, checkToolSchemas2, TracingMcpClient2, bridgeTools2 };