@nyte-ai/host 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,63 @@
+import {
+  oauthKey2,
+  oauthStore2,
+  createAuthProvider2
+} from "./canvas-preview-5z63am63.js";
+
+// src/mcp/connect.ts
+import { isAbsolute, join, resolve } from "node:path";
+import process from "node:process";
+import { StdioTransport, StreamableHttpTransport } from "@earendil-works/pi-mcp";
+var connectServer2 = (entry, context) => {
+  const { transport } = entry;
+  if (transport.kind === "stdio") {
+    const base = context.workspace.root ?? context.home;
+    const cwd = transport.cwd === null ? base : home(transport.cwd, context.home);
+    return new StdioTransport({
+      command: home(transport.command, context.home),
+      args: transport.args.map((arg) => home(arg, context.home)),
+      env: expand(transport.env, entry.name),
+      cwd: isAbsolute(cwd) ? cwd : resolve(base, cwd),
+      stderr: "pipe"
+    });
+  }
+  const headers = expand(transport.headers, entry.name);
+  if (Object.keys(headers).some((name) => name.toLowerCase() === "authorization"))
+    return new StreamableHttpTransport({ url: transport.url, headers });
+  return new StreamableHttpTransport({
+    url: transport.url,
+    headers,
+    authProvider: createAuthProvider2({
+      serverUrl: transport.url,
+      store: oauthStore2(context.secrets, oauthKey2(entry.name, transport.url)),
+      settings: () => oauthSettings2(transport.oauth, entry.name),
+      onChallenge: context.challenged
+    })
+  });
+};
+function oauthSettings2(config, server) {
+  const { clientSecret, authServerMetadataUrl, ...rest } = config;
+  return {
+    ...rest,
+    ...clientSecret === undefined ? {} : { clientSecret: expand({ clientSecret }, server).clientSecret },
+    ...authServerMetadataUrl === undefined ? {} : { authServerMetadataUrl: new URL(authServerMetadataUrl) }
+  };
+}
+function home(path, directory) {
+  if (path === "~")
+    return directory;
+  return path.startsWith("~/") ? join(directory, path.slice(2)) : path;
+}
+function expand(values, server) {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+      const found = process.env[name];
+      if (found === undefined)
+        throw new Error(`${server} needs the environment variable ${name}. Set it where Nyte runs, then restart Nyte.`);
+      return found;
+    })
+  ]));
+}
+
+export { connectServer2, oauthSettings2 };

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

@@ -0,0 +1,144 @@
+// src/serve/stream-server.ts
+import { deflateSync } from "fflate";
+import { SdkError } from "@nyte-ai/schema";
+import { CHANNEL_HEADER, asSdkError, encodeError, streamBuffer } from "@nyte-ai/protocol";
+var encoder = new TextEncoder;
+var CHUNK_BYTES = 48 * 1024;
+var DEFLATE_MIN_BYTES = 16 * 1024;
+function createStreamChannels2() {
+  const channels = new Map;
+  const owned = (id, connection) => {
+    const channel = channels.get(id);
+    if (channel === undefined)
+      throw new SdkError("unavailable", "The stream channel is closed.");
+    if (channel.connection !== connection)
+      throw new SdkError("denied", "The stream channel belongs to another connection.");
+    return channel;
+  };
+  return {
+    open(connection, signal, deflate) {
+      const id = crypto.randomUUID();
+      const controller = new AbortController;
+      const streams = new Map;
+      let timer;
+      const finish = () => {
+        if (controller.signal.aborted)
+          return;
+        controller.abort();
+        channels.delete(id);
+        clearInterval(timer);
+        signal.removeEventListener("abort", aborted);
+        for (const stream of streams.values())
+          stream.abort();
+        streams.clear();
+      };
+      const buffer = streamBuffer(finish);
+      const fail = (error) => {
+        if (controller.signal.aborted)
+          return;
+        buffer.end(encoder.encode(`event: error
+data: ${JSON.stringify(encodeError(error))}
+
+`));
+        finish();
+      };
+      const aborted = () => {
+        fail(signal.reason instanceof SdkError ? signal.reason : new SdkError("unavailable", "The stream channel disconnected."));
+      };
+      channels.set(id, {
+        connection,
+        signal: controller.signal,
+        deflate,
+        streams,
+        push: (frame, signal) => buffer.write(encoder.encode(`data: ${JSON.stringify(frame)}
+
+`), signal)
+      });
+      buffer.push(encoder.encode(`: connected
+
+`));
+      timer = setInterval(() => {
+        buffer.push(encoder.encode(`: ping
+
+`));
+      }, 15000);
+      if (signal.aborted)
+        aborted();
+      else
+        signal.addEventListener("abort", aborted, { once: true });
+      return new Response(buffer.body, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          [CHANNEL_HEADER]: id
+        }
+      });
+    },
+    async start(connection, channelId, streamId, request, serve) {
+      const channel = owned(channelId, connection);
+      if (channel.streams.has(streamId))
+        throw new SdkError("invalid", "The stream identifier is already in use.");
+      const controller = new AbortController;
+      channel.streams.set(streamId, controller);
+      const abortSetup = () => controller.abort(request.reason);
+      request.addEventListener("abort", abortSetup, { once: true });
+      const signal = AbortSignal.any([controller.signal, channel.signal]);
+      (async () => {
+        let reader;
+        const cancel = () => {
+          reader?.cancel().catch(() => {
+            return;
+          });
+        };
+        signal.addEventListener("abort", cancel, { once: true });
+        try {
+          if (request.aborted)
+            abortSetup();
+          signal.throwIfAborted();
+          const response = await serve(signal);
+          reader = response.body?.getReader();
+          request.removeEventListener("abort", abortSetup);
+          if (signal.aborted)
+            return;
+          if (reader !== undefined)
+            for (;; ) {
+              const next = await reader.read();
+              if (signal.aborted || next.done)
+                break;
+              for (let start = 0;start < next.value.byteLength; start += CHUNK_BYTES) {
+                if (signal.aborted)
+                  break;
+                const chunk = next.value.subarray(start, start + CHUNK_BYTES);
+                await channel.push(channel.deflate && chunk.byteLength >= DEFLATE_MIN_BYTES ? {
+                  kind: "deflated",
+                  stream: streamId,
+                  data: deflateSync(chunk, { level: 1 }).toBase64()
+                } : { kind: "chunk", stream: streamId, data: chunk.toBase64() }, signal);
+              }
+            }
+          if (!signal.aborted)
+            await channel.push({ kind: "end", stream: streamId }, signal);
+        } catch (error) {
+          if (!signal.aborted)
+            await channel.push({
+              kind: "error",
+              stream: streamId,
+              error: JSON.stringify(encodeError(asSdkError(error)))
+            }, signal);
+        } finally {
+          request.removeEventListener("abort", abortSetup);
+          signal.removeEventListener("abort", cancel);
+          channel.streams.delete(streamId);
+          controller.abort();
+          cancel();
+        }
+      })();
+      return new Response(null, { status: 202 });
+    },
+    cancel(connection, channelId, streamId) {
+      owned(channelId, connection).streams.get(streamId)?.abort();
+    }
+  };
+}
+
+export { createStreamChannels2 };

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

@@ -0,0 +1,112 @@
+import {
+  readErrorCode2
+} from "./canvas-preview-mgcx2b2p.js";
+
+// src/plugins/loader.ts
+import { readdir, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { SdkError } from "@nyte-ai/schema";
+import { dev } from "@nyte-ai/core";
+var EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+async function loadPluginFiles2(dir) {
+  return loadAll(await pluginFilesIn(dir));
+}
+async function loadPluginDirectory2(dir) {
+  return importEach(await pluginFilesIn(dir));
+}
+function pluginLoader2(dirs) {
+  return async (paths) => {
+    const roots = (await Promise.all(dirs.map((dir) => realpath(dir).catch(() => null)))).filter((root) => root !== null);
+    const files = await Promise.all(paths.map(async (path) => {
+      const real = await realpath(path).catch(() => null);
+      if (real === null)
+        throw new SdkError("invalid", `No plugin file is at ${path}.`);
+      if (!roots.some((root) => inside(root, real)))
+        throw new SdkError("denied", `${path} is not in a plugin directory this host loads.`);
+      return real;
+    }));
+    return (await loadAll(files)).map((loaded) => loaded.plugin);
+  };
+}
+async function loadAll(files) {
+  const { loaded, failed } = await importEach(files);
+  const issues = failed.map((entry) => entry.issue);
+  if (issues.length > 0)
+    throw new SdkError("invalid", `${issues.length === 1 ? "A plugin file" : `${issues.length} plugin files`} did not load: ${failed.map((entry) => `${entry.path}: ${entry.issue.message}`).join("; ")}`, { issues });
+  return loaded;
+}
+async function importEach(files) {
+  const loaded = [];
+  const failed = [];
+  for (const path of files) {
+    const outcome = await importPlugin(path);
+    dev("plugins", "file", { path, outcome: "plugin" in outcome ? "loaded" : "failed" });
+    if ("plugin" in outcome)
+      loaded.push({ plugin: outcome.plugin, path });
+    else
+      failed.push({
+        path,
+        issue: {
+          severity: "error",
+          path: [path],
+          message: outcome.reason,
+          source: { plugin: path, file: path }
+        }
+      });
+  }
+  return { loaded, failed };
+}
+async function pluginFilesIn(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch((error) => {
+    if (readErrorCode2(error) === "ENOENT" || readErrorCode2(error) === "ENOTDIR")
+      return [];
+    throw error;
+  });
+  return (await Promise.all(entries.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0).map(async (entry) => {
+    const path = join(dir, entry.name);
+    if (entry.isFile())
+      return EXTENSIONS.some((extension) => entry.name.endsWith(extension)) ? [path] : [];
+    if (!entry.isDirectory())
+      return [];
+    for (const extension of EXTENSIONS) {
+      const index = join(path, `index${extension}`);
+      if ((await stat(index).catch(() => null))?.isFile() === true)
+        return [index];
+    }
+    return [];
+  }))).flat();
+}
+async function importPlugin(path) {
+  try {
+    const stats = await stat(path);
+    const url = pathToFileURL(path);
+    url.searchParams.set("nyte", `${stats.mtimeMs}-${stats.size}`);
+    const imported = await import(url.href);
+    const exported = typeof imported === "object" && imported !== null && "default" in imported ? imported.default : undefined;
+    return fitsCorePlugin(exported) ? { plugin: exported } : { reason: "Its default export is not a core plugin (an object with a string id)." };
+  } catch (error) {
+    return { reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+function fitsCorePlugin(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string")
+    return false;
+  const object = (field) => field === undefined || typeof field === "object" && field !== null;
+  if ("contribute" in value && !object(value.contribute))
+    return false;
+  if ("hooks" in value && !object(value.hooks))
+    return false;
+  if ("activate" in value && value.activate !== undefined && typeof value.activate !== "function")
+    return false;
+  if (!("environment" in value) || value.environment === undefined)
+    return true;
+  const environment = value.environment;
+  return typeof environment === "object" && environment !== null && "kind" in environment && typeof environment.kind === "string" && "inspect" in environment && typeof environment.inspect === "function" && "attach" in environment && typeof environment.attach === "function";
+}
+function inside(root, path) {
+  const within = relative(root, path);
+  return within !== "" && !within.startsWith("..") && !isAbsolute(within);
+}
+
+export { loadPluginFiles2, loadPluginDirectory2, pluginLoader2 };

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

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