zidane-ui 9.0.4 → 9.1.3

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

@@ -1,283 +0,0 @@
-/**
- * A `MachinesHost` on a running zidane-server, over a shared browser client
- * (`createServerClient`), for a web app the server serves: the one server it
- * talks to (from the client's state and the handshake: name, version, the
- * token's scope, uptime), its machines (`machines.list`, `machines.forget`,
- * kept current by the `machine:status` signal and re-read after every
- * handshake; `tokens.machineInvite` makes a join code when the server's
- * `url` is given), its self-update (`server.update.*`), its client tokens
- * (`tokens.list` / `create` / `revoke`, re-read on `tokens:changed`), what it can do (`host.capabilities`)
- * and per-session presence
- * (`presence.list`, kept current by `presence:changed`, re-listed after every
- * handshake). Of settings sync, the server's side: its record
- * (`sync.status`, re-read after every handshake, every reset and every
- * `sync:changed`), dropping an
- * override (`sync.reset`), its providers (`auth.status`) and a sign-in there
- * (`auth.oauth.*`, `serverOAuthFlow`).
- *
- * What a token may do comes from the handshake (`client.can`), in
- * `permitted`: a `chat` or `approve` token lists machines and reads the
- * update status, only an `admin` one forgets machines, runs updates and
- * manages tokens. The components hide what is not permitted.
- *
- * A store it hands out may listen to the client for good (who is online):
- * `close()` stops every listener.
- *
- * Left out, with no zidane-server method behind them: `retry` (the client
- * reconnects by itself), the desktop's host registry (`testHost`, `addHost`,
- * `renameHost`, `setHostUrl`, `removeHost`, `savedHosts`), this computer's
- * machine `links`, `pickFolder`, the local `daemon`, and this computer's sync
- * engine (`sync.state`, `configure`, `push`, `takeOver`: a browser is not a device
- * that pushes its settings; `sync.claim` / `sync.push` are a device's calls).
- * `sync.*` needs an admin token: below it the record reads `null` and a reset
- * rejects.
- */
-import { formatJoinString, IpcErrorCode, type ServerClient, type ServerClientState } from 'zidane/ipc/browser';
-import type { HostSignal } from 'zidane/ipc';
-
-import type { HostStatus } from '../chat/headless/hosts';
-import {
-  machinesError,
-  type HostSummary,
-  type HostsState,
-  type MachinesAction,
-  type MachinesHost,
-} from '../machines/headless/host';
-import { createPresenceStore } from '../machines/headless/presence';
-import { createMachineLists, createOnlineMachines, lazyReadable } from '../machines/headless/stores';
-import { createHostSyncReads, type SyncStatus } from '../machines/headless/sync';
-import { closableClient } from './closable-client';
-import { serverOAuthFlow } from './server-oauth-flow';
-
-/** Options for {@link createServerMachinesHost}. */
-export interface ServerMachinesHostOptions {
-  /** The client to speak through, shared with the chat host (`createServerHost({ client })`) and other areas' hosts. */
-  client: ServerClient;
-  /** The server's name before (or without) the one its handshake reports. Default `zidane-server`. */
-  name?: string;
-  /**
-   * The server's `ws://` or `wss://` URL as a machine reaches it (a web page's own origin), for join codes.
-   * Absent: no `machines.invite`.
-   */
-  url?: string;
-}
-
-/** The {@link MachinesHost} {@link createServerMachinesHost} returns. */
-export interface ServerMachinesHost extends MachinesHost {
-  /** Stops listening to the client (the client stays open). */
-  close(): void;
-}
-
-/** The id the server goes by until its handshake names it (`hello.hostId`). */
-export const SERVER_MACHINES_HOST_ID = 'server';
-
-const ACTIONS: readonly [MachinesAction, Parameters<ServerClient['can']>[0]][] = [
-  ['machines.list', 'machines.list'],
-  ['machines.forget', 'machines.forget'],
-  ['machines.invite', 'tokens.machineInvite'],
-  ['update.status', 'server.update.status'],
-  ['update.manage', 'server.update.check'],
-  ['tokens.list', 'tokens.list'],
-  ['tokens.manage', 'tokens.create'],
-];
-
-/**
- * Creates a {@link MachinesHost} on a running zidane-server.
- *
- * @param options - The shared client and the server's fallback name.
- */
-export function createServerMachinesHost(options: ServerMachinesHostOptions): ServerMachinesHost {
-  const { client, close } = closableClient(options.client);
-  const fallbackName = options.name ?? 'zidane-server';
-  const serverUrl = options.url;
-  let lastConnectedAt: number | undefined;
-  let everOpen = false;
-  let wasOpen = false;
-
-  const summary = (state: ServerClientState): HostSummary => {
-    const hello = state.status === 'open' ? state.hello : client.hello();
-    if (state.status === 'open' && !wasOpen) lastConnectedAt = Date.now();
-    wasOpen = state.status === 'open';
-    everOpen ||= wasOpen;
-    const status: HostStatus =
-      state.status === 'open'
-        ? 'connected'
-        : state.status === 'connecting'
-          ? everOpen
-            ? 'reconnecting'
-            : 'connecting'
-          : state.status === 'retrying'
-            ? 'reconnecting'
-            : state.status === 'refused'
-              ? state.reason === 'protocol'
-                ? 'version-mismatch'
-                : state.reason === 'token' || state.reason === 'scope'
-                  ? 'auth-refused'
-                  : 'offline'
-              : 'offline';
-    const error = state.status === 'retrying' ? state.error : state.status === 'refused' ? state.message : undefined;
-    return {
-      id: hello?.hostId ?? SERVER_MACHINES_HOST_ID,
-      kind: 'server',
-      name: hello?.hostName ?? fallbackName,
-      status,
-      ...(error ? { error } : {}),
-      ...(hello?.appVersion ? { serverVersion: hello.appVersion } : {}),
-      ...(hello?.scope ? { scope: hello.scope } : {}),
-      ...(hello?.startedAt ? { startedAt: hello.startedAt } : {}),
-      ...(hello?.machineServe ? { machineServe: true } : {}),
-      ...(lastConnectedAt ? { lastConnectedAt } : {}),
-    };
-  };
-
-  const hosts = lazyReadable<HostsState>({ enabled: true, hosts: [summary(client.state())] }, (sink) => {
-    const apply = (state: ServerClientState) => sink.set({ enabled: true, hosts: [summary(state)] });
-    apply(client.state());
-    return client.onState(apply);
-  });
-
-  const permittedNow = (): ReadonlySet<MachinesAction> | null =>
-    client.state().status === 'open'
-      ? new Set(ACTIONS.filter(([, method]) => client.can(method)).map(([a]) => a))
-      : null;
-  const sameSet = (a: ReadonlySet<MachinesAction> | null, b: ReadonlySet<MachinesAction> | null) =>
-    a === b || (a !== null && b !== null && a.size === b.size && [...a].every((x) => b.has(x)));
-  const permitted = lazyReadable<ReadonlySet<MachinesAction> | null>(permittedNow(), (sink) => {
-    const apply = () => {
-      const next = permittedNow();
-      if (!sameSet(sink.get(), next)) sink.set(next);
-    };
-    apply();
-    return client.onState(apply);
-  });
-
-  const onMachineStatus = (listener: (change: { name: string; status: 'online' | 'offline' }) => void) =>
-    client.onSignal((signal: HostSignal) => {
-      if (signal.kind === 'machine:status') listener({ name: signal.name, status: signal.status });
-    });
-  // One server: every id the components pass names the same list.
-  const lists = createMachineLists(
-    async () => {
-      const machines = await client.call('machines.list', {});
-      return Array.isArray(machines) ? machines : [];
-    },
-    (onChange) => {
-      const offStatus = onMachineStatus(() => onChange(SERVER_MACHINES_HOST_ID));
-      const offOpen = client.onOpen(() => onChange(SERVER_MACHINES_HOST_ID));
-      return () => {
-        offStatus();
-        offOpen();
-      };
-    },
-  );
-
-  // One server: every id names the same record. A reconnect re-reads it (it may have changed meanwhile).
-  const syncStatus = createHostSyncReads<SyncStatus>(
-    () => client.call('sync.status', {}),
-    (onChange) => {
-      const offOpen = client.onOpen(() => onChange());
-      // A claim, a push, an override or a reset, from this page or another device.
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        if (signal.kind === 'sync:changed') onChange();
-      });
-      return () => {
-        offOpen();
-        offSignal();
-      };
-    },
-  );
-
-  const guard = async <T>(
-    kind: 'read' | 'update' | 'tokens' | 'forget' | 'sync',
-    call: () => Promise<T>,
-  ): Promise<T> => {
-    try {
-      return await call();
-    } catch (error) {
-      throw machinesError(kind, error);
-    }
-  };
-
-  return {
-    hosts,
-    machines: {
-      list: () => lists(SERVER_MACHINES_HOST_ID),
-      online: createOnlineMachines(onMachineStatus),
-      forget: (_hostId, machineId) =>
-        guard('forget', async () => {
-          await client.call('machines.forget', { machineId });
-        }),
-      ...(serverUrl
-        ? {
-            invite: async (_hostId: string, params: { name?: string; ttlMs?: number } = {}) => {
-              try {
-                const { code, expiresAt } = await client.call('tokens.machineInvite', params);
-                return { code, expiresAt, join: formatJoinString(serverUrl, code) };
-              } catch (error) {
-                const forbidden = (error as { code?: unknown } | null)?.code === IpcErrorCode.Forbidden;
-                throw { ...machinesError('invite', error), ...(forbidden ? { forbidden } : {}) };
-              }
-            },
-          }
-        : {}),
-    },
-    updates: {
-      status: (_hostId) => guard('update', () => client.call('server.update.status', {})),
-      check: (_hostId) => guard('update', () => client.call('server.update.check', {})),
-      install: (_hostId) => guard('update', () => client.call('server.update.install', {})),
-      configure: (_hostId, enabled) => guard('update', () => client.call('server.update.configure', { enabled })),
-    },
-    tokens: {
-      list: (_hostId) => guard('tokens', () => client.call('tokens.list', {})),
-      create: (_hostId, name, scope) => guard('tokens', () => client.call('tokens.create', { name, scope })),
-      revoke: (_hostId, id) =>
-        guard('tokens', async () => {
-          await client.call('tokens.revoke', { id });
-        }),
-      onChanged: (_hostId, listener) =>
-        client.onSignal((signal: HostSignal) => {
-          if (signal.kind === 'tokens:changed') listener();
-        }),
-    },
-    sync: {
-      status: () => syncStatus(SERVER_MACHINES_HOST_ID),
-      reset: (_hostId, field) =>
-        guard('sync', async () => {
-          await client.call('sync.reset', { field });
-          void syncStatus(SERVER_MACHINES_HOST_ID).refresh();
-        }),
-      providers: (_hostId) => guard('read', async () => (await client.call('auth.status', {})).providers),
-    },
-    signIn: (_hostId, target, onDone) => serverOAuthFlow(client, target, onDone ? { onDone: () => onDone() } : {}),
-    // One server: every host id names it.
-    capabilities: (_hostId, opts) =>
-      guard('read', () => client.call('host.capabilities', opts?.refresh ? { refresh: true } : {})),
-    presence: createPresenceStore((apply) => {
-      let stopped = false;
-      let sawSignal = false;
-      const list = (always: boolean) => {
-        client.call('presence.list', {}).then(
-          (sessions) => {
-            if (!stopped && (always || !sawSignal) && Array.isArray(sessions)) apply(sessions);
-          },
-          () => undefined,
-        );
-      };
-      const offSignal = client.onSignal((signal: HostSignal) => {
-        if (signal.kind !== 'presence:changed') return;
-        sawSignal = true;
-        apply(signal.sessions);
-      });
-      // A reconnect: the last snapshot predates it.
-      const offOpen = client.onOpen(() => list(true));
-      if (client.hello()) list(false);
-      return () => {
-        stopped = true;
-        offSignal();
-        offOpen();
-      };
-    }),
-    permitted,
-    close,
-  };
-}

package/src/adapters/server-oauth-flow.ts

@@ -1,133 +0,0 @@
-/**
- * A browser sign-in over zidane-server's `auth.oauth.*`, as a `SignInFlow`:
- * the server keeps the PKCE verifier and the tokens, the page shows the
- * address (or a device code) and passes back a pasted redirect or code. A
- * question the provider asks (a choice of flow, a free text), before or
- * after the page, is a `prompt` answered with `submit`. An MCP server's
- * sign-in comes back to the server's own callback (`redirectUri`): the flow
- * waits for the server once the page is open. Shared by the onboarding host
- * (Connect) and the settings host (Accounts, MCP servers).
- */
-import type { OnboardingSignInState } from 'zidane/chat/pure';
-import type { HostOAuthBegin, HostOAuthComplete, HostOAuthStep } from 'zidane/ipc';
-import type { ServerClient } from 'zidane/ipc/browser';
-
-import { writable } from '../chat/headless/store';
-import type { SignInFlow } from '../onboarding/headless/host';
-
-/** What `auth.oauth.begin` signs in to. */
-export type ServerOAuthTarget =
-  { provider: string; cwd?: string } | { mcpServer: string; cwd?: string; redirectUri?: string };
-
-/** Options for {@link serverOAuthFlow}. */
-export interface ServerOAuthFlowOptions {
-  /** Called once the server stored the tokens, with what it answered. */
-  onDone?: (result: HostOAuthComplete) => void;
-  /** The open flows' cancels: the flow adds its own while it runs, so a host can stop them all. */
-  stops?: Set<() => void>;
-}
-
-function messageOf(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-/**
- * Starts a sign-in on the server.
- *
- * @param client - The shared client.
- * @param target - The provider or MCP server, and the folder whose catalog counts.
- * @param options - What to do once it is done, and where to register its cancel.
- */
-export function serverOAuthFlow(
-  client: ServerClient,
-  target: ServerOAuthTarget,
-  options: ServerOAuthFlowOptions = {},
-): SignInFlow {
-  const { stops } = options;
-  const state = writable<OnboardingSignInState>({ kind: 'starting' });
-  let flowId: string | null = null;
-  let ended = false;
-  // The question being asked, and whether it came after the page (answered, the flow completes again).
-  let step: { question: HostOAuthStep; afterPage: boolean } | null = null;
-
-  const end = (next: OnboardingSignInState) => {
-    ended = true;
-    stops?.delete(cancel);
-    state.set(next);
-  };
-  const fail = (error: unknown) => {
-    if (!ended) end({ kind: 'error', message: messageOf(error) });
-  };
-  const ask = (question: HostOAuthStep, afterPage: boolean) => {
-    step = { question, afterPage };
-    state.set(
-      question.kind === 'select'
-        ? { kind: 'prompt', message: question.message, options: question.options.map((o) => o.label) }
-        : {
-            kind: 'prompt',
-            message: question.message,
-            ...(question.placeholder ? { placeholder: question.placeholder } : {}),
-          },
-    );
-  };
-  const finish = (result: HostOAuthComplete) => {
-    if (ended) return;
-    if (result.step) return ask(result.step, true);
-    end({ kind: 'done' });
-    options.onDone?.(result);
-  };
-  const complete = (input?: string) => {
-    if (!flowId) return;
-    client.call('auth.oauth.complete', { flowId, ...(input ? { input } : {}) }).then(finish, fail);
-  };
-  const begun = (begin: HostOAuthBegin) => {
-    if (ended) return;
-    flowId = begin.flowId;
-    if (begin.mode === 'step' && begin.step) return ask(begin.step, false);
-    if (begin.mode === 'device') {
-      const expiresInSeconds = Math.max(0, Math.round((begin.expiresAt - Date.now()) / 1000));
-      state.set({ kind: 'device', url: begin.url, userCode: begin.userCode ?? '', expiresInSeconds });
-      // A device flow finishes on the server once the user enters the code: wait for it.
-      complete();
-      return;
-    }
-    state.set({ kind: 'url', url: begin.url });
-    // An MCP server's page sends the browser back to the server, which takes the code: wait for it.
-    if (begin.mode === 'browser' && 'mcpServer' in target) complete();
-  };
-  const cancel = () => {
-    if (ended) return;
-    ended = true;
-    stops?.delete(cancel);
-    if (flowId) void client.call('auth.oauth.cancel', { flowId }).catch(() => undefined);
-  };
-  stops?.add(cancel);
-  client.call('auth.oauth.begin', target).then((begin) => {
-    if (ended) void client.call('auth.oauth.cancel', { flowId: begin.flowId }).catch(() => undefined);
-    else begun(begin);
-  }, fail);
-
-  return {
-    state,
-    submit: (text) => {
-      const value = text.trim();
-      if (ended || !flowId) return;
-      if (step) {
-        const { question, afterPage } = step;
-        step = null;
-        const answer =
-          question.kind === 'select' ? question.options.find((o) => o.label === value || o.id === value)?.id : value;
-        client
-          .call('auth.oauth.respond', {
-            flowId,
-            stepId: question.id,
-            ...(answer !== undefined ? { value: answer } : {}),
-          })
-          .then((begin) => (afterPage ? complete() : begun(begin)), fail);
-      } else if (value) {
-        complete(value);
-      }
-    },
-    cancel,
-  };
-}