zidane-ui 9.1.1 → 9.1.3

package/src/adapters/closable-client.ts

@@ -1,34 +0,0 @@
-import type { ServerClient } from 'zidane/ipc/browser';
-
-/**
- * A view of a shared client whose listeners one `close()` removes, for a host
- * that listens for its whole life: the host listens through `client`, and its
- * own `close()` calls this one. The shared client stays open. A listener added
- * after `close()` is never attached.
- */
-export function closableClient(shared: ServerClient): { client: ServerClient; close(): void } {
-  const offs = new Set<() => void>();
-  let closed = false;
-  const track =
-    <L>(on: (listener: L) => () => void) =>
-    (listener: L): (() => void) => {
-      if (closed) return () => undefined;
-      const off = on(listener);
-      const once = () => {
-        if (offs.delete(once)) off();
-      };
-      offs.add(once);
-      return once;
-    };
-  const client: ServerClient = Object.create(shared);
-  client.onSignal = track(shared.onSignal);
-  client.onOpen = track(shared.onOpen);
-  client.onState = track(shared.onState);
-  return {
-    client,
-    close() {
-      closed = true;
-      for (const off of [...offs]) off();
-    },
-  };
-}

package/src/adapters/extension-modules.ts

@@ -1,360 +0,0 @@
-/**
- * Loading an extension's `ui.tsx` bundle in a browser, from zidane-server.
- *
- * The server bundles each extension's `ui` entry into one ESM module (zidane's `compileUiEntry`)
- * and keeps the host modules (`react`, `react/jsx-runtime`, `react-dom`, `zidane-ui/*`) as bare
- * imports: the components must run on the app's own React and kit, or their hooks and contexts
- * split from the app's. A page can't map bare specifiers to modules it already loaded (a vite
- * build has no stable URL for its React, and a static import map can't name them), so the loader
- * links the bundle against a host module map instead: each `import … from '<host module>'`
- * becomes a read of the module the app put in the map ({@link linkExtensionModule}), and the
- * linked code is imported from a `blob:` URL. Where each bundle is comes from the folder's
- * `extensions.ui.list` (`ServerExtensionsHost.bundle`); the bundle itself is fetched with the
- * client's token, by content hash (`immutable`), so the browser cache keeps it until the code changes.
- *
- *   const loader = createServerExtensionModuleLoader({
- *     origin: 'https://zidane.example.com', token, bundle: host.bundle,
- *     modules: { react: React, 'react/jsx-runtime': jsxRuntime, 'zidane-ui/extensions/kit': kit },
- *   });
- *   <AppHostProvider host={host} loadExtensionModule={loader.load}>…
- */
-import { SERVER_EXTENSIONS_WEBVIEW_PATH } from 'zidane/ipc/browser';
-
-/** Loads an extension's `ui.tsx` module: its exports by name (`zidane-ui/extensions`' `ExtensionModuleLoader`). */
-export type ExtensionModuleLoad = (extensionId: string) => Promise<Readonly<Record<string, unknown>>>;
-
-/** The global the linked bundles read host modules from. */
-export const EXTENSION_HOST_MODULES_GLOBAL = '__zidaneExtensionHostModules__';
-
-/** A module namespace (`import * as React from 'react'`). */
-export type ExtensionHostModule = Readonly<Record<string, unknown>>;
-
-/** Host modules by specifier: what the app hands the extensions' components. */
-export type ExtensionHostModules = Readonly<Record<string, ExtensionHostModule>>;
-
-/**
- * Host modules by specifier, each a namespace or a loader of one (a function resolving the namespace): a
- * loader runs the first time a bundle imports its specifier, so the app's first load stays small.
- */
-export type ExtensionHostModuleSources = Readonly<
-  Record<string, ExtensionHostModule | (() => Promise<ExtensionHostModule>)>
->;
-
-/** A linked bundle: its code, and the host modules it reads. */
-export interface LinkedExtensionModule {
-  /** The bundle with its host-module imports rewritten to reads of the shared module map. */
-  code: string;
-  /** The host module specifiers the code reads, each once. */
-  uses: readonly string[];
-}
-
-/** A bundle that imports something the app does not provide. */
-export class ExtensionModuleLinkError extends Error {
-  /**
-   * @param specifiers - The specifiers the app has no module for.
-   */
-  constructor(readonly specifiers: readonly string[]) {
-    super(
-      `the extension module imports ${specifiers.map((s) => `"${s}"`).join(', ')}, which this app does not provide`,
-    );
-    this.name = 'ExtensionModuleLinkError';
-  }
-}
-
-const HELPER = '__zidaneHostModule$';
-// A static import or re-export as a bundler emits it, one per statement: `import D, { a as b } from "x";`,
-// `import * as N from "x";`, `import "x";`, `export { a } from "x";`, `export * from "x";`.
-const STATIC_IMPORT =
-  /^[ \t]*import\s*(?:([\w$]+)\s*,?\s*)?(?:\*\s*as\s+([\w$]+)|\{([^}]*)\})?\s*(?:from\s*)?(["'])([^"'\n]+)\4[ \t]*;?/gm;
-const RE_EXPORT = /^[ \t]*export\s*(?:\*\s*(?:as\s+([\w$]+)\s*)?|\{([^}]*)\})\s*from\s*(["'])([^"'\n]+)\3[ \t]*;?/gm;
-const DYNAMIC_IMPORT = /\bimport\(\s*(["'])([^"'\n]+)\1\s*\)/g;
-
-/** `a, b as c, "d" as e, default as f` → a destructuring pattern `a, b: c, "d": e, default: f`. */
-function bindings(list: string): string {
-  return list
-    .split(',')
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => part.replace(/^(["']?[\w$-]+["']?)\s+as\s+([\w$]+)$/, '$1: $2'))
-    .join(', ');
-}
-
-const isBare = (specifier: string): boolean => !/^(?:[./]|[a-z][a-z\d+.-]*:)/i.test(specifier);
-
-/**
- * Rewrites a bundle's imports of host modules into reads of the host module map, so the code runs
- * as a module with no imports. A bare import the map has no module for fails, every one named.
- * Relative and URL imports are left alone (a self-contained bundle has none).
- *
- * @param code - One ESM module (zidane's `compileUiEntry` output).
- * @param provided - Whether the app provides a specifier.
- * @returns The linked code and the host modules it reads.
- * @throws {ExtensionModuleLinkError} When it imports a bare specifier the app does not provide.
- */
-export function linkExtensionModule(code: string, provided: (specifier: string) => boolean): LinkedExtensionModule {
-  const missing = new Set<string>();
-  const uses = new Set<string>();
-  const host = (specifier: string): string | undefined => {
-    if (!isBare(specifier)) return undefined;
-    if (!provided(specifier)) missing.add(specifier);
-    uses.add(specifier);
-    return `${HELPER}(${JSON.stringify(specifier)})`;
-  };
-  let seq = 0;
-  let linked = code.replace(
-    STATIC_IMPORT,
-    (statement, def: string | undefined, ns: string | undefined, named: string | undefined, _q, specifier: string) => {
-      // A stylesheet the kit's (`zidane-ui/styles/…`) or another host module's: the app already loads its CSS.
-      if (!def && !ns && named === undefined && isBare(specifier) && specifier.endsWith('.css')) return '';
-      const read = host(specifier);
-      if (!read) return statement;
-      const out: string[] = [];
-      if (def) out.push(`const ${def} = ${HELPER}.default(${JSON.stringify(specifier)});`);
-      if (ns) out.push(`const ${ns} = ${read};`);
-      if (named !== undefined && bindings(named)) out.push(`const { ${bindings(named)} } = ${read};`);
-      return out.join(' ');
-    },
-  );
-  linked = linked.replace(
-    RE_EXPORT,
-    (statement, as: string | undefined, named: string | undefined, _q, specifier: string) => {
-      const read = host(specifier);
-      if (!read) return statement;
-      if (named === undefined) {
-        if (!as) throw new ExtensionModuleLinkError([`export * from "${specifier}"`]);
-        return `const ${as} = ${read}; export { ${as} };`;
-      }
-      const pairs = named
-        .split(',')
-        .map((part) => part.trim())
-        .filter(Boolean)
-        .map((part) => {
-          const [from, to = from] = part.split(/\s+as\s+/);
-          return { from: from!, to: to!, local: `${HELPER}re${++seq}` };
-        });
-      return `const { ${pairs.map((p) => `${p.from}: ${p.local}`).join(', ')} } = ${read}; export { ${pairs.map((p) => `${p.local} as ${p.to}`).join(', ')} };`;
-    },
-  );
-  linked = linked.replace(DYNAMIC_IMPORT, (call, _q, specifier: string) => {
-    const read = host(specifier);
-    return read ? `Promise.resolve().then(() => ${read})` : call;
-  });
-  if (missing.size > 0) throw new ExtensionModuleLinkError([...missing]);
-  const global = JSON.stringify(EXTENSION_HOST_MODULES_GLOBAL);
-  const helper =
-    `const ${HELPER} = (s) => { const m = globalThis[${global}]?.[s]; if (!m) throw new Error('zidane: no host module ' + s); return m; };\n` +
-    `${HELPER}.default = (s) => { const m = ${HELPER}(s); return 'default' in m ? m.default : m; };\n`;
-  return { code: helper + linked, uses: [...uses] };
-}
-
-/**
- * Puts `modules` in the host module map linked bundles read (merged over what is there).
- *
- * @param modules - Host modules by specifier.
- * @param target - The global object. Default `globalThis`.
- */
-export function installExtensionHostModules(modules: ExtensionHostModules, target: object = globalThis): void {
-  const slot = target as Record<string, ExtensionHostModules | undefined>;
-  slot[EXTENSION_HOST_MODULES_GLOBAL] = { ...slot[EXTENSION_HOST_MODULES_GLOBAL], ...modules };
-}
-
-/** One extension's bundle in the folder's listing: where it is (relative to the server's origin), or why it did not bundle. */
-export type ServerExtensionBundle = { hash: string; url: string } | { errors: readonly string[] };
-
-/**
- * Where an extension's bundle is, from the folder's current listing (`ServerExtensionsHost.bundle`);
- * `fresh`: list again first (the listed URL went stale). `undefined`: it has none.
- */
-export type ServerExtensionBundleLookup = (
-  extensionId: string,
-  opts?: { fresh?: boolean },
-) => Promise<ServerExtensionBundle | undefined>;
-
-/** A bundle that could not be loaded: not listed, did not bundle, or the server refused. */
-export class ExtensionModuleLoadError extends Error {
-  /**
-   * @param extensionId - The extension.
-   * @param message - What went wrong.
-   */
-  constructor(
-    readonly extensionId: string,
-    message: string,
-  ) {
-    super(`${extensionId}: ${message}`);
-    this.name = 'ExtensionModuleLoadError';
-  }
-}
-
-/** Options for {@link createServerExtensionModuleLoader}. */
-export interface ServerExtensionModuleLoaderOptions {
-  /** The server's HTTP origin (`https://zidane.example.com`). */
-  origin: string;
-  /** The client token. Absent: a server without auth. */
-  token?: string;
-  /** Where each bundle is: `ServerExtensionsHost.bundle`. */
-  bundle: ServerExtensionBundleLookup;
-  /** The host modules the components import, each a namespace or a loader of one. */
-  modules: ExtensionHostModuleSources;
-  /** `fetch`. Default: the global one. */
-  fetch?: typeof fetch;
-  /** Evaluates linked code as a module and returns its exports. Default: import from a `blob:` URL. */
-  importModule?: (code: string) => Promise<Readonly<Record<string, unknown>>>;
-}
-
-/** What {@link createServerExtensionModuleLoader} returns. */
-export interface ServerExtensionModuleLoader {
-  /** `AppHostProvider`'s `loadExtensionModule`. A new function after {@link ServerExtensionModuleLoader.invalidate}. */
-  load: ExtensionModuleLoad;
-  /** A fresh `load` (the folder changed, an extension reloaded, the server came back): a module loads again. */
-  invalidate(): ExtensionModuleLoad;
-}
-
-const blobImport = async (code: string): Promise<Readonly<Record<string, unknown>>> => {
-  const url = URL.createObjectURL(new Blob([code], { type: 'text/javascript' }));
-  try {
-    return (await import(/* @vite-ignore */ url)) as Readonly<Record<string, unknown>>;
-  } finally {
-    URL.revokeObjectURL(url);
-  }
-};
-
-/**
- * Creates a loader of extension `ui.tsx` modules from zidane-server: each bundle where the folder's
- * listing says, by its hash, linked against `modules`. A bundle URL the server no longer knows (it
- * restarted since the listing) is looked up again in a fresh listing, once.
- *
- * @param options - The server's origin and token, where bundles are, the host modules.
- */
-export function createServerExtensionModuleLoader(
-  options: ServerExtensionModuleLoaderOptions,
-): ServerExtensionModuleLoader {
-  const doFetch = options.fetch ?? ((input: RequestInfo | URL, init?: RequestInit) => fetch(input, init));
-  const importModule = options.importModule ?? blobImport;
-  const headers: Record<string, string> = options.token ? { authorization: `Bearer ${options.token}` } : {};
-  const provided = (specifier: string): boolean => Object.hasOwn(options.modules, specifier);
-  const resolved = new Map<string, Promise<ExtensionHostModule>>();
-  const resolve = (specifier: string): Promise<ExtensionHostModule> => {
-    let module = resolved.get(specifier);
-    if (!module) {
-      const source = options.modules[specifier]!;
-      module = typeof source === 'function' ? source() : Promise.resolve(source);
-      resolved.set(specifier, module);
-      module.catch(() => resolved.delete(specifier));
-    }
-    return module;
-  };
-  const link = async (code: string): Promise<string> => {
-    const linked = linkExtensionModule(code, provided);
-    const modules = await Promise.all(linked.uses.map(async (s) => [s, await resolve(s)] as const));
-    installExtensionHostModules(Object.fromEntries(modules));
-    return linked.code;
-  };
-
-  const fetchBundle = (url: string) => doFetch(/^https?:/i.test(url) ? url : `${options.origin}${url}`, { headers });
-
-  const make = (): ExtensionModuleLoad => async (extensionId) => {
-    let bundle = await options.bundle(extensionId);
-    if (!bundle) throw new ExtensionModuleLoadError(extensionId, 'no ui bundle on the server');
-    if ('errors' in bundle) throw new ExtensionModuleLoadError(extensionId, bundle.errors.join('; '));
-    let response = await fetchBundle(bundle.url);
-    if (response.status === 404) {
-      bundle = await options.bundle(extensionId, { fresh: true });
-      if (!bundle) throw new ExtensionModuleLoadError(extensionId, 'no ui bundle on the server');
-      if ('errors' in bundle) throw new ExtensionModuleLoadError(extensionId, bundle.errors.join('; '));
-      response = await fetchBundle(bundle.url);
-    }
-    if (!response.ok)
-      throw new ExtensionModuleLoadError(extensionId, `the server answered ${response.status} for its bundle`);
-    return importModule(await link(await response.text()));
-  };
-
-  const loader: ServerExtensionModuleLoader = {
-    load: make(),
-    invalidate() {
-      loader.load = make();
-      return loader.load;
-    },
-  };
-  return loader;
-}
-
-/** Options for {@link createServerWebviewSources}. */
-export interface ServerWebviewSourcesOptions {
-  /** The server's HTTP origin. */
-  origin: string;
-  /** The client token. Absent: a server without auth. */
-  token?: string;
-  /** The folder whose extensions the webviews belong to (`null`: none). */
-  cwd: () => string | null;
-  /** `fetch`. Default: the global one. */
-  fetch?: typeof fetch;
-  /** Called with a mint that failed. Default: a console warning. */
-  onError?: (error: unknown) => void;
-}
-
-/** Webview URLs from zidane-server, for `ExtensionWebview`'s `resolveSrc`. */
-export interface ServerWebviewSources {
-  /**
-   * The URL a webview's iframe loads: a `url` source as given, a `file` source the URL the server
-   * minted for it (`null` until it answered; subscribers hear when it did).
-   */
-  resolveSrc(webview: { id: string; src: { url: string } | { file: string } }): string | null;
-  /** Called when a minted URL arrives. Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-  /** Forgets the minted URLs (the folder changed): the next `resolveSrc` mints again. */
-  clear(): void;
-  /**
-   * Forgets the minted URLs and tells subscribers, so every shown webview mints again (a rebuild, a
-   * reconnect to a server that may have restarted and dropped its tickets).
-   */
-  reset(): void;
-}
-
-/**
- * Creates the webview URL source over zidane-server: a `file` source is minted once per folder
- * (`POST /zidane/extensions/webview?cwd=&id=`, with the token) into a URL under an unguessable ticket,
- * served sandboxed with no network: the page talks to its extension only through the RPC bridge.
- *
- * @param options - The server's origin and token, the folder.
- */
-export function createServerWebviewSources(options: ServerWebviewSourcesOptions): ServerWebviewSources {
-  const doFetch = options.fetch ?? ((input: RequestInfo | URL, init?: RequestInit) => fetch(input, init));
-  const onError = options.onError ?? ((error: unknown) => console.warn('[zidane-ui] webview:', error));
-  const minted = new Map<string, string | null>();
-  const listeners = new Set<() => void>();
-  return {
-    resolveSrc(webview) {
-      if ('url' in webview.src) return webview.src.url;
-      const cwd = options.cwd();
-      if (!cwd) return null;
-      const key = `${cwd}\u0000${webview.id}`;
-      if (minted.has(key)) return minted.get(key) ?? null;
-      minted.set(key, null);
-      const url = `${options.origin}${SERVER_EXTENSIONS_WEBVIEW_PATH}?cwd=${encodeURIComponent(cwd)}&id=${encodeURIComponent(webview.id)}`;
-      doFetch(url, { method: 'POST', headers: options.token ? { authorization: `Bearer ${options.token}` } : {} })
-        .then(async (response) => {
-          if (!response.ok) throw new Error(`the server answered ${response.status} for webview ${webview.id}`);
-          const { url: path } = (await response.json()) as { url: string };
-          if (!minted.has(key)) return;
-          minted.set(key, /^https?:/i.test(path) ? path : `${options.origin}${path}`);
-          for (const listener of [...listeners]) listener();
-        })
-        .catch((error: unknown) => {
-          minted.delete(key);
-          onError(error);
-        });
-      return null;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    clear() {
-      minted.clear();
-    },
-    reset() {
-      minted.clear();
-      for (const listener of [...listeners]) listener();
-    },
-  };
-}

package/src/adapters/index.ts

@@ -1,35 +0,0 @@
-/**
- * `zidane-ui/adapters`: browser-safe `ChatHost` factories over a real agent:
- * `createRunHost` (your run function), `createWorkerHost` / `exposeRunHost`
- * (a Web Worker), `createSseHost` (`zidane-ui/server`'s SSE handler),
- * `createServerHost` (zidane-server over WebSocket), and their wire protocols;
- * `createServerExtensionsHost` and `createServerExtensionModuleLoader` (extensions' UI);
- * `createStreamPacer` paces a run's live events into its transcript.
- */
-export * from './run-host';
-export * from './worker-host';
-export * from './worker-protocol';
-export * from './sse-host';
-export * from './sse-parser';
-export * from './sse-protocol';
-export * from './server-client';
-export * from './server-host';
-export * from './server-approvals-host';
-export * from './server-session-host';
-export * from './server-composer-host';
-export * from './server-palette-host';
-export * from './server-terminal-host';
-export * from './server-git-host';
-export * from './server-files-host';
-export * from './server-machines-host';
-export * from './server-onboarding-host';
-export * from './server-settings-host';
-export * from './server-sidebar-host';
-export * from './server-extensions-host';
-export * from './extension-modules';
-export * from './browser-appearance-host';
-export * from './browser-keybindings-host';
-export * from './browser-workspace-host';
-export * from './live';
-export * from './live-events';
-export * from './stream-pacer';

package/src/adapters/live-events.ts

@@ -1,6 +0,0 @@
-/**
- * zidane's live event rule, re-exported for the adapters' public entry. It
- * lives with the session stream store (`chat/headless/streams/`), which
- * folds every transcript with it.
- */
-export { applyLiveEvent, closeThinkingSegment, finishLive } from '../chat/headless/streams/live-events';