@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-8xgt67ka.js

@@ -0,0 +1,598 @@
+import {
+  watchPath2
+} from "./canvas-preview-mgcx2b2p.js";
+import {
+  readMcpFile2,
+  parseMcpConfig2,
+  planMcpEdit2,
+  writeMcpFile2
+} from "./canvas-preview-kdqgrstc.js";
+import {
+  oauthKey2,
+  oauthStore2,
+  signIn2
+} from "./canvas-preview-5z63am63.js";
+import {
+  connectServer2,
+  oauthSettings2
+} from "./canvas-preview-h8hshnff.js";
+import {
+  toolExposure2,
+  checkToolSchemas2,
+  TracingMcpClient2,
+  bridgeTools2
+} from "./canvas-preview-vaatfznm.js";
+
+// src/mcp/hub.ts
+import { join } from "node:path";
+import { StdioTransport } from "@earendil-works/pi-mcp";
+import { McpOAuthAuthorizationRequiredError } from "@earendil-works/pi-mcp/oauth";
+import { processEnvironment, closable, dev, forwarded, traced } from "@nyte-ai/core";
+import { isJson, isJsonObject, SdkError } from "@nyte-ai/schema";
+var STDERR_TAIL = 4000;
+var WATCH_DELAY_MS = 100;
+var LINGER_MS = 30000;
+var UNTRUSTED = {
+  kind: "invalid",
+  message: "Project servers need a trusted folder on this machine."
+};
+function createMcpHub2(input) {
+  return ({ secrets }) => hub({ ...input, connect: input.connect ?? connectServer2, secrets });
+}
+function hub(input) {
+  const pools = new Map;
+  const contents = new Map;
+  const watched = new Map;
+  const userPath = join(input.home, ".nyte", "mcp.json");
+  let closed = false;
+  const notify = (pool) => {
+    for (const listener of pool.listeners)
+      listener();
+  };
+  const reconcile = (pool) => {
+    pool.config = parseMcpConfig2(pool.files.map((file) => ({
+      ...file,
+      contents: contents.get(file.path) ?? { kind: "missing" }
+    })));
+    for (const [name, link] of pool.links) {
+      const entry = pool.config.servers.get(name);
+      if (entry !== undefined && entry.enabled && linkKey(entry) === link.key) {
+        link.entry = entry;
+        continue;
+      }
+      pool.links.delete(name);
+      link.close();
+    }
+    for (const entry of pool.config.servers.values())
+      if (entry.enabled && !pool.links.has(entry.name))
+        pool.links.set(entry.name, openLink(entry, pool));
+    notify(pool);
+  };
+  const openLink = (entry, pool) => {
+    let state = { kind: "connecting" };
+    let listed = null;
+    let bridged = null;
+    let client = null;
+    let stderr = () => null;
+    let challenge = null;
+    let ended = false;
+    let delay = 1000;
+    let timer;
+    const attempted = Promise.withResolvers();
+    let attempting = attempted.promise;
+    const attempt = () => {
+      attempting = null;
+      attempted.resolve();
+    };
+    const set = (next) => {
+      if (ended)
+        return;
+      state = next;
+      if (next.kind !== "connecting")
+        attempt();
+      notify(pool);
+    };
+    const schedule = (wait) => {
+      clearTimeout(timer);
+      if (!ended)
+        timer = setTimeout(() => void connectTraced(), wait);
+    };
+    const retry = () => {
+      schedule(delay);
+      delay = Math.min(delay * 2, 30000);
+    };
+    const drop = (message) => {
+      const previous = client;
+      client = null;
+      previous?.close().catch(() => {
+        return;
+      });
+      if (ended)
+        return;
+      set({ kind: "failed", message, stderr: stderr() });
+      dev("mcp", "link failed", { server: entry.name, retryIn: delay });
+      retry();
+    };
+    const connect = async () => {
+      if (link.entry.transport.kind === "stdio")
+        await processEnvironment();
+      if (ended)
+        return;
+      const next = new TracingMcpClient2({
+        name: "nyte",
+        version: "0.1.0",
+        requestTimeoutMs: link.entry.timeoutMs
+      });
+      next.onClose(() => {
+        if (client === next)
+          drop(`The connection to ${entry.name} closed.`);
+      });
+      let transport;
+      try {
+        transport = input.connect(link.entry, {
+          workspace: pool.workspace,
+          home: input.home,
+          secrets: input.secrets,
+          challenged: (next) => {
+            challenge = next;
+          }
+        });
+      } catch (error) {
+        set({ kind: "failed", message: errorMessage(error), stderr: null });
+        return;
+      }
+      try {
+        stderr = () => transport instanceof StdioTransport && transport.stderr !== "" ? transport.stderr.slice(-STDERR_TAIL) : null;
+        await next.connect(transport);
+        if (ended) {
+          await next.close();
+          return;
+        }
+        const refresh = async () => {
+          const offered = await next.listTools();
+          if (client !== next)
+            return;
+          const { usable, issues } = checkToolSchemas2(entry.name, offered);
+          dev("mcp", "tools listed", { server: entry.name, tools: usable.length });
+          listed = { tools: usable, instructions: next.instructions ?? null };
+          set({ kind: "connected", tools: usable, issues });
+        };
+        client = next;
+        delay = 1000;
+        next.onNotification("notifications/tools/list_changed", async () => {
+          try {
+            await refresh();
+          } catch (error) {
+            if (client === next)
+              drop(`${entry.name} failed to list its tools: ${errorMessage(error)}`);
+          }
+        });
+        await refresh();
+      } catch (error) {
+        if (client === next)
+          client = null;
+        await next.close().catch(() => {
+          return;
+        });
+        if (ended)
+          return;
+        if (error instanceof McpOAuthAuthorizationRequiredError) {
+          if (state.kind !== "needs-sign-in")
+            set({ kind: "needs-sign-in" });
+          return;
+        }
+        set({
+          kind: "failed",
+          message: `${entry.name} failed to connect: ${errorMessage(error)}`,
+          stderr: stderr()
+        });
+        retry();
+      }
+    };
+    const connectTraced = () => traced("mcp.connect", null, { server: entry.name }, connect);
+    const call = (name, args, options) => {
+      if (client === null)
+        throw new Error(notConnected(entry.name, state));
+      return client.callTool(name, args, options);
+    };
+    const link = {
+      key: linkKey(entry),
+      entry,
+      state: () => state,
+      brief: () => ({
+        name: entry.name,
+        instructions: listed?.instructions ?? null,
+        unavailable: listed === null && (state.kind === "failed" || state.kind === "needs-sign-in") ? state.kind : null
+      }),
+      challenge: () => challenge,
+      tools() {
+        if (listed === null)
+          return [];
+        if (bridged?.entry !== link.entry || bridged.listed !== listed)
+          bridged = {
+            entry: link.entry,
+            listed,
+            tools: bridgeTools2(link.entry, listed.tools, call)
+          };
+        return bridged.tools;
+      },
+      attempting: () => attempting,
+      async close() {
+        ended = true;
+        attempt();
+        clearTimeout(timer);
+        const previous = client;
+        client = null;
+        await previous?.close().catch(() => {
+          return;
+        });
+      }
+    };
+    connectTraced();
+    return link;
+  };
+  const load = async (paths) => {
+    await Promise.all(paths.map(async (path) => {
+      contents.set(path, await readMcpFile2(path));
+    }));
+  };
+  const changed = (path) => {
+    load([path]).then(() => {
+      if (!watched.has(path)) {
+        contents.delete(path);
+        return;
+      }
+      for (const pool of pools.values())
+        if (pool.files.some((file) => file.path === path))
+          reconcile(pool);
+    });
+  };
+  const unfollow = (path) => {
+    if ([...pools.values()].some((pool) => pool.files.some((file) => file.path === path)))
+      return;
+    watched.get(path)?.();
+    watched.delete(path);
+    contents.delete(path);
+  };
+  const shut = (pool) => {
+    clearTimeout(pool.linger);
+    if (pools.get(pool.key) !== pool)
+      return;
+    pools.delete(pool.key);
+    for (const link of pool.links.values())
+      link.close();
+    pool.links.clear();
+    notify(pool);
+    for (const file of pool.files)
+      unfollow(file.path);
+  };
+  const idle = (pool) => {
+    clearTimeout(pool.linger);
+    if (closed || pools.get(pool.key) !== pool || pool.holders > 0)
+      return;
+    if ([...pools.values()].some((other) => other !== pool && other.workspace.id === pool.workspace.id)) {
+      shut(pool);
+      return;
+    }
+    pool.linger = setTimeout(() => shut(pool), LINGER_MS);
+    pool.linger.unref();
+  };
+  const filesFor = (workspace) => [
+    { path: userPath, scope: "user" },
+    ...workspace.trusted && workspace.root !== null ? [{ path: join(workspace.root, ".nyte", "mcp.json"), scope: "project" }] : []
+  ];
+  const open = (workspace) => {
+    const key = poolKey(workspace);
+    const known = pools.get(key);
+    if (known !== undefined)
+      return known;
+    const files = filesFor(workspace);
+    const unread = files.flatMap((file) => watched.has(file.path) ? [] : [file.path]);
+    for (const path of unread)
+      watched.set(path, watchPath2(path, { delay: WATCH_DELAY_MS }, () => changed(path)));
+    const pool = {
+      key,
+      workspace,
+      files,
+      config: { servers: new Map, issues: [] },
+      loaded: load(unread).then(() => {
+        pool.loading = false;
+        if (pools.get(key) === pool)
+          reconcile(pool);
+      }),
+      loading: true,
+      links: new Map,
+      listeners: new Set,
+      holders: 0,
+      linger: undefined
+    };
+    pools.set(key, pool);
+    return pool;
+  };
+  const held = async (workspace, run) => {
+    if (closed)
+      throw new SdkError("unavailable", "The host is closing.");
+    const pool = open(workspace);
+    pool.holders += 1;
+    idle(pool);
+    try {
+      await pool.loaded;
+      return await run(pool);
+    } finally {
+      pool.holders -= 1;
+      idle(pool);
+    }
+  };
+  const restart = (pool, server) => {
+    const link = pool.links.get(server);
+    if (link !== undefined) {
+      pool.links.delete(server);
+      link.close();
+    }
+    reconcile(pool);
+  };
+  const restartSignedIn = (key) => {
+    const signed = [...pools.values()].flatMap((pool) => [...pool.links].flatMap(([server, link]) => link.entry.transport.kind === "http" && oauthKey2(server, link.entry.transport.url) === key ? [{ pool, server }] : []));
+    for (const { pool, server } of signed)
+      restart(pool, server);
+  };
+  const configFor = async (workspace, replaced) => parseMcpConfig2(await Promise.all(filesFor(workspace).map(async (file) => ({
+    ...file,
+    contents: replaced?.path === file.path ? { kind: "text", text: replaced.text } : await readMcpFile2(file.path)
+  }))));
+  const writing = new Map;
+  const edit = (workspace, path, server, change, check) => {
+    const queued = (writing.get(path) ?? Promise.resolve()).then(async () => {
+      const plan = await planMcpEdit2(path, change);
+      if (plan.kind !== "planned")
+        return plan;
+      if (check === "introduced-issues") {
+        const about = (config) => config.issues.filter((issue) => issue.path[1] === server).map((issue) => issue.message);
+        const before = new Set(about(await configFor(workspace)));
+        const introduced = about(await configFor(workspace, { path, text: plan.text })).find((message) => !before.has(message));
+        if (introduced !== undefined)
+          return { kind: "invalid", message: introduced };
+      }
+      await writeMcpFile2(path, plan.text);
+      if (watched.has(path))
+        contents.set(path, { kind: "text", text: plan.text });
+      for (const pool of pools.values())
+        if (pool.files.some((file) => file.path === path))
+          reconcile(pool);
+      return { kind: "updated" };
+    });
+    writing.set(path, queued.catch(() => {
+      return;
+    }));
+    return queued;
+  };
+  const signingIn = new Set;
+  const view = (pool) => ({
+    issues: [
+      ...pool.config.issues,
+      ...[...pool.links.values()].flatMap((link) => {
+        const state = link.state();
+        return state.kind === "connected" ? state.issues : [];
+      })
+    ],
+    servers: [...pool.config.servers.values()].toSorted((a, b) => a.name.localeCompare(b.name)).map((entry) => ({
+      name: entry.name,
+      scope: entry.scope,
+      path: entry.path,
+      override: entry.override,
+      transport: entry.transport.kind === "stdio" ? { kind: "stdio", command: entry.transport.command, args: entry.transport.args } : { kind: "http", url: entry.transport.url },
+      exposure: entry.exposure,
+      description: entry.description,
+      state: entry.enabled ? serverState(entry, pool.links.get(entry.name)?.state() ?? { kind: "connecting" }) : { kind: "disabled" }
+    }))
+  });
+  return {
+    watch(workspace) {
+      return closable(() => {
+        if (closed)
+          return { pull: async () => ({ done: true, value: undefined }), close() {} };
+        const pool = open(workspace);
+        let dirty = true;
+        let ended = false;
+        let wake = null;
+        const listener = () => {
+          dirty = true;
+          wake?.();
+        };
+        pool.holders += 1;
+        idle(pool);
+        pool.listeners.add(listener);
+        return {
+          async pull() {
+            await pool.loaded;
+            while (!dirty && !ended && !closed && pools.get(pool.key) === pool)
+              await new Promise((resolve) => wake = resolve);
+            wake = null;
+            if (ended || closed || pools.get(pool.key) !== pool)
+              return { done: true, value: undefined };
+            dirty = false;
+            return { done: false, value: view(pool) };
+          },
+          close() {
+            if (ended)
+              return;
+            ended = true;
+            wake?.();
+            pool.listeners.delete(listener);
+            pool.holders -= 1;
+            idle(pool);
+          }
+        };
+      });
+    },
+    tools(workspace) {
+      const pool = pools.get(poolKey(workspace));
+      return pool === undefined ? [] : [...pool.links.values()].flatMap((link) => link.tools());
+    },
+    briefs(workspace) {
+      const pool = pools.get(poolKey(workspace));
+      return pool === undefined ? [] : [...pool.links.values()].map((link) => link.brief()).toSorted((a, b) => a.name.localeCompare(b.name));
+    },
+    async ready(workspace, signal) {
+      const watched = [...pools.values()].filter((pool) => pool.workspace.id === workspace);
+      const attempting = (pool) => [...pool.links.values()].flatMap((link) => link.attempting() ?? []);
+      const attempts = watched.flatMap((pool) => pool.loading ? [pool.loaded.then(() => Promise.all(attempting(pool))).then(() => {
+        return;
+      })] : attempting(pool));
+      if (attempts.length === 0 || signal.aborted)
+        return false;
+      const aborted = Promise.withResolvers();
+      signal.addEventListener("abort", () => aborted.resolve(), { once: true });
+      await Promise.race([Promise.all(attempts), aborted.promise]);
+      return true;
+    },
+    reconnect: (workspace, server) => held(workspace, async (pool) => {
+      const entry = pool.config.servers.get(server);
+      if (entry === undefined)
+        return { kind: "missing" };
+      if (!entry.enabled)
+        return { kind: "invalid", message: `${server} is turned off.` };
+      restart(pool, server);
+      return { kind: "updated" };
+    }),
+    async setEnabled(workspace, server, enabled) {
+      const entry = (await configFor(workspace)).servers.get(server);
+      if (entry === undefined)
+        return { kind: "missing" };
+      const override = entry.override !== null;
+      return edit(workspace, entry.override ?? entry.path, server, (servers) => {
+        const current = servers[server];
+        if (!isJsonObject(current))
+          return null;
+        const { enabled: _previous, ...rest } = current;
+        return {
+          ...servers,
+          [server]: override ? { ...rest, enabled } : enabled ? rest : { ...rest, enabled: false }
+        };
+      }, "introduced-issues");
+    },
+    login(workspace, server) {
+      let begun = null;
+      const begin = () => begun ??= held(workspace, async (pool) => {
+        const entry = pool.config.servers.get(server);
+        if (entry === undefined)
+          return failedLogin(`No MCP server is named ${server}.`);
+        const { transport } = entry;
+        if (transport.kind !== "http")
+          return failedLogin(`${server} runs a command, so it has nothing to sign in to.`);
+        if (Object.keys(transport.headers).some((name) => name.toLowerCase() === "authorization"))
+          return failedLogin(`${server} sends its own Authorization header.`);
+        const key = oauthKey2(server, transport.url);
+        if (signingIn.has(key))
+          return failedLogin(`A sign-in to ${server} is already running.`);
+        let settings;
+        try {
+          settings = oauthSettings2(transport.oauth, server);
+        } catch (error) {
+          return failedLogin(errorMessage(error));
+        }
+        signingIn.add(key);
+        pool.holders += 1;
+        return signIn2({
+          server,
+          serverUrl: transport.url,
+          store: oauthStore2(input.secrets, key),
+          settings,
+          challenge: pool.links.get(server)?.challenge() ?? null,
+          signedIn: () => restartSignedIn(key),
+          ended: () => {
+            signingIn.delete(key);
+            pool.holders -= 1;
+            idle(pool);
+          }
+        });
+      });
+      return {
+        steps: () => forwarded(async () => (await begin()).steps()),
+        async answer(code) {
+          if (begun === null)
+            throw new SdkError("invalid", "Read the login's steps before answering.");
+          await (await begun).answer(code);
+        }
+      };
+    },
+    async logout(workspace, server) {
+      const entry = (await configFor(workspace)).servers.get(server);
+      if (entry === undefined)
+        return { kind: "missing" };
+      if (entry.transport.kind !== "http")
+        return { kind: "invalid", message: `${server} runs a command and has no sign-in.` };
+      const key = oauthKey2(server, entry.transport.url);
+      await input.secrets.delete(key);
+      restartSignedIn(key);
+      return { kind: "updated" };
+    },
+    async add(workspace, server, config, scope) {
+      const path = filesFor(workspace).find((file) => file.scope === scope)?.path;
+      if (path === undefined)
+        return UNTRUSTED;
+      if (!isJson(config))
+        return { kind: "invalid", message: "The server's config is not JSON." };
+      return edit(workspace, path, server, (servers) => ({ ...servers, [server]: config }), "introduced-issues");
+    },
+    async remove(workspace, server, scope) {
+      const path = filesFor(workspace).find((file) => file.scope === scope)?.path;
+      if (path === undefined)
+        return UNTRUSTED;
+      return edit(workspace, path, server, (servers) => {
+        if (!(server in servers))
+          return null;
+        const { [server]: _removed, ...rest } = servers;
+        return rest;
+      }, "none");
+    },
+    async close() {
+      closed = true;
+      const live = [...pools.values()];
+      const links = live.flatMap((pool) => [...pool.links.values()]);
+      for (const pool of live)
+        shut(pool);
+      await Promise.all(links.map((link) => link.close()));
+    }
+  };
+}
+function serverState(entry, state) {
+  if (state.kind !== "connected")
+    return state;
+  return {
+    kind: "connected",
+    tools: state.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? tool.title ?? tool.name,
+      exposure: toolExposure2(entry, tool.name)
+    }))
+  };
+}
+function notConnected(server, state) {
+  if (state.kind === "failed")
+    return `${server} is not connected: ${state.message}`;
+  if (state.kind === "needs-sign-in")
+    return `${server} needs the user to sign in again before its tools work.`;
+  return `${server} is reconnecting; try the call again shortly.`;
+}
+function poolKey(workspace) {
+  return JSON.stringify([workspace.id, workspace.root, workspace.trusted]);
+}
+function linkKey(entry) {
+  return JSON.stringify([entry.transport, entry.timeoutMs]);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function failedLogin(reason) {
+  return {
+    async* steps() {
+      yield { kind: "failed", reason };
+    },
+    answer: async () => {
+      return;
+    }
+  };
+}
+
+export { createMcpHub2 };