@nyte-ai/host 0.0.0-stage → 0.0.18

package/src/canvas-preview.ts

@@ -0,0 +1,402 @@
+/**
+ * The canvas previewer for a host without Electron: a headless Chromium
+ * already on this machine, driven over the DevTools protocol on a pipe, so
+ * nothing new is installed and no debugging port is opened. Each preview
+ * starts its own browser with a throwaway profile and stops it after. The
+ * page loads the shell directory the chat serves, from a made-up https
+ * origin the previewer answers itself under the chat's shell policy and
+ * frame sandbox; every other request is refused, no host name resolves,
+ * WebRTC may only go through a proxy that leads nowhere, and permission
+ * prompts are denied, so the canvas stays as sealed as in the chat.
+ */
+import { spawn } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { Readable, Writable } from "node:stream";
+import { runCanvasPreview } from "@nyte-ai/plugin/core/canvas-preview";
+import type {
+  CanvasPreviewOutcome,
+  CanvasPreviewPage,
+  CanvasPreviewRequest,
+  CanvasPreviewer,
+} from "@nyte-ai/plugin/core/canvas-preview";
+import { Type } from "typebox";
+import type { TSchema } from "typebox";
+import { Value } from "typebox/value";
+
+const ORIGIN = "https://canvas.preview/";
+
+/**
+ * Returns the shell a previewer serves: every file of the canvas package's
+ * `dist/shell`, base64 by its path from it (`index.html`,
+ * `libraries/three.js`), as `@nyte-ai/canvas/shell-files` exports them.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export type CanvasShellFiles = Readonly<Record<string, string>>;
+
+/** The policy the chat's clients serve the shell's page under, plus the sandbox its frame adds there, so the top-level page gets the frame's opaque origin. */
+const SHELL_POLICY =
+  "default-src 'none'; script-src 'self' blob:; style-src 'self' 'unsafe-inline'; img-src data: blob:; font-src 'self'; connect-src 'none'; base-uri 'none'; form-action 'none'; sandbox allow-scripts";
+
+const SHELL_TYPES = new Map([
+  ["html", "text/html; charset=utf-8"],
+  ["js", "text/javascript; charset=utf-8"],
+  ["css", "text/css; charset=utf-8"],
+  ["woff2", "font/woff2"],
+]);
+
+/** The newest browser of `prefix` in Playwright's download cache, which the canvas package's own checks install. */
+function playwrightBrowser(prefix: string, executables: readonly string[]): string | undefined {
+  const cache =
+    process.env["PLAYWRIGHT_BROWSERS_PATH"] ??
+    (process.platform === "darwin"
+      ? join(homedir(), "Library", "Caches", "ms-playwright")
+      : process.platform === "win32"
+        ? join(process.env["LOCALAPPDATA"] ?? homedir(), "ms-playwright")
+        : join(homedir(), ".cache", "ms-playwright"));
+
+  if (!existsSync(cache)) return undefined;
+  const versions = readdirSync(cache)
+    .filter((name) => name.startsWith(`${prefix}-`))
+    .toSorted(
+      (left, right) =>
+        Number(right.slice(prefix.length + 1)) - Number(left.slice(prefix.length + 1)),
+    );
+
+  return versions
+    .flatMap((version) => executables.map((executable) => join(cache, version, executable)))
+    .find((path) => existsSync(path));
+}
+
+/**
+ * Finds a Chromium to preview with: `NYTE_CANVAS_CHROMIUM`, then
+ * Playwright's headless shell or Chromium, then an installed Chrome or
+ * Chromium. Undefined when there is none.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export function findChromium(): string | undefined {
+  const named = process.env["NYTE_CANVAS_CHROMIUM"];
+
+  if (named !== undefined && named !== "") return existsSync(named) ? named : undefined;
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+
+  return (
+    playwrightBrowser("chromium_headless_shell", [
+      `chrome-headless-shell-mac-${arch}/chrome-headless-shell`,
+      "chrome-headless-shell-linux64/chrome-headless-shell",
+      "chrome-headless-shell-win64/chrome-headless-shell.exe",
+    ]) ??
+    playwrightBrowser("chromium", [
+      `chrome-mac-${arch}/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing`,
+      "chrome-mac/Chromium.app/Contents/MacOS/Chromium",
+      "chrome-linux64/chrome",
+      "chrome-linux/chrome",
+      "chrome-win64/chrome.exe",
+    ]) ??
+    [
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+      "/Applications/Chromium.app/Contents/MacOS/Chromium",
+      "/usr/bin/google-chrome",
+      "/usr/bin/google-chrome-stable",
+      "/usr/bin/chromium",
+      "/usr/bin/chromium-browser",
+      join(
+        process.env["PROGRAMFILES"] ?? "C:\\Program Files",
+        "Google/Chrome/Application/chrome.exe",
+      ),
+    ].find((path) => existsSync(path))
+  );
+}
+
+const Reply = Type.Object({
+  id: Type.Number(),
+  result: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+  error: Type.Optional(Type.Object({ message: Type.String() })),
+});
+
+const Event = Type.Object({
+  method: Type.String(),
+  params: Type.Record(Type.String(), Type.Unknown()),
+  sessionId: Type.Optional(Type.String()),
+});
+
+const Paused = Type.Object({
+  requestId: Type.String(),
+  request: Type.Object({ url: Type.String() }),
+});
+
+function read<S extends TSchema>(schema: S, value: unknown, what: string) {
+  if (!Value.Check(schema, value)) throw new Error(`Chromium answered ${what} unreadably.`);
+
+  return value;
+}
+
+/** One DevTools connection over Chromium's pipe: NUL-terminated JSON both ways. */
+class Pipe {
+  readonly #write: Writable;
+  readonly #waiting = new Map<
+    number,
+    { resolve(value: unknown): void; reject(error: Error): void }
+  >();
+  readonly #listeners = new Set<(method: string, params: Record<string, unknown>) => void>();
+  #next = 0;
+  #buffer = "";
+  #closed: Error | undefined;
+
+  constructor(write: Writable, readable: Readable) {
+    this.#write = write;
+    readable.setEncoding("utf8");
+    readable.on("data", (chunk: string) => this.#receive(chunk));
+    readable.on("close", () => this.close(new Error("Chromium closed its DevTools pipe.")));
+    write.on("error", (error: Error) => this.close(error));
+  }
+
+  send(method: string, params: Record<string, unknown> = {}, sessionId?: string): Promise<unknown> {
+    if (this.#closed !== undefined) return Promise.reject(this.#closed);
+    this.#next += 1;
+    const id = this.#next;
+
+    return new Promise((resolve, reject) => {
+      this.#waiting.set(id, { resolve, reject });
+      this.#write.write(`${JSON.stringify({ id, method, params, sessionId })}\0`);
+    });
+  }
+
+  listen(listener: (method: string, params: Record<string, unknown>) => void): void {
+    this.#listeners.add(listener);
+  }
+
+  close(error: Error): void {
+    this.#closed ??= error;
+
+    for (const waiting of this.#waiting.values()) waiting.reject(error);
+    this.#waiting.clear();
+  }
+
+  #receive(chunk: string): void {
+    this.#buffer += chunk;
+    const messages = this.#buffer.split("\0");
+    this.#buffer = messages.pop() ?? "";
+
+    for (const text of messages) {
+      const message: unknown = JSON.parse(text);
+
+      if (Value.Check(Reply, message)) {
+        const waiting = this.#waiting.get(message.id);
+        this.#waiting.delete(message.id);
+
+        if (message.error === undefined) waiting?.resolve(message.result ?? {});
+        else waiting?.reject(new Error(message.error.message));
+      } else if (Value.Check(Event, message))
+        for (const listener of this.#listeners) listener(message.method, message.params);
+    }
+  }
+}
+
+/** Answers the page's requests: the shell's files from memory, nothing else at all. */
+function serve(pipe: Pipe, shell: CanvasShellFiles, sessionId: string): void {
+  pipe.listen((method, params) => {
+    if (method !== "Fetch.requestPaused" || !Value.Check(Paused, params)) return;
+    const { requestId, request } = params;
+    const requested = request.url.startsWith(ORIGIN)
+      ? request.url.slice(ORIGIN.length).split(/[?#]/u)[0]
+      : undefined;
+    const path = requested === "" ? "index.html" : requested;
+    const body = path !== undefined && Object.hasOwn(shell, path) ? shell[path] : undefined;
+    const type = SHELL_TYPES.get(path?.split(".").at(-1) ?? "");
+
+    if (path === undefined || body === undefined || type === undefined) {
+      void pipe
+        .send("Fetch.failRequest", { requestId, errorReason: "BlockedByClient" }, sessionId)
+        .catch(() => undefined);
+
+      return;
+    }
+
+    void pipe
+      .send(
+        "Fetch.fulfillRequest",
+        {
+          requestId,
+          responseCode: 200,
+          responseHeaders: [
+            { name: "Content-Type", value: type },
+            { name: "Access-Control-Allow-Origin", value: "*" },
+            ...(path === "index.html"
+              ? [{ name: "Content-Security-Policy", value: SHELL_POLICY }]
+              : []),
+          ],
+          body,
+        },
+        sessionId,
+      )
+      .catch(() => undefined);
+  });
+}
+
+async function previewIn(
+  pipe: Pipe,
+  shell: CanvasShellFiles,
+  request: CanvasPreviewRequest,
+): Promise<CanvasPreviewOutcome> {
+  const target = read(
+    Type.Object({ targetId: Type.String() }),
+    await pipe.send("Target.createTarget", { url: "about:blank" }),
+    "a new page",
+  );
+  const { sessionId } = read(
+    Type.Object({ sessionId: Type.String() }),
+    await pipe.send("Target.attachToTarget", { targetId: target.targetId, flatten: true }),
+    "an attach",
+  );
+  const send = (method: string, params: Record<string, unknown> = {}) =>
+    pipe.send(method, params, sessionId);
+  serve(pipe, shell, sessionId);
+  const loaded = new Promise<void>((resolve) =>
+    pipe.listen((method) => {
+      if (method === "Page.loadEventFired") resolve();
+    }),
+  );
+  await send("Fetch.enable", { patterns: [{ urlPattern: "*" }] });
+  await send("Page.enable");
+  await send("Page.navigate", { url: ORIGIN });
+  await loaded;
+
+  const page: CanvasPreviewPage = {
+    async evaluate(expression) {
+      const answer = read(
+        Type.Object({
+          result: Type.Object({ value: Type.Optional(Type.Unknown()) }),
+          exceptionDetails: Type.Optional(Type.Object({ text: Type.String() })),
+        }),
+        await send("Runtime.evaluate", { expression, awaitPromise: true, returnByValue: true }),
+        "an evaluation",
+      );
+
+      if (answer.exceptionDetails !== undefined)
+        throw new Error(`The preview page threw: ${answer.exceptionDetails.text}`);
+
+      return answer.result.value;
+    },
+    async resize(width, height) {
+      await send("Emulation.setDeviceMetricsOverride", {
+        width,
+        height,
+        deviceScaleFactor: 1,
+        mobile: false,
+      });
+    },
+    async capture() {
+      const { data } = read(
+        Type.Object({ data: Type.String() }),
+        await send("Page.captureScreenshot", { format: "png" }),
+        "a screenshot",
+      );
+
+      return new Uint8Array(Buffer.from(data, "base64"));
+    },
+  };
+
+  return { kind: "rendered", report: await runCanvasPreview(page, request) };
+}
+
+function stop(child: ChildProcess): Promise<void> {
+  if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
+
+  return new Promise((resolve) => {
+    const kill = setTimeout(() => child.kill("SIGKILL"), 2000);
+    child.once("exit", () => {
+      clearTimeout(kill);
+      resolve();
+    });
+    child.kill();
+  });
+}
+
+/**
+ * Returns a previewer over a headless Chromium on this machine
+ * (`findChromium`), serving `shell`; it answers `unavailable` when there is
+ * no Chromium or it fails to start, and stops the browser when the
+ * preview's signal aborts.
+ *
+ * @category host
+ * @since 0.1.0
+ */
+export function chromiumCanvasPreview(
+  shell: CanvasShellFiles,
+  executable: () => string | undefined = findChromium,
+): CanvasPreviewer {
+  return async (request, signal) => {
+    const path = executable();
+
+    if (path === undefined)
+      return {
+        kind: "unavailable",
+        reason: "No Chrome or Chromium was found on this machine.",
+      };
+    const profile = await mkdtemp(join(tmpdir(), "nyte-canvas-preview-"));
+    const child = spawn(
+      path,
+      [
+        "--headless",
+        "--remote-debugging-pipe",
+        `--user-data-dir=${profile}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-extensions",
+        "--disable-background-networking",
+        "--disable-sync",
+        "--mute-audio",
+        "--deny-permission-prompts",
+        "--force-webrtc-ip-handling-policy=disable_non_proxied_udp",
+        "--webrtc-ip-handling-policy=disable_non_proxied_udp",
+        "--proxy-server=socks5://127.0.0.1:9",
+        "--proxy-bypass-list=<-loopback>",
+        "--host-resolver-rules=MAP * ~NOTFOUND",
+        "--hide-scrollbars",
+        "--enable-unsafe-swiftshader",
+        "--use-mock-keychain",
+        "--password-store=basic",
+        "about:blank",
+      ],
+      { stdio: ["ignore", "ignore", "ignore", "pipe", "pipe"] },
+    );
+    const [, , , input, output] = child.stdio;
+
+    try {
+      if (!(input instanceof Writable) || !(output instanceof Readable))
+        return { kind: "unavailable", reason: "Chromium did not open its DevTools pipe." };
+      const pipe = new Pipe(input, output);
+      child.once("error", (error) => pipe.close(error));
+      const stopped = Promise.withResolvers<never>();
+      const stop = (): void => stopped.reject(new Error("The preview was stopped."));
+      signal.addEventListener("abort", stop, { once: true });
+
+      try {
+        signal.throwIfAborted();
+
+        return await Promise.race([previewIn(pipe, shell, request), stopped.promise]);
+      } catch (error) {
+        return {
+          kind: "unavailable",
+          reason: `Chromium could not render the preview: ${error instanceof Error ? error.message : String(error)}`,
+        };
+      } finally {
+        signal.removeEventListener("abort", stop);
+        void pipe.send("Browser.close").catch(() => undefined);
+        pipe.close(new Error("The preview finished."));
+      }
+    } finally {
+      await stop(child);
+      await rm(profile, { recursive: true, force: true });
+    }
+  };
+}

package/src/credentials.ts

@@ -0,0 +1,294 @@
+import { readCredentialAccounts } from "@nyte-ai/ai/auth/types";
+import type { CredentialAccounts, CredentialStore } from "@nyte-ai/ai/auth/types";
+import { SdkError } from "@nyte-ai/schema";
+import { keyedSerial } from "@nyte-ai/schema/serial";
+import type { Json, Ref } from "@nyte-ai/schema";
+import { decodeKvValue, envelope, kvRef } from "@nyte-ai/core/store";
+import type { Store, StoreConnection } from "@nyte-ai/core";
+import { Type } from "typebox";
+import type { Static } from "typebox";
+import { Value } from "typebox/value";
+import type { SecretsSource } from "./secrets.ts";
+
+const SealedCredentialSchema = Type.Union([
+  Type.Object({
+    type: Type.Union([Type.Literal("api_key"), Type.Literal("oauth")]),
+    iv: Type.String(),
+    ciphertext: Type.String(),
+  }),
+  Type.Object({
+    active: Type.Union([Type.String(), Type.Null()]),
+    accounts: Type.Array(
+      Type.Object({
+        id: Type.String({ minLength: 1 }),
+        label: Type.String({ minLength: 1 }),
+        type: Type.Union([Type.Literal("api_key"), Type.Literal("oauth")]),
+      }),
+    ),
+    iv: Type.String(),
+    ciphertext: Type.String(),
+  }),
+]);
+
+export type SealedCredential = Static<typeof SealedCredentialSchema>;
+
+const PREFIX = kvRef("secret", "models", "");
+
+const RETRIES = 5;
+
+/**
+ * Returns `@nyte-ai/ai`'s `CredentialStore` over a host `Store`, so a host's
+ * model logins live with its sessions and pass to
+ * `createModels({ credentials })` (§42e); a Durable Object and a Vercel
+ * instance keep theirs.
+ *
+ * Each call opens a store connection and closes it when done; the `Store` is
+ * the caller's. `read` is `unsealCredential` over the record, `list` answers
+ * non-secret account metadata per ref under `kv/secret/models/`, `modify` is
+ * `modifyCredential`, and `delete` sets the ref to null, serialised as
+ * `modify` is. Building it touches nothing, `list` never calls `key()` and
+ * `read` calls it only when that provider's record exists (§50b, §55); the
+ * imported key is kept once `key()` resolves, a rejection is not (§43k). While `key()` rejects (a deploy
+ * without `NYTE_SECRET_KEY`), `read` answers undefined, `list` and `delete`
+ * work (they need no key) and `modify` rejects that error, so provider keys
+ * from the environment still resolve and logins answer `unavailable`. Web
+ * Crypto only, no `node:*` (the `./credentials` subpath).
+ */
+export function credentialStore(store: Store, secrets: SecretsSource): CredentialStore {
+  let key: Promise<CryptoKey> | null = null;
+  const writes = keyedSerial<string>();
+
+  const readKey = (): Promise<CryptoKey> => {
+    const known = key ?? importedKey(secrets);
+
+    key = known;
+    known.catch(() => {
+      if (key === known) key = null;
+    });
+
+    return known;
+  };
+
+  const serialised = <T>(
+    provider: string,
+    signal: AbortSignal | undefined,
+    task: () => Promise<T>,
+  ): Promise<T> =>
+    writes.run(provider, () => {
+      signal?.throwIfAborted();
+
+      return task();
+    });
+
+  return {
+    async read(provider, options) {
+      options?.signal?.throwIfAborted();
+      const { sealed } = await connected(store, (connection) => recordAt(connection, provider));
+
+      if (sealed === null) return undefined;
+      const unlocked = await readKey().catch(() => null);
+
+      return unlocked === null ? undefined : unsealCredential(unlocked, sealed);
+    },
+    async list(options) {
+      options?.signal?.throwIfAborted();
+
+      return connected(store, async (connection) => {
+        const refs = await connection.refs.list(PREFIX);
+
+        const rows = await Promise.all(
+          refs.map(async (ref) => {
+            const sealed =
+              ref.target === null
+                ? null
+                : readSealedCredential(decodeKvValue(await connection.objects.get(ref.target)));
+
+            if (sealed === null) return [];
+            const providerId = ref.name.slice(PREFIX.length);
+
+            if ("type" in sealed)
+              return [
+                { providerId, id: "default", label: "Default", type: sealed.type, active: true },
+              ];
+
+            return sealed.accounts.map((account) => ({
+              providerId,
+              ...account,
+              active: sealed.active === account.id,
+            }));
+          }),
+        );
+
+        return rows.flat();
+      });
+    },
+    modify(provider, fn, options) {
+      return serialised(provider, options?.signal, async () =>
+        modifyCredential(store, await readKey(), provider, fn, options?.signal),
+      );
+    },
+    delete(provider, options) {
+      return serialised(provider, options?.signal, () =>
+        connected(store, async (connection) => {
+          await connection.refs.set([{ name: kvRef("secret", "models", provider), target: null }]);
+        }),
+      );
+    },
+  };
+}
+
+/** Returns `plain` sealed under the secrets key as `<iv>.<ciphertext>`, both base64; a desktop keeps its account token this way (§55). */
+export async function sealSecret(secrets: SecretsSource, plain: string): Promise<string> {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    await importedKey(secrets),
+    new TextEncoder().encode(plain),
+  );
+
+  return `${iv.toBase64()}.${new Uint8Array(ciphertext).toBase64()}`;
+}
+
+/** Returns the text `sealSecret` sealed; rejects when it was sealed under another key or is not such a text. */
+export async function openSecret(secrets: SecretsSource, sealed: string): Promise<string> {
+  const [iv = "", ciphertext = ""] = sealed.split(".");
+
+  const plain = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: Uint8Array.fromBase64(iv) },
+    await importedKey(secrets),
+    Uint8Array.fromBase64(ciphertext),
+  );
+
+  return new TextDecoder().decode(plain);
+}
+
+async function importedKey(secrets: SecretsSource): Promise<CryptoKey> {
+  const bytes = await secrets.key();
+
+  if (bytes.length !== 32)
+    throw new SdkError("invalid", `The secrets key is ${bytes.length} bytes; AES-256 needs 32.`);
+
+  return crypto.subtle.importKey("raw", new Uint8Array(bytes), "AES-GCM", false, [
+    "encrypt",
+    "decrypt",
+  ]);
+}
+
+async function unsealCredential(
+  key: CryptoKey,
+  record: SealedCredential,
+): Promise<CredentialAccounts | undefined> {
+  let parsed: unknown;
+
+  try {
+    const plain = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: Uint8Array.fromBase64(record.iv) },
+      key,
+      Uint8Array.fromBase64(record.ciphertext),
+    );
+
+    parsed = JSON.parse(new TextDecoder().decode(plain));
+  } catch {
+    return undefined;
+  }
+
+  return readCredentialAccounts(parsed);
+}
+
+async function modifyCredential(
+  store: Store,
+  key: CryptoKey,
+  provider: string,
+  fn: (current: CredentialAccounts | undefined) => Promise<CredentialAccounts | undefined>,
+  signal: AbortSignal | undefined,
+): Promise<CredentialAccounts | undefined> {
+  const name = kvRef("secret", "models", provider);
+  let started = false;
+
+  return connected(store, async (connection) => {
+    for (let attempt = 0; attempt <= RETRIES; attempt += 1) {
+      const { ref, sealed } = await recordAt(connection, provider);
+      const current = sealed === null ? undefined : await unsealCredential(key, sealed);
+
+      if (!started) signal?.throwIfAborted();
+      started = true;
+      const next = await fn(current);
+
+      if (next === undefined) return current;
+
+      const target =
+        next.accounts.length === 0
+          ? null
+          : await connection.objects.put(envelope("kv", await seal(key, next), Date.now()));
+
+      const outcome = await connection.refs.set([
+        { name, target, expect: ref === null ? "absent" : ref.revision },
+      ]);
+
+      if (outcome.kind === "set") return next;
+    }
+
+    throw new SdkError(
+      "unavailable",
+      `The ${provider} credential kept changing under this write; try again.`,
+    );
+  });
+}
+
+async function seal(key: CryptoKey, credential: CredentialAccounts): Promise<Json> {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+
+  const ciphertext = new Uint8Array(
+    await crypto.subtle.encrypt(
+      { name: "AES-GCM", iv },
+      key,
+      new TextEncoder().encode(JSON.stringify(credential)),
+    ),
+  );
+
+  return {
+    active: credential.active,
+    accounts: credential.accounts.map((account) => ({
+      id: account.id,
+      label: account.label,
+      type: account.credential.type,
+    })),
+    iv: iv.toBase64(),
+    ciphertext: ciphertext.toBase64(),
+  };
+}
+
+async function recordAt(
+  connection: StoreConnection,
+  provider: string,
+): Promise<{ readonly ref: Ref | null; readonly sealed: SealedCredential | null }> {
+  const ref = await connection.refs.get(kvRef("secret", "models", provider));
+
+  return {
+    ref,
+    sealed:
+      ref === null || ref.target === null
+        ? null
+        : readSealedCredential(decodeKvValue(await connection.objects.get(ref.target))),
+  };
+}
+
+function readSealedCredential(body: Json | undefined): SealedCredential | null {
+  if (!Value.Check(SealedCredentialSchema, body)) return null;
+
+  if ("type" in body) return body;
+
+  const ids = new Set(body.accounts.map((account) => account.id));
+
+  return ids.size === body.accounts.length && (body.active === null || ids.has(body.active))
+    ? body
+    : null;
+}
+
+async function connected<T>(
+  store: Store,
+  task: (connection: StoreConnection) => Promise<T>,
+): Promise<T> {
+  return task(await store.open());
+}

package/src/deploy/cloudflare/README.md

@@ -0,0 +1,3 @@
+# Cloudflare
+
+`worker.ts` runs one Nyte host in one SQLite-backed Durable Object, `NyteHost`, and the Worker in front of it sends every request to that object. The object keeps sessions in its own storage through `durableObjectStore`, serves a chat-only workspace (no files, no processes), answers the protocol through `listenFetch`, and runs sessions from its alarm: each pass advances up to 32 due heads within 10 seconds, re-alarms at once for the rest, and sets the alarm for the next due head from its `nyte_schedule` table. It imports only the node-free subpaths (`@nyte-ai/host/durable-object`, `/listen-fetch`, `/providers`), never the Node root. `wrangler.jsonc` requires the `NYTE_TOKEN` secret (at least 16 characters): run `wrangler secret put NYTE_TOKEN`, to enable `secrets.set` also `wrangler secret put NYTE_SECRET_KEY` with a base64 key, and to answer identity challenges `wrangler secret put NYTE_IDENTITY_KEY` with a base64 32-byte Ed25519 seed (without it `/.nyte/identity` answers `unknown`), then `wrangler deploy` from this directory.