@nyte-ai/host 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,369 @@
+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";
+import {
+  claimStore2
+} from "./canvas-preview-a3yw0j70.js";
+
+// src/sqlite.ts
+import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+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 sqliteStore2(input) {
+  let database = null;
+  let opening = null;
+  let closing = null;
+  let workers = null;
+  let release = null;
+  const open = async () => {
+    const claim = "path" in input ? claimStore2(input.path) : null;
+    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();
+      claim?.();
+      throw error;
+    }
+    database = created;
+    release = claim;
+    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();
+        release?.();
+        workers = null;
+        database = null;
+        release = 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 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 revisions = updates.map((update) => {
+            const revision = mintRevision2();
+            if (update.target === null)
+              deleteRef.run(update.name);
+            else
+              putRef.run(update.name, update.target, 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 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 { sqliteStore2 };

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

@@ -0,0 +1,81 @@
+import {
+  answerRepair2
+} from "./canvas-preview-2zdyh9ny.js";
+import {
+  package_default
+} from "./canvas-preview-g3qj3y3k.js";
+
+// src/deploy/vercel/server/utils/host.ts
+import process from "node:process";
+import { createModels } from "@nyte-ai/ai/models";
+import { SdkError } from "@nyte-ai/schema";
+import { composeHost } from "@nyte-ai/core/server";
+import { postgresStore } from "@nyte-ai/host";
+import { credentialStore } from "@nyte-ai/host/credentials";
+import { seedSigner } from "@nyte-ai/host/identity";
+import { listenFetch } from "@nyte-ai/host/listen-fetch";
+import { sandboxProvider } from "@nyte-ai/host/providers";
+var PAGE = 100;
+var boot = async () => {
+  throw new SdkError("unavailable", "Supply a boot over your sandbox SDK in server/utils/host.ts.");
+};
+var building = null;
+function vercelHost2(dispatch) {
+  const built = building ??= build(dispatch);
+  built.catch(() => {
+    if (building === built)
+      building = null;
+  });
+  return built;
+}
+async function build(dispatch) {
+  const connectionString = process.env.DATABASE_URL;
+  if (connectionString === undefined || connectionString === "")
+    throw new SdkError("unavailable", "Set DATABASE_URL to the Postgres database the host keeps.");
+  const identityKey = process.env.NYTE_IDENTITY_KEY;
+  const store = postgresStore({ connectionString });
+  const secrets = secretsFrom(process.env.NYTE_SECRET_KEY);
+  const description = { name: "nyte-host", platform: "vercel", version: package_default.version };
+  const host = await composeHost({
+    store,
+    models: createModels({ credentials: credentialStore(store, secrets) }),
+    plugins: [{ id: "sandbox", environment: sandboxProvider({ boot }) }],
+    workspace: { kind: "sandbox", locator: { name: process.env.NYTE_SANDBOX ?? "nyte" } },
+    execution: { kind: "dispatch", dispatch },
+    poll: 1000,
+    secrets,
+    home: null,
+    description
+  });
+  const repair = async () => {
+    let cursor;
+    do {
+      const page = await host.execution.repair({ cursor, limit: PAGE });
+      cursor = page.next ?? undefined;
+    } while (cursor !== undefined);
+  };
+  const listener = await listenFetch(host, {
+    transport: { kind: "fetch" },
+    auth: { kind: "token", token: process.env.NYTE_TOKEN ?? "" },
+    execution: { kind: "admit-only" },
+    describe: () => description,
+    ...identityKey === undefined || identityKey === "" ? {} : { identity: await seedSigner(host.hostId, Uint8Array.fromBase64(identityKey)) },
+    before: (request) => answerRepair2(request, process.env.CRON_SECRET, repair)
+  }).catch(async (error) => {
+    await host.close();
+    throw error;
+  });
+  return { host, listener };
+}
+function secretsFrom(key) {
+  if (key === undefined || key === "")
+    return {
+      key: async () => {
+        throw new SdkError("unavailable", "Set NYTE_SECRET_KEY to a base64 32-byte key.");
+      }
+    };
+  const bytes = new Uint8Array(Buffer.from(key, "base64"));
+  return { key: async () => bytes };
+}
+
+export { vercelHost2 };

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

@@ -0,0 +1,156 @@
+// package.json
+var package_default = {
+  name: "@nyte-ai/host",
+  version: "0.0.18",
+  private: false,
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/interfaces-lab/nyte.git",
+    directory: "packages/host"
+  },
+  files: [
+    "dist",
+    "src",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  type: "module",
+  exports: {
+    ".": "./src/index.ts",
+    "./canvas-preview": "./src/canvas-preview.ts",
+    "./credentials": "./src/credentials.ts",
+    "./durable-object": "./src/durable-object.ts",
+    "./identity": "./src/identity.ts",
+    "./listen-fetch": "./src/listen-fetch.ts",
+    "./providers": "./src/providers.ts",
+    "./secrets": "./src/secrets.ts",
+    "./shell-env": "./src/shell-env.ts",
+    "./usage": "./src/usage.ts",
+    "./store-usage": "./src/store-usage.ts",
+    "./usage-service": "./src/usage-service.ts",
+    "./usage-scan": "./src/usage-scan.ts",
+    "./usage-worker": "./src/usage-worker.ts",
+    "./deploy/cloudflare": "./src/deploy/cloudflare/worker.ts",
+    "./deploy/vercel": "./src/deploy/vercel/nitro.config.ts"
+  },
+  publishConfig: {
+    exports: {
+      ".": {
+        types: "./dist/src/index.d.ts",
+        import: "./dist/src/index.js"
+      },
+      "./canvas-preview": {
+        types: "./dist/src/canvas-preview.d.ts",
+        import: "./dist/src/canvas-preview.js"
+      },
+      "./credentials": {
+        types: "./dist/src/credentials.d.ts",
+        import: "./dist/src/credentials.js"
+      },
+      "./durable-object": {
+        types: "./dist/src/durable-object.d.ts",
+        import: "./dist/src/durable-object.js"
+      },
+      "./identity": {
+        types: "./dist/src/identity.d.ts",
+        import: "./dist/src/identity.js"
+      },
+      "./listen-fetch": {
+        types: "./dist/src/listen-fetch.d.ts",
+        import: "./dist/src/listen-fetch.js"
+      },
+      "./providers": {
+        types: "./dist/src/providers.d.ts",
+        import: "./dist/src/providers.js"
+      },
+      "./secrets": {
+        types: "./dist/src/secrets.d.ts",
+        import: "./dist/src/secrets.js"
+      },
+      "./shell-env": {
+        types: "./dist/src/shell-env.d.ts",
+        import: "./dist/src/shell-env.js"
+      },
+      "./usage": {
+        types: "./dist/src/usage.d.ts",
+        import: "./dist/src/usage.js"
+      },
+      "./store-usage": {
+        types: "./dist/src/store-usage.d.ts",
+        import: "./dist/src/store-usage.js"
+      },
+      "./usage-service": {
+        types: "./dist/src/usage-service.d.ts",
+        import: "./dist/src/usage-service.js"
+      },
+      "./usage-scan": {
+        types: "./dist/src/usage-scan.d.ts",
+        import: "./dist/src/usage-scan.js"
+      },
+      "./usage-worker": {
+        types: "./dist/src/usage-worker.d.ts",
+        import: "./dist/src/usage-worker.js"
+      },
+      "./deploy/cloudflare": {
+        types: "./dist/src/deploy/cloudflare/worker.d.ts",
+        import: "./dist/src/deploy/cloudflare/worker.js"
+      },
+      "./deploy/vercel": {
+        types: "./dist/src/deploy/vercel/nitro.config.d.ts",
+        import: "./dist/src/deploy/vercel/nitro.config.js"
+      }
+    },
+    access: "public",
+    provenance: true
+  },
+  scripts: {
+    clean: "rm -rf node_modules .turbo",
+    typecheck: "tsgo --noEmit && tsgo --noEmit -p src/deploy/vercel",
+    test: "vitest --run",
+    "check:store": "node scripts/check-store.ts",
+    "compact:store": "node scripts/compact-store.ts",
+    "build:package": "bun ../../scripts/sdk-packages.mjs build host"
+  },
+  dependencies: {
+    "@earendil-works/pi-mcp": "1.3.0",
+    "@lydell/node-pty": "1.2.0-beta.15",
+    "@nyte-ai/ai": "workspace:*",
+    "@nyte-ai/core": "workspace:*",
+    "@nyte-ai/plugin": "workspace:*",
+    "@nyte-ai/protocol": "workspace:*",
+    "@nyte-ai/schema": "workspace:*",
+    fflate: "0.8.3",
+    ignore: "7.0.9",
+    pg: "8.23.0",
+    typebox: "1.3.36"
+  },
+  devDependencies: {
+    "@electric-sql/pglite": "0.5.8",
+    "@nyte-ai/canvas": "workspace:*",
+    "@types/node": "^26.6.5",
+    "@types/pg": "8.23.1",
+    "fast-check": "4.10.2",
+    nitro: "3.0.260903-beta",
+    typescript: "6.0.3",
+    vitest: "^5.0.5",
+    workflow: "4.8.8"
+  },
+  peerDependencies: {
+    nitro: "3.0.260903-beta",
+    workflow: "4.8.8"
+  },
+  peerDependenciesMeta: {
+    nitro: {
+      optional: true
+    },
+    workflow: {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=26.4.0"
+  }
+};
+
+export { package_default };

package/dist/chunks/canvas-preview-h8hshnff.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 (for the CLI, \`nyte service stop\`).`);
+      return found;
+    })
+  ]));
+}
+
+export { connectServer2, oauthSettings2 };