@nyte-ai/host 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,36 @@
+import {
+  vercelHost2
+} from "./canvas-preview-ewgspmsd.js";
+import {
+  stepFrom2
+} from "./canvas-preview-65xqjw7f.js";
+
+// src/deploy/vercel/server/workflows/drive.ts
+import { sleep } from "workflow";
+import { start } from "workflow/api";
+async function dispatchHead2(target) {
+  await start(driveHead2, [target]);
+}
+async function driveHead2(input) {
+  "use workflow";
+  for (;; ) {
+    const next = stepFrom2(await advanceHead2(input), Date.now());
+    if (next.kind === "stop")
+      return;
+    if (next.kind === "sleep")
+      await sleep(next.ms);
+  }
+}
+async function advanceHead2(input) {
+  "use step";
+  const { host } = await vercelHost2(dispatchHead2);
+  const coverage = await host.execution.cover({ kind: "sessions", sessions: [input.session] });
+  try {
+    await host.server.tick(Date.now());
+    return await host.execution.advance(input);
+  } finally {
+    await coverage.close();
+  }
+}
+
+export { dispatchHead2, driveHead2, advanceHead2 };

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-m02v4yy6.js

@@ -0,0 +1,386 @@
+// src/serve/binding.ts
+import { isJson, SdkError } from "@nyte-ai/schema";
+import { mapped, viewFrames } from "@nyte-ai/protocol";
+var LOGIN_LIFETIME = 10 * 60 * 1000;
+var attempts = new WeakMap;
+var holds = new WeakMap;
+function bindConnection2(connection, options) {
+  const { wire } = options.server;
+  const { principal } = connection;
+  const logins = attempts.get(options.server) ?? new Map;
+  attempts.set(options.server, logins);
+  const pages = holds.get(options.server) ?? new Map;
+  holds.set(options.server, pages);
+  const session = (id) => connection.session(id);
+  const workspace = (id) => connection.workspace(id);
+  const files = async (id) => available(await workspace(id).files(), "files");
+  const git = async (id) => available(await workspace(id).git(), "git");
+  const github = async (id) => available(await workspace(id).github(), "github");
+  const browser = async (id) => available(await workspace(id).browser(), "browser");
+  const findLogin = (provider) => logins.get(principalKey(principal, provider)) ?? fail("unknown", `No login for ${provider} is in progress.`);
+  const endLogin = (provider, attempt) => {
+    clearTimeout(attempt.timer);
+    const key = principalKey(principal, provider);
+    if (logins.get(key) === attempt)
+      logins.delete(key);
+    attempt.steps?.return?.();
+  };
+  const hold = (page) => {
+    const key = principalKey(principal, page.id);
+    const known = pages.get(key) ?? [];
+    pages.set(key, known.includes(page) ? known : [...known, page]);
+    return page;
+  };
+  const release = async (page) => {
+    const key = principalKey(principal, page);
+    const [last, ...rest] = [...pages.get(key) ?? []].reverse();
+    if (rest.length === 0)
+      pages.delete(key);
+    else
+      pages.set(key, rest.reverse());
+    await last?.close();
+  };
+  const findPage = async (at, id) => pages.get(principalKey(principal, id))?.[0] ?? wire.page(id) ?? hold(await (await browser(at)).adopt(id));
+  const describePage = async (page) => {
+    const view = await page.view();
+    return { id: page.id, url: view.url, title: view.title, holders: wire.holders(page.id) };
+  };
+  const findReceipt = (at, id) => at === null ? wire.batchReceipt(id) : session(at).receipt(id);
+  const startedJob = (job) => ({
+    ...wire.job(job.id) ?? fail("unknown", `Job ${job.id} is gone.`),
+    key: job.key
+  });
+  return {
+    "connection.watch": async () => mapped(connection.watch(), (view) => hostWire(view, principal)),
+    "connection.blob": async ({ id }) => ({ reader: await connection.blob(id) }),
+    "models.list": () => connection.models.list(),
+    "models.accounts": ({ provider }) => connection.models.accounts(provider),
+    "models.selectAccount": async ({ provider, account }) => {
+      await connection.models.selectAccount(provider, account);
+      return null;
+    },
+    "models.usage": () => connection.models.usage(),
+    "models.refresh": async ({ provider }) => {
+      await connection.models.refresh(provider);
+      return null;
+    },
+    "models.setDefault": ({ ref }) => connection.models.setDefault(ref),
+    "models.verify": ({ provider }) => connection.models.verify(provider),
+    "models.login": async (input) => {
+      const { provider } = input;
+      const login = connection.models.login(input);
+      const key = principalKey(principal, provider);
+      const previous = logins.get(key);
+      if (previous !== undefined)
+        endLogin(provider, previous);
+      const attempt = {
+        login,
+        steps: null,
+        timer: setTimeout(() => endLogin(provider, attempt), LOGIN_LIFETIME)
+      };
+      logins.set(key, attempt);
+      return null;
+    },
+    "models.logout": async ({ provider }) => {
+      await connection.models.logout(provider);
+      return null;
+    },
+    "login.steps": async ({ provider }) => {
+      const attempt = findLogin(provider);
+      if (attempt.steps !== null)
+        fail("invalid", `The login for ${provider} is already streaming.`);
+      const steps = attempt.login.steps()[Symbol.asyncIterator]();
+      attempt.steps = steps;
+      return {
+        [Symbol.asyncIterator]: () => ({
+          async next() {
+            const next = await steps.next();
+            if (next.done === true || next.value.kind === "done" || next.value.kind === "failed")
+              endLogin(provider, attempt);
+            return next;
+          },
+          async return() {
+            endLogin(provider, attempt);
+            return { done: true, value: undefined };
+          }
+        })
+      };
+    },
+    "login.answer": async ({ provider, code }) => {
+      await findLogin(provider).login.answer(code);
+      return null;
+    },
+    "settings.apply": ({ id, value }) => connection.settings.apply(id, value),
+    "workspaces.list": () => connection.workspaces.list(),
+    "workspaces.inspect": ({ target }) => connection.workspaces.inspect(target),
+    "workspaces.add": ({ target, options }) => connection.workspaces.add(target, options),
+    "workspaces.forget": ({ id }) => connection.workspaces.forget(id),
+    "sessions.watch": async (input) => connection.sessions.watch(input),
+    "sessions.start": async (input) => {
+      const { session, receipt } = await connection.sessions.start(input);
+      return { session: session.id, receipt: receipt.id, message: receipt.message };
+    },
+    "sessions.list": (input) => connection.sessions.list(input),
+    "session.info": ({ session: id }) => session(id).info(),
+    "session.update": ({ session: id, patch }) => session(id).update(patch),
+    "session.remove": ({ session: id }) => session(id).remove(),
+    "session.stop": ({ session: id }) => session(id).stop(),
+    "session.command": ({ session: id, name, text }) => session(id).command(name, text),
+    "session.completeCommand": ({ session: id, name, prefix }) => session(id).completeCommand(name, prefix),
+    "head.send": async ({ session: id, head, content, options }) => {
+      const receipt = await session(id).head(head).send(content, options);
+      return { receipt: receipt.id, message: receipt.message };
+    },
+    "head.configure": ({ session: id, head, patch }) => session(id).head(head).configure(patch),
+    "head.view": ({ session: id, head, options }) => session(id).head(head).view(options),
+    "head.watch": async ({ session: id, head, options }) => {
+      await session(id).info();
+      return viewFrames(session(id).head(head).watch(options));
+    },
+    "head.history": ({ session: id, head, before, limit }) => session(id).head(head).history({ before, limit }),
+    "head.tree": ({ session: id, head }) => session(id).head(head).tree(),
+    "head.move": async ({ session: id, head, position, options, id: receipt }) => ({
+      receipt: (await wire.move(id, head, position, { ...options, id: receipt })).id
+    }),
+    "head.compact": ({ session: id, head, instructions }) => session(id).head(head).compact({ instructions }),
+    "heads.create": ({ session: id, name, input }) => session(id).heads.create(name, input),
+    "heads.merge": ({ session: id, name, options }) => session(id).heads.merge(name, options),
+    "heads.remove": ({ session: id, name, options }) => session(id).heads.remove(name, options),
+    "run.stop": ({ session: id, run }) => session(id).run(run).stop(),
+    "run.settled": ({ session: id, run }, { signal }) => session(id).run(run).settled({ signal }),
+    "receipt.status": async ({ session: id, receipt }) => {
+      const status = await findReceipt(id, receipt)?.status() ?? { kind: "missing" };
+      return status.kind === "settled" ? { kind: "settled", outcome: toJson(status.outcome) } : status;
+    },
+    "receipt.settled": async ({ session: id, receipt }, { signal }) => {
+      const handle = findReceipt(id, receipt) ?? fail("unknown", `No receipt has the id ${receipt}.`);
+      return toJson(await handle.settled({ signal }));
+    },
+    "receipt.stop": async ({ session: id, receipt }) => {
+      const stopped = await findReceipt(id, receipt)?.stop() ?? { kind: "missing" };
+      return stopped.kind === "settled" ? { kind: "settled", outcome: toJson(stopped.outcome) } : stopped;
+    },
+    "receipt.landed": async ({ session: id, receipt }) => wire.sendReceipt(id ?? fail("invalid", "Only a send's receipt has landed."), receipt).landed(),
+    "parts.create": async ({ session: id, kind, input }) => {
+      const definition = await wire.partDefinition(id, kind) ?? fail("unknown", `No part definition has the kind ${kind}.`);
+      return { part: (await session(id).parts.create(definition, input)).id };
+    },
+    "part.update": ({ session: id, part, next, options }) => session(id).part(part).update(next, options),
+    "part.act": async ({ session: id, part, action, input }) => {
+      const outcome = await session(id).part(part).act(action, input);
+      return outcome.kind === "ok" ? { kind: "ok", output: toJson(outcome.output) } : outcome;
+    },
+    "part.answer": async ({ session: id, part }, { signal }) => {
+      const answer = await session(id).part(part).answer({ signal });
+      return answer === null ? null : { action: String(answer.action), input: toJson(answer.input) };
+    },
+    "part.close": async ({ session: id, part }) => {
+      await session(id).part(part).close();
+      return null;
+    },
+    "workspace.info": ({ workspace: id }) => workspace(id).info(),
+    "workspace.catalog": ({ workspace: id }) => workspace(id).catalog(),
+    "workspace.command": ({ workspace: id, name, text }) => workspace(id).command(name, text),
+    "workspace.completeCommand": ({ workspace: id, name, prefix }) => workspace(id).completeCommand(name, prefix),
+    "workspace.watch": async ({ workspace: id }) => workspace(id).watch(),
+    "mcp.watch": async ({ workspace: id }) => workspace(id).mcp.watch(),
+    "mcp.reconnect": ({ workspace: id, server }) => workspace(id).mcp.reconnect(server),
+    "mcp.setEnabled": ({ workspace: id, server, enabled }) => workspace(id).mcp.setEnabled(server, enabled),
+    "mcp.login": async ({ workspace: id, server }) => {
+      const login = JSON.stringify(["mcp", id, server]);
+      const previous = logins.get(principalKey(principal, login));
+      if (previous !== undefined)
+        endLogin(login, previous);
+      const attempt = {
+        login: workspace(id).mcp.login(server),
+        steps: null,
+        timer: setTimeout(() => endLogin(login, attempt), LOGIN_LIFETIME)
+      };
+      logins.set(principalKey(principal, login), attempt);
+      return { login };
+    },
+    "mcp.logout": ({ workspace: id, server }) => workspace(id).mcp.logout(server),
+    "mcp.add": ({ workspace: id, server, config, scope }) => workspace(id).mcp.add(server, config, scope),
+    "mcp.remove": ({ workspace: id, server, scope }) => workspace(id).mcp.remove(server, scope),
+    "workspace.update": ({ workspace: id, patch }) => workspace(id).update(patch),
+    "workspace.reload": ({ workspace: id }) => workspace(id).reload(),
+    "workspace.changes": ({ workspace: id, run }) => workspace(id).changes(run),
+    "workspace.patches": async ({ workspace: id, run, paths, options }) => mapped(workspace(id).patches(run, paths, options), patchesWire),
+    "workspace.files": async ({ workspace: id }) => capabilityWire(await workspace(id).files()),
+    "workspace.git": async ({ workspace: id }) => capabilityWire(await workspace(id).git()),
+    "workspace.github": async ({ workspace: id }) => capabilityWire(await workspace(id).github()),
+    "workspace.browser": async ({ workspace: id }) => capabilityWire(await workspace(id).browser()),
+    "jobs.start": async ({ workspace: id, command, session, title, pty, id: job }) => startedJob(await workspace(id).jobs.start({ command, session, title, pty, id: job })),
+    "jobs.recover": async ({ workspace: id, key }) => {
+      const recovered = await workspace(id).jobs.recover(key);
+      return "id" in recovered ? startedJob(recovered) : recovered;
+    },
+    "jobs.list": ({ workspace: id }) => workspace(id).jobs.list(),
+    "jobs.watch": async ({ workspace: id }) => jobChanges(workspace(id).jobs.watch()),
+    "job.write": async ({ workspace: id, job }, { body }) => {
+      await workspace(id).job(job).write(await readBytes(body));
+      return null;
+    },
+    "job.output": async ({ workspace: id, job }) => workspace(id).job(job).output(),
+    "job.resize": ({ workspace: id, job, size }) => workspace(id).job(job).resize(size),
+    "job.idle": ({ workspace: id, job }) => workspace(id).job(job).idle(),
+    "job.stop": ({ workspace: id, job }) => workspace(id).job(job).stop(),
+    "job.settled": ({ workspace: id, job }, { signal }) => workspace(id).job(job).settled({ signal }),
+    "files.read": async ({ workspace: id, path }) => (await files(id)).read(path),
+    "files.bytes": async ({ workspace: id, path }) => {
+      const reader = await (await files(id)).bytes(path);
+      const version = "version" in reader && typeof reader.version === "string" ? reader.version : null;
+      return version === null ? { reader } : { reader, headers: { "X-Nyte-Version": version } };
+    },
+    "files.stat": async ({ workspace: id, path }) => (await files(id)).stat(path),
+    "files.write": async ({ workspace: id, path, options }, { body }) => (await files(id)).write(path, await readBytes(body), options),
+    "files.remove": async ({ workspace: id, path, options }) => (await files(id)).remove(path, options),
+    "files.batch": async ({ workspace: id, entries, id: receipt }) => ({
+      receipt: (await wire.batch(id, await files(id), entries, receipt)).id
+    }),
+    "files.format": async ({ workspace: id, path, contents }) => (await files(id)).format(path, contents),
+    "files.scan": async ({ workspace: id, directory, ignored }) => (await files(id)).scan({ directory, ignored }),
+    "files.find": async ({ workspace: id, query, limit }) => (await files(id)).find({ query, limit }),
+    "files.search": async ({ workspace: id, ...input }) => (await files(id)).search(input),
+    "files.watch": async ({ workspace: id, paths }) => (await files(id)).watch({ paths }),
+    "files.upload": async ({ workspace: id }, { body }) => (await files(id)).upload(readChunks(body)),
+    "git.status": async ({ workspace: id }) => (await git(id)).status(),
+    "git.watch": async ({ workspace: id }) => (await git(id)).watch(),
+    "git.changes": async ({ workspace: id, scope, options }) => (await git(id)).changes(scope, options),
+    "git.watchChanges": async ({ workspace: id, scope, options }) => (await git(id)).watchChanges(scope, options),
+    "git.patches": async ({ workspace: id, scope, paths, options }) => mapped((await git(id)).patches(scope, paths, options), patchesWire),
+    "git.contents": async ({ workspace: id, path, scope }) => (await git(id)).contents(path, scope),
+    "git.log": async ({ workspace: id, cursor, limit }) => (await git(id)).log({ cursor, limit }),
+    "git.refs": async ({ workspace: id }) => (await git(id)).refs(),
+    "git.blame": async ({ workspace: id, path }) => (await git(id)).blame(path),
+    "git.stage": async ({ workspace: id, paths, options }) => (await git(id)).stage(paths, options),
+    "git.unstage": async ({ workspace: id, paths, options }) => (await git(id)).unstage(paths, options),
+    "git.discard": async ({ workspace: id, paths, options }) => (await git(id)).discard(paths, options),
+    "git.commit": async ({ workspace: id, input, options }) => (await git(id)).commit(input, options),
+    "git.branch": async ({ workspace: id, input, options }) => (await git(id)).branch(input, options),
+    "git.push": async ({ workspace: id, input, options }) => (await git(id)).push(input, options),
+    "github.account": () => connection.github.account(),
+    "github.signIn": () => connection.github.signIn(),
+    "github.signOut": () => connection.github.signOut(),
+    "github.state": async ({ workspace: id }) => (await github(id)).state(),
+    "github.createPullRequest": async ({ workspace: id, input }) => (await github(id)).createPullRequest(input),
+    "browser.open": async ({ workspace: id, url, id: key }) => {
+      const api = await browser(id);
+      return describePage(hold(await wire.openPage({
+        id: key,
+        input: { workspace: id, url },
+        open: () => api.open({ url })
+      })));
+    },
+    "browser.adopt": async ({ workspace: id, id: page }) => describePage(hold(await (await browser(id)).adopt(page))),
+    "browser.list": async ({ workspace: id }) => (await browser(id)).list(),
+    "browser.watch": async ({ workspace: id }) => (await browser(id)).watch(),
+    "page.view": async ({ workspace: id, page }) => (await findPage(id, page)).view(),
+    "page.watch": async ({ workspace: id, page }) => (await findPage(id, page)).watch(),
+    "page.snapshot": async ({ workspace: id, page, ref }) => (await findPage(id, page)).snapshot({ ref }),
+    "page.navigate": async ({ workspace: id, page, url }) => (await findPage(id, page)).navigate(url),
+    "page.back": async ({ workspace: id, page }) => (await findPage(id, page)).back(),
+    "page.forward": async ({ workspace: id, page }) => (await findPage(id, page)).forward(),
+    "page.reload": async ({ workspace: id, page }) => (await findPage(id, page)).reload(),
+    "page.stopLoading": async ({ workspace: id, page }) => (await findPage(id, page)).stopLoading(),
+    "page.click": async ({ workspace: id, page, ref, button, double, expect }) => (await findPage(id, page)).click({ ref, button, double, expect }),
+    "page.type": async ({ workspace: id, page, ref, text, clear, submit, expect }) => (await findPage(id, page)).type({ ref, text, clear, submit, expect }),
+    "page.press": async ({ workspace: id, page, key, ref }) => (await findPage(id, page)).press({ key, ref }),
+    "page.scroll": async ({ workspace: id, page, direction, ref, pages: count }) => (await findPage(id, page)).scroll({ direction, ref, pages: count }),
+    "page.wait": async ({ workspace: id, page, condition }) => (await findPage(id, page)).wait(condition),
+    "page.console": async ({ workspace: id, page, limit, clear }) => (await findPage(id, page)).console({ limit, clear }),
+    "page.capture": async ({ workspace: id, page }) => ({
+      reader: await (await findPage(id, page)).capture()
+    }),
+    "page.evaluate": async ({ workspace: id, page, expression, options }) => (await findPage(id, page)).evaluate(expression, options),
+    "page.close": async ({ page }) => {
+      await release(page);
+      return null;
+    },
+    "plugins.replace": ({ plugins, scope }) => connection.plugins.replace(plugins, scope),
+    "plugins.check": ({ plugins }) => connection.plugins.check(plugins),
+    "principals.list": async () => (await connection.principals.list()).map((view) => ({
+      ...view,
+      authority: [...view.authority]
+    })),
+    "principals.pair": ({ authority, label }) => connection.principals.pair({ authority: new Set(authority), label }),
+    "principals.revoke": async ({ id }) => {
+      await connection.principals.revoke(id);
+      return null;
+    }
+  };
+}
+async function* jobChanges(lists) {
+  let previous = null;
+  for await (const jobs of lists) {
+    if (previous === null)
+      yield { kind: "jobs", jobs };
+    else {
+      const kept = new Set(jobs.map((job) => job.id));
+      const unmoved = new Set(previous);
+      for (const job of previous)
+        if (!kept.has(job.id))
+          yield { kind: "forgotten", id: job.id };
+      for (const job of jobs)
+        if (!unmoved.has(job))
+          yield { kind: "job", job };
+    }
+    previous = jobs;
+  }
+}
+async function* readChunks(body) {
+  if (body === null)
+    return;
+  const reader = body.getReader();
+  try {
+    for (;; ) {
+      const read = await reader.read();
+      if (read.done)
+        return;
+      yield read.value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function readBytes(body) {
+  const chunks = [];
+  for await (const chunk of readChunks(body))
+    chunks.push(chunk);
+  const bytes = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function hostWire(view, principal) {
+  return { ...view, authority: [...view.authority], principal };
+}
+function patchesWire(set) {
+  return { revision: set.revision, entries: Object.fromEntries(set.entries) };
+}
+function capabilityWire(capability) {
+  if (capability.kind !== "available")
+    return capability;
+  return { kind: "available" };
+}
+function available(capability, what) {
+  if (capability.kind === "available")
+    return capability.api;
+  if (capability.kind === "denied")
+    fail("denied", `${what}: ${capability.reason}`);
+  return fail("unavailable", `${what}: ${capability.reason}`);
+}
+function toJson(value) {
+  return isJson(value) ? value : null;
+}
+function principalKey(principal, name) {
+  return JSON.stringify([principal, name]);
+}
+function fail(code, message) {
+  throw new SdkError(code, message);
+}
+
+export { bindConnection2 };