zidane-ui 9.0.4 → 9.1.3

package/src/settings/headless/enabled.ts

@@ -1,44 +0,0 @@
-/**
- * The enabled allowlists (`enabledSkills`, `enabledMcps`,
- * `enabledExtensions`, `enabledPlugins`) against a discovered catalog:
- *
- *   - `undefined`: every catalog entry is on (a fresh install).
- *   - `[]`: the whole kind is off.
- *   - `[names]`: exactly those.
- *
- * The first toggle seeds the list from the catalog, so entries found later
- * are not dropped silently. One list serves every folder while the catalog
- * is one folder's, so names off this catalog (another project's) stay in it
- * untouched.
- */
-
-/** The settings keys that hold an enabled allowlist. */
-export type SettingsEnabledListKey = 'enabledSkills' | 'enabledMcps' | 'enabledExtensions' | 'enabledPlugins';
-
-/**
- * The names that are on.
- *
- * @param list - The stored allowlist (`undefined`: every entry).
- * @param catalog - The names in the catalog.
- */
-export function enabledNames(list: readonly string[] | undefined, catalog: readonly string[]): ReadonlySet<string> {
-  return new Set(list ?? catalog);
-}
-
-/**
- * The allowlist after turning `name` on or off.
- *
- * @param list - The stored allowlist (`undefined`: every entry).
- * @param catalog - The names in the catalog (the ones the list governs here).
- * @param name - The entry toggled.
- * @returns The new list, sorted: this catalog's enabled names plus every stored name off it.
- */
-export function toggleEnabled(list: readonly string[] | undefined, catalog: readonly string[], name: string): string[] {
-  const next = new Set(enabledNames(list, catalog));
-  if (next.has(name)) next.delete(name);
-  else next.add(name);
-  const inCatalog = new Set(catalog);
-  const kept = [...next].filter((n) => inCatalog.has(n));
-  const offCatalog = (list ?? []).filter((n) => !inCatalog.has(n));
-  return [...new Set([...kept, ...offCatalog])].sort();
-}

package/src/settings/headless/fixture-accounts.ts

@@ -1,260 +0,0 @@
-/**
- * The in-memory `providers` and `mcp` groups of the fixture settings host
- * (`createFixtureSettingsHost({ accounts })`), for docs, demos, galleries
- * and an app's own tests. Every action lands at once; a browser sign-in
- * opens its page and waits for `control.finishSignIn()` (or `signInMs`).
- */
-import type { McpFormResult, OnboardingSignInState } from 'zidane/chat/pure';
-
-import { writable } from '../../chat/headless/store';
-import type { SignInFlow } from '../../onboarding/headless/host';
-import type { SettingsMcpHost, SettingsMcpInstance, SettingsMcpServer } from './mcp';
-import type {
-  SettingsCredential,
-  SettingsPreferredCredential,
-  SettingsProvider,
-  SettingsProvidersHost,
-  SettingsSignInOptions,
-} from './providers';
-import { createSettingsResource } from './resource';
-
-/** What the fixture's Accounts and MCP servers hold. Each key offers its group. */
-export interface FixtureSettingsAccountsData {
-  /** The providers (offers `providers`). */
-  providers?: readonly SettingsProvider[];
-  /** The MCP servers (offers `mcp`). */
-  mcp?: readonly SettingsMcpServer[];
-  /** Their running processes (offers `mcp.instances` and `mcp.restart`). */
-  mcpInstances?: readonly SettingsMcpInstance[];
-  /** A sign-in finishes on its own after this many ms. Default: only on `control.finishSignIn()`. */
-  signInMs?: number;
-  /** The address a sign-in opens. Default: `https://example.com/sign-in`. */
-  signInUrl?: string;
-}
-
-/** Reads what the fixture holds and finishes its sign-ins. */
-export interface FixtureSettingsAccountsControl {
-  /** The providers held now. */
-  providers(): readonly SettingsProvider[];
-  /** The MCP servers held now. */
-  servers(): readonly SettingsMcpServer[];
-  /** The servers restarted, in order. */
-  restarts(): readonly string[];
-  /** Finishes every sign-in that waits for its browser. */
-  finishSignIn(): void;
-}
-
-/** The groups and their control. */
-export interface FixtureSettingsAccounts {
-  /** The `providers` group, when `data.providers` was given. */
-  providers?: SettingsProvidersHost;
-  /** The `mcp` group, when `data.mcp` was given. */
-  mcp?: SettingsMcpHost;
-  /** Reads what the groups hold and finishes their sign-ins. */
-  control: FixtureSettingsAccountsControl;
-}
-
-const API_KEY_DETAIL = 'credentials.json';
-const OAUTH_DETAIL = 'expires in 30 days';
-
-/** The provider with its flags derived from its credentials. */
-function withFlags(provider: SettingsProvider, methods: readonly SettingsCredential[]): SettingsProvider {
-  const stored = methods.filter((m) => m.source !== 'env');
-  // Exactly one stored credential is in use: the marked one, else the first.
-  const active = stored.find((m) => m.active) ?? stored[0];
-  const next = methods.map((m) => (m.source === 'env' ? m : { ...m, active: m === active }));
-  return {
-    ...provider,
-    methods: next,
-    hasApiKey: stored.some((m) => m.source === 'apikey'),
-    hasOAuth: stored.some((m) => m.source === 'oauth'),
-    available: next.length > 0 || Boolean(provider.configuredFields && Object.keys(provider.configuredFields).length),
-  };
-}
-
-/**
- * Creates the fixture's `providers` and `mcp` groups.
- *
- * @param data - The providers and servers held, and how sign-ins finish.
- */
-export function createFixtureSettingsAccounts(data: FixtureSettingsAccountsData = {}): FixtureSettingsAccounts {
-  const url = data.signInUrl ?? 'https://example.com/sign-in';
-  let providers = (data.providers ?? []).map((p) => withFlags(p, p.methods));
-  let servers = [...(data.mcp ?? [])];
-  let instances = [...(data.mcpInstances ?? [])];
-  const restarts: string[] = [];
-  const waiting = new Set<() => void>();
-  const providerList = createSettingsResource(async () => providers, { initial: providers });
-  const serverList = createSettingsResource(async () => servers, { initial: servers });
-  const instanceList = createSettingsResource(async () => instances, { initial: instances });
-
-  const editProvider = async (key: string, edit: (p: SettingsProvider) => SettingsProvider) => {
-    if (!providers.some((p) => p.key === key)) throw new Error(`No provider ${key}`);
-    providers = providers.map((p) => (p.key === key ? edit(p) : p));
-    await providerList.refresh();
-  };
-  const editServer = (name: string, edit: (s: SettingsMcpServer) => SettingsMcpServer) => {
-    if (!servers.some((s) => s.name === name)) throw new Error(`No server ${name}`);
-    servers = servers.map((s) => (s.name === name ? edit(s) : s));
-  };
-
-  /** A sign-in that opens its page, then waits for its browser. */
-  const flow = (finish: () => Promise<void>): SignInFlow => {
-    const state = writable<OnboardingSignInState>({ kind: 'starting' });
-    let ended = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const done = () => {
-      if (ended) return;
-      ended = true;
-      waiting.delete(done);
-      if (timer) clearTimeout(timer);
-      void finish().then(() => state.set({ kind: 'done' }));
-    };
-    queueMicrotask(() => {
-      if (ended) return;
-      state.set({ kind: 'url', url });
-      waiting.add(done);
-      if (data.signInMs !== undefined) timer = setTimeout(done, data.signInMs);
-    });
-    return {
-      state,
-      cancel: () => {
-        ended = true;
-        waiting.delete(done);
-        if (timer) clearTimeout(timer);
-      },
-    };
-  };
-
-  const providersHost: SettingsProvidersHost = {
-    list: () => providerList,
-    setApiKey: (_cwd, key, value) =>
-      editProvider(key, (p) => {
-        if (!value.trim()) throw new Error('The API key is empty.');
-        const rest = p.methods.filter((m) => m.source !== 'apikey');
-        return withFlags(p, [
-          { source: 'apikey', key: `${key}:apikey`, detail: API_KEY_DETAIL, active: true },
-          ...rest.map((m) => ({ ...m, active: false })),
-        ]);
-      }),
-    configure: (_cwd, key, fields) =>
-      editProvider(key, (p) => {
-        const secret = new Set((p.customFields ?? []).filter((f) => f.secret).map((f) => f.key));
-        const shown = Object.fromEntries(Object.entries(fields).filter(([k, v]) => !secret.has(k) && v.trim()));
-        return withFlags({ ...p, configuredFields: shown }, p.methods);
-      }),
-    clear: (_cwd, key) =>
-      editProvider(key, (p) =>
-        withFlags(
-          { ...p, configuredFields: undefined },
-          p.methods.filter((m) => m.source === 'env'),
-        ),
-      ),
-    remove: (_cwd, key, credential) =>
-      editProvider(key, (p) =>
-        withFlags(
-          p,
-          p.methods.filter((m) => m.key !== credential),
-        ),
-      ),
-    setPreferred: (_cwd, key, target: SettingsPreferredCredential) =>
-      editProvider(key, (p) => {
-        const pick = p.methods.find((m) =>
-          typeof target === 'string' ? m.source === target : m.key !== undefined && m.key === target.key,
-        );
-        return withFlags(
-          p,
-          p.methods.map((m) => (m.source === 'env' ? m : { ...m, active: m === pick })),
-        );
-      }),
-    rename: (_cwd, key, credential, label) =>
-      editProvider(key, (p) =>
-        withFlags(
-          p,
-          p.methods.map((m) => (m.key === credential ? { ...m, label: label || 'Default' } : m)),
-        ),
-      ),
-    signIn: (key, options: SettingsSignInOptions = {}) =>
-      flow(() =>
-        editProvider(key, (p) => {
-          if (options.replaceKey) {
-            return withFlags(
-              p,
-              p.methods.map((m) => (m.key === options.replaceKey ? { ...m, detail: OAUTH_DETAIL } : m)),
-            );
-          }
-          const label = options.label ?? 'Default';
-          const others = p.methods.map((m) => ({ ...m, active: false }));
-          return withFlags(p, [
-            ...others,
-            { source: 'oauth', key: `${key}:oauth:${label}`, label, detail: OAUTH_DETAIL, active: true },
-          ]);
-        }),
-      ),
-  };
-
-  const mcpHost: SettingsMcpHost = {
-    servers: () => serverList,
-    projectScope: true,
-    test: async (_cwd, name) => {
-      editServer(name, (s) => ({
-        ...s,
-        test:
-          s.authState === 'needs-auth'
-            ? { kind: 'needs-auth', at: Date.now() }
-            : { kind: 'ok', at: Date.now(), tools: s.tools?.length ?? 0 },
-        toolsUpdatedAt: Date.now(),
-      }));
-      await serverList.refresh();
-    },
-    signIn: (_cwd, name) =>
-      flow(async () => {
-        editServer(name, (s) => ({ ...s, authState: 'authed', lastError: undefined }));
-        await serverList.refresh();
-      }),
-    signOut: async (_cwd, name) => {
-      editServer(name, (s) => ({ ...s, authState: s.transport === 'http' ? 'needs-auth' : 'idle' }));
-      await serverList.refresh();
-    },
-    add: async (cwd, { entry, scope }: McpFormResult) => {
-      const server: SettingsMcpServer = {
-        name: entry.name,
-        transport: entry.transport === 'stdio' ? 'stdio' : 'http',
-        ...(entry.command ? { command: [entry.command, ...(entry.args ?? [])].join(' ') } : {}),
-        ...(entry.url ? { url: entry.url } : {}),
-        authState: entry.transport === 'stdio' ? 'idle' : 'needs-auth',
-        path: scope === 'project' && cwd ? `${cwd}/.zidane/mcps.json` : '~/.zidane/mcps.json',
-        removable: true,
-      };
-      servers = [...servers.filter((s) => s.name !== entry.name), server];
-    },
-    remove: async (_cwd, name) => {
-      editServer(name, (s) => s);
-      servers = servers.filter((s) => s.name !== name);
-    },
-    ...(data.mcpInstances
-      ? {
-          instances: () => instanceList,
-          // A fresh process: a new pid, the same sessions.
-          restart: async (_cwd: string, name: string) => {
-            restarts.push(name);
-            instances = instances.map((i) => (i.name === name && i.pid !== undefined ? { ...i, pid: i.pid + 1 } : i));
-            await instanceList.refresh();
-          },
-        }
-      : {}),
-  };
-
-  return {
-    ...(data.providers ? { providers: providersHost } : {}),
-    ...(data.mcp ? { mcp: mcpHost } : {}),
-    control: {
-      providers: () => providers,
-      servers: () => servers,
-      restarts: () => restarts,
-      finishSignIn: () => {
-        for (const done of [...waiting]) done();
-      },
-    },
-  };
-}

package/src/settings/headless/fixture-host.ts

@@ -1,162 +0,0 @@
-/**
- * A `SettingsHost` that runs in memory, for docs, demos, galleries and an
- * app's own tests: the settings start from `DEFAULT_SETTINGS` and the
- * `values` given, and every write lands at once. `control` changes the
- * stored settings from outside (another window edited them), refuses
- * writes, or makes reads fail.
- */
-import type { Settings } from 'zidane/chat';
-
-import { writable } from '../../chat/headless/store';
-import { DEFAULT_SETTINGS } from './catalog';
-import type { SettingsDocument, SettingsError, SettingsHost } from './host';
-import {
-  createFixtureSettingsSections,
-  type FixtureSettingsSectionsControl,
-  type FixtureSettingsSectionsData,
-} from './fixture-sections';
-import {
-  createFixtureSettingsAccounts,
-  type FixtureSettingsAccountsControl,
-  type FixtureSettingsAccountsData,
-} from './fixture-accounts';
-import { createFixtureSettingsModels, type FixtureSettingsModelsData } from './fixture-models';
-import {
-  createFixturePerformanceHost,
-  type FixturePerformanceControl,
-  type FixturePerformanceOptions,
-} from './fixture-performance';
-import type {
-  SettingsClaudeImportDetect,
-  SettingsClaudeImportSelection,
-  SettingsClaudeImportSummary,
-} from './claude-import';
-
-/** Options for {@link createFixtureSettingsHost}. */
-export interface FixtureSettingsOptions {
-  /** The stored settings over `DEFAULT_SETTINGS`. */
-  values?: Partial<Settings>;
-  /** Leave `update` out: every row read-only. Default: false. */
-  readOnly?: boolean;
-  /** Offer `writable` with this value (a connection that may or may not write). Default: not offered. */
-  writable?: boolean;
-  /** The settings can't be read: `document` lands on an error. Default: false. */
-  unreadable?: boolean;
-  /** The catalog and diagnostics sections' data (skills, extensions, plugins, …); each key offers its group. */
-  sections?: FixtureSettingsSectionsData;
-  /** Accounts' providers and MCP servers' servers; each key offers its group. */
-  accounts?: FixtureSettingsAccountsData;
-  /** The model rows' decision models, tests and last used model; each key offers its member of `models`. */
-  models?: FixtureSettingsModelsData;
-  /** What `~/.claude` holds and what an import answers; offers `claudeImport`. */
-  claudeImport?: { detect: SettingsClaudeImportDetect; summary: SettingsClaudeImportSummary };
-  /** Offers `performance`: a believable app whose figures drift while watched. */
-  performance?: FixturePerformanceOptions;
-}
-
-/** Changes the fixture's stored settings from outside. */
-export interface FixtureSettingsControl {
-  /** The settings stored now. */
-  stored(): Settings;
-  /** Another writer changed the stored settings; the host reads them on its next `refresh`. */
-  store(patch: Partial<Settings>): void;
-  /** Refuse (`true`) or take (`false`) the next writes. */
-  refuse(next: boolean): void;
-  /** Make reads fail (`true`) or succeed (`false`). */
-  unreadable(next: boolean): void;
-  /** The catalog and diagnostics sections' data and what their actions did. */
-  sections: FixtureSettingsSectionsControl;
-  /** Accounts' providers and MCP servers' servers, and their sign-ins. */
-  accounts: FixtureSettingsAccountsControl;
-  /** The Claude Code imports run, in order. */
-  claudeImports(): SettingsClaudeImportSelection[];
-  /** The performance member's control (`null` without `options.performance`). */
-  performance: FixturePerformanceControl | null;
-}
-
-/** A fixture settings host and its control. */
-export type FixtureSettingsHost = SettingsHost & { control: FixtureSettingsControl };
-
-/**
- * Creates an in-memory {@link SettingsHost}.
- *
- * @param options - The stored settings, and whether it is read-only, may write, or fails reads.
- * @returns The host and its control.
- */
-export function createFixtureSettingsHost(options: FixtureSettingsOptions = {}): FixtureSettingsHost {
-  let stored: Settings = { ...DEFAULT_SETTINGS, ...options.values };
-  let refusing = false;
-  const claudeImport = options.claudeImport;
-  const imports: SettingsClaudeImportSelection[] = [];
-  let failing = options.unreadable === true;
-  const read = (): SettingsDocument =>
-    failing ? { status: 'error', error: { kind: 'unreachable' } } : { status: 'ready', values: stored };
-  const document = writable<SettingsDocument>(read());
-  const { control: sections, ...sectionMembers } = createFixtureSettingsSections(options.sections);
-  const { control: accounts, ...accountMembers } = createFixtureSettingsAccounts(options.accounts);
-  const performance = options.performance ? createFixturePerformanceHost(options.performance) : null;
-  const refresh = async () => {
-    const current = document.get();
-    if (failing && current.status === 'ready') return;
-    document.set(read());
-  };
-  const update = async (patch: Partial<Settings>) => {
-    const current = document.get();
-    if (current.status === 'ready') document.set({ status: 'ready', values: { ...current.values, ...patch } });
-    if (refusing) {
-      document.set(read());
-      const error: SettingsError = { kind: 'refused' };
-      throw error;
-    }
-    stored = { ...stored, ...patch };
-    document.set(read());
-  };
-  return {
-    document,
-    refresh,
-    ...(options.readOnly ? {} : { update }),
-    ...(options.writable !== undefined ? { writable: writable(options.writable) } : {}),
-    ...sectionMembers,
-    ...accountMembers,
-    ...createFixtureSettingsModels(options.models),
-    ...(claudeImport
-      ? {
-          claudeImport: {
-            detect: async () => claudeImport.detect,
-            run: async (_cwd: string, selection: SettingsClaudeImportSelection) => {
-              imports.push(selection);
-              return claudeImport.summary;
-            },
-          },
-        }
-      : {}),
-    ...(performance
-      ? {
-          performance: {
-            history: performance.history,
-            watch: performance.watch,
-            threads: performance.threads,
-            resetCounters: performance.resetCounters,
-            exportReport: performance.exportReport,
-            profile: performance.profile,
-          },
-        }
-      : {}),
-    control: {
-      performance: performance?.control ?? null,
-      claudeImports: () => [...imports],
-      stored: () => stored,
-      store: (patch) => {
-        stored = { ...stored, ...patch };
-      },
-      refuse: (next) => {
-        refusing = next;
-      },
-      unreadable: (next) => {
-        failing = next;
-      },
-      sections,
-      accounts,
-    },
-  };
-}

package/src/settings/headless/fixture-models.ts

@@ -1,51 +0,0 @@
-/**
- * The `models` group of the fixture settings host: decision models, tests
- * and the last used model from the data given. Each key of the data offers
- * its member.
- */
-import type { ModelPickRef } from '../../chat/headless/composer/models';
-import type { SettingsHost } from './host';
-import type { SettingsDecisionModel, SettingsModelTest, SettingsModelsHost } from './models';
-import { createSettingsResource, keyedSettingsResources } from './resource';
-
-/** The fixture's model data; each key offers its member of `models`. */
-export interface FixtureSettingsModelsData {
-  /** The decision models (for every folder). */
-  decisionModels?: SettingsDecisionModel[];
-  /** How a test of each model goes, by model setting; a model left out fails as `unavailable`. Offers `test` and `testDecision`. */
-  tests?: Record<string, SettingsModelTest>;
-  /** The last model picked (`null`: none). */
-  lastUsed?: ModelPickRef | null;
-}
-
-const failed = (model: string): SettingsModelTest => ({
-  ok: false,
-  reason: 'unavailable',
-  message: `${model} is not signed in`,
-  durationMs: 0,
-});
-
-/**
- * Creates the fixture's `models` group.
- *
- * @param data - The models data; absent: no `models` group.
- */
-export function createFixtureSettingsModels(data?: FixtureSettingsModelsData): Pick<SettingsHost, 'models'> {
-  if (!data) return {};
-  const models: SettingsModelsHost = {};
-  const { decisionModels, tests, lastUsed } = data;
-  if (decisionModels) {
-    models.decisionModels = keyedSettingsResources(() => createSettingsResource(async () => decisionModels));
-  }
-  if (tests) {
-    models.test = async (_cwd, model) => tests[model] ?? failed(model);
-    // No model: the one agents would get, the first available.
-    models.testDecision = async (_cwd, model) => {
-      const first = decisionModels?.find((m) => m.available);
-      const key = model ?? (first ? `${first.providerKey}/${first.modelId}` : undefined);
-      return (key && tests[key]) || failed(key ?? 'decisions');
-    };
-  }
-  if (lastUsed !== undefined) models.lastUsed = async () => lastUsed;
-  return Object.keys(models).length > 0 ? { models } : {};
-}