sailfork / t3code-github / .repos/ alchemy-effect/ packages/ alchemy/ src/ Cli/ components/ view/ ProfileDashboard.tsx

/** @jsxRuntime automatic */
/** @jsxImportSource @alchemy.run/sigil */
/**
 * GUI-style dashboard behind bare `alchemy profile`. One Sigil app stays
 * mounted for the whole session and screens replace each other in place:
 *
 *   overview — chip tabs (default profile first), selected profile's
 *              provider details with an up/down focus cursor, keybind bar,
 *              inline rename/new/delete/remove
 *   edit     — replaces the overview: per-provider cycle rows
 *              (keep / reconfigure / remove, add for unconnected)
 *
 * Pure store actions (create/rename/delete) round-trip through
 * the hub via a request bridge WITHOUT unmounting — results come back as
 * in-app notices. Only flows that must prompt in the transcript (provider
 * configuration, credential refresh) resolve the session. The built-in
 * `default` profile is pinned first and can be neither renamed nor deleted.
 */
import { useEffect, useState } from "@alchemy.run/sigil/react";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Scheduler from "effect/Scheduler";
import type { JSX } from "react";
import { Interaction, type NonInteractiveTerminal } from "../../../Interaction.ts";
import { theme } from "../../../Util/Theme.ts";
import {
  Alert,
  Box,
  CycleList,
  Gutter,
  InlineConfirm,
  KeyBar,
  LiveStore,
  Pointer,
  PromptFrame,
  Spinner,
  Stack,
  Status,
  Tabs,
  Text,
  TextField,
  Toast,
  useCycleNavigation,
  useGlyphs,
  useKeyGlyphs,
  useLiveStore,
  useTerminalInput,
  useTerminalSize,
  VirtualList,
} from "../ui/index.ts";
import {
  type EditState,
  editStateStyle,
  ProviderBlock,
  providerBlockHeight,
  providerColumnWidths,
  type ProfileProviderDisplay,
} from "./Profile.tsx";

// --- data contracts ---------------------------------------------------------

export interface DashboardEntry {
  readonly name: string;
  readonly isActive: boolean;
  readonly isDefault: boolean;
}

export interface ProfileDetailsPayload {
  readonly providers: ReadonlyArray<ProfileProviderDisplay>;
  /** Registry providers not yet connected to this profile. */
  readonly available: ReadonlyArray<string>;
}

export type PureAction =
  | { kind: "create"; name: string }
  | { kind: "rename"; name: string; newName: string }
  | { kind: "delete"; name: string };

export type FlowAction =
  | {
      kind: "edit-apply";
      name: string;
      add: string[];
      reconfigure: string[];
      remove: string[];
    }
  | { kind: "refresh"; name: string; provider?: string };

export type ExternalAction = FlowAction | { kind: "exit" };

export interface ExecuteResult {
  readonly ok: boolean;
  readonly message: string;
  readonly entries: ReadonlyArray<DashboardEntry>;
  /** Profile to focus after the action (e.g. the new name of a rename). */
  readonly selected?: string;
}

// --- store ------------------------------------------------------------------

export type Details =
  | { state: "loading" }
  | ({ state: "ready" } & ProfileDetailsPayload)
  | { state: "failed"; message: string };

interface Notice {
  readonly ok: boolean;
  readonly message: string;
}

interface Flow {
  readonly kind: FlowAction["kind"];
  readonly name: string;
  readonly provider?: string;
  /** Inline flows render within the overview (refresh spinner). */
  readonly inline: boolean;
}

interface DashState {
  readonly entries: ReadonlyArray<DashboardEntry>;
  readonly details: ReadonlyMap<string, Details>;
  readonly notice: Notice | undefined;
  readonly busy: boolean;
  /** One-shot tab focus request (e.g. follow a rename to its new name). */
  readonly focus: string | undefined;
  /** Active in-app flow; `inline` flows render within the overview. */
  readonly flow: Flow | undefined;
}

/**
 * Immutable-snapshot store on top of `LiveStore`, so every mutation notifies
 * the mounted dashboard. The resolver bridge and the notice auto-dismiss
 * timer live outside the snapshot — they carry no visual state.
 */
export class DashStore extends LiveStore<DashState> {
  private resolver: ((action: PureAction | ExternalAction) => void) | null = null;

  constructor(entries: ReadonlyArray<DashboardEntry>) {
    super({
      entries,
      details: new Map(),
      notice: undefined,
      busy: false,
      focus: undefined,
      flow: undefined,
    });
  }

  detailsFor(name: string): Details {
    return this.snapshot().details.get(name) ?? { state: "loading" };
  }
  detailNames(): ReadonlySet<string> {
    return new Set(this.snapshot().details.keys());
  }
  setDetails(name: string, details: Details) {
    this.update((state) => ({
      ...state,
      details: new Map(state.details).set(name, details),
    }));
  }
  setFlow(flow: Flow | undefined) {
    this.update((state) => ({ ...state, flow }));
  }
  clearFocus() {
    this.update((state) => ({ ...state, focus: undefined }));
  }
  dispose() {
    this.resolver = null;
  }
  clearNotice() {
    this.update((state) => ({ ...state, notice: undefined }));
  }
  applyResult(result: ExecuteResult) {
    this.update((state) => ({
      ...state,
      entries: result.entries,
      notice: { ok: result.ok, message: result.message },
      focus: result.ok ? result.selected : undefined,
      busy: false,
    }));
  }
  bindResolver(resolve: (action: PureAction | ExternalAction) => void) {
    this.resolver = resolve;
  }
  readonly dispatch = (action: PureAction | ExternalAction) => {
    if (this.snapshot().busy || this.resolver === null) return;
    const resolve = this.resolver;
    this.resolver = null;
    this.update((state) => ({ ...state, busy: true, notice: undefined }));
    resolve(action);
  };
}

// --- building blocks --------------------------------------------------------

type DetailsPaneProps = {
  details: Details;
  refreshingProvider?: string;
  /** Index into `details.providers` the up/down cursor rests on. */
  focusedIndex: number;
};

function DetailsPane({ details, refreshingProvider, focusedIndex }: DetailsPaneProps): JSX.Element {
  if (details.state === "loading") {
    return <Spinner label="resolving credentials…" />;
  }
  if (details.state === "failed") {
    return <Status variant="error">{details.message}</Status>;
  }
  if (details.providers.length === 0) {
    return <Text tone="muted">No accounts connected — press e to add one.</Text>;
  }
  const { providers } = details;
  const { nameWidth, methodWidth } = providerColumnWidths(providers);
  const focusedProvider = providers[focusedIndex]?.name;
  const reauthHint = "press r to re-login";
  // The same blocks `profile show` prints, windowed to the rows the terminal
  // leaves the pane: the list shrinks to fit (see the root layout in
  // `Dashboard`) and scrolls just enough to keep the focused provider in view.
  // The profile-level slot (no focused provider) shows the list from the top.
  return (
    <Box flexDirection="column" minHeight={0}>
      <VirtualList
        items={providers}
        getKey={(provider) => provider.name}
        itemHeight={(provider, index) => providerBlockHeight(provider, index === 0)}
        focusedIndex={Math.max(0, focusedIndex)}
        renderItem={(provider, index) => (
          <ProviderBlock
            provider={provider}
            first={index === 0}
            nameWidth={nameWidth}
            methodWidth={methodWidth}
            reauthHint={reauthHint}
            refreshingProvider={refreshingProvider}
            focusedProvider={focusedProvider}
            focusColumn
          />
        )}
      />
    </Box>
  );
}

// --- edit screen ------------------------------------------------------------

interface EditRow {
  readonly provider: string;
  readonly method: string | undefined; // undefined = not connected
  readonly states: ReadonlyArray<EditState>;
}

type EditScreenProps = {
  profile: string;
  rows: ReadonlyArray<EditRow>;
  onApply: (choices: ReadonlyArray<EditState>) => void;
  onBack: () => void;
};

function EditScreen({ profile, rows, onApply, onBack }: EditScreenProps): JSX.Element {
  const { cursor, indices, move, cycle } = useCycleNavigation(rows.map((row) => row.states.length));
  const keys = useKeyGlyphs();
  const glyphs = useGlyphs();
  const [unchanged, setUnchanged] = useState(false);
  useTerminalInput((input, key) => {
    const plain = !key.ctrl && !key.meta;
    if (key.escape) return onBack();
    if (key.up || (plain && input === "k")) move(-1);
    else if (key.down || (plain && input === "j")) move(1);
    else if ((plain && input === " ") || key.right) {
      cycle(1);
      setUnchanged(false);
    } else if (key.left) {
      cycle(-1);
      setUnchanged(false);
    } else if (key.enter) {
      if (indices.every((index) => index === 0)) setUnchanged(true);
      else onApply(rows.map((row, i) => row.states[indices[i]]!));
    }
  });
  if (rows.length === 0) {
    return (
      <Stack>
        <Text>
          <Text bold color={theme.color.accent}>
            edit accounts
          </Text>
          <Text tone="muted"> · {profile}</Text>
        </Text>
        <Status>No providers are available for this profile.</Status>
        <KeyBar keys={[[keys.escape, "back"]]} />
      </Stack>
    );
  }
  const choices = rows.map((row) => ({
    label: row.provider,
    description: row.method ?? "not connected",
    states: row.states.map((state) => ({
      value: state,
      label: editStateStyle[state].label,
      icon: glyphs[editStateStyle[state].icon],
      variant: editStateStyle[state].variant,
    })),
  }));
  return (
    <Stack gap={1}>
      <Text>
        <Text bold color={theme.color.accent}>
          edit accounts
        </Text>
        <Text tone="muted"> · {profile}</Text>
      </Text>
      <CycleList choices={choices} cursor={cursor} indices={indices} />
      {unchanged ? (
        <Alert variant="warning" title="No changes to apply">
          Press Space to change an account, or Esc to go back.
        </Alert>
      ) : null}
      <KeyBar
        keys={[
          [keys.upDown, "navigate"],
          [keys.space, "change"],
          [keys.enter, "apply"],
          [keys.escape, "back"],
        ]}
      />
    </Stack>
  );
}

// --- main component ---------------------------------------------------------

type Mode = "normal" | "rename" | "create" | "delete" | "remove";

type DashboardControlsProps = {
  readonly mode: Mode;
  readonly busy: boolean;
  readonly flow: Flow | undefined;
  readonly entry: DashboardEntry | undefined;
  readonly provider: ProfileProviderDisplay | undefined;
  readonly keybinds: ReadonlyArray<readonly [string, string]>;
  readonly keyGlyphs: ReturnType<typeof useKeyGlyphs>;
  readonly store: DashStore;
  readonly setMode: (mode: Mode) => void;
};

function DashboardControls({
  mode,
  busy,
  flow,
  entry,
  provider,
  keybinds,
  keyGlyphs,
  store,
  setMode,
}: DashboardControlsProps) {
  if (flow?.inline !== true && (busy || flow !== undefined)) return null;
  if (mode === "normal") return <KeyBar keys={keybinds} marginTop={0} />;
  if (mode === "delete" && entry !== undefined) {
    return (
      <InlineConfirm
        message={`Delete '${entry.name}' and all its stored credentials?`}
        confirmLabel="Delete"
        cancelLabel="Cancel"
        onSubmit={(confirmed) => {
          setMode("normal");
          if (confirmed) store.dispatch({ kind: "delete", name: entry.name });
        }}
        onCancel={() => setMode("normal")}
      />
    );
  }
  if (mode === "remove" && entry !== undefined && provider !== undefined) {
    return (
      <InlineConfirm
        message={`Remove '${provider.name}' from profile '${entry.name}'?`}
        confirmLabel="Remove"
        cancelLabel="Cancel"
        onSubmit={(confirmed) => {
          setMode("normal");
          if (confirmed) {
            store.dispatch({
              kind: "edit-apply",
              name: entry.name,
              add: [],
              reconfigure: [],
              remove: [provider.name],
            });
          }
        }}
        onCancel={() => setMode("normal")}
      />
    );
  }

  const renaming = mode === "rename" && entry !== undefined;
  return (
    <PromptFrame
      message={renaming ? `rename '${entry.name}' to` : "new profile name"}
      layout="inline"
      keys={[
        [keyGlyphs.enter, "confirm"],
        [keyGlyphs.escape, "cancel"],
      ]}
    >
      <TextField
        key={`${mode}-${entry?.name ?? ""}`}
        placeholder={renaming ? `${entry.name}-new` : "my-profile"}
        onSubmit={(value) => {
          const name = value.trim();
          if (name.length === 0) return;
          setMode("normal");
          store.dispatch(
            renaming
              ? { kind: "rename", name: entry.name, newName: name }
              : { kind: "create", name },
          );
        }}
        onCancel={() => setMode("normal")}
      />
    </PromptFrame>
  );
}

type DashboardProps = {
  store: DashStore;
  initialSelected: number;
};

export function Dashboard({ store, initialSelected }: DashboardProps): JSX.Element {
  const state = useLiveStore(store);
  const keyGlyphs = useKeyGlyphs();
  const { rows } = useTerminalSize();
  const [selected, setSelected] = useState(initialSelected);
  // -1 is the profile-level slot: no provider is focused and profile actions
  // are shown. Up/down cycles through this slot and every connected provider.
  const [focusedProvider, setFocusedProvider] = useState(-1);
  const [mode, setMode] = useState<Mode>("normal");
  const [screen, setScreen] = useState<"overview" | "edit">("overview");
  const { entries, focus: requestedFocus, flow, busy, notice } = state;
  useEffect(() => {
    if (requestedFocus === undefined) return;
    const focusIndex = entries.findIndex((entry) => entry.name === requestedFocus);
    store.clearFocus();
    if (focusIndex >= 0) {
      setSelected(focusIndex);
    }
  }, [entries, requestedFocus, store]);
  const index = Math.min(Math.max(selected, 0), entries.length - 1);
  const entry = entries[index];
  const details = entry === undefined ? undefined : store.detailsFor(entry.name);
  const providers = details?.state === "ready" ? details.providers : [];
  const provider = providers[focusedProvider];
  const moveProviderFocus = (delta: -1 | 1) =>
    setFocusedProvider((current) => {
      const slotCount = providers.length + 1;
      const position = current + 1;
      return ((position + delta + slotCount) % slotCount) - 1;
    });
  useEffect(() => setFocusedProvider(-1), [entry?.name]);

  useTerminalInput((input, key) => {
    // flow prompts, the edit screen, and the inline TextField/InlineConfirm
    // modes own the keyboard
    if (flow !== undefined || screen === "edit" || busy) return;
    if (mode !== "normal") return;
    if (input === "q" || key.escape || (key.ctrl && input === "c")) {
      store.dispatch({ kind: "exit" });
    } else if (key.ctrl || key.meta) {
      return;
    } else if (entry === undefined) {
      if (input === "n") setMode("create");
    } else if (key.left) {
      setSelected((s) => (s + entries.length - 1) % entries.length);
      setFocusedProvider(-1);
    } else if (key.right) {
      setSelected((s) => (s + 1) % entries.length);
      setFocusedProvider(-1);
    } else if (key.up && providers.length > 0) {
      moveProviderFocus(-1);
    } else if (key.down && providers.length > 0) {
      moveProviderFocus(1);
    } else if (provider === undefined && input === "R" && !entry.isDefault) {
      setMode("rename");
    } else if (provider === undefined && input === "d" && !entry.isDefault) {
      setMode("delete");
    } else if (provider === undefined && input === "e" && details?.state === "ready") {
      setScreen("edit");
    } else if (provider === undefined && input === "r") {
      store.dispatch({ kind: "refresh", name: entry.name });
    } else if (provider === undefined && input === "n") {
      setMode("create");
    } else if (input === "e" && provider !== undefined) {
      store.dispatch({
        kind: "edit-apply",
        name: entry.name,
        add: [],
        reconfigure: [provider.name],
        remove: [],
      });
    } else if (input === "r" && provider !== undefined) {
      store.dispatch({
        kind: "refresh",
        name: entry.name,
        provider: provider.name,
      });
    } else if (input === "d" && provider !== undefined) {
      setMode("remove");
    }
  });

  if (flow !== undefined && !flow.inline) {
    return (
      <Text>
        <Text bold color={theme.color.accent}>
          {flow.kind === "refresh" ? "refresh" : "edit accounts"}
        </Text>
        <Text tone="muted"> · {flow.name}</Text>
      </Text>
    );
  }

  if (
    screen === "edit" &&
    entry !== undefined &&
    details !== undefined &&
    details.state === "ready"
  ) {
    const rows: EditRow[] = [
      ...details.providers.map((provider) => ({
        provider: provider.name,
        method: provider.method,
        states: ["keep", "reconfigure", "remove"] as const,
      })),
      ...details.available.map((name) => ({
        provider: name,
        method: undefined,
        states: ["skip", "add"] as const,
      })),
    ];
    return (
      <EditScreen
        profile={entry.name}
        rows={rows}
        onBack={() => setScreen("overview")}
        onApply={(choices) => {
          const pick = (state: EditState) =>
            rows.flatMap((row, i) => (choices[i] === state ? [row.provider] : []));
          const action: ExternalAction = {
            kind: "edit-apply",
            name: entry.name,
            add: pick("add"),
            reconfigure: pick("reconfigure"),
            remove: pick("remove"),
          };
          setScreen("overview");
          if (action.add.length + action.reconfigure.length + action.remove.length === 0) {
            return;
          }
          store.dispatch(action);
        }}
      />
    );
  }

  const annotation = entry !== undefined && entry.isActive ? "active" : "";

  const keybinds: ReadonlyArray<readonly [string, string]> =
    entry === undefined
      ? [
          ["n", "new"],
          ["q", "quit"],
        ]
      : [
          [keyGlyphs.leftRight, "switch profile"],
          ...(providers.length === 0 ? [] : ([[keyGlyphs.upDown, "focus provider"]] as const)),
          ...(provider !== undefined
            ? ([
                ["e", "reconfigure"],
                ["r", "refresh"],
                ["d", "remove"],
              ] as const)
            : ([
                ...(details?.state === "ready"
                  ? ([
                      ["e", "edit"],
                      ["r", "refresh"],
                    ] as const)
                  : []),
                ["n", "new"],
                ...(entry.isDefault
                  ? []
                  : ([
                      ["R", "rename"],
                      ["d", "delete"],
                    ] as const)),
              ] as ReadonlyArray<readonly [string, string]>)),
          ["q", "quit"],
        ];

  // The frame never exceeds the terminal: the provider list is the only part
  // allowed to shrink (a `VirtualList` windows it to whatever rows are left),
  // so every other row of chrome opts out of shrinking. Short lists keep the
  // compact layout because the cap is a maximum, not a fixed height.
  return (
    <Stack maxHeight={rows}>
      <Stack flexShrink={0}>
        <Tabs
          tabs={entries.map((e) => ({
            id: e.name,
            label: e.name,
            marked: e.isActive,
          }))}
          active={entry?.name ?? ""}
        />
      </Stack>
      <Stack gap={1} minHeight={0}>
        {entry === undefined ? (
          <Text tone="muted">No profiles yet — press n to create one.</Text>
        ) : (
          <>
            {/* The profile row is the first focus slot. It sits in the same
                gutter as the provider rows and shares their cursor column, so
                the pointer moves in a straight line as focus travels. */}
            <Box flexShrink={0}>
              <Gutter>
                <Box flexDirection="row">
                  <Pointer focused={provider === undefined} />
                  <Text> </Text>
                  <Text bold color={provider === undefined ? theme.paint.focus : undefined}>
                    {entry.name}
                  </Text>
                  {annotation === "" ? null : <Text tone="muted"> · {annotation}</Text>}
                </Box>
              </Gutter>
            </Box>
            <Box flexDirection="column" minHeight={0}>
              <DetailsPane
                details={details ?? { state: "loading" }}
                focusedIndex={focusedProvider}
                refreshingProvider={flow?.kind === "refresh" ? flow.provider : undefined}
              />
            </Box>
          </>
        )}
      </Stack>
      {/* Keep one stable status row so notices do not push the controls around.
          It shares the gutter with the profile/provider rows above it. */}
      <Box minHeight={1} flexShrink={0} paddingLeft={theme.space.indent}>
        {busy && flow === undefined ? (
          <Spinner label="working…" />
        ) : notice !== undefined ? (
          <Toast variant={notice.ok ? "info" : "error"}>{notice.message}</Toast>
        ) : null}
      </Box>
      <Stack flexShrink={0}>
        <DashboardControls
          mode={mode}
          busy={busy}
          flow={flow}
          entry={entry}
          provider={provider}
          keybinds={keybinds}
          keyGlyphs={keyGlyphs}
          store={store}
          setMode={setMode}
        />
      </Stack>
    </Stack>
  );
}

// --- session driver ---------------------------------------------------------

export interface DashboardSessionOptions<R> {
  readonly entries: ReadonlyArray<DashboardEntry>;
  readonly selected: string | undefined;
  /**
   * Resolves a profile's provider details. A typed failure renders as the
   * detail pane's `failed` state, showing the error's message.
   */
  readonly loadDetails: (
    name: string,
  ) => Effect.Effect<ProfileDetailsPayload, { readonly message: string }, R>;
  /** Executes a pure store action and returns the refreshed state. */
  readonly execute: (action: PureAction) => Effect.Effect<ExecuteResult, never, R>;
  /**
   * Runs an edit/refresh flow. Its prompts render inside the dashboard via
   * the embedded session; resolves with a toast outcome — `ok: false`
   * renders as a persistent error notice instead of an auto-dismissing
   * success toast.
   */
  readonly runFlow: (
    action: FlowAction,
    events: {
      readonly onProviderStart: (provider: string) => Effect.Effect<void>;
    },
  ) => Effect.Effect<{ ok: boolean; message: string }, never, R>;
  /** Re-reads entries after a flow (the active profile may have changed). */
  readonly reloadEntries: Effect.Effect<ReadonlyArray<DashboardEntry>, never, R>;
}

/**
 * Runs the dashboard inside one Interaction session. Pure actions and
 * edit/refresh flows share the same frame, and the session clears it on
 * exit.
 */
export const runProfileDashboardSession = <R,>(
  options: DashboardSessionOptions<R>,
): Effect.Effect<void, NonInteractiveTerminal, R | Interaction> =>
  Effect.flatMap(Interaction, (cli) =>
    cli.session(
      // live is Scope-bound; the session scope is its release backstop
      // (the ensuring(live.close) below settles it on the normal path).
      Effect.scoped(
        Effect.gen(function* () {
          const store = new DashStore(options.entries);
          let noticeFiber: Fiber.Fiber<void, never> | undefined;

          const applyResult = Effect.fn(function* (result: ExecuteResult) {
            if (noticeFiber !== undefined) yield* Fiber.interrupt(noticeFiber);
            store.applyResult(result);
            if (result.ok) {
              noticeFiber = yield* Effect.sleep("4 seconds").pipe(
                Effect.andThen(Effect.sync(() => store.clearNotice())),
                Effect.forkChild,
              );
            }
          });

          const loadInto = (name: string) =>
            options.loadDetails(name).pipe(
              Effect.flatMap((payload) =>
                Effect.sync(() => store.setDetails(name, { state: "ready", ...payload })),
              ),
              Effect.catch((error) =>
                Effect.sync(() =>
                  store.setDetails(name, {
                    state: "failed",
                    message: error.message,
                  }),
                ),
              ),
              Effect.catchDefect((defect) =>
                Effect.sync(() =>
                  store.setDetails(name, {
                    state: "failed",
                    message: String(defect),
                  }),
                ),
              ),
              // Provider discovery can build very large Layers. Yield often
              // enough for Sigil's 80ms animation clock to keep painting while
              // that CPU-heavy Effect graph is evaluated.
              Effect.provideService(Scheduler.MaxOpsBeforeYield, 64),
            );

          const initialSelected = Math.max(
            0,
            options.entries.findIndex((entry) => entry.name === options.selected),
          );

          const live = yield* cli.live(
            <Dashboard store={store} initialSelected={initialSelected} />,
            { placement: "beforeTranscript" },
          );

          // Mount the spinner before starting stack import/provider builds.
          // Forking the loader first allowed synchronous module evaluation to
          // delay the dashboard's first frame, making it look fully hung.
          const loader = yield* Effect.forEach(options.entries, (entry) => loadInto(entry.name), {
            concurrency: 2,
            discard: true,
          }).pipe(Effect.delay("1 millis"), Effect.forkChild);

          yield* Effect.gen(function* () {
            while (true) {
              const action = yield* Effect.callback<PureAction | ExternalAction>((resume) => {
                store.bindResolver((action) => resume(Effect.succeed(action)));
              });
              switch (action.kind) {
                case "exit":
                  return;
                case "refresh":
                case "edit-apply": {
                  store.setFlow({
                    kind: action.kind,
                    name: action.name,
                    provider: action.kind === "refresh" ? action.provider : undefined,
                    // refresh keeps the overview on screen with a spinner; only
                    // account editing takes over the whole view
                    inline: action.kind === "refresh",
                  });
                  const flowEffect = options.runFlow(action, {
                    onProviderStart: (provider) =>
                      Effect.sync(() =>
                        store.setFlow({
                          kind: "refresh",
                          name: action.name,
                          provider,
                          inline: true,
                        }),
                      ),
                  });
                  // Provider login implementations emit useful progress in
                  // standalone commands. Inside the dashboard that progress
                  // belongs in the provider pane, not the transcript.
                  const quietRefreshCli = {
                    ...cli,
                    output: {
                      ...cli.output,
                      info: () => Effect.void,
                      success: () => Effect.void,
                    },
                  } satisfies Interaction["Service"];
                  const result = yield* cli.session(
                    action.kind === "refresh"
                      ? flowEffect.pipe(Effect.provideService(Interaction, quietRefreshCli))
                      : flowEffect,
                  );
                  const entries = yield* options.reloadEntries;
                  if (action.kind === "refresh") {
                    // Keep the provider-level spinner visible until the new
                    // expiry/token details have replaced the old ones.
                    yield* loadInto(action.name);
                  } else {
                    store.setDetails(action.name, { state: "loading" });
                    yield* loadInto(action.name).pipe(Effect.forkChild);
                  }
                  store.setFlow(undefined);
                  yield* applyResult({
                    ok: result.ok,
                    message: result.message,
                    entries,
                    selected: action.name,
                  });
                  break;
                }
                default: {
                  const result = yield* options.execute(action);
                  // a renamed/created profile needs its details (re)resolved
                  const names = store.detailNames();
                  yield* applyResult(result);
                  yield* Effect.forEach(
                    result.entries.filter((e) => !names.has(e.name)),
                    (e) => loadInto(e.name),
                    { concurrency: 2, discard: true },
                  ).pipe(Effect.forkChild);
                }
              }
            }
          }).pipe(
            Effect.ensuring(Effect.sync(() => store.dispose())),
            Effect.ensuring(
              Effect.suspend(() =>
                noticeFiber === undefined ? Effect.void : Fiber.interrupt(noticeFiber),
              ),
            ),
            Effect.ensuring(live.close),
            Effect.ensuring(Fiber.interrupt(loader)),
          );
        }),
      ),
    ),
  );