import "../../index.css"; import {  type AuthAccessStreamEvent,  type AuthAccessSnapshot,  AuthSessionId,  DEFAULT_SERVER_SETTINGS,  EnvironmentId,  type DesktopBridge,  type DesktopUpdateChannel,  type DesktopUpdateState,  type LocalApi,  ProviderDriverKind,  ProviderInstanceId,  type ServerConfig,  type ServerProvider,  type SourceControlDiscoveryResult,} from "@t3tools/contracts";import { DateTime, Option } from "effect";import { page } from "vitest/browser";import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import { render } from "vitest-browser-react";import type { ReactNode } from "react";import {  RouterProvider,  createMemoryHistory,  createRootRoute,  createRoute,  createRouter,} from "@tanstack/react-router"; import { __resetLocalApiForTests } from "../../localApi";import { AppAtomRegistryProvider, resetAppAtomRegistryForTests } from "../../rpc/atomRegistry";import { resetServerStateForTests, setServerConfigSnapshot } from "../../rpc/serverState";import { useUiStateStore } from "../../uiStateStore";import { ConnectionsSettings } from "./ConnectionsSettings";import { DiagnosticsSettingsPanel } from "./DiagnosticsSettings";import { GeneralSettingsPanel, ProviderSettingsPanel } from "./SettingsPanels";import { SourceControlSettingsPanel } from "./SourceControlSettings"; function renderWithTestRouter(children: ReactNode) {  const rootRoute = createRootRoute({    component: () => children,  });  const indexRoute = createRoute({    getParentRoute: () => rootRoute,    path: "/",  });  const router = createRouter({    routeTree: rootRoute.addChildren([indexRoute]),    history: createMemoryHistory({ initialEntries: ["/"] }),  });   return render(<RouterProvider router={router} />);} const authAccessHarness = vi.hoisted(() => {  type Snapshot = AuthAccessSnapshot;  let snapshot: Snapshot = {    pairingLinks: [],    clientSessions: [],  };  let revision = 1;  const listeners = new Set<(event: AuthAccessStreamEvent) => void>();   const emitEvent = (event: AuthAccessStreamEvent) => {    for (const listener of listeners) {      listener(event);    }  };   return {    reset() {      snapshot = {        pairingLinks: [],        clientSessions: [],      };      revision = 1;      listeners.clear();    },    setSnapshot(next: Snapshot) {      snapshot = next;    },    emitSnapshot() {      emitEvent({        version: 1 as const,        revision,        type: "snapshot" as const,        payload: snapshot,      });      revision += 1;    },    emitEvent,    emitPairingLinkUpserted(pairingLink: Snapshot["pairingLinks"][number]) {      emitEvent({        version: 1,        revision,        type: "pairingLinkUpserted",        payload: pairingLink,      });      revision += 1;    },    emitPairingLinkRemoved(id: string) {      emitEvent({        version: 1,        revision,        type: "pairingLinkRemoved",        payload: { id },      });      revision += 1;    },    emitClientUpserted(clientSession: Snapshot["clientSessions"][number]) {      emitEvent({        version: 1,        revision,        type: "clientUpserted",        payload: clientSession,      });      revision += 1;    },    emitClientRemoved(sessionId: string) {      emitEvent({        version: 1,        revision,        type: "clientRemoved",        payload: {          sessionId: AuthSessionId.make(sessionId),        },      });      revision += 1;    },    subscribe(listener: (event: AuthAccessStreamEvent) => void) {      listeners.add(listener);      listener({        version: 1,        revision: 1,        type: "snapshot",        payload: snapshot,      });      return () => {        listeners.delete(listener);      };    },  };}); const mockConnectDesktopSshEnvironment = vi.hoisted(() => vi.fn()); vi.mock("../../environments/runtime", () => {  const primaryConnection = {    kind: "primary" as const,    knownEnvironment: {      id: "environment-local",      label: "Local environment",      source: "manual" as const,      environmentId: EnvironmentId.make("environment-local"),      target: {        httpBaseUrl: "http://localhost:3000",        wsBaseUrl: "ws://localhost:3000",      },    },    environmentId: EnvironmentId.make("environment-local"),    client: {      server: {        subscribeAuthAccess: (listener: Parameters<typeof authAccessHarness.subscribe>[0]) =>          authAccessHarness.subscribe(listener),      },    },    ensureBootstrapped: async () => undefined,    reconnect: async () => undefined,    dispose: async () => undefined,  };   return {    getEnvironmentHttpBaseUrl: () => "http://localhost:3000",    getSavedEnvironmentRecord: () => null,    getSavedEnvironmentRuntimeState: () => null,    hasSavedEnvironmentRegistryHydrated: () => true,    listSavedEnvironmentRecords: () => [],    resetSavedEnvironmentRegistryStoreForTests: () => undefined,    resetSavedEnvironmentRuntimeStoreForTests: () => undefined,    resolveEnvironmentHttpUrl: (_environmentId: unknown, path: string) =>      new URL(path, "http://localhost:3000").toString(),    waitForSavedEnvironmentRegistryHydration: async () => undefined,    addSavedEnvironment: vi.fn(),    connectDesktopSshEnvironment: mockConnectDesktopSshEnvironment,    disconnectSavedEnvironment: vi.fn(),    ensureEnvironmentConnectionBootstrapped: async () => undefined,    getPrimaryEnvironmentConnection: () => primaryConnection,    readEnvironmentConnection: () => primaryConnection,    reconnectSavedEnvironment: vi.fn(),    removeSavedEnvironment: vi.fn(),    requireEnvironmentConnection: () => primaryConnection,    resetEnvironmentServiceForTests: () => undefined,    startEnvironmentConnectionService: () => undefined,    subscribeEnvironmentConnections: () => () => {},    useSavedEnvironmentRegistryStore: (      selector: (state: { byId: Record<string, never> }) => unknown,    ) => selector({ byId: {} }),    useSavedEnvironmentRuntimeStore: (      selector: (state: { byId: Record<string, never> }) => unknown,    ) => selector({ byId: {} }),  };}); function createBaseServerConfig(): ServerConfig {  return {    environment: {      environmentId: EnvironmentId.make("environment-local"),      label: "Local environment",      platform: { os: "darwin" as const, arch: "arm64" as const },      serverVersion: "0.0.0-test",      capabilities: { repositoryIdentity: true },    },    auth: {      policy: "loopback-browser",      bootstrapMethods: ["one-time-token"],      sessionMethods: ["browser-session-cookie", "bearer-session-token"],      sessionCookieName: "t3_session",    },    cwd: "/repo/project",    keybindingsConfigPath: "/repo/project/.t3code-keybindings.json",    keybindings: [],    issues: [],    providers: [],    availableEditors: ["cursor"],    observability: {      logsDirectoryPath: "/repo/project/.t3/logs",      localTracingEnabled: true,      otlpTracesUrl: "http://localhost:4318/v1/traces",      otlpTracesEnabled: true,      otlpMetricsEnabled: false,    },    settings: DEFAULT_SERVER_SETTINGS,  };} function createOutdatedProvider(driver: string): ServerProvider {  return {    instanceId: ProviderInstanceId.make(driver),    driver: ProviderDriverKind.make(driver),    enabled: true,    installed: true,    version: "1.0.0",    status: "ready",    auth: { status: "authenticated" },    checkedAt: "2026-05-04T10:00:00.000Z",    models: [],    slashCommands: [],    skills: [],    versionAdvisory: {      status: "behind_latest",      currentVersion: "1.0.0",      latestVersion: "1.1.0",      message: "Update available.",      checkedAt: "2026-05-04T10:00:00.000Z",      updateCommand: "npm install -g openai/codex@latest",      canUpdate: true,    },  };} function makeUtc(value: string) {  return DateTime.makeUnsafe(Date.parse(value));} function makePairingLink(input: {  readonly id: string;  readonly credential: string;  readonly role: "owner" | "client";  readonly subject: string;  readonly label?: string;  readonly createdAt: string;  readonly expiresAt: string;}): AuthAccessSnapshot["pairingLinks"][number] {  return {    ...input,    createdAt: makeUtc(input.createdAt),    expiresAt: makeUtc(input.expiresAt),  };} function makeClientSession(input: {  readonly sessionId: string;  readonly subject: string;  readonly role: "owner" | "client";  readonly method: "browser-session-cookie";  readonly client?: {    readonly label?: string;    readonly ipAddress?: string;    readonly userAgent?: string;    readonly deviceType?: "desktop" | "mobile" | "tablet" | "bot" | "unknown";    readonly os?: string;    readonly browser?: string;  };  readonly issuedAt: string;  readonly expiresAt: string;  readonly lastConnectedAt?: string | null;  readonly connected: boolean;  readonly current: boolean;}): AuthAccessSnapshot["clientSessions"][number] {  return {    ...input,    client: {      deviceType: "unknown",      ...input.client,    },    sessionId: AuthSessionId.make(input.sessionId),    issuedAt: makeUtc(input.issuedAt),    expiresAt: makeUtc(input.expiresAt),    lastConnectedAt:      input.lastConnectedAt === undefined || input.lastConnectedAt === null        ? null        : makeUtc(input.lastConnectedAt),  };} const createDesktopBridgeStub = (overrides?: {  readonly discoverSshHosts?: DesktopBridge["discoverSshHosts"];  readonly serverExposureState?: Awaited<ReturnType<DesktopBridge["getServerExposureState"]>>;  readonly advertisedEndpoints?: Awaited<ReturnType<DesktopBridge["getAdvertisedEndpoints"]>>;  readonly setServerExposureMode?: DesktopBridge["setServerExposureMode"];  readonly setUpdateChannel?: DesktopBridge["setUpdateChannel"];}): DesktopBridge => {  const idleUpdateState: DesktopUpdateState = {    enabled: false,    status: "idle",    channel: "latest",    currentVersion: "0.0.0-test",    hostArch: "arm64",    appArch: "arm64",    runningUnderArm64Translation: false,    availableVersion: null,    downloadedVersion: null,    downloadPercent: null,    checkedAt: null,    message: null,    errorContext: null,    canRetry: false,  };   return {    getAppBranding: vi.fn().mockReturnValue(null),    getLocalEnvironmentBootstrap: () => ({      label: "Local environment",      httpBaseUrl: "http://127.0.0.1:3773",      wsBaseUrl: "ws://127.0.0.1:3773",      bootstrapToken: "desktop-bootstrap-token",    }),    getClientSettings: vi.fn().mockResolvedValue(null),    setClientSettings: vi.fn().mockResolvedValue(undefined),    getSavedEnvironmentRegistry: vi.fn().mockResolvedValue([]),    setSavedEnvironmentRegistry: vi.fn().mockResolvedValue(undefined),    getSavedEnvironmentSecret: vi.fn().mockResolvedValue(null),    setSavedEnvironmentSecret: vi.fn().mockResolvedValue(true),    removeSavedEnvironmentSecret: vi.fn().mockResolvedValue(undefined),    discoverSshHosts: overrides?.discoverSshHosts ?? vi.fn().mockResolvedValue([]),    ensureSshEnvironment: vi.fn().mockImplementation(async (target) => ({      target,      httpBaseUrl: "http://127.0.0.1:3774/",      wsBaseUrl: "ws://127.0.0.1:3774/",      pairingToken: "ssh-pairing-token",    })),    disconnectSshEnvironment: vi.fn().mockResolvedValue(undefined),    fetchSshEnvironmentDescriptor: vi.fn().mockResolvedValue({      environmentId: "environment-ssh",      label: "SSH environment",      platform: {        os: "linux",        arch: "x64",      },      serverVersion: "0.0.0-test",      capabilities: {        repositoryIdentity: true,      },    }),    bootstrapSshBearerSession: vi.fn().mockResolvedValue({      authenticated: true,      role: "owner",      sessionMethod: "bearer-session-token",      expiresAt: "2026-05-01T12:00:00.000Z",      sessionToken: "ssh-bearer-token",    }),    fetchSshSessionState: vi.fn().mockResolvedValue({      authenticated: true,      auth: {        policy: "remote-reachable",        bootstrapMethods: ["one-time-token"],        sessionMethods: ["browser-session-cookie", "bearer-session-token"],        sessionCookieName: "t3_session",      },      role: "owner",      sessionMethod: "bearer-session-token",      expiresAt: "2026-05-01T12:00:00.000Z",    }),    issueSshWebSocketToken: vi.fn().mockResolvedValue({      token: "ssh-ws-token",      expiresAt: "2026-05-01T12:05:00.000Z",    }),    onSshPasswordPrompt: vi.fn(() => () => {}),    resolveSshPasswordPrompt: vi.fn().mockResolvedValue(undefined),    getServerExposureState: vi.fn().mockResolvedValue(      overrides?.serverExposureState ?? {        mode: "local-only",        endpointUrl: null,        advertisedHost: null,        tailscaleServeEnabled: false,        tailscaleServePort: 443,      },    ),    setServerExposureMode:      overrides?.setServerExposureMode ??      vi.fn().mockImplementation(async (mode) => ({        mode,        endpointUrl: mode === "network-accessible" ? "http://192.168.1.44:3773" : null,        advertisedHost: mode === "network-accessible" ? "192.168.1.44" : null,        tailscaleServeEnabled: false,        tailscaleServePort: 443,      })),    setTailscaleServeEnabled: vi.fn().mockImplementation(async (input) => ({      mode: overrides?.serverExposureState?.mode ?? "network-accessible",      endpointUrl: overrides?.serverExposureState?.endpointUrl ?? "http://192.168.1.44:3773",      advertisedHost: overrides?.serverExposureState?.advertisedHost ?? "192.168.1.44",      tailscaleServeEnabled: input.enabled,      tailscaleServePort: input.port ?? 443,    })),    getAdvertisedEndpoints: vi.fn().mockResolvedValue(overrides?.advertisedEndpoints ?? []),    pickFolder: vi.fn().mockResolvedValue(null),    confirm: vi.fn().mockResolvedValue(false),    setTheme: vi.fn().mockResolvedValue(undefined),    showContextMenu: vi.fn().mockResolvedValue(null),    openExternal: vi.fn().mockResolvedValue(true),    onMenuAction: () => () => {},    getUpdateState: vi.fn().mockResolvedValue(idleUpdateState),    setUpdateChannel:      overrides?.setUpdateChannel ??      vi.fn().mockImplementation(async (channel: DesktopUpdateChannel) => ({        ...idleUpdateState,        channel,      })),    checkForUpdate: vi.fn().mockResolvedValue({ checked: false, state: idleUpdateState }),    downloadUpdate: vi      .fn()      .mockResolvedValue({ accepted: false, completed: false, state: idleUpdateState }),    installUpdate: vi      .fn()      .mockResolvedValue({ accepted: false, completed: false, state: idleUpdateState }),    onUpdateState: () => () => {},  };}; describe("GeneralSettingsPanel observability", () => {  let mounted:    | (Awaited<ReturnType<typeof render>> & {        cleanup?: () => Promise<void>;        unmount?: () => Promise<void>;      })    | null = null;   beforeEach(async () => {    resetServerStateForTests();    await __resetLocalApiForTests();    localStorage.clear();    useUiStateStore.setState({ defaultAdvertisedEndpointKey: null });    authAccessHarness.reset();    mockConnectDesktopSshEnvironment.mockReset();  });   afterEach(async () => {    if (mounted) {      const teardown = mounted.cleanup ?? mounted.unmount;      await teardown?.call(mounted).catch(() => {});    }    mounted = null;    vi.unstubAllGlobals();    Reflect.deleteProperty(window, "desktopBridge");    Reflect.deleteProperty(window, "nativeApi");    document.body.innerHTML = "";    resetServerStateForTests();    await __resetLocalApiForTests();    authAccessHarness.reset();  });   it("hides owner pairing tools in browser-served loopback builds without remote exposure", async () => {    Reflect.deleteProperty(window, "desktopBridge");    authAccessHarness.setSnapshot({      pairingLinks: [],      clientSessions: [        makeClientSession({          sessionId: "session-owner",          subject: "browser-owner",          role: "owner",          method: "browser-session-cookie",          client: {            label: "Chrome on Mac",            deviceType: "desktop",            os: "macOS",            browser: "Chrome",            ipAddress: "127.0.0.1",          },

Lines 1–500 of 1306. Load more