@nyte-ai/host 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,194 @@
+// src/mcp/config.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, realpath, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { isJsonObject, McpExposureNameType, McpOAuthConfigType } from "@nyte-ai/schema";
+import { isJson } from "@nyte-ai/schema";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var ExposureName = McpExposureNameType;
+var Entry = Type.Object({
+  type: Type.Optional(Type.Enum(["stdio", "http", "streamable-http", "sse"])),
+  command: Type.Optional(Type.String({ minLength: 1 })),
+  args: Type.Optional(Type.Array(Type.String())),
+  env: Type.Optional(Type.Record(Type.String(), Type.String())),
+  cwd: Type.Optional(Type.String()),
+  url: Type.Optional(Type.String({ minLength: 1 })),
+  headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+  oauth: Type.Optional(McpOAuthConfigType),
+  enabled: Type.Optional(Type.Boolean()),
+  timeout: Type.Optional(Type.Number({ exclusiveMinimum: 0 })),
+  description: Type.Optional(Type.String()),
+  exposure: Type.Optional(ExposureName),
+  toolExposure: Type.Optional(Type.Record(Type.String(), ExposureName))
+});
+var ConfigFile = Type.Object({
+  mcpServers: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+});
+var OVERRIDE_KEYS = new Set(["enabled", "exposure", "toolExposure"]);
+var EXPOSURE = {
+  direct: "model",
+  deferred: "deferred",
+  codemode: "code",
+  "codemode-deferred": "code",
+  hidden: "hidden"
+};
+async function readMcpFile2(path) {
+  try {
+    return { kind: "text", text: await readFile(path, "utf8") };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return { kind: "missing" };
+    return { kind: "unreadable", message: error instanceof Error ? error.message : String(error) };
+  }
+}
+function parseMcpConfig2(files) {
+  const servers = new Map;
+  const canonical = new Map;
+  const issues = [];
+  for (const file of files) {
+    if (file.contents.kind === "missing")
+      continue;
+    const fail = (path, message) => {
+      issues.push({
+        severity: "error",
+        path: ["mcpServers", ...path],
+        message,
+        source: { plugin: "mcp", file: file.path }
+      });
+    };
+    if (file.contents.kind === "unreadable") {
+      fail([], `The file cannot be read: ${file.contents.message}`);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(file.contents.text);
+    } catch (error) {
+      fail([], `The file is not valid JSON: ${error instanceof Error ? error.message : ""}`);
+      continue;
+    }
+    if (!Value.Check(ConfigFile, parsed)) {
+      fail([], 'The file must be an object with an "mcpServers" object.');
+      continue;
+    }
+    for (const [name, raw] of Object.entries(parsed.mcpServers ?? {})) {
+      if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+        fail([name], `Server names may contain only letters, digits, "_" and "-": ${name}.`);
+        continue;
+      }
+      const key = name.replaceAll("-", "_");
+      const taken = canonical.get(key);
+      if (taken !== undefined && taken !== name) {
+        fail([name], `${name} and ${taken} name the same server.`);
+        continue;
+      }
+      if (!Value.Check(Entry, raw)) {
+        const [first] = Value.Errors(Entry, raw);
+        fail([name], `${name}${first?.instancePath ?? ""} ${first?.message ?? "is invalid"}.`);
+        continue;
+      }
+      const base = servers.get(name);
+      if (raw.command === undefined && raw.url === undefined && raw.type === undefined) {
+        const extra = Object.keys(raw).filter((field) => !OVERRIDE_KEYS.has(field));
+        if (file.scope !== "project" || base === undefined)
+          fail([name], `${name} needs "command" or "url".`);
+        else if (extra.length > 0)
+          fail([name], `An override of ${name} can only set enabled, exposure and toolExposure.`);
+        else
+          servers.set(name, { ...base, ...settings(raw, base), override: file.path });
+        continue;
+      }
+      const transport = readTransport(raw);
+      if (typeof transport === "string") {
+        fail([name], `${name}: ${transport}`);
+        continue;
+      }
+      canonical.set(key, name);
+      servers.set(name, {
+        name,
+        scope: file.scope,
+        path: file.path,
+        override: null,
+        transport,
+        timeoutMs: (raw.timeout ?? 60) * 1000,
+        description: raw.description ?? null,
+        ...settings(raw, null)
+      });
+    }
+  }
+  return { servers, issues };
+}
+function readTransport(raw) {
+  if (raw.type === "sse")
+    return `the SSE transport is not supported; use the server's streamable HTTP url, often ending in "/mcp".`;
+  if (raw.command !== undefined && raw.url !== undefined)
+    return 'set "command" or "url", not both.';
+  if (raw.command !== undefined && raw.type !== undefined && raw.type !== "stdio")
+    return `type ${raw.type} needs "url", not "command".`;
+  if (raw.command !== undefined)
+    return {
+      kind: "stdio",
+      command: raw.command,
+      args: raw.args ?? [],
+      env: raw.env ?? {},
+      cwd: raw.cwd ?? null
+    };
+  if (raw.url === undefined)
+    return `type ${raw.type ?? "stdio"} needs "command" or "url".`;
+  if (raw.type === "stdio")
+    return 'type stdio needs "command", not "url".';
+  const url = URL.parse(raw.url);
+  if (url === null || url.protocol !== "https:" && url.protocol !== "http:")
+    return `${raw.url} is not an http or https URL.`;
+  if (raw.command === undefined && raw.oauth?.callbackUrl !== undefined) {
+    const callback = URL.parse(raw.oauth.callbackUrl);
+    if (callback === null || callback.protocol !== "http:" || !["localhost", "127.0.0.1", "[::1]"].includes(callback.hostname))
+      return "oauth.callbackUrl must be an http URL on localhost, 127.0.0.1 or [::1].";
+  }
+  if (raw.oauth?.authServerMetadataUrl !== undefined) {
+    const metadata = URL.parse(raw.oauth.authServerMetadataUrl);
+    if (metadata === null || metadata.protocol !== "https:" && !["localhost", "127.0.0.1", "[::1]"].includes(metadata.hostname))
+      return "oauth.authServerMetadataUrl must use https, except on localhost.";
+  }
+  return { kind: "http", url: raw.url, headers: raw.headers ?? {}, oauth: raw.oauth ?? {} };
+}
+function settings(raw, base) {
+  return {
+    enabled: raw.enabled ?? base?.enabled ?? true,
+    exposure: raw.exposure === undefined ? base?.exposure ?? "code" : EXPOSURE[raw.exposure],
+    toolExposure: raw.toolExposure === undefined ? base?.toolExposure ?? [] : Object.entries(raw.toolExposure).map(([pattern, name]) => [pattern, EXPOSURE[name]])
+  };
+}
+async function planMcpEdit2(path, change) {
+  const contents = await readMcpFile2(path);
+  if (contents.kind === "unreadable")
+    return { kind: "invalid", message: `${path} cannot be read: ${contents.message}` };
+  let parsed = {};
+  if (contents.kind === "text") {
+    try {
+      parsed = JSON.parse(contents.text);
+    } catch {
+      return { kind: "invalid", message: `${path} is not valid JSON; fix it first.` };
+    }
+  }
+  if (!isJson(parsed) || !isJsonObject(parsed))
+    return { kind: "invalid", message: `${path} is not a JSON object.` };
+  const servers = parsed.mcpServers ?? {};
+  if (!isJsonObject(servers))
+    return { kind: "invalid", message: `${path} has an "mcpServers" that is not an object.` };
+  const next = change(servers);
+  if (next === null)
+    return { kind: "missing" };
+  return { kind: "planned", text: `${JSON.stringify({ ...parsed, mcpServers: next }, null, 2)}
+` };
+}
+async function writeMcpFile2(path, text) {
+  const target = await realpath(path).catch(() => path);
+  const temporary = `${target}.${randomUUID()}.tmp`;
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(temporary, text, { mode: 384 });
+  await rename(temporary, target);
+}
+
+export { readMcpFile2, parseMcpConfig2, planMcpEdit2, writeMcpFile2 };

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

@@ -0,0 +1,12 @@
+// src/local/text.ts
+function decodeText2(bytes) {
+  if (bytes.includes(0))
+    return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+export { decodeText2 };

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

@@ -0,0 +1,141 @@
+// src/usage-history.ts
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { Type } from "typebox";
+function fileScanSchema2(scan) {
+  return Type.Object({
+    size: Type.Number({ minimum: 0 }),
+    mtimeMs: Type.Number(),
+    position: Type.Number({ minimum: 0 }),
+    committed: scan
+  });
+}
+
+class UsageScanCache2 {
+  #files;
+  #changed = false;
+  constructor(files = []) {
+    this.#files = new Map(files);
+  }
+  keys() {
+    return this.#files.keys();
+  }
+  entries() {
+    return this.#files.entries();
+  }
+  get(path) {
+    return this.#files.get(path);
+  }
+  set(path, scan) {
+    if (this.#files.get(path) === scan)
+      return;
+    this.#files.set(path, scan);
+    this.#changed = true;
+  }
+  keepOnly(seen) {
+    for (const path of this.#files.keys()) {
+      if (seen.has(path))
+        continue;
+      this.#files.delete(path);
+      this.#changed = true;
+    }
+  }
+  get changed() {
+    return this.#changed;
+  }
+  markSaved() {
+    this.#changed = false;
+  }
+}
+async function readHistory2(path, info, parser, cache, signal) {
+  const hit = cache?.get(path);
+  const unchanged = hit !== undefined && hit.size === info.size && hit.mtimeMs === info.mtimeMs;
+  if (unchanged && hit.position === info.size)
+    return hit.committed;
+  const from = unchanged || hit !== undefined && info.size > hit.size ? hit : undefined;
+  const fold = parser(from?.committed);
+  let position = from?.position ?? 0;
+  let unterminated;
+  for await (const line of historyLines(path, position, signal)) {
+    signal?.throwIfAborted();
+    if (!line.terminated) {
+      unterminated = line;
+      continue;
+    }
+    fold.line(line);
+    position = line.end;
+  }
+  const committed = fold.scan();
+  cache?.set(path, unchanged ? hit : { size: info.size, mtimeMs: info.mtimeMs, position, committed });
+  if (unterminated === undefined)
+    return committed;
+  fold.line(unterminated);
+  return fold.scan();
+}
+async function* historyLines(path, start, signal) {
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const stat = await file.stat();
+    if (!stat.isFile())
+      throw new Error("History is not a regular file.");
+    const buffer = Buffer.alloc(64 * 1024);
+    let pending = Buffer.alloc(0);
+    let pendingStart = start;
+    let position = start;
+    while (position < stat.size) {
+      signal?.throwIfAborted();
+      const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, stat.size - position), position);
+      if (bytesRead === 0)
+        break;
+      position += bytesRead;
+      const read = buffer.subarray(0, bytesRead);
+      const chunk = pending.length === 0 ? read : Buffer.concat([pending, read]);
+      let from = 0;
+      for (let newline = chunk.indexOf(10);newline !== -1; newline = chunk.indexOf(10, from)) {
+        yield {
+          text: chunk.toString("utf8", from, newline),
+          terminated: true,
+          end: pendingStart + newline + 1
+        };
+        from = newline + 1;
+      }
+      pendingStart += from;
+      pending = Buffer.from(chunk.subarray(from));
+    }
+    if (pending.length > 0)
+      yield {
+        text: pending.toString("utf8"),
+        terminated: false,
+        end: pendingStart + pending.length
+      };
+  } finally {
+    await file.close();
+  }
+}
+async function readCacheDocument2(path, validator) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    return validator.Check(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+async function writeCacheDocument2(path, document) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(temporary, JSON.stringify(document), { mode: 384 });
+    await rename(temporary, path);
+    return true;
+  } catch {
+    await rm(temporary, { force: true }).catch(() => {
+      return;
+    });
+    return false;
+  }
+}
+
+export { fileScanSchema2, UsageScanCache2, readHistory2, readCacheDocument2, writeCacheDocument2 };

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

@@ -0,0 +1,271 @@
+// src/local/tree.ts
+import { watch } from "node:fs";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import { basename, dirname, join, sep } from "node:path";
+import ignore from "ignore";
+var WALK_LIMIT2 = 50000;
+var WALK_PAGE = 500;
+function createIgnores2(root) {
+  const rules = new Map;
+  const loadRules = (directory) => {
+    const known = rules.get(directory);
+    if (known !== undefined)
+      return known;
+    const sources = [join(root, directory, ".gitignore")];
+    if (directory === "")
+      sources.push(join(root, ".git", "info", "exclude"));
+    const loaded = Promise.all(sources.map((source) => readFile(source, "utf8").catch(() => null))).then((texts) => {
+      const found = texts.filter((text) => text !== null);
+      return found.length === 0 ? null : found.reduce((matcher, text) => matcher.add(text), ignore());
+    });
+    rules.set(directory, loaded);
+    return loaded;
+  };
+  const matches = async (path, directory) => {
+    const segments = path.split("/");
+    if (segments.includes(".git"))
+      return true;
+    let result = false;
+    for (let depth = 0;depth < segments.length; depth += 1) {
+      const matcher = await loadRules(segments.slice(0, depth).join("/"));
+      if (matcher === null)
+        continue;
+      const relative = segments.slice(depth).join("/") + (directory ? "/" : "");
+      if (!ignore.isPathValid(relative.replace(/\/$/, "")))
+        continue;
+      const test = matcher.test(relative);
+      if (test.ignored)
+        result = true;
+      else if (test.unignored)
+        result = false;
+    }
+    return result;
+  };
+  return {
+    matches,
+    async ignored(path, directory) {
+      const segments = path.split("/");
+      for (let depth = 1;depth < segments.length; depth += 1)
+        if (await matches(segments.slice(0, depth).join("/"), true))
+          return true;
+      return matches(path, directory);
+    },
+    forget(directory) {
+      rules.delete(directory);
+    }
+  };
+}
+async function* walkTree2(root, options) {
+  const ignores = options.ignores ?? createIgnores2(root);
+  const limit = options.limit ?? WALK_LIMIT2;
+  const size = options.page ?? WALK_PAGE;
+  const queue = [trimSlashes(options.directory ?? "")];
+  let page = [];
+  let count = 0;
+  let denied = false;
+  for (let next = queue.shift();next !== undefined; next = queue.shift()) {
+    const directory = next;
+    const listed = await readdir(join(root, directory), { withFileTypes: true }).catch((error) => {
+      if (readErrorCode2(error) === "EACCES" || readErrorCode2(error) === "EPERM")
+        denied = true;
+      return null;
+    });
+    if (listed === null)
+      continue;
+    listed.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+    const entries = await Promise.all(listed.map(async (dirent) => {
+      const path = directory === "" ? dirent.name : `${directory}/${dirent.name}`;
+      const kind = dirent.isSymbolicLink() ? "symlink" : dirent.isDirectory() ? "directory" : dirent.isFile() ? "file" : null;
+      if (kind === null || dirent.name === ".git")
+        return null;
+      if (options.ignored === "exclude" && await ignores.matches(path, kind === "directory"))
+        return null;
+      if (kind === "directory")
+        return { path, kind, size: null };
+      const stats = await lstat(join(root, path)).catch(() => null);
+      return stats === null ? null : { path, kind, size: stats.size };
+    }));
+    for (const entry of entries) {
+      if (entry === null)
+        continue;
+      page.push(entry);
+      count += 1;
+      if (entry.kind === "directory")
+        queue.push(entry.path);
+      if (count >= limit) {
+        yield { kind: "entries", entries: page };
+        yield { kind: "incomplete", reason: "limit" };
+        return;
+      }
+      if (page.length >= size) {
+        yield { kind: "entries", entries: page };
+        page = [];
+      }
+    }
+  }
+  if (page.length > 0)
+    yield { kind: "entries", entries: page };
+  yield denied ? { kind: "incomplete", reason: "permission" } : { kind: "complete" };
+}
+function watchTree2(root, options, changed) {
+  let pending = new Set;
+  let timer = null;
+  let polling = null;
+  let watcher = null;
+  let fellBack = false;
+  let stopped = false;
+  const flush = () => {
+    timer = null;
+    const paths = pending;
+    pending = new Set;
+    if (!stopped && paths.size > 0)
+      changed(paths);
+  };
+  const note = (path) => {
+    pending.add(path);
+    timer ??= setTimeout(flush, options.delay);
+  };
+  const poll = (every) => {
+    let known = null;
+    const tick = async () => {
+      const seen = new Map;
+      for await (const frame of walkTree2(root, { ignored: "include" }))
+        if (frame.kind === "entries")
+          for (const entry of frame.entries) {
+            const stats = await lstat(join(root, entry.path)).catch(() => null);
+            seen.set(entry.path, stats === null ? "" : `${stats.size}:${stats.mtimeMs}`);
+          }
+      if (known !== null) {
+        for (const [path, stamp] of seen)
+          if (known.get(path) !== stamp)
+            note(path);
+        for (const path of known.keys())
+          if (!seen.has(path))
+            note(path);
+      }
+      known = seen;
+    };
+    const again = () => {
+      if (stopped)
+        return;
+      polling = setTimeout(() => {
+        tick().then(again, again);
+      }, every);
+    };
+    tick().then(again, again);
+  };
+  const fallback = () => {
+    watcher?.close();
+    watcher = null;
+    if (stopped || fellBack)
+      return;
+    fellBack = true;
+    options.unwatched?.();
+    if (options.poll !== null)
+      poll(options.poll);
+  };
+  try {
+    watcher = watch(root, { recursive: true }, (_event, filename) => note(filename === null ? "" : filename.split(sep).join("/")));
+    watcher.on("error", fallback);
+  } catch {
+    fallback();
+  }
+  return () => {
+    stopped = true;
+    watcher?.close();
+    if (timer !== null)
+      clearTimeout(timer);
+    if (polling !== null)
+      clearTimeout(polling);
+  };
+}
+function watchPath2(target, options, changed) {
+  let pending = new Set;
+  let timer = null;
+  let watchers = [];
+  let generation = 0;
+  let moved = false;
+  let stopped = false;
+  const flush = () => {
+    timer = null;
+    const paths = pending;
+    pending = new Set;
+    if (stopped)
+      return;
+    if (moved) {
+      moved = false;
+      arm();
+    }
+    if (paths.size > 0)
+      changed(paths);
+  };
+  const note = (path, replaced) => {
+    pending.add(path);
+    moved ||= replaced;
+    timer ??= setTimeout(flush, options.delay);
+  };
+  const listen = (at, recursive, heard) => {
+    try {
+      const watcher = watch(at, { recursive, persistent: false }, (event, name) => heard(event, name === null ? null : name.split(sep).join("/")));
+      watcher.on("error", () => note("", true));
+      watchers.push(watcher);
+    } catch {}
+  };
+  const arm = async () => {
+    generation += 1;
+    const armed = generation;
+    for (const watcher of watchers)
+      watcher.close();
+    watchers = [];
+    let existing = target;
+    let missing = null;
+    let stats = await lstat(existing).catch(() => null);
+    while (stats === null) {
+      const parent = dirname(existing);
+      if (parent === existing)
+        return;
+      missing = basename(existing);
+      existing = parent;
+      stats = await lstat(existing).catch(() => null);
+    }
+    if (stopped || armed !== generation)
+      return;
+    if (missing !== null) {
+      const awaited = missing;
+      if (stats.isDirectory())
+        listen(existing, false, (_event, name) => {
+          if (name === null || name === awaited)
+            note("", true);
+        });
+      return;
+    }
+    if (!stats.isDirectory()) {
+      listen(target, false, (event) => note("", event === "rename"));
+      return;
+    }
+    const own = basename(target);
+    listen(target, true, (_event, name) => note(name ?? "", false));
+    listen(dirname(target), false, (event, name) => {
+      if (name === null || name === own)
+        note("", event === "rename");
+    });
+  };
+  arm();
+  return () => {
+    stopped = true;
+    generation += 1;
+    for (const watcher of watchers)
+      watcher.close();
+    watchers = [];
+    if (timer !== null)
+      clearTimeout(timer);
+  };
+}
+function readErrorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+function trimSlashes(path) {
+  return path.replace(/\\/g, "/").replace(/^\.?\/+|\/+$/g, "").replace(/^\.$/, "");
+}
+
+export { WALK_LIMIT2, createIgnores2, walkTree2, watchTree2, watchPath2, readErrorCode2 };

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

@@ -0,0 +1,81 @@
+import {
+  answerRepair2
+} from "./canvas-preview-2zdyh9ny.js";
+import {
+  package_default
+} from "./canvas-preview-jeddjex8.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 };