zidane-ui 9.0.4 → 9.1.3

package/src/adapters/server-settings-sections.ts

@@ -1,184 +0,0 @@
-/**
- * The catalog and diagnostics groups of the zidane-server `SettingsHost`
- * (`createServerSettingsHost`), over the shared browser client:
- *
- * - `environments`: `environments.list` / `.update` (admin) / `.verify`.
- * - `instructions`: `sessions.contextSegments`, `sessions.createSystemOverride` (admin).
- * - `hostCatalog`: `catalog.skills|mcps|extensions|plugins`, kept current by
- *   `catalog:changed`; installs (`catalog.install|remove|update`, admin)
- *   when the server takes them (`remoteInstalls` on its hello) and the
- *   token reaches them. Its MCP servers are the accounts' `mcp` group.
- *
- * - `extensions`: the server's extensions (`catalog.extensions`), the
- *   options and action rows their folder declares
- *   (`extensions.configSchema` / `actions`, refetched on `catalog:changed`),
- *   the actions' probes (`extensions.actionStatuses`), a run
- *   (`extensions.runAction`, admin) and a scaffold (`extensions.create`,
- *   admin, when the server takes installs; a project one inside the server's
- *   workspace roots).
- * - `claudeImport`: the server's `~/.claude` (`claudeImport.detect` / `run`,
- *   admin, when the server takes installs).
- * - `logs`: the server's log (`logs.list`, admin), followed while shown
- *   (`logs.watch`, `logs:record`; watched again after a reconnect).
- *
- * Left out, as the protocol has no method for them: the local-disk
- * `skills` / `plugins` groups and the extensions' installs and removals by
- * folder (SKILL.md reads and writes, project-scope installs, the source
- * browser; a web app installs into the server's catalogs through
- * `hostCatalog`), `paths` and opening an instruction file in an editor.
- */
-import { IpcErrorCode, ServerCallError, ServerConnectionError, type ServerClient } from 'zidane/ipc/browser';
-import type { HostSignal } from 'zidane/ipc';
-
-import type { SettingsError, SettingsHost } from '../settings/headless/host';
-import { createSettingsResource, keyedSettingsResources } from '../settings/headless/resource';
-import type {
-  SettingsCatalogEntries,
-  SettingsCatalogKind,
-  SettingsExtensionCreate,
-  SettingsExtensionsHost,
-  SettingsLogsHost,
-  SettingsResource,
-} from '../settings/headless/sections-host';
-
-const errorOf = (error: unknown): SettingsError => {
-  const detail = error instanceof Error ? error.message : undefined;
-  const kind =
-    error instanceof ServerConnectionError
-      ? 'unreachable'
-      : error instanceof ServerCallError && error.code === IpcErrorCode.Forbidden
-        ? 'refused'
-        : 'failed';
-  return detail ? { kind, detail } : { kind };
-};
-
-/** The client's call, rejecting with a {@link SettingsError}. */
-export function settingsCaller(client: ServerClient): ServerClient['call'] {
-  return async (method, params) => {
-    try {
-      return await client.call(method, params);
-    } catch (error) {
-      throw errorOf(error);
-    }
-  };
-}
-
-const CATALOG_METHOD = {
-  skills: 'catalog.skills',
-  mcps: 'catalog.mcps',
-  extensions: 'catalog.extensions',
-  plugins: 'catalog.plugins',
-} as const;
-
-/**
- * The server's catalog and diagnostics groups.
- *
- * @param client - The shared client.
- */
-export function serverSettingsSections(
-  client: ServerClient,
-): Pick<SettingsHost, 'environments' | 'instructions' | 'hostCatalog' | 'extensions' | 'claudeImport' | 'logs'> {
-  const call = settingsCaller(client);
-  const installs = () => client.hello()?.remoteInstalls === true;
-  /** A folder's read, again when the server's extensions change. */
-  const extensionsResource = <T>(read: (cwd: string) => Promise<T>) => {
-    const made = new Set<SettingsResource<T>>();
-    client.onSignal((signal: HostSignal) => {
-      if (signal.kind === 'catalog:changed' && signal.catalog === 'extensions') for (const r of made) void r.refresh();
-    });
-    return keyedSettingsResources((cwd: string) => {
-      const resource = createSettingsResource(() => read(cwd));
-      made.add(resource);
-      return resource;
-    });
-  };
-  const extensions: SettingsExtensionsHost = {
-    list: async (cwd) => (await call('catalog.extensions', cwd ? { cwd } : {})).extensions,
-    configSchema: extensionsResource((cwd) => call('extensions.configSchema', { cwd })),
-    actions: extensionsResource((cwd) => call('extensions.actions', { cwd })),
-    actionStatuses: (cwd) => call('extensions.actionStatuses', { cwd }),
-    ...(client.can('extensions.runAction')
-      ? {
-          runAction: (cwd: string, extension: string, key: string) =>
-            call('extensions.runAction', { cwd, extension, key }),
-        }
-      : {}),
-    ...(installs() && client.can('extensions.create')
-      ? { create: (request: SettingsExtensionCreate) => call('extensions.create', request) }
-      : {}),
-  };
-  const logs: SettingsLogsHost = {
-    list: async () => (await call('logs.list', {})).records,
-    follow: (onRecord) => {
-      const watch = () => void client.call('logs.watch', {}).catch(() => undefined);
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'logs:record') onRecord(signal.record);
-      });
-      // A reconnect is a new connection: the server forgot the watch.
-      const offOpen = client.onOpen(watch);
-      watch();
-      return () => {
-        offSignal();
-        offOpen();
-        void client.call('logs.unwatch', {}).catch(() => undefined);
-      };
-    },
-  };
-  return {
-    ...(client.can('logs.list') ? { logs } : {}),
-    ...(client.can('extensions.configSchema') ? { extensions } : {}),
-    ...(installs() && client.can('claudeImport.run')
-      ? {
-          claudeImport: {
-            detect: (cwd: string) => call('claudeImport.detect', cwd ? { cwd } : {}),
-            run: (cwd: string, selection) => call('claudeImport.run', { ...(cwd ? { cwd } : {}), ...selection }),
-          },
-        }
-      : {}),
-    environments: {
-      list: (cwd) => call('environments.list', cwd ? { cwd } : {}),
-      update: async (change) => {
-        await call('environments.update', change);
-      },
-      verify: (kind) => call('environments.verify', { kind }),
-    },
-    instructions: {
-      segments: (sessionId) => call('sessions.contextSegments', { sessionId }),
-      createSystemOverride: async (sessionId) => {
-        await call('sessions.createSystemOverride', { sessionId });
-      },
-    },
-    hostCatalog: {
-      list: async <K extends SettingsCatalogKind>(kind: K, cwd?: string) => {
-        const method = CATALOG_METHOD[kind];
-        // A server too old to list its catalogs: the section shows its enabled list instead.
-        if (client.state().status === 'open' && !client.can(method)) return null;
-        const params = cwd ? { cwd } : {};
-        const answer = await call(method, params);
-        const entries =
-          'skills' in answer
-            ? answer.skills
-            : 'servers' in answer
-              ? answer.servers
-              : 'extensions' in answer
-                ? answer.extensions
-                : answer.plugins;
-        return entries as SettingsCatalogEntries[K][];
-      },
-      onChanged: (listener) =>
-        client.onSignal((signal: HostSignal) => {
-          if (signal.kind === 'catalog:changed') listener(signal.catalog);
-        }),
-      installs: async () => client.hello()?.remoteInstalls === true && client.can('catalog.install'),
-      install: async (kind, spec) => {
-        await call('catalog.install', { kind, spec, scope: 'user' });
-      },
-      remove: async (kind, name) => {
-        await call('catalog.remove', { kind, name });
-      },
-      update: async (kind, name) => {
-        await call('catalog.update', { kind, name });
-      },
-    },
-  };
-}

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

@@ -1,59 +0,0 @@
-/**
- * A `SidebarHost` on a running zidane-server: a session's environment
- * commands (`sessions.environmentActions`, `sessions.runEnvironmentAction`,
- * which needs an `admin` token), setting a failed environment up again
- * (`sessions.retryEnvironment`) and, when the handshake lists it, the rows'
- * badges (`artifacts.badges`, read again on a session's `artifact:recorded` /
- * `artifact:changed` and on `catalog:changed` for extensions).
- *
- * Left out, with no zidane-server method behind them: `revealPath` (the
- * folders are on the server, not where the browser runs) and `openWindow`
- * (a browser opens its own tabs). Built after the handshake
- * (`await client.ready`). Share the chat host's client:
- * `createServerSidebarHost({ client: chat.client })`.
- */
-import { ARTIFACT_BADGES_MAX } from 'zidane/chat/pure';
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import type { SidebarHost } from '../chat/headless/sidebar/host';
-
-/** Options for {@link createServerSidebarHost}. */
-export interface ServerSidebarHostOptions {
-  /** The client to speak through, shared with the chat host (`createServerHost(…).client`). */
-  client: ServerClient;
-}
-
-/**
- * Creates a {@link SidebarHost} over a zidane-server client.
- *
- * @param options - The client to speak through.
- */
-export function createServerSidebarHost(options: ServerSidebarHostOptions): SidebarHost {
-  const { client } = options;
-  return {
-    environment: {
-      actions: (sessionId) => client.call('sessions.environmentActions', { sessionId }),
-      run: (sessionId, actionId) => client.call('sessions.runEnvironmentAction', { sessionId, actionId }),
-      retry: async (sessionId) => {
-        await client.call('sessions.retryEnvironment', { sessionId });
-      },
-    },
-    ...(client.can('artifacts.badges')
-      ? {
-          badges: {
-            read: (sessionIds) => client.call('artifacts.badges', { sessionIds: [...sessionIds] }),
-            batchMax: ARTIFACT_BADGES_MAX,
-            onArtifactsChanged: (listener) =>
-              client.onSignal((signal) => {
-                if (signal.kind === 'artifact:recorded' || signal.kind === 'artifact:changed')
-                  listener(signal.sessionId);
-              }),
-            onRegistryChanged: (listener) =>
-              client.onSignal((signal) => {
-                if (signal.kind === 'catalog:changed' && signal.catalog === 'extensions') listener();
-              }),
-          },
-        }
-      : {}),
-  };
-}

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

@@ -1,124 +0,0 @@
-/**
- * A `TerminalHost` on a running zidane-server, over a shared browser client
- * (`createServerClient`): a session's terminals (`terminal.state`,
- * `terminal.open`), project and draft terminals when the server runs them
- * (`HelloResult.projectTerminals`: `terminal.projectState`,
- * `terminal.openInProject`, `terminal.adopt`, `terminal.releaseDraft`), and
- * a view's link to one terminal (`terminal.attach` / `detach` / `write` /
- * `resize` / `ack`). The `terminal:changed`, `terminal:project-changed`,
- * `terminal:output` and `terminal:reset` signals keep the store current;
- * every reconnect re-attaches the views.
- *
- * Every `terminal.*` method needs an `admin` token: without it the scope
- * reads as unavailable. Layouts stay in the page (no layout methods).
- */
-import type { ServerClient } from 'zidane/ipc/browser';
-import type { HostSignal } from 'zidane/ipc';
-
-import type { TerminalHost, TerminalSessionState } from '../terminal/headless/host';
-
-/** Options for {@link createServerTerminalHost}. */
-export interface ServerTerminalHostOptions {
-  /** The client to speak through, shared with the chat host (`createServerHost({ client })`) and other areas' hosts. */
-  client: ServerClient;
-}
-
-const LOCAL = { kind: 'local', remote: false } as const;
-
-/** A void method's answer (JSON-RPC sends `null`). */
-const done = (call: Promise<unknown>): Promise<void> => call.then(() => undefined);
-
-/**
- * Creates a {@link TerminalHost} on a running zidane-server.
- *
- * @param options - The shared client.
- */
-export function createServerTerminalHost(options: ServerTerminalHostOptions): TerminalHost {
-  const { client } = options;
-  /** The connection is open and the token cannot call `method`. */
-  const refused = (method: Parameters<ServerClient['can']>[0]) => client.hello() !== null && !client.can(method);
-  const projects = () => client.hello()?.projectTerminals === true;
-
-  return {
-    async state(scope): Promise<TerminalSessionState> {
-      if (scope.session) {
-        if (refused('terminal.state')) return { available: false, environment: LOCAL, terminals: [] };
-        return client.call('terminal.state', { sessionId: scope.session });
-      }
-      await client.ready;
-      if (!projects() || refused('terminal.projectState'))
-        return { available: false, environment: LOCAL, terminals: [] };
-      const p = await client.call('terminal.projectState', {
-        cwd: scope.cwd,
-        ...(scope.draft ? { draftId: scope.draft } : {}),
-      });
-      return {
-        available: p.available,
-        ...(p.reason !== undefined ? { reason: p.reason } : {}),
-        environment: LOCAL,
-        terminals: p.terminals,
-      };
-    },
-    open: (scope, { target, cols, rows }) =>
-      scope.session
-        ? client.call('terminal.open', { sessionId: scope.session, ...(target ? { target } : {}), cols, rows })
-        : client.call('terminal.openInProject', {
-            cwd: scope.cwd,
-            ...(scope.draft ? { draftId: scope.draft } : {}),
-            cols,
-            rows,
-          }),
-    attach: (terminalId, clientId) => client.call('terminal.attach', { terminalId, clientId }),
-    detach: (terminalId, clientId) => done(client.call('terminal.detach', { terminalId, clientId })),
-    write: (terminalId, data, from) =>
-      done(
-        client.call('terminal.write', {
-          terminalId,
-          data,
-          ...(from ? { clientId: from.clientId, ...(from.response ? { response: true } : {}) } : {}),
-        }),
-      ),
-    resize: (terminalId, clientId, cols, rows, claim) =>
-      done(client.call('terminal.resize', { terminalId, clientId, cols, rows, claim })),
-    ack: (terminalId, clientId, offset) => done(client.call('terminal.ack', { terminalId, clientId, offset })),
-    close: (terminalId) => done(client.call('terminal.close', { terminalId })),
-    restart: (terminalId) => done(client.call('terminal.restart', { terminalId })),
-    setHidden: (terminalId, hidden) => done(client.call('terminal.setHidden', { terminalId, hidden })),
-    async adoptDraft(draftId, sessionId) {
-      const { adopted } = await client.call('terminal.adopt', { draftId, sessionId });
-      return { adopted };
-    },
-    releaseDraft: (draftId) => done(client.call('terminal.releaseDraft', { draftId })),
-    listen(sink) {
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        switch (signal.kind) {
-          case 'terminal:changed':
-            sink.sessionChanged(signal.sessionId, signal.terminals);
-            break;
-          case 'terminal:project-changed':
-            sink.projectChanged({
-              root: signal.root,
-              ...(signal.draftId ? { draftId: signal.draftId } : {}),
-              terminals: signal.terminals,
-            });
-            break;
-          case 'terminal:output':
-          case 'terminal:reset': {
-            const data = { terminalId: signal.terminalId, offset: signal.offset, data: signal.data };
-            if (signal.kind === 'terminal:output') sink.output(data);
-            else sink.reset(data);
-            break;
-          }
-        }
-      });
-      // A new connection has no views attached and may have missed lists.
-      const offOpen = client.onOpen((_hello, reconnected) => {
-        if (reconnected) sink.relink(true);
-      });
-      return () => {
-        offSignal();
-        offOpen();
-      };
-    },
-  };
-}

package/src/adapters/server-transcript-members.ts

@@ -1,131 +0,0 @@
-/**
- * The transcript extras of a zidane-server `ChatHost`: the shared search
- * (`search.set`, `search:changed`), what prose chips name on the server's
- * disk (`files.resolvePaths`) and what chip hover cards read
- * (`sessions.list`, `catalog.skills`, `commands.list`, a commit's facts
- * through `git.commit`, a session's context gauge through
- * `sessions.contextBreakdown`), the extensions' text references
- * (`references.providers` / `resolve`, stale on `catalog:changed`) and badge
- * menu items (`badges.actions` / `run`). A read is left out once the
- * handshake says the connection may not call it; a failed read is unknown.
- *
- * No site icons: the page's Content-Security-Policy (`img-src 'self' data:
- * blob:`) keeps a browser from loading other sites' images, so link badges
- * show the globe.
- */
-import { fmtTokens, type BadgeTarget } from 'zidane/chat/pure';
-import type { HostSignal } from 'zidane/ipc';
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import type { ChatHost } from '../chat/headless/host';
-import type { ChatSearchState } from '../chat/headless/transcript-host';
-
-/** The members `createServerHost` adds for the transcript's extras. */
-export type ServerTranscriptMembers = Pick<ChatHost, 'searchSync' | 'paths' | 'chips' | 'references' | 'badges'>;
-
-/**
- * Builds the transcript extras over a server connection.
- *
- * @param client - The connection.
- */
-export function createServerTranscriptMembers(client: ServerClient): ServerTranscriptMembers {
-  // Built before the handshake too (`createServerHost`): offered until a hello says the server lacks the method.
-  const may = (method: Parameters<ServerClient['can']>[0]) => client.hello() === null || client.can(method);
-  return {
-    ...(may('references.resolve')
-      ? {
-          references: {
-            providers: (cwd: string, options?: { peek?: boolean }) =>
-              client.call('references.providers', { cwd, ...(options?.peek ? { peek: true } : {}) }),
-            resolve: (cwd: string, items: readonly { providerId: string; key: string }[]) =>
-              client.call('references.resolve', { cwd, items: [...items] }),
-            resolveMax: 50,
-            onChanged: (listener: (change: { kind: 'all' }) => void) =>
-              client.onSignal((signal: HostSignal) => {
-                if (signal.kind === 'catalog:changed' && signal.catalog === 'extensions') listener({ kind: 'all' });
-              }),
-          },
-        }
-      : {}),
-    ...(may('badges.run')
-      ? {
-          badges: {
-            actions: (cwd: string, target: BadgeTarget) => client.call('badges.actions', { cwd, target }),
-            run: (cwd: string, source: string, id: string, target: BadgeTarget) =>
-              client.call('badges.run', { cwd, source, id, target }),
-          },
-        }
-      : {}),
-    searchSync: {
-      async set(sessionId, { active, query }) {
-        await client.call('search.set', { sessionId, active, query });
-      },
-      onChanged(listener) {
-        return client.onSignal((signal: HostSignal) => {
-          if (signal.kind !== 'search:changed') return;
-          const state: ChatSearchState = { sessionId: signal.sessionId, active: signal.active, query: signal.query };
-          listener(state);
-        });
-      },
-    },
-    ...(may('files.resolvePaths')
-      ? {
-          paths: {
-            // A folder outside the server's workspace roots can't be checked.
-            resolve: (cwd: string, texts: readonly string[]) =>
-              client.call('files.resolvePaths', { cwd, texts: [...texts] }).catch(() => null),
-          },
-        }
-      : {}),
-    chips: {
-      ...(may('git.commit')
-        ? { commit: (cwd: string, sha: string) => client.call('git.commit', { cwd, sha }).catch(() => null) }
-        : {}),
-      ...(may('sessions.contextBreakdown')
-        ? {
-            // Labeled as the composer's gauge labels its own (`fmtTokens`).
-            async context(sessionId: string) {
-              const breakdown = await client.call('sessions.contextBreakdown', { sessionId }).catch(() => null);
-              return breakdown
-                ? {
-                    modelId: breakdown.modelId,
-                    usedLabel: fmtTokens(breakdown.used),
-                    windowLabel: fmtTokens(breakdown.effectiveWindow),
-                    fraction: breakdown.fraction,
-                  }
-                : null;
-            },
-          }
-        : {}),
-      async sessions() {
-        const rows = await client.call('sessions.list', { archive: 'all' });
-        return rows.map((row) => ({
-          id: row.id,
-          title: row.title,
-          status: row.status,
-          updatedAt: row.updatedAt,
-          ...((row.projectRoot ?? row.cwd) ? { project: row.projectRoot ?? row.cwd } : {}),
-          ...(row.modelId ? { modelId: row.modelId } : {}),
-          ...(row.environment?.branch ? { branch: row.environment.branch } : {}),
-        }));
-      },
-      async skills(cwd) {
-        const { skills } = await client.call('catalog.skills', { cwd });
-        return skills.map((s) => ({
-          name: s.name,
-          description: s.description,
-          ...(s.source && s.source !== 'inline' ? { source: s.source } : {}),
-        }));
-      },
-      async commands(cwd) {
-        const list = await client.call('commands.list', { cwd });
-        return list.map((c) => ({
-          name: c.name,
-          ...(c.description ? { description: c.description } : {}),
-          ...(c.aliases?.length ? { aliases: c.aliases } : {}),
-          ...(c.group ? { group: c.group } : {}),
-        }));
-      },
-    },
-  };
-}