zidane-ui 9.1.1 → 9.1.4

package/src/adapters/server-extensions-host.ts

@@ -1,979 +0,0 @@
-/**
- * An `ExtensionsHost` on a running zidane-server, over the same client as the chat host
- * (`createServerClient`, or `createServerHost(...).client`), spoken through zidane's typed extensions client
- * (`createExtensionsClient` from `zidane/ipc/browser`): what the extensions of one folder
- * contribute to the UI, and the way back to them.
- *
- *   - items and `ui` bundles: `extensions.ui.list`, kept current by `extensions:ui` (listed again on
- *     `reset`, a reconnect and a folder change)
- *   - callbacks: `extensions.ui.invoke` (panel load and actions, references, badge menus, settings
- *     actions)
- *   - dialogs and toasts routed to this window into a `createDialogQueue`, answered with
- *     `ui.dialog.answer`, withdrawn on `ui:dialog:close`. A form's fields are checked with
- *     `ui.dialog.validate` (`dialogs.validate`), and a form is answered only once every field passes
- *   - `ctx.ui` panels, navigation, composer edits, notifications and `ctx.keymap.dispatch` chords into a
- *     `createUiEffectChannel`, answered with `ui.client.reply`
- *   - links: `openLink` offers a link to the folder's link handlers (`extensions.links.open`)
- *   - the token's scope (`scope`, from the handshake): action settings above it show disabled
- *   - RPC: `rpc.call` (aborts send `rpc.cancel`); the server checks each method's `scope` against
- *     this window's token (`rpc.forbidden` below it)
- *   - stores: `extensions.storage.load` / `.set`, kept current by `extensions:storage`; a write shows at
- *     once and settles to what the server holds (a refused one is put back)
- *   - settings (`extensions.settings`, the catalog provenance), integrations, commands (with their
- *     key scope, `editable` flag and mode, and the keymap mode on top)
- *   - webviews (with `assets`): a `file` source's URL minted by the server, minted again after a
- *     reconnect, a rebuild or a folder change
- *
- * The host announces the window on every connect (`ui.client.announce`): the server routes
- * dialogs only to windows that did. Call `announce` again when the shown session changes or the
- * user acts in the window. Sign-in steps of an OAuth or command integration go to `onFlowStep`;
- * by default a link opens in a new tab and a question shows as one of this host's dialogs.
- *
- * A reconnect may be a restarted server, whose bundle URLs and webview tickets are gone: the host
- * lists everything again and tells `onReset` listeners, as after a rebuild.
- *
- * `invoke` takes each callback's folder; the items, settings, commands and integrations are the
- * folder given by `cwd` / `setFolder`.
- */
-import {
-  createExtensionsClient,
-  IpcErrorCode,
-  ServerCallError,
-  ServerConnectionError,
-  type ExtensionsClient,
-  type HostSignal,
-  type IpcResult,
-  type ServerClient,
-} from 'zidane/ipc/browser';
-
-import { writable, type Readable, type Writable } from '../chat/headless/store';
-import { createDialogQueue } from '../extensions/headless/dialog-queue';
-import { createUiEffectChannel } from '../extensions/headless/effect-channel';
-import {
-  ExtensionsHostError,
-  type ExtensionCallbackId,
-  type ExtensionCallbacks,
-  type ExtensionCommands,
-  type ExtensionCommandWire,
-  type ExtensionComposerFile,
-  type ExtensionDialogs,
-  type ExtensionIntegrationConnectionWire,
-  type ExtensionIntegrations,
-  type ExtensionIntegrationWire,
-  type ExtensionItemStores,
-  type ExtensionPanelChange,
-  type ExtensionProvenanceWire,
-  type ExtensionSettings,
-  type ExtensionSettingsWire,
-  type ExtensionStorage,
-  type ExtensionStoreRef,
-  type ExtensionsHost,
-  type ExtensionUiEffect,
-  type ExtensionWebviews,
-  type ExtensionAccessScope,
-} from '../extensions/headless/host';
-import {
-  EXTENSION_TOKENS,
-  type DialogRequestWire,
-  type ExtensionItem,
-  type ExtensionTokenName,
-} from '../extensions/headless/wire';
-import {
-  createServerWebviewSources,
-  type ServerExtensionBundleLookup,
-  type ServerWebviewSources,
-} from './extension-modules';
-
-type SignalOf<K extends HostSignal['kind']> = Extract<HostSignal, { kind: K }>;
-type UiSnapshotWire = IpcResult<'extensions.ui.list'>;
-type FlowStep = SignalOf<'extensions:integration-flow'>['step'];
-type UiClientRequestWire = SignalOf<'ui:client'>['request'];
-type IntegrationWire = IpcResult<'extensions.integrations.list'>[number];
-type ConnectionWire = NonNullable<IntegrationWire['connection']>;
-type CommandWire = IpcResult<'extensions.commands'>['commands'][number];
-
-/** What the window says about itself (`ui.client.announce`). */
-export interface ExtensionsClientAnnounce {
-  /** Sessions it shows now. */
-  viewing?: string[];
-  /** The user just acted in it: it becomes the last active window. */
-  active?: boolean;
-}
-
-/** Answers one sign-in step of an integration flow: the value for a step that asks (`undefined` cancels). */
-export type ExtensionFlowStepHandler = (step: FlowStep, reply: (value: string | undefined) => void) => void;
-
-/** Where the server serves the extensions' assets (webview pages), and the token they are fetched with. */
-export interface ServerExtensionAssetsAccess {
-  /** The server's HTTP origin (`https://zidane.example.com`). */
-  origin: string;
-  /** The client token. Absent: a server without auth. */
-  token?: string;
-  /** `fetch`. Default: the global one. */
-  fetch?: typeof fetch;
-}
-
-/** Options for {@link createServerExtensionsHost}. */
-export interface ServerExtensionsHostOptions {
-  /** The client to speak through, shared with the chat host. */
-  client: ServerClient;
-  /** The folder whose extensions show. `null`: none until {@link ServerExtensionsHost.setFolder}. */
-  cwd?: string | null;
-  /** Shows one sign-in step. Default: links open in a new tab; questions show as dialogs of this host. */
-  onFlowStep?: ExtensionFlowStepHandler;
-  /** Called with errors no caller can receive (a failed listing). Default: a console warning. */
-  onError?: (error: unknown) => void;
-  /** Where webview pages are minted. Absent: no `webviews` (a `file` source shows nothing). */
-  assets?: ServerExtensionAssetsAccess;
-}
-
-/** A command as this host lists it: the kit's wire, plus where its keybinding fires. */
-export interface ServerExtensionCommandWire extends ExtensionCommandWire {
-  /** Where focus must be for its keybinding: `global`, `composer`, `transcript`, `sidebar`, `modal`, `panel:<id>`, `screen:<id>`. */
-  scope: string;
-  /** Its keybinding also fires while a text field has focus. */
-  editable: boolean;
-  /** Its keybinding fires only while this keymap mode is on top. */
-  mode?: string;
-  /** Shown in key hints. */
-  hint: boolean;
-  /** `session`: needs a session; `idle`: also no run in flight. */
-  when: 'always' | 'session' | 'idle';
-  /** Turned off by its extension. */
-  enabled: boolean;
-}
-
-/** The commands, with the keymap mode on top for the session the window shows. */
-export interface ServerExtensionCommands extends ExtensionCommands {
-  list: Readable<readonly ServerExtensionCommandWire[]>;
-  /** The keymap mode on top (`undefined`: none). */
-  mode: Readable<string | undefined>;
-}
-
-/** Dialogs, with the form field check. */
-export interface ServerExtensionDialogs extends ExtensionDialogs {
-  /**
-   * Checks one field of a form dialog as the user edits it (`ui.dialog.validate`): the message to
-   * show under it, or `null` when it is valid (or the dialog is gone).
-   */
-  validate(dialogId: string, key: string, value: unknown): Promise<string | null>;
-}
-
-/** The {@link ExtensionsHost} {@link createServerExtensionsHost} returns. */
-export interface ServerExtensionsHost extends ExtensionsHost {
-  invoke: NonNullable<ExtensionsHost['invoke']>;
-  dialogs: ServerExtensionDialogs;
-  effects: NonNullable<ExtensionsHost['effects']>;
-  rpc: NonNullable<ExtensionsHost['rpc']>;
-  storage: NonNullable<ExtensionsHost['storage']>;
-  settings: NonNullable<ExtensionsHost['settings']>;
-  integrations: NonNullable<ExtensionsHost['integrations']>;
-  commands: ServerExtensionCommands;
-  panelChanged: NonNullable<ExtensionsHost['panelChanged']>;
-  openLink: NonNullable<ExtensionsHost['openLink']>;
-  scope: NonNullable<ExtensionsHost['scope']>;
-  /** With `assets`: the webview URLs the server mints. */
-  webviews?: ExtensionWebviews & ServerWebviewSources;
-  /** Settles once the first listing of the folder's items, settings, commands and integrations is in. */
-  ready: Promise<void>;
-  /**
-   * An extension's `ui` bundle in the folder's current listing (`url` relative to the server's
-   * origin), why it did not bundle, or `undefined`: it has none. `fresh`: list again first.
-   */
-  bundle: ServerExtensionBundleLookup;
-  /** Shows another folder's extensions (`null`: none). */
-  setFolder(cwd: string | null): void;
-  /** The folder shown now. */
-  folder(): string | null;
-  /** Tells the server what this window shows (kept and sent again on every reconnect). */
-  announce(info: ExtensionsClientAnnounce): Promise<void>;
-  /**
-   * The folder's extensions were rebuilt, or the connection came back (maybe to a restarted server):
-   * their `ui` modules may have changed. Returns the unsubscribe.
-   */
-  onReset(listener: () => void): () => void;
-  /** Stops listening to the client (the client stays open). Pending dialogs close unanswered. */
-  close(): void;
-}
-
-const CATALOG_KINDS = ['tools', 'agents', 'subagents', 'models', 'providers', 'mcp', 'skills'] as const;
-
-/** Any rejection as the host's typed error. */
-function hostError(err: unknown): ExtensionsHostError {
-  if (err instanceof ExtensionsHostError) return err;
-  if (err instanceof ServerConnectionError) return new ExtensionsHostError({ code: 'unavailable' });
-  if (err instanceof ServerCallError && err.code === IpcErrorCode.Forbidden)
-    return new ExtensionsHostError({ code: 'refused', reason: 'not-allowed', message: err.message });
-  // zidane's RpcCallError (a method's declared error, or a reserved rpc.* type).
-  if (err instanceof Error && err.name === 'RpcCallError' && typeof (err as { type?: unknown }).type === 'string') {
-    const { type, data } = err as Error & { type: string; data?: unknown };
-    return new ExtensionsHostError({
-      code: 'rpc',
-      type,
-      message: err.message,
-      ...(data !== undefined ? { data } : {}),
-    });
-  }
-  return new ExtensionsHostError({ code: 'failed', message: err instanceof Error ? err.message : String(err) });
-}
-
-const rethrow = (err: unknown): never => {
-  throw hostError(err);
-};
-
-/** A refusal for invalid params as `refused` / `invalid`, anything else as {@link hostError}. */
-const rethrowInvalid = (err: unknown): never => {
-  if (err instanceof ServerCallError && err.code === -32602)
-    throw new ExtensionsHostError({ code: 'refused', reason: 'invalid', message: err.message });
-  return rethrow(err);
-};
-
-/** The invoke request a callback travels as. */
-function invokeRequest<K extends ExtensionCallbackId>(
-  id: K,
-  args: ExtensionCallbacks[K]['args'],
-): Record<string, unknown> {
-  const a = args as Record<string, unknown>;
-  switch (id) {
-    case 'panel.load':
-      return { op: id, panelId: a.panelId, ...(a.context !== undefined ? { ctx: a.context } : {}) };
-    case 'panel.action':
-      return {
-        op: id,
-        panelId: a.panelId,
-        actionId: a.actionId,
-        ...(a.payload !== undefined ? { payload: a.payload } : {}),
-        ...(a.context !== undefined ? { ctx: a.context } : {}),
-      };
-    case 'badge.run':
-      return {
-        op: id,
-        source: a.source,
-        actionId: a.actionId,
-        target: a.target,
-        ...(a.sessionId ? { sessionId: a.sessionId } : {}),
-      };
-    default: {
-      const { cwd: _cwd, ...rest } = a;
-      return { op: id, ...rest };
-    }
-  }
-}
-
-/** `ui:client`'s request as the effect the app applies. */
-function effectOf(request: UiClientRequestWire): ExtensionUiEffect {
-  switch (request.op) {
-    case 'keymap.dispatch':
-      return { kind: 'keymap', chord: request.chord, ...(request.sessionId ? { sessionId: request.sessionId } : {}) };
-    case 'panel':
-      return {
-        kind: 'panel',
-        action: request.action,
-        panelId: request.panelId,
-        ...(request.sessionId ? { sessionId: request.sessionId } : {}),
-        ...(request.focus ? { focus: request.focus } : {}),
-      };
-    case 'panelState':
-      return { kind: 'panel-state', ...(request.sessionId ? { sessionId: request.sessionId } : {}) };
-    case 'navigate':
-      return { kind: 'navigate', to: request.to };
-    case 'composer':
-      return { kind: 'composer', op: request.edit, ...(request.sessionId ? { sessionId: request.sessionId } : {}) };
-    case 'notify': {
-      const { op: _op, ...rest } = request;
-      return { kind: 'notify', ...rest };
-    }
-  }
-}
-
-const TEXT_TYPES: Readonly<Record<string, string>> = {
-  md: 'text/markdown',
-  json: 'application/json',
-  html: 'text/html',
-  css: 'text/css',
-  csv: 'text/csv',
-  xml: 'application/xml',
-  svg: 'image/svg+xml',
-  js: 'text/javascript',
-  mjs: 'text/javascript',
-  ts: 'text/typescript',
-  tsx: 'text/typescript',
-  yaml: 'application/yaml',
-  yml: 'application/yaml',
-};
-
-/** UTF-8 text as base64. */
-function base64Text(text: string): string {
-  const bytes = new TextEncoder().encode(text);
-  let binary = '';
-  for (let i = 0; i < bytes.length; i += 0x8000) binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
-  return btoa(binary);
-}
-
-/**
- * The files of a `ctx.composer.attach` with each server path read into bytes through the session's
- * workspace (`sessions.workspaceReadFile`): a browser can't read a server path itself. Text only (the
- * read answers text); a path that doesn't read, or reads as binary, stays a path, which the composer
- * does not stage.
- */
-async function readAttachPaths(
-  client: ServerClient,
-  files: readonly ExtensionComposerFile[],
-  sessionId: string | undefined,
-): Promise<ExtensionComposerFile[]> {
-  if (!sessionId || !client.can('sessions.workspaceReadFile')) return [...files];
-  return Promise.all(
-    files.map(async (file) => {
-      if (!('path' in file)) return file;
-      try {
-        const text = await client.call('sessions.workspaceReadFile', { sessionId, path: file.path });
-        if (typeof text !== 'string' || /[\u0000\uFFFD]/.test(text)) return file;
-        const name = file.path.split(/[\\/]/).pop() || file.path;
-        const ext = name.includes('.') ? name.split('.').pop()!.toLowerCase() : '';
-        return { name, mimeType: TEXT_TYPES[ext] ?? 'text/plain', data: base64Text(text) };
-      } catch {
-        return file;
-      }
-    }),
-  );
-}
-
-function integrationOf(wire: IntegrationWire): ExtensionIntegrationWire {
-  // An older host sends only the default connection.
-  const raw = wire.connections ?? (wire.connection ? [wire.connection] : []);
-  const defaultAccount = wire.connection?.account ?? raw.find((c) => c.isDefault)?.account ?? raw[0]?.account;
-  const connections = raw.map((c) => connectionOf(c, c.account === defaultAccount));
-  const connection = connections.find((c) => c.isDefault);
-  return {
-    id: wire.id,
-    name: wire.name,
-    ...(wire.description ? { description: wire.description } : {}),
-    extensionId: wire.extensionId,
-    methods: wire.methods.map((m) => {
-      const extra = m as { placeholder?: string; help?: string };
-      return {
-        type: m.type,
-        id: m.id,
-        label: m.label,
-        ...(extra.placeholder ? { placeholder: extra.placeholder } : {}),
-        ...(extra.help ? { help: extra.help } : {}),
-      };
-    }),
-    ...(connection ? { connection } : {}),
-    ...(connections.length > 0 ? { connections } : {}),
-  };
-}
-
-function connectionOf(wire: ConnectionWire, isDefault: boolean): ExtensionIntegrationConnectionWire {
-  return {
-    methodId: wire.methodId,
-    // An older host may name no account: its one connection is the default one.
-    account: wire.account || 'default',
-    ...(wire.label ? { label: wire.label } : {}),
-    ...(isDefault ? { isDefault: true } : {}),
-    connectedAt: wire.connectedAt,
-  };
-}
-
-const EMPTY_SETTINGS: ExtensionSettingsWire = {
-  schema: { categories: [], items: [] },
-  actions: [],
-  values: {},
-  locked: [],
-};
-
-/** A form dialog's request with what the user entered as its values and each field's error as its description. */
-function formWithErrors(
-  request: Extract<DialogRequestWire, { kind: 'form' }>,
-  extensionId: string,
-  entered: Readonly<Record<string, unknown>>,
-  errors: Readonly<Record<string, string>>,
-): DialogRequestWire {
-  const settings = request.settings;
-  return {
-    ...request,
-    settings: {
-      ...settings,
-      schema: {
-        ...settings.schema,
-        items: settings.schema.items.map((item) =>
-          errors[item.key] !== undefined ? { ...item, description: errors[item.key] } : item,
-        ),
-      },
-      values: { ...settings.values, [extensionId]: { ...settings.values[extensionId], ...entered } as never },
-    },
-  };
-}
-
-/**
- * Creates an {@link ExtensionsHost} over a zidane-server client.
- *
- * @param options - The client, the folder, the sign-in step handler, the error sink and where assets are.
- */
-export function createServerExtensionsHost(options: ServerExtensionsHostOptions): ServerExtensionsHost {
-  const { client, onError = (error) => console.warn('[zidane-ui] extensions host:', error) } = options;
-  const ext = createExtensionsClient({ request: client.call, onSignal: (listener) => client.onSignal(listener) });
-  let cwd = options.cwd ?? null;
-  let announced: ExtensionsClientAnnounce = {};
-  const offs: (() => void)[] = [];
-  const on = <K extends HostSignal['kind']>(kind: K, fn: (signal: SignalOf<K>) => void): void => {
-    offs.push(
-      client.onSignal((signal) => {
-        if (signal.kind === kind) fn(signal as SignalOf<K>);
-      }),
-    );
-  };
-  const panelListeners = new Set<(change: ExtensionPanelChange) => void>();
-  const resetListeners = new Set<() => void>();
-  const webviews = options.assets
-    ? createServerWebviewSources({ ...options.assets, cwd: () => cwd, onError })
-    : undefined;
-
-  // Items, per token, and the bundles of the same listing.
-  const stores = Object.fromEntries(
-    EXTENSION_TOKENS.map((token) => [token, writable<readonly ExtensionItem[]>([])]),
-  ) as Record<ExtensionTokenName, Writable<readonly ExtensionItem[]>>;
-  const items = stores as unknown as ExtensionItemStores;
-  let listSeq = 0;
-  let listing: Promise<{ cwd: string; bundles: UiSnapshotWire['bundles'] } | null> = Promise.resolve(null);
-  const listItems = (): Promise<void> => {
-    const mine = ++listSeq;
-    const folder = cwd;
-    if (!folder) {
-      for (const token of EXTENSION_TOKENS) stores[token].set([]);
-      listing = Promise.resolve(null);
-      return Promise.resolve();
-    }
-    const snapshot = ext.ui.list(folder);
-    listing = snapshot.then(
-      (s) => ({ cwd: folder, bundles: s.bundles ?? {} }),
-      () => null,
-    );
-    return snapshot.then((s) => {
-      if (mine !== listSeq) return;
-      const byToken = s as unknown as Partial<Record<string, readonly ExtensionItem[]>>;
-      for (const token of EXTENSION_TOKENS) stores[token].set(byToken[token] ?? []);
-    }, onError);
-  };
-  const upsert = (entry: ExtensionItem): void => {
-    const store = stores[entry.token] as Writable<readonly ExtensionItem[]> | undefined;
-    if (!store) return;
-    store.set((prev) => {
-      const index = prev.findIndex((e) => e.key === entry.key);
-      return index < 0 ? [...prev, entry] : prev.map((e, i) => (i === index ? entry : e));
-    });
-  };
-  const remove = (key: string, token: string): void => {
-    const store = (stores as Partial<Record<string, Writable<readonly ExtensionItem[]>>>)[token];
-    store?.set((prev) => (prev.some((e) => e.key === key) ? prev.filter((e) => e.key !== key) : prev));
-  };
-  const reset = (): void => {
-    webviews?.reset();
-    void refreshAll();
-    for (const listener of [...resetListeners]) listener();
-  };
-  offs.push(
-    ext.ui.onChange((signalCwd, change) => {
-      if (change.type === 'reset') {
-        reset();
-        return;
-      }
-      // Signals name the folder the server resolved: one that is not ours word for word may still be ours.
-      if (signalCwd !== cwd) {
-        if (change.type === 'upsert' || change.type === 'remove') void listItems();
-        return;
-      }
-      if (change.type === 'upsert') upsert(change.entry as unknown as ExtensionItem);
-      else if (change.type === 'remove') remove(change.key, change.token);
-      // A settings page joins the settings wire's pages: read it again.
-      const token = change.type === 'upsert' ? change.entry.token : change.type === 'remove' ? change.token : null;
-      if (token === 'settings-page') void settings.refresh();
-    }),
-    // Panel changes come on their own signal (`extensions:panel`), for the folder shown.
-    ext.ui.onPanelChanged(({ cwd: signalCwd, ...change }) => {
-      if (signalCwd !== cwd) return;
-      for (const listener of [...panelListeners]) listener(change);
-    }),
-  );
-
-  const bundle: ServerExtensionBundleLookup = async (extensionId, opts = {}) => {
-    if (opts.fresh) await listItems();
-    const listed = await listing;
-    const found = listed?.bundles[extensionId];
-    if (found) return { hash: found.hash, url: found.url };
-    if (!listed) return undefined;
-    // Not bundled: the folder's entries say why, if its ui entry failed to compile.
-    const entry = (await ext.entries.list(listed.cwd).catch(() => [])).find((e) => e.id === extensionId);
-    return entry?.uiErrors?.length ? { errors: entry.uiErrors } : undefined;
-  };
-
-  const invoke = <K extends ExtensionCallbackId>(id: K, args: ExtensionCallbacks[K]['args']) => {
-    const folder = (args as { cwd?: string }).cwd ?? cwd;
-    if (!folder) return Promise.reject(new ExtensionsHostError({ code: 'unavailable' }));
-    return ext.ui
-      .invoke(folder, invokeRequest(id, args) as never)
-      .then((result) => (result ?? undefined) as ExtensionCallbacks[K]['result'], rethrow);
-  };
-
-  // Dialogs and ctx.ui calls routed to this window.
-  const queue = createDialogQueue();
-  const validators = new Map<string, (key: string, value: unknown) => Promise<string | null>>();
-  const channel = createUiEffectChannel();
-  offs.push(
-    ext.serve({
-      async dialog(request, ctx) {
-        const show = (req: DialogRequestWire) =>
-          queue.show(req, {
-            id: ctx.dialogId,
-            extensionId: ctx.extensionId,
-            ...(ctx.sessionId ? { sessionId: ctx.sessionId } : {}),
-            signal: ctx.signal,
-          });
-        validators.set(ctx.dialogId, ctx.validate);
-        try {
-          const original = request as DialogRequestWire;
-          let answer = await show(original);
-          // A form goes back only once every field passes: the host refuses an invalid answer.
-          while (original.kind === 'form' && answer !== null && typeof answer === 'object') {
-            const entered = answer as Record<string, unknown>;
-            const keys = new Set([...original.settings.schema.items.map((item) => item.key), ...Object.keys(entered)]);
-            const checked = await Promise.all(
-              [...keys].map(async (key) => [key, await ctx.validate(key, entered[key])] as const),
-            );
-            const errors = Object.fromEntries(checked.filter(([, error]) => error !== null)) as Record<string, string>;
-            if (Object.keys(errors).length === 0) break;
-            answer = await show(formWithErrors(original, ctx.extensionId, entered, errors));
-          }
-          return answer;
-        } finally {
-          validators.delete(ctx.dialogId);
-        }
-      },
-      async client(request) {
-        let effect = effectOf(request);
-        if (effect.kind === 'composer' && effect.op.op === 'attach') {
-          const files = await readAttachPaths(client, effect.op.files, effect.sessionId ?? announced.viewing?.[0]);
-          effect = { ...effect, op: { op: 'attach', files } };
-        }
-        return channel.apply(effect);
-      },
-    }),
-  );
-  const dialogs: ServerExtensionDialogs = {
-    ...queue.dialogs,
-    validate(dialogId, key, value) {
-      const validate = validators.get(dialogId);
-      return validate ? validate(key, value).catch(() => null) : Promise.resolve(null);
-    },
-  };
-
-  const storage = serverStorage(ext, () => cwd, onError);
-  offs.push(storage.off);
-  const settings = serverSettings(client, () => cwd, onError);
-  const integrations = serverIntegrations(
-    client,
-    () => cwd,
-    onError,
-    options.onFlowStep ?? defaultFlowStep(queue.show),
-  );
-  const commands = serverCommands(
-    ext,
-    () => cwd,
-    () => announced.viewing?.[0],
-    onError,
-  );
-  on('extensions:integrations', () => integrations.refresh());
-  offs.push(ext.commands.onChange(() => commands.refresh()));
-  on('settings:changed', () => settings.refresh());
-
-  const refreshAll = (): Promise<void> => {
-    storage.reload();
-    return Promise.all([listItems(), settings.refresh(), integrations.refresh(), commands.refresh()]).then(
-      () => undefined,
-    );
-  };
-  const sendAnnounce = (): Promise<void> => ext.announce({ ...announced, dialogs: true, ui: true });
-  offs.push(
-    client.onOpen((_hello, reconnected) => {
-      void sendAnnounce().catch(onError);
-      // Maybe a restarted server: its bundle URLs and webview tickets are gone.
-      if (reconnected) reset();
-    }),
-  );
-  if (client.hello()) void sendAnnounce().catch(onError);
-  const ready = refreshAll();
-
-  // The token's scope, from the handshake (`null`: not limited, as a server without auth).
-  const scope = writable<ExtensionAccessScope | null>(client.hello()?.scope ?? null);
-  offs.push(client.onOpen((hello) => scope.set(hello.scope ?? null)));
-
-  return {
-    ready,
-    items,
-    invoke,
-    dialogs,
-    effects: channel.effects,
-    async rpc(contract, method, input, opts = {}) {
-      return ext
-        .rpc(contract, method, input, {
-          ...(cwd ? { cwd } : {}),
-          ...(opts.signal ? { signal: opts.signal } : {}),
-        })
-        .catch(rethrow);
-    },
-    async openLink(link) {
-      if (!cwd || !client.can('extensions.links.open')) return false;
-      const { handled } = await ext.links.open(cwd, link).catch(rethrow);
-      return handled;
-    },
-    scope,
-    storage: storage.storage,
-    settings: settings.settings,
-    integrations: integrations.integrations,
-    commands: commands.commands,
-    ...(webviews ? { webviews } : {}),
-    bundle,
-    setFolder(next) {
-      if (next === cwd) return;
-      cwd = next;
-      webviews?.reset();
-      void refreshAll();
-    },
-    folder: () => cwd,
-    announce(info) {
-      const session = announced.viewing?.[0];
-      announced = info;
-      // The keymap mode on top is per session.
-      if (info.viewing?.[0] !== session) void commands.refresh();
-      return sendAnnounce().catch(rethrow);
-    },
-    panelChanged(listener) {
-      panelListeners.add(listener);
-      return () => panelListeners.delete(listener);
-    },
-    onReset(listener) {
-      resetListeners.add(listener);
-      return () => resetListeners.delete(listener);
-    },
-    close() {
-      for (const off of offs.splice(0)) off();
-      queue.clear();
-    },
-  };
-}
-
-interface StoreSlot {
-  ref: ExtensionStoreRef;
-  value: Writable<unknown>;
-  /** The store's schema version, as its record carries it (`v`). */
-  schema?: number;
-  /** The entry's write count on the server: a signal below it is older than what the slot holds. */
-  version: number;
-  projectRoot?: string;
-}
-
-const storeKey = (ref: ExtensionStoreRef): string =>
-  [ref.extensionId, ref.scope, ref.sessionId ?? '', ref.name].join('\u0000');
-
-type StoreRecord = { v?: number; value?: unknown } | undefined;
-
-/**
- * The typed stores: loaded per ref, written as store records, followed through `extensions:storage`.
- * A write shows at once and settles to what the server answers it holds; a refused one is put back.
- */
-function serverStorage(ext: ExtensionsClient, folder: () => string | null, onError: (error: unknown) => void) {
-  const slots = new Map<string, StoreSlot>();
-  const location = (ref: ExtensionStoreRef) => ({
-    extensionId: ref.extensionId,
-    scope: ref.scope,
-    ...(ref.sessionId ? { sessionId: ref.sessionId } : {}),
-  });
-  const hold = (slot: StoreSlot, record: StoreRecord): void => {
-    if (typeof record?.v === 'number') slot.schema = record.v;
-    slot.value.set(record && typeof record === 'object' && 'value' in record ? record.value : undefined);
-  };
-  const load = (slot: StoreSlot): void => {
-    const cwd = folder();
-    if (!cwd) return;
-    ext.storage.load(cwd, location(slot.ref)).then((snapshot) => {
-      slot.projectRoot = snapshot.projectRoot;
-      hold(slot, snapshot.stores[slot.ref.name] as StoreRecord);
-    }, onError);
-  };
-  const off = ext.storage.onChange((signal) => {
-    if (signal.area !== 'stores') return;
-    const slot = slots.get(
-      storeKey({
-        extensionId: signal.extensionId,
-        scope: signal.scope,
-        name: signal.key,
-        ...(signal.sessionId ? { sessionId: signal.sessionId } : {}),
-      }),
-    );
-    if (!slot) return;
-    if (signal.scope !== 'user' && slot.projectRoot !== signal.projectRoot) return;
-    if (typeof signal.version === 'number') {
-      if (signal.version < slot.version) return;
-      slot.version = signal.version;
-    }
-    hold(slot, signal.value as StoreRecord);
-  });
-  const slotOf = (ref: ExtensionStoreRef): StoreSlot => {
-    const key = storeKey(ref);
-    let slot = slots.get(key);
-    if (!slot) {
-      slot = { ref, value: writable<unknown>(undefined), version: 0 };
-      slots.set(key, slot);
-      load(slot);
-    }
-    return slot;
-  };
-  const storage: ExtensionStorage = {
-    store: (ref): Readable<unknown> => slotOf(ref).value,
-    async set(ref, value) {
-      const cwd = folder();
-      if (!cwd) throw new ExtensionsHostError({ code: 'unavailable' });
-      const slot = slotOf(ref);
-      const before = slot.value.get();
-      slot.value.set(value);
-      const record = { v: slot.schema ?? 1, value } as never;
-      const result = await ext.storage.set(cwd, location(ref), 'stores', ref.name, record).catch((err: unknown) => {
-        slot.value.set(before);
-        return rethrowInvalid(err);
-      });
-      if (result.version >= slot.version) {
-        slot.version = result.version;
-        if (result.accepted) {
-          if (typeof (result.value as StoreRecord)?.v === 'number') slot.schema = (result.value as { v: number }).v;
-        } else hold(slot, result.value as StoreRecord);
-      } else if (!result.accepted) slot.value.set(before);
-      if (!result.accepted)
-        throw new ExtensionsHostError({ code: 'refused', reason: 'invalid', message: result.reason });
-    },
-  };
-  return { storage, reload: () => slots.forEach(load), off };
-}
-
-/** Every extension's settings, with the catalog items extensions changed. */
-function serverSettings(client: ServerClient, folder: () => string | null, onError: (error: unknown) => void) {
-  const wire = writable<ExtensionSettingsWire>(EMPTY_SETTINGS);
-  let seq = 0;
-  let loading: Promise<void> = Promise.resolve();
-  const refresh = (): Promise<void> => {
-    loading = load();
-    return loading;
-  };
-  const load = (): Promise<void> => {
-    const mine = ++seq;
-    const cwd = folder();
-    if (!cwd) return Promise.resolve(wire.set(EMPTY_SETTINGS));
-    const provenance = Promise.all(
-      CATALOG_KINDS.map((kind) =>
-        client.call('extensions.catalogs.provenance', { cwd, kind }).then(
-          (items) => items.map((item) => ({ ...item, kind })),
-          () => [],
-        ),
-      ),
-    ).then((lists) => lists.flat() as unknown as ExtensionProvenanceWire[]);
-    // The wire names each extension (`extensions`: display name and icon): the server fills it.
-    return Promise.all([client.call('extensions.settings', { cwd }), provenance]).then(([settings, changed]) => {
-      if (mine !== seq) return;
-      const { sources: _sources, ...rest } = settings;
-      wire.set({ ...(rest as unknown as ExtensionSettingsWire), provenance: changed });
-    }, onError);
-  };
-  const settings: ExtensionSettings = {
-    wire,
-    async set(extensionId, key, value) {
-      const cwd = folder();
-      if (!cwd) throw new ExtensionsHostError({ code: 'unavailable' });
-      await loading;
-      if (wire.get().locked.includes(`${extensionId}:${key}`))
-        throw new ExtensionsHostError({ code: 'refused', reason: 'locked' });
-      await client
-        .call('extensions.settings.set', { cwd, extension: extensionId, key, value, scope: 'user' })
-        .catch((err: unknown) => {
-          if (err instanceof ServerCallError && err.code === -32602)
-            throw new ExtensionsHostError({ code: 'refused', reason: 'invalid', message: err.message });
-          return rethrow(err);
-        });
-      wire.set((prev) => ({
-        ...prev,
-        values: { ...prev.values, [extensionId]: { ...prev.values[extensionId], [key]: value as never } },
-      }));
-      void refresh();
-    },
-  };
-  return { settings, refresh };
-}
-
-/** Steps shown the default way: a link in a new tab, a question as a dialog of this host. */
-function defaultFlowStep(show: ReturnType<typeof createDialogQueue>['show']): ExtensionFlowStepHandler {
-  const ask = (
-    request: DialogRequestWire,
-    reply: (value: string | undefined) => void,
-    pick?: (answer: unknown) => string | undefined,
-  ) =>
-    void show(request, { extensionId: 'zidane' }).then(
-      (answer) => reply(pick ? pick(answer) : typeof answer === 'string' ? answer : undefined),
-      () => reply(undefined),
-    );
-  return (step, reply) => {
-    switch (step.type) {
-      case 'auth':
-        globalThis.open?.(step.url, '_blank', 'noopener');
-        return;
-      case 'device':
-        void show(
-          { kind: 'toast', text: `${step.userCode} · ${step.verificationUri}`, tone: 'info' },
-          { extensionId: 'zidane' },
-        );
-        return;
-      case 'prompt':
-        return ask(
-          { kind: 'prompt', title: step.message, ...(step.placeholder ? { placeholder: step.placeholder } : {}) },
-          reply,
-        );
-      case 'manual-code':
-        return ask({ kind: 'prompt', title: 'Paste the address the browser ended on' }, reply);
-      case 'select':
-        return ask(
-          { kind: 'select', title: step.message, options: step.options },
-          reply,
-          (answer) => (answer as { ids?: string[] } | undefined)?.ids?.[0],
-        );
-      default:
-        return;
-    }
-  };
-}
-
-/** Integrations: Connect (a key, or a sign-in flow whose steps `onStep` shows) and Disconnect. */
-function serverIntegrations(
-  client: ServerClient,
-  folder: () => string | null,
-  onError: (error: unknown) => void,
-  onStep: ExtensionFlowStepHandler,
-) {
-  const list = writable<readonly ExtensionIntegrationWire[]>([]);
-  let seq = 0;
-  const refresh = (): Promise<void> => {
-    const mine = ++seq;
-    const cwd = folder();
-    if (!cwd) return Promise.resolve(list.set([]));
-    return client.call('extensions.integrations.list', { cwd }).then((wires) => {
-      if (mine === seq) list.set(wires.map(integrationOf));
-    }, onError);
-  };
-  const need = (): string => {
-    const cwd = folder();
-    if (!cwd) throw new ExtensionsHostError({ code: 'unavailable' });
-    return cwd;
-  };
-  const integrations: ExtensionIntegrations = {
-    list,
-    async connect(integrationId, { methodId, key }) {
-      const cwd = need();
-      const method = list
-        .get()
-        .find((i) => i.id === integrationId)
-        ?.methods.find((m) => m.id === methodId);
-      if (key !== undefined || method?.type === 'apiKey') {
-        await client
-          .call('extensions.integrations.connectKey', { cwd, integrationId, key: key ?? '', methodId })
-          .catch((err: unknown) => {
-            if (err instanceof ServerCallError && err.code !== IpcErrorCode.Forbidden)
-              throw new ExtensionsHostError({ code: 'refused', reason: 'invalid', message: err.message });
-            return rethrow(err);
-          });
-      } else {
-        const flowId = `flow-ui-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-        const off = client.onSignal((signal) => {
-          if (signal.kind !== 'extensions:integration-flow' || signal.flowId !== flowId) return;
-          const step = signal.step;
-          onStep(step, (value) => {
-            if ('inputId' in step)
-              void client
-                .call('extensions.integrations.flowInput', {
-                  flowId,
-                  inputId: step.inputId,
-                  ...(value !== undefined ? { value } : {}),
-                })
-                .catch(onError);
-          });
-        });
-        try {
-          await client.call('extensions.integrations.start', { cwd, integrationId, methodId, flowId }).catch(rethrow);
-        } finally {
-          off();
-        }
-      }
-      await refresh();
-    },
-    async disconnect(integrationId, opts) {
-      await client
-        .call('extensions.integrations.disconnect', {
-          cwd: need(),
-          integrationId,
-          ...(opts?.account !== undefined ? { account: opts.account } : {}),
-        })
-        .catch(rethrow);
-      await refresh();
-    },
-    async setDefault(integrationId, account) {
-      await client.call('extensions.integrations.setDefault', { cwd: need(), integrationId, account }).catch(rethrow);
-      await refresh();
-    },
-  };
-  return { integrations, refresh };
-}
-
-/** The unified commands of the folder, and the keymap mode on top for the session on screen. */
-function serverCommands(
-  ext: ExtensionsClient,
-  folder: () => string | null,
-  session: () => string | undefined,
-  onError: (error: unknown) => void,
-) {
-  const list = writable<readonly ServerExtensionCommandWire[]>([]);
-  const mode = writable<string | undefined>(undefined);
-  let seq = 0;
-  const commandOf = (c: CommandWire): ServerExtensionCommandWire => ({
-    id: c.id,
-    title: c.title,
-    ...(c.description ? { description: c.description } : {}),
-    ...(c.slash ? { slash: c.slash.name } : {}),
-    ...(c.bind.length > 0 ? { bind: c.bind } : {}),
-    ...(c.extensionId ? { extensionId: c.extensionId } : {}),
-    scope: c.scope ?? 'global',
-    editable: c.editable === true,
-    ...(c.mode ? { mode: c.mode } : {}),
-    hint: c.hint === true,
-    when: c.when ?? 'always',
-    enabled: c.enabled !== false,
-  });
-  const refresh = (): Promise<void> => {
-    const mine = ++seq;
-    const cwd = folder();
-    if (!cwd) {
-      list.set([]);
-      mode.set(undefined);
-      return Promise.resolve();
-    }
-    return ext.commands.list(cwd, session()).then((result) => {
-      if (mine !== seq) return;
-      list.set(result.commands.map(commandOf));
-      if (mode.get() !== result.mode) mode.set(result.mode);
-    }, onError);
-  };
-  const commands: ServerExtensionCommands = {
-    list,
-    mode,
-    async run(id, opts = {}) {
-      const cwd = folder();
-      if (!cwd) throw new ExtensionsHostError({ code: 'unavailable' });
-      return ext.commands.run(cwd, id, opts).catch(rethrow);
-    },
-  };
-  return { commands, refresh };
-}