@nyte-ai/host 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,252 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+
+// src/local/patch.ts
+import { lineDiff } from "@nyte-ai/core";
+import { writePatch } from "@nyte-ai/schema";
+var PATCH_LIMIT2 = 1024 * 1024;
+var ESCAPES = new Map([
+  ["a", 7],
+  ["b", 8],
+  ["f", 12],
+  ["n", 10],
+  ["r", 13],
+  ["t", 9],
+  ["v", 11],
+  ['"', 34],
+  ["\\", 92]
+]);
+function splitDiff(output) {
+  const lines = output.split(`
+`);
+  if (lines.at(-1) === "")
+    lines.pop();
+  const sections = [];
+  let index = 0;
+  while (index < lines.length) {
+    const header = lines[index] ?? "";
+    if (!header.startsWith("diff --git ")) {
+      index += 1;
+      continue;
+    }
+    const start = index;
+    const named = headerPaths(header.slice("diff --git ".length));
+    let oldPath = named?.old ?? null;
+    let newPath = named?.new ?? null;
+    let binary = false;
+    let hunked = false;
+    let added = 0;
+    let removed = 0;
+    index += 1;
+    while (index < lines.length && !(lines[index] ?? "").startsWith("diff --git ")) {
+      const line = lines[index] ?? "";
+      index += 1;
+      if (line.startsWith("@@ "))
+        hunked = true;
+      else if (hunked && line.startsWith("+"))
+        added += 1;
+      else if (hunked && line.startsWith("-"))
+        removed += 1;
+      else if (hunked)
+        continue;
+      else if (line.startsWith("--- "))
+        oldPath = sidePath(line.slice(4), "a/");
+      else if (line.startsWith("+++ "))
+        newPath = sidePath(line.slice(4), "b/");
+      else if (/^(?:rename|copy) from /u.test(line))
+        oldPath = unquote(line.replace(/^(?:rename|copy) from /u, ""));
+      else if (/^(?:rename|copy) to /u.test(line))
+        newPath = unquote(line.replace(/^(?:rename|copy) to /u, ""));
+      else if (line.startsWith("new file mode "))
+        oldPath = null;
+      else if (line.startsWith("deleted file mode "))
+        newPath = null;
+      else if (line.startsWith("Binary files ") || line === "GIT binary patch")
+        binary = true;
+    }
+    sections.push({
+      oldPath,
+      newPath,
+      binary,
+      hunked,
+      added,
+      removed,
+      text: `${lines.slice(start, index).join(`
+`)}
+`
+    });
+  }
+  return sections;
+}
+function sectionEntry(path, status, section) {
+  const digest = sha2562(section.text);
+  if (section.binary)
+    return { path, status, digest, kind: "binary" };
+  if (section.text.length > PATCH_LIMIT2)
+    return { path, status, digest, kind: "too-large", limit: PATCH_LIMIT2 };
+  if (!section.hunked)
+    return { path, status, digest, kind: "empty" };
+  return {
+    path,
+    status,
+    digest,
+    kind: "text",
+    added: section.added,
+    removed: section.removed,
+    patch: section.text
+  };
+}
+function textEntry2(path, status, before, after, options) {
+  const { hunks, added, removed } = lineDiff(before ?? "", after ?? "", options);
+  if (hunks.length === 0) {
+    const mode = options?.ignoreWhitespace === true ? "ignore-whitespace" : "";
+    return {
+      path,
+      status,
+      digest: sha2562(`${mode}\x00${before ?? ""}\x00${after ?? ""}`),
+      kind: "empty"
+    };
+  }
+  const patch = writePatch(path, status, hunks);
+  return { path, status, digest: sha2562(patch), kind: "text", added, removed, patch };
+}
+async function readPatches2(files, read, emptyDigest) {
+  const settle = (batch, ran) => {
+    const sections = splitDiff(ran.stdout.toString("utf8"));
+    return batch.map((file) => {
+      const section = sections.find((candidate) => (candidate.newPath ?? candidate.oldPath) === file.path);
+      return section === undefined ? { path: file.path, status: file.status, digest: emptyDigest(file), kind: "empty" } : sectionEntry(file.path, file.status, section);
+    });
+  };
+  const together = await read(files, PATCH_LIMIT2 * files.length + 4096).catch(() => null);
+  if (together !== null && !together.truncated && (together.code === 0 || together.code === 1))
+    return settle(files, together);
+  const entries = [];
+  for (const file of files) {
+    const failed = (reason) => ({
+      path: file.path,
+      status: file.status,
+      digest: "",
+      kind: "failed",
+      reason
+    });
+    const alone = await read([file], PATCH_LIMIT2 + 1).catch((error) => error instanceof Error ? error.message : String(error));
+    if (typeof alone === "string")
+      entries.push(failed(alone));
+    else if (alone.truncated)
+      entries.push({
+        path: file.path,
+        status: file.status,
+        digest: sha2562(alone.stdout),
+        kind: "too-large",
+        limit: PATCH_LIMIT2
+      });
+    else if (alone.code !== 0 && alone.code !== 1)
+      entries.push(failed(alone.stderr.trim() || "git diff failed"));
+    else
+      entries.push(...settle([file], alone));
+  }
+  return entries;
+}
+function lineStat2(before, after) {
+  const { added, removed } = lineDiff(before, after);
+  return { kind: "text", added, removed };
+}
+function headerPaths(rest) {
+  if (rest.startsWith('"')) {
+    const end = quotedEnd(rest);
+    const old = unquote(rest.slice(0, end + 1));
+    const next = unquote(rest.slice(end + 2));
+    return { old: old.replace(/^a\//, ""), new: next.replace(/^b\//, "") };
+  }
+  const half = (rest.length - 5) / 2;
+  if (Number.isInteger(half) && rest.startsWith("a/") && rest.slice(half + 2, half + 5) === " b/") {
+    const path = rest.slice(2, half + 2);
+    if (rest.slice(half + 5) === path)
+      return { old: path, new: path };
+  }
+  const split = /^.{2}(.*?) b\/(.*)$/su.exec(rest);
+  return split === null ? null : { old: split[1] ?? "", new: unquote(split[2] ?? "") };
+}
+function quotedEnd(text) {
+  for (let index = 1;index < text.length; index += 1) {
+    if (text[index] === "\\")
+      index += 1;
+    else if (text[index] === '"')
+      return index;
+  }
+  return text.length - 1;
+}
+function sidePath(text, prefix) {
+  const name = unquote(text.replace(/\t$/, ""));
+  if (name === "/dev/null")
+    return null;
+  return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
+function unquote(text) {
+  if (!text.startsWith('"') || !text.endsWith('"') || text.length < 2)
+    return text;
+  const bytes = [];
+  const encoder = new TextEncoder;
+  for (let index = 1;index < text.length - 1; index += 1) {
+    const char = text[index] ?? "";
+    if (char !== "\\") {
+      bytes.push(...encoder.encode(char));
+      continue;
+    }
+    const next = text[index + 1] ?? "";
+    const octal = /^[0-7]{3}$/.exec(text.slice(index + 1, index + 4));
+    if (octal !== null) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      index += 3;
+      continue;
+    }
+    bytes.push(ESCAPES.get(next) ?? next.charCodeAt(0));
+    index += 1;
+  }
+  return new TextDecoder().decode(new Uint8Array(bytes));
+}
+function parseNumstat2(output) {
+  const tokens = output.split("\x00");
+  const stats = new Map;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index] ?? "";
+    if (token === "")
+      continue;
+    const [added = "", removed = "", path = ""] = token.split("\t");
+    let name = path;
+    if (path === "") {
+      name = tokens[index + 2] ?? "";
+      index += 2;
+    }
+    stats.set(name, added === "-" || removed === "-" ? { kind: "binary" } : { kind: "text", added: Number(added) || 0, removed: Number(removed) || 0 });
+  }
+  return stats;
+}
+function parseNameStatus2(output) {
+  const tokens = output.split("\x00");
+  const changed = [];
+  for (let index = 0;index < tokens.length; index += 1) {
+    const code = tokens[index] ?? "";
+    if (code === "")
+      continue;
+    const letter = code[0];
+    if (letter === "R" || letter === "C") {
+      const from = tokens[index + 1] ?? "";
+      const path = tokens[index + 2] ?? "";
+      index += 2;
+      changed.push(letter === "R" ? { path, status: "renamed", from } : { path, status: "added" });
+      continue;
+    }
+    const path = tokens[index + 1] ?? "";
+    index += 1;
+    changed.push({
+      path,
+      status: letter === "A" ? "added" : letter === "D" ? "deleted" : letter === "U" ? "conflicted" : "modified"
+    });
+  }
+  return changed;
+}
+
+export { PATCH_LIMIT2, textEntry2, readPatches2, lineStat2, parseNumstat2, parseNameStatus2 };

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 };