zidane-ui 9.0.4 → 9.1.3

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

@@ -1,519 +0,0 @@
-/**
- * A `MachinesHost` held in memory, for docs, demos, galleries and tests:
- * the hosts, each server's machines, this computer's links, each server's
- * self-update and tokens, and a local daemon. Every action changes the
- * fixture's own state and tells the matching `on…` callback.
- */
-import type {
-  DaemonHealth,
-  HostCapabilities,
-  MachineInfo,
-  MachineLinksStatus,
-  OnboardingSignInState,
-  ServerUpdateStatus,
-} from 'zidane/chat/pure';
-
-import { writable } from '../../chat/headless/store';
-import type { SignInFlow } from '../../onboarding/headless/host';
-import {
-  machinesError,
-  type DaemonStatus,
-  type HostCheckResult,
-  type HostProviderAuth,
-  type HostSummary,
-  type HostsState,
-  type MachineActionResult,
-  type MachineInvite,
-  type MachinesAction,
-  type MachinesHost,
-  type ServerToken,
-  type ServerTokenScope,
-} from './host';
-import { createPresenceStore, type SessionPresence } from './presence';
-import { createMachineLists, createOnlineMachines } from './stores';
-import { createHostSyncReads, type HostSyncPatch, type HostSyncState, type SyncStatus } from './sync';
-
-/** Options of {@link createFixtureMachinesHost}. */
-export interface FixtureMachinesOptions {
-  /** The hosts, This computer first. Default: This computer alone. */
-  hosts?: readonly HostSummary[];
-  /** More than This computer shows. Default: true. */
-  enabled?: boolean;
-  /** Each server's machines, by host id. */
-  machines?: Readonly<Record<string, readonly MachineInfo[]>>;
-  /** This computer's links. Default: none. */
-  links?: MachineLinksStatus;
-  /** Each server's self-update, by host id; `null`: the server predates it. Default: an up-to-date one. */
-  updates?: Readonly<Record<string, ServerUpdateStatus | null>>;
-  /** Each server's tokens, by host id. Default: none. */
-  tokens?: Readonly<Record<string, readonly ServerToken[]>>;
-  /** The local daemon's status, or `false` for no daemon. Default: no daemon. */
-  daemon?: DaemonStatus | false;
-  /** The daemon's health. Default: `connected`. */
-  health?: DaemonHealth;
-  /** What every host can do, or `false` for no `capabilities`. Default: false. */
-  capabilities?: HostCapabilities | false;
-  /** Called when a capability read reaches the fixture. */
-  onCapabilities?: (hostId: string, refresh: boolean) => void;
-  /** Every live session's presence, or `false` for no `presence`. Default: false. */
-  presence?: readonly SessionPresence[] | false;
-  /** What the token may do, or `false` for no `permitted` store (everything). Default: false. */
-  permitted?: readonly MachinesAction[] | false;
-  /** The folders `pickFolder` answers, in turn. Default: `/home/me/project`. */
-  folders?: readonly string[];
-  /** Called when a retry reaches the fixture. */
-  onRetry?: (hostId: string) => void;
-  /** Called when a test reaches the fixture. */
-  onTest?: (target: { id: string } | { url: string; token: string }) => void;
-  /** Called when an add reaches the fixture. */
-  onAdd?: (input: { url: string; token: string; name?: string }) => void;
-  /** Called when a rename reaches the fixture. */
-  onRename?: (id: string, name: string) => void;
-  /** Called when a URL change reaches the fixture. */
-  onSetUrl?: (id: string, url: string) => void;
-  /** Called when a removal reaches the fixture. */
-  onRemove?: (id: string) => void;
-  /** Called when a forget reaches the fixture. */
-  onForget?: (hostId: string, machineId: string) => void;
-  /** Called when a join code is asked for; what it returns is the code. Default: a made-up code, 10 minutes. */
-  onInvite?: (hostId: string, options: { name?: string; ttlMs?: number }) => { code: string; expiresAt: number } | void;
-  /** Called when an update action reaches the fixture. */
-  onUpdate?: (hostId: string, action: 'check' | 'install' | 'configure', enabled?: boolean) => void;
-  /** Called when a token is created. */
-  onCreateToken?: (hostId: string, name: string, scope: ServerTokenScope) => void;
-  /** Called when a token is revoked. */
-  onRevokeToken?: (hostId: string, id: string) => void;
-  /** Called when a link action reaches the fixture. */
-  onLink?: (action: 'shareStart' | 'shareStop' | 'useServer', hostId: string, detail?: unknown) => void;
-  /** Called when a daemon action reaches the fixture. */
-  onDaemon?: (action: 'reconnect' | 'restart' | 'stopRun' | 'relaunchApp', detail?: unknown) => void;
-  /** Each server's sync from this computer, by host id, or `false` for no `sync`. Default: false. */
-  sync?: Readonly<Record<string, HostSyncState>> | false;
-  /** Each server's providers (`sync.providers`), by host id. Default: none. */
-  providers?: Readonly<Record<string, readonly HostProviderAuth[]>>;
-  /** Called when a sync action reaches the fixture; what it throws, the action rejects with. */
-  onSync?: (action: 'configure' | 'push' | 'takeOver' | 'reset', hostId: string, detail?: unknown) => void;
-  /** Offer `signIn` (a sign-in that shows its page and completes after `signInMs`). Default: false. */
-  signIn?: boolean;
-  /** How long a fixture sign-in waits on its page before it completes, ms. Default: never (it waits). */
-  signInMs?: number;
-  /** The page a fixture sign-in opens. Default: an example address. */
-  signInUrl?: string;
-  /** Called when a sign-in starts. */
-  onSignIn?: (hostId: string, target: unknown) => void;
-}
-
-/** Pushes the fixture can make, as a backend would. */
-export interface FixtureMachinesControl {
-  /** Replaces the hosts (a status push). */
-  setHosts(hosts: readonly HostSummary[]): void;
-  /** A machine came online or went offline: its server's list follows. */
-  setMachineStatus(hostId: string, machineId: string, status: 'online' | 'offline'): void;
-  /** Replaces the links (a links push). */
-  setLinks(links: MachineLinksStatus): void;
-  /** Sets the daemon's health. */
-  setHealth(health: DaemonHealth): void;
-  /** Sets what the token may do. */
-  setPermitted(actions: readonly MachinesAction[] | null): void;
-  /** Replaces every session's presence (a presence push). */
-  setPresence(sessions: readonly SessionPresence[]): void;
-}
-
-/** An in-memory {@link MachinesHost} and its control. */
-export type FixtureMachinesHost = MachinesHost & { control: FixtureMachinesControl };
-
-/** This computer, as every host lists it first. */
-export const FIXTURE_LOCAL_HOST: HostSummary = { id: 'local', kind: 'local', name: 'This computer', status: 'local' };
-
-const UP_TO_DATE = (current: string): ServerUpdateStatus => ({
-  enabled: true,
-  supported: true,
-  current,
-  latest: current,
-  state: 'idle',
-});
-
-/** `wss://box.example:4280` → `box.example`. */
-function hostnameOf(url: string): string {
-  try {
-    return new URL(url).hostname || url;
-  } catch {
-    return url;
-  }
-}
-
-/**
- * Creates a {@link MachinesHost} held in memory.
- *
- * @param options - The hosts, machines, links, updates, tokens and daemon it starts with, and the callbacks it tells.
- */
-export function createFixtureMachinesHost(options: FixtureMachinesOptions = {}): FixtureMachinesHost {
-  const hosts = writable<HostsState>({
-    enabled: options.enabled ?? true,
-    hosts: options.hosts ?? [FIXTURE_LOCAL_HOST],
-  });
-  const machines = new Map(Object.entries(options.machines ?? {}).map(([id, list]) => [id, [...list]]));
-  const updates = new Map(Object.entries(options.updates ?? {}));
-  const tokens = new Map(Object.entries(options.tokens ?? {}).map(([id, list]) => [id, [...list]]));
-  const links = writable<MachineLinksStatus>(options.links ?? { shares: [], uses: [] });
-  const health = writable<DaemonHealth>(options.health ?? 'connected');
-  const permitted = writable<ReadonlySet<MachinesAction> | null>(new Set(options.permitted || []));
-  const statusListeners = new Set<(change: { hostId: string; name: string; status: 'online' | 'offline' }) => void>();
-  const folders = options.folders ?? ['/home/me/project'];
-  let folderTurn = 0;
-  let tokenCount = 0;
-
-  const hostOf = (id: string) => hosts.get().hosts.find((host) => host.id === id);
-  const patchHost = (id: string, patch: Partial<HostSummary> | null) =>
-    hosts.set((state) => ({
-      ...state,
-      hosts: patch
-        ? state.hosts.map((host) => (host.id === id ? { ...host, ...patch } : host))
-        : state.hosts.filter((host) => host.id !== id),
-    }));
-  const check = (url: string, token: string): HostCheckResult => {
-    if (!/^wss?:\/\//.test(url)) return { ok: false, error: 'invalid-url', message: 'Use a ws:// or wss:// URL.' };
-    if (!token.startsWith('zds_')) return { ok: false, error: 'invalid-token', message: 'Not a device token.' };
-    return { ok: true, name: hostnameOf(url), serverVersion: '1.0.0', latencyMs: 12 };
-  };
-  const updateOf = (hostId: string) =>
-    updates.has(hostId) ? updates.get(hostId)! : UP_TO_DATE(hostOf(hostId)?.serverVersion ?? '1.0.0');
-  const setUpdate = (hostId: string, next: ServerUpdateStatus) => {
-    updates.set(hostId, next);
-    return next;
-  };
-  const linked = (next: MachineLinksStatus): MachineActionResult => {
-    links.set(next);
-    return { ok: true, links: next };
-  };
-
-  const syncStates = new Map(Object.entries(options.sync || {}));
-  const syncListeners = new Set<(hostId?: string) => void>();
-  const listenSync = (onChange: (hostId?: string) => void) => {
-    syncListeners.add(onChange);
-    return () => syncListeners.delete(onChange);
-  };
-  /** Tells `onSync`; what it throws is the action's refusal. */
-  const tellSync = (action: 'configure' | 'push' | 'takeOver' | 'reset', hostId: string, detail?: unknown) => {
-    try {
-      options.onSync?.(action, hostId, detail);
-    } catch (error) {
-      throw machinesError('sync', error);
-    }
-  };
-  const patchSync = (hostId: string, edit: (state: HostSyncState) => HostSyncState) => {
-    const current = syncStates.get(hostId);
-    if (!current) throw machinesError('sync', 'Sync is not running.');
-    syncStates.set(hostId, edit(current));
-    for (const listener of [...syncListeners]) listener(hostId);
-  };
-  const syncState = createHostSyncReads<HostSyncState>(async (hostId) => syncStates.get(hostId) ?? null, listenSync);
-  const syncStatus = createHostSyncReads<SyncStatus>(
-    async (hostId) => syncStates.get(hostId)?.status ?? null,
-    listenSync,
-  );
-  const signIn = (hostId: string, target: unknown, onDone?: () => void): SignInFlow => {
-    options.onSignIn?.(hostId, target);
-    const state = writable<OnboardingSignInState>({ kind: 'starting' });
-    let ended = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    queueMicrotask(() => {
-      if (ended) return;
-      state.set({ kind: 'url', url: options.signInUrl ?? 'https://example.com/oauth/authorize' });
-      if (options.signInMs !== undefined)
-        timer = setTimeout(() => {
-          ended = true;
-          state.set({ kind: 'done' });
-          onDone?.();
-        }, options.signInMs);
-    });
-    return {
-      state,
-      cancel: () => {
-        ended = true;
-        if (timer) clearTimeout(timer);
-      },
-    };
-  };
-
-  const daemonStatus = options.daemon;
-  let presenceList: readonly SessionPresence[] = options.presence || [];
-  const presenceSinks = new Set<(sessions: readonly SessionPresence[]) => void>();
-  const presence = options.presence
-    ? createPresenceStore((apply) => {
-        presenceSinks.add(apply);
-        apply(presenceList);
-        return () => presenceSinks.delete(apply);
-      })
-    : undefined;
-  const host: FixtureMachinesHost = {
-    hosts,
-    refreshHosts: async () => undefined,
-    async retry(hostId) {
-      options.onRetry?.(hostId);
-      if (hostOf(hostId)) patchHost(hostId, { status: 'connected' });
-    },
-    async testHost(target) {
-      options.onTest?.(target);
-      if ('id' in target) {
-        const saved = hostOf(target.id);
-        return saved
-          ? {
-              ok: true,
-              name: saved.name,
-              latencyMs: 12,
-              ...(saved.serverVersion ? { serverVersion: saved.serverVersion } : {}),
-            }
-          : { ok: false, error: 'unknown-host', message: 'No such host.' };
-      }
-      return check(target.url, target.token);
-    },
-    async addHost(input) {
-      options.onAdd?.(input);
-      const result = check(input.url, input.token);
-      if (!result.ok) return result;
-      const name = input.name?.trim() || result.name;
-      const added: HostSummary = {
-        id: `host-${hosts.get().hosts.length}`,
-        kind: 'server',
-        name,
-        status: 'connected',
-        url: input.url,
-        serverName: result.name,
-        serverVersion: '1.0.0',
-        addedAt: Date.now(),
-        lastConnectedAt: Date.now(),
-      };
-      hosts.set((state) => ({ ...state, hosts: [...state.hosts, added] }));
-      return { ...result, name, host: added };
-    },
-    async renameHost(id, name) {
-      options.onRename?.(id, name);
-      if (!name.trim()) return { ok: false, error: 'invalid-name', message: 'A host needs a name.' };
-      if (!hostOf(id)) return { ok: false, error: 'unknown-host', message: 'No such host.' };
-      patchHost(id, { name: name.trim() });
-      return { ok: true, name: name.trim() };
-    },
-    async setHostUrl(id, url) {
-      options.onSetUrl?.(id, url);
-      const saved = hostOf(id);
-      if (!saved) return { ok: false, error: 'unknown-host', message: 'No such host.' };
-      if (!/^wss?:\/\//.test(url)) return { ok: false, error: 'invalid-url', message: 'Use a ws:// or wss:// URL.' };
-      patchHost(id, { url, status: 'connected' });
-      return {
-        ok: true,
-        name: saved.name,
-        latencyMs: 12,
-        ...(saved.serverVersion ? { serverVersion: saved.serverVersion } : {}),
-      };
-    },
-    async removeHost(id) {
-      options.onRemove?.(id);
-      patchHost(id, null);
-    },
-    machines: {
-      list: createMachineLists(
-        async (hostId) => machines.get(hostId) ?? [],
-        (onChange) => {
-          const listener = (change: { hostId: string }) => onChange(change.hostId);
-          statusListeners.add(listener);
-          return () => statusListeners.delete(listener);
-        },
-      ),
-      online: createOnlineMachines((onChange) => {
-        statusListeners.add(onChange);
-        return () => statusListeners.delete(onChange);
-      }),
-      async forget(hostId, machineId) {
-        options.onForget?.(hostId, machineId);
-        machines.set(
-          hostId,
-          (machines.get(hostId) ?? []).filter((machine) => machine.id !== machineId),
-        );
-      },
-      async invite(hostId, inviteOptions = {}): Promise<MachineInvite> {
-        if (options.permitted && !permitted.get()?.has('machines.invite'))
-          throw { kind: 'invite', detail: '"tokens.machineInvite" needs an admin token.', forbidden: true };
-        const made = options.onInvite?.(hostId, inviteOptions) ?? {
-          code: 'K7Q2-9XPM',
-          expiresAt: Date.now() + Math.min(inviteOptions.ttlMs ?? 600_000, 600_000),
-        };
-        const host = hostOf(hostId);
-        const url = host?.url ?? `wss://${host?.name ?? hostId}`;
-        return { ...made, join: `${url}#${made.code}` };
-      },
-    },
-    links: {
-      state: links,
-      refresh: async () => undefined,
-      async shareStart(hostId, name, roots, token) {
-        options.onLink?.('shareStart', hostId, { name, roots, token });
-        const shares = links.get().shares.filter((share) => share.hostId !== hostId);
-        return linked({
-          ...links.get(),
-          shares: [...shares, { hostId, name: name || 'this-computer', roots: [...roots], state: 'connected' }],
-        });
-      },
-      async shareStop(hostId) {
-        options.onLink?.('shareStop', hostId);
-        return linked({ ...links.get(), shares: links.get().shares.filter((share) => share.hostId !== hostId) });
-      },
-      async useServer(hostId, enabled) {
-        options.onLink?.('useServer', hostId, enabled);
-        const uses = links.get().uses.filter((use) => use.hostId !== hostId);
-        const name = hostOf(hostId)?.name ?? hostId;
-        return linked({
-          ...links.get(),
-          uses: enabled ? [...uses, { hostId, state: 'connected', machineName: name }] : uses,
-        });
-      },
-    },
-    pickFolder: async () => folders[folderTurn++ % folders.length] ?? null,
-    updates: {
-      status: async (hostId) => updateOf(hostId),
-      async check(hostId) {
-        options.onUpdate?.(hostId, 'check');
-        const current = updateOf(hostId) ?? UP_TO_DATE('1.0.0');
-        // Off, a newer release is downloaded and waits for Install now.
-        const ready = !current.enabled && current.latest !== undefined && current.latest !== current.current;
-        return setUpdate(hostId, { ...current, state: ready ? 'ready' : 'idle', lastCheckAt: Date.now() });
-      },
-      async install(hostId) {
-        options.onUpdate?.(hostId, 'install');
-        const current = updateOf(hostId) ?? UP_TO_DATE('1.0.0');
-        return setUpdate(hostId, { ...current, state: 'installing' });
-      },
-      async configure(hostId, enabled) {
-        options.onUpdate?.(hostId, 'configure', enabled);
-        const current = updateOf(hostId) ?? UP_TO_DATE('1.0.0');
-        return setUpdate(hostId, { ...current, enabled });
-      },
-    },
-    tokens: {
-      list: async (hostId) => tokens.get(hostId) ?? [],
-      async create(hostId, name, scope) {
-        options.onCreateToken?.(hostId, name, scope);
-        tokenCount += 1;
-        const created: ServerToken = { id: `tok_fixture${tokenCount}`, name, scope, createdAt: Date.now() };
-        tokens.set(hostId, [...(tokens.get(hostId) ?? []), created]);
-        return { ...created, token: `zds_fixture_secret_${tokenCount}` };
-      },
-      async revoke(hostId, id) {
-        options.onRevokeToken?.(hostId, id);
-        tokens.set(
-          hostId,
-          (tokens.get(hostId) ?? []).map((token) => (token.id === id ? { ...token, revokedAt: Date.now() } : token)),
-        );
-      },
-    },
-    ...(daemonStatus
-      ? {
-          daemon: {
-            health,
-            status: async () => daemonStatus,
-            async reconnect() {
-              options.onDaemon?.('reconnect');
-              return daemonStatus;
-            },
-            async restart(force: boolean) {
-              options.onDaemon?.('restart', force);
-              return { deferred: !force && (daemonStatus.sessions ?? []).some((s) => s.running) };
-            },
-            async stopRun(target: string) {
-              options.onDaemon?.('stopRun', target);
-              return target === 'all' ? (daemonStatus.sessions ?? []).filter((s) => s.running).length : 1;
-            },
-            async relaunchApp() {
-              options.onDaemon?.('relaunchApp');
-            },
-          },
-        }
-      : {}),
-    ...(options.capabilities
-      ? {
-          capabilities: async (hostId: string, opts?: { refresh?: boolean }) => {
-            options.onCapabilities?.(hostId, opts?.refresh === true);
-            return options.capabilities as HostCapabilities;
-          },
-        }
-      : {}),
-    ...(presence ? { presence } : {}),
-    ...(options.permitted ? { permitted } : {}),
-    ...(options.sync
-      ? {
-          sync: {
-            state: syncState,
-            status: syncStatus,
-            async configure(hostId: string, patch: HostSyncPatch) {
-              tellSync('configure', hostId, patch);
-              patchSync(hostId, (state) =>
-                state.config
-                  ? {
-                      ...state,
-                      config: {
-                        ...state.config,
-                        ...(patch.mode ? { mode: patch.mode } : {}),
-                        ...(patch.categories ? { categories: [...patch.categories] } : {}),
-                        ...(patch.keys ? { keys: [...patch.keys] } : {}),
-                      },
-                    }
-                  : state,
-              );
-            },
-            async push(hostId: string) {
-              tellSync('push', hostId);
-              patchSync(hostId, (state) =>
-                state.config ? { ...state, config: { ...state.config, pending: [], lastSyncAt: Date.now() } } : state,
-              );
-            },
-            async takeOver(hostId: string) {
-              tellSync('takeOver', hostId);
-              patchSync(hostId, (state) => ({
-                ...state,
-                conflict: null,
-                status:
-                  state.status && state.device
-                    ? {
-                        ...state.status,
-                        source: { deviceId: state.device.id, deviceName: state.device.name, claimedAt: Date.now() },
-                      }
-                    : state.status,
-              }));
-            },
-            async reset(hostId: string, field: string) {
-              tellSync('reset', hostId, field);
-              patchSync(hostId, (state) => {
-                if (!state.status) return state;
-                const overrides = { ...state.status.overrides };
-                delete overrides[field];
-                return { ...state, status: { ...state.status, overrides } };
-              });
-            },
-            providers: async (hostId: string) => options.providers?.[hostId] ?? [],
-          },
-        }
-      : {}),
-    ...(options.signIn ? { signIn } : {}),
-    control: {
-      setHosts: (next) => hosts.set((state) => ({ ...state, hosts: next })),
-      setMachineStatus(hostId, machineId, status) {
-        const list = machines.get(hostId) ?? [];
-        const machine = list.find((m) => m.id === machineId);
-        if (!machine) return;
-        machines.set(
-          hostId,
-          list.map((m) => (m.id === machineId ? { ...m, status } : m)),
-        );
-        for (const listener of [...statusListeners]) listener({ hostId, name: machine.name, status });
-      },
-      setLinks: (next) => links.set(next),
-      setHealth: (next) => health.set(next),
-      setPermitted: (actions) => permitted.set(actions ? new Set(actions) : null),
-      setPresence(sessions) {
-        presenceList = sessions;
-        for (const apply of [...presenceSinks]) apply(sessions);
-      },
-    },
-  };
-  return host;
-}

package/src/machines/headless/fixtures.ts

@@ -1,164 +0,0 @@
-/**
- * Demo data for the machines area: a desktop's hosts (This computer, a
- * connected server, one refusing the token, one offline), a server's machines,
- * its self-update and tokens, and a daemon holding two sessions.
- */
-import type { HostCapabilities, MachineInfo, ServerUpdateStatus } from 'zidane/chat/pure';
-
-import type { DaemonStatus, HostProviderAuth, HostSummary, ServerToken } from './host';
-import { FIXTURE_LOCAL_HOST } from './fixture-host';
-import type { HostSyncState } from './sync';
-
-const DAY = 86_400_000;
-/** A fixed "now" for the demo data, so screenshots don't drift. */
-export const DEMO_NOW = Date.UTC(2025, 5, 2, 10, 0, 0);
-
-/** A desktop's hosts: This computer, then three saved servers. */
-export const DEMO_HOSTS: readonly HostSummary[] = [
-  FIXTURE_LOCAL_HOST,
-  {
-    id: 'box',
-    kind: 'server',
-    name: 'Box',
-    status: 'connected',
-    url: 'wss://box.example.com',
-    serverName: 'box-1',
-    serverVersion: '1.4.2',
-    addedAt: DEMO_NOW - 30 * DAY,
-    lastConnectedAt: DEMO_NOW - 5 * 60_000,
-    machineServe: true,
-  },
-  {
-    id: 'attic',
-    kind: 'server',
-    name: 'Attic',
-    status: 'auth-refused',
-    url: 'wss://attic.example.com',
-    error: 'token refused (401)',
-  },
-  {
-    id: 'lab',
-    kind: 'server',
-    name: 'Lab',
-    status: 'offline',
-    url: 'wss://lab.example.com',
-    error: 'connect ECONNREFUSED',
-  },
-];
-
-/** The machines Box holds. */
-export const DEMO_MACHINES: readonly MachineInfo[] = [
-  {
-    id: 'm-laptop',
-    name: 'laptop',
-    roots: [{ path: '/Users/me/code' }],
-    status: 'online',
-    lastSeen: DEMO_NOW - 60_000,
-  },
-  { id: 'm-desk', name: 'desk', roots: [{ path: '/home/me/src' }], status: 'offline', lastSeen: DEMO_NOW - 2 * DAY },
-];
-
-/** Box's self-update, a release waiting for runs to pause. */
-export const DEMO_UPDATE_WAITING: ServerUpdateStatus = {
-  enabled: true,
-  supported: true,
-  current: '1.4.2',
-  latest: '1.5.0',
-  state: 'waiting',
-  updatedFrom: '1.4.1',
-};
-
-/** Box's client tokens. */
-export const DEMO_TOKENS: readonly ServerToken[] = [
-  { id: 'tok_phone', name: 'phone', scope: 'chat', createdAt: DEMO_NOW - 10 * DAY, lastUsedAt: DEMO_NOW - 3_600_000 },
-  { id: 'tok_laptop', name: 'laptop', scope: 'admin', createdAt: DEMO_NOW - 40 * DAY, lastUsedAt: DEMO_NOW - 60_000 },
-  {
-    id: 'tok_old',
-    name: 'old tablet',
-    scope: 'approve',
-    createdAt: DEMO_NOW - 90 * DAY,
-    revokedAt: DEMO_NOW - 20 * DAY,
-  },
-];
-
-/** What a demo server can do: git and docker found, gh missing, the OS sandbox, Docker and E2B environments. */
-export const DEMO_CAPABILITIES: HostCapabilities = {
-  os: { platform: 'linux', arch: 'x64', release: '6.8' },
-  tools: [
-    { name: 'git', found: true, version: 'git version 2.45.0' },
-    { name: 'gh', found: false },
-    { name: 'docker', found: true, version: 'Docker 27.1' },
-  ],
-  sandbox: { ok: true, backend: 'bwrap' },
-  environments: [
-    { kind: 'local', label: 'Local', available: true },
-    { kind: 'docker', label: 'Docker', available: true },
-    { kind: 'e2b', label: 'E2B', available: false, reason: 'no API key' },
-  ],
-  allows: { remoteInstalls: true, asMachine: true, sync: false, clone: true, createFolders: true },
-  workspace: { roots: ['/data/workspaces'], freeBytes: 42 * 1024 ** 3 },
-  probedAt: 1_700_000_000_000,
-};
-
-/** A connected daemon holding a running session and one waiting for an answer. */
-export const DEMO_DAEMON: DaemonStatus = {
-  enabled: true,
-  state: 'connected',
-  socketPath: '/tmp/zidane/daemon.sock',
-  window: { protocolVersion: 12, buildId: 'demo' },
-  daemon: { pid: 4242, protocolVersion: 12, startedAt: DEMO_NOW - 3 * 3_600_000 },
-  sessions: [
-    { sessionId: 'local:s-refactor', running: true, waitingForYou: false, windows: 1 },
-    { sessionId: 'local:s-deploy', running: true, waitingForYou: true, windows: 0 },
-  ],
-};
-
-/** This computer keeping Box in sync: settings, instructions and API keys (Anthropic's opted in), a field edited on Box since, a skipped MCP server. */
-export const DEMO_SYNC: HostSyncState = {
-  enabled: true,
-  device: { id: 'dev-laptop', name: 'laptop' },
-  config: {
-    mode: 'keep',
-    categories: ['settings', 'files', 'mcps', 'keys'],
-    keys: ['anthropic'],
-    pending: [],
-    lastSyncAt: DEMO_NOW - 4 * 60_000,
-    results: {
-      mcps: {
-        applied: [],
-        unchanged: [],
-        skipped: [{ field: 'mcp:local-db', reason: 'stdio servers stay here' }],
-        warnings: [],
-      },
-    },
-  },
-  connected: true,
-  supported: true,
-  status: {
-    source: { deviceId: 'dev-laptop', deviceName: 'laptop', claimedAt: DEMO_NOW - 30 * DAY },
-    categories: ['settings', 'files', 'mcps', 'keys'],
-    keys: ['anthropic'],
-    fields: { 'setting:approvalMode': { category: 'settings', syncedAt: DEMO_NOW - DAY } },
-    overrides: { 'setting:maxTurns': { at: DEMO_NOW - 2 * DAY } },
-  },
-  conflict: null,
-  busy: false,
-  local: {
-    keyProviders: [
-      { key: 'anthropic', label: 'Anthropic' },
-      { key: 'openai', label: 'OpenAI' },
-    ],
-    accounts: [
-      { key: 'anthropic', label: 'Anthropic', apiKey: true, signIns: [] },
-      { key: 'openai', label: 'OpenAI', apiKey: true, signIns: ['Default'] },
-    ],
-    localExtensions: [],
-    stdioMcps: ['local-db'],
-  },
-};
-
-/** Box's providers: Anthropic set up, OpenAI signs in with OAuth there. */
-export const DEMO_SERVER_PROVIDERS: readonly HostProviderAuth[] = [
-  { key: 'anthropic', label: 'Anthropic', configured: true, oauth: false, methods: [] },
-  { key: 'openai', label: 'OpenAI', configured: false, oauth: true, methods: [] },
-];