Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

23.7 KB
Raw Blame
import 'support/resource_picker.dart';

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/core/models.dart';
import 'package:harness/core/dsh_catalog.dart';
import 'package:harness/widgets/agent_picker.dart';
import 'package:harness/core/config.dart';
import 'package:harness/auth/auth_session.dart';
import 'package:harness/auth/cli_login.dart';
import 'package:harness/screens/swarm_screen.dart';
import 'package:harness/state/app_state.dart';
import 'package:harness/state/harness_placement.dart';
import 'package:harness/state/new_harness.dart';
import 'package:harness/state/swarm_catalog.dart';
import 'package:harness/usage/models_menu_controller.dart';
import 'package:harness/usage/usage_accounts.dart';
import 'package:harness/usage/usage_controller.dart';
import 'package:harness/usage/usage_source.dart';
import 'package:harness/usage/usage_window.dart';
import 'package:harness/widgets/new_harness_form.dart';

import 'swarm_screen_test.dart' show terminal;
import 'swarm_state_test.dart' show createApp;
import 'support/model_manager.dart';

import 'keymap_host_test.dart' show key;

/// Stands in for the machine behind the Open Grid door: the probes New Agent
/// makes answer at once, and the harness list says whether Grid is installed
/// there. Nothing is created — the door's job ends when New Agent is open on
/// the right machine with Grid chosen, or the Store is open on Grid's page.
class _GridApp extends AppNotifier {
  _GridApp({required this.grid, this.harness = AppNotifier.gridHarness})
    : super(
        config: AppConfig.dev,
        authSession: AuthSession(),
        configStore: null,
      ) {
    hasNavigationRail = false;
  }

  /// Per machine: true = Grid installed, false = listed but not installed,
  /// absent = the machine never heard of it.
  final Map<String, bool> grid;
  final String harness;

  @override
  Future<void> probeEngines(String machineId, {bool force = false}) async {}

  @override
  Future<void> probeDsh(
    String machineId, {
    bool force = false,
    bool userAction = false,
  }) async {
    final installed = grid[machineId];
    machineStates[machineId]!.dsh.replace([
      if (installed != null)
        DshEntry(
          id: harness,
          name: harness == AppNotifier.machinesHarness
              ? 'Machine Monitor'
              : 'Grid',
          engine: 'codex',
          description: 'Talk to your fleet.',
          installed: installed,
        ),
    ]);
    notifyListeners();
  }

  @override
  Future<Map<String, dynamic>> listCodexProfiles(
    String machineId, {
    Set<String> observedPaths = const {},
  }) async => {'profiles': <dynamic>[]};
}

_GridApp _gridApp({
  required Map<String, bool> grid,
  bool secondMachine = false,
  String harness = AppNotifier.gridHarness,
}) {
  final app = _GridApp(grid: grid, harness: harness);
  const machine = Machine(
    machineId: 'm',
    authMode: MachineAuthMode.remote,
    name: 'Test host',
  );
  app.machines = [machine];
  app.machineStates['m'] = MachineState(machine)
    ..localOnly = true
    ..nodeOnline = true
    ..agentLoadStatus = AgentLoadStatus.loaded;
  if (secondMachine) {
    const other = Machine(
      machineId: 'other',
      authMode: MachineAuthMode.remote,
      name: 'Studio',
    );
    app.machines = [machine, other];
    app.machineStates['other'] = MachineState(other)
      ..nodeOnline = true
      ..agentLoadStatus = AgentLoadStatus.loaded;
  }
  return app;
}

class _NoopLogin extends CliLogin {
  int logoutCalls = 0;
  @override
  Future<void> logout() async {
    logoutCalls++;
  }
}

class _Source implements UsageSource {
  _Source(this.provider, this.answer);
  @override
  final UsageProvider provider;
  Future<ProviderUsage> Function() answer;
  int calls = 0;
  @override
  Future<ProviderUsage> read() {
    calls++;
    return answer();
  }
}

void main() {
  final instant = DateTime.utc(2026, 9, 13, 12);
  ProviderUsage reading({
    double session = 85,
    double weekly = 30,
    DateTime? reset,
    DateTime? fetched,
    String? account = 'aabbccddeeff0011',
    String? email = '[email protected]',
  }) => ProviderUsage(
    provider: UsageProvider.claude,
    status: UsageStatus.ok,
    account: account,
    email: email,
    fetchedAt: fetched ?? instant,
    windows: [
      UsageWindow(label: 'Session', usedPercent: session, resetsAt: reset),
      UsageWindow(label: 'Weekly', usedPercent: weekly),
    ],
  );

  test(
    'remaining means the limiting window, with account deduplication',
    () async {
      final source = _Source(UsageProvider.claude, () async => reading());
      final usage = UsageController(
        sources: [source],
        autoStart: false,
        remote: () async => [
          MachineUsage(machineName: 'Shared Mac', readings: [reading()]),
          MachineUsage(
            machineName: 'Other Mac',
            readings: [
              reading(
                account: '1122334455667788',
                email: '[email protected]',
                session: 50,
              ),
            ],
          ),
        ],
      );
      final menu = ModelsMenuController(usage: usage, now: () => instant);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      await menu.refresh();
      expect(menu.rows, hasLength(2));
      expect(menu.rows.first['title'], 'Anthropic');
      expect(menu.rows.first['status'], '15% remaining');
      expect(menu.rows.first['details'], contains('Weekly — 70% remaining'));
      expect(menu.rows.first['account'], '[email protected]');
      expect(menu.rows.first['machines'], ['Shared Mac']);
      expect(menu.rows.first['accountKey'], 'aabbccddeeff0011');
      expect(menu.rows.last['title'], 'Anthropic');
      expect(menu.rows.last['account'], '[email protected]');
      expect(menu.rows.last['status'], '50% remaining');
      expect(
        menu.rows.map((row) => row['details']).toString(),
        isNot(contains('aabbccddeeff0011')),
      );
    },
  );

  test(
    'no startup work; opening coalesces and caches requests for a minute',
    () async {
      var now = instant;
      var answer = Completer<ProviderUsage>();
      final source = _Source(UsageProvider.claude, () => answer.future);
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => now);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      expect(source.calls, 0);
      final first = menu.refresh();
      expect(menu.refresh(), same(first));
      expect(source.calls, 1);
      answer.complete(reading());
      await first;
      await menu.refresh();
      expect(source.calls, 1);
      now = now.add(const Duration(minutes: 1));
      answer = Completer<ProviderUsage>();
      final second = menu.refresh();
      expect(source.calls, 2);
      answer.complete(reading());
      await second;
    },
  );

  group('sign-out', () {
    List<MachineUsage> otherAccount() => [
      MachineUsage(
        machineName: 'Other Mac',
        readings: [
          reading(account: '1122334455667788', email: '[email protected]'),
        ],
      ),
    ];
    bool remoteRow(Map<String, Object?> row) => row['local'] == false;

    test('sign-out forgets remote usage rows', () async {
      final usage = UsageController(
        sources: [_Source(UsageProvider.claude, () async => reading())],
        autoStart: false,
        remote: () async => otherAccount(),
      );
      final menu = ModelsMenuController(usage: usage, now: () => instant);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      await menu.refresh();
      expect(menu.rows.where(remoteRow), hasLength(1));

      menu.reset();

      expect(menu.rows.where(remoteRow), isEmpty);
      expect(menu.rows.single['account'], '[email protected]');
    });

    test('a remote read the old account started lands nowhere', () async {
      final answers = <Completer<List<MachineUsage>>>[];
      final source = _Source(UsageProvider.claude, () async => reading());
      final usage = UsageController(
        sources: [source],
        autoStart: false,
        remote: () {
          answers.add(Completer());
          return answers.last.future;
        },
      );
      final menu = ModelsMenuController(usage: usage, now: () => instant);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      final asked = menu.refresh();

      menu.reset();
      answers.single.complete(otherAccount());
      await asked;

      expect(menu.rows.where(remoteRow), isEmpty);
      // The next account reads at once, not a minute after the old one did.
      final next = menu.refresh();
      expect(source.calls, 2);
      answers.last.complete(const []);
      await next;
    });

    test('the next account reads while the old one\'s read is held', () async {
      final locals = <Completer<ProviderUsage>>[];
      final remotes = <Completer<List<MachineUsage>>>[];
      final source = _Source(UsageProvider.claude, () {
        locals.add(Completer());
        return locals.last.future;
      });
      final usage = UsageController(
        sources: [source],
        autoStart: false,
        remote: () {
          remotes.add(Completer());
          return remotes.last.future;
        },
      );
      var clock = instant;
      final menu = ModelsMenuController(usage: usage, now: () => clock);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      final old = menu.refresh();

      menu.reset();
      final next = menu.refresh();
      expect(source.calls, 2);

      // The old account's read lands late, and fails: it must neither end
      // nor fail the next account's read.
      locals.first.completeError(StateError('old account'));
      remotes.first.complete(otherAccount());
      await old;
      clock = instant.add(const Duration(minutes: 2));
      final reopened = menu.refresh();
      expect(source.calls, 2);

      locals.last.complete(reading());
      remotes.last.complete([
        MachineUsage(
          machineName: 'Studio',
          readings: [reading(account: '99aa', email: '[email protected]')],
        ),
      ]);
      await Future.wait([next, reopened]);

      final remote = menu.rows.where(remoteRow).single;
      expect(remote['account'], '[email protected]');
      expect(remote['status'], '15% remaining');
    });

    for (final expires in [false, true]) {
      test('${expires ? 'expiry' : 'sign-out'} resets the window\'s Models '
          'menu', () async {
        // Never the real CLI: its logout would sign this computer out.
        final login = _NoopLogin();
        final app = AppNotifier(
          config: AppConfig.dev,
          authSession: AuthSession(),
          configStore: null,
          cliLogin: login,
        );
        addTearDown(app.dispose);
        final menu = app.modelsMenu;
        var told = 0;
        menu.addListener(() => told++);
        if (expires) {
          app.expireSessionForTest('Session expired.');
        } else {
          await app.logout();
        }
        expect(login.logoutCalls, expires ? 0 : 1);
        expect(told, greaterThan(0));
        expect(app.modelsMenu, same(menu), reason: 'pickers keep listening');
        expect(menu.rows.where(remoteRow), isEmpty);
      });
    }
  });

  test(
    'readings without email do not expose their internal account key',
    () async {
      final source = _Source(
        UsageProvider.claude,
        () async => reading(email: null),
      );
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => instant);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      await menu.refresh();
      expect(menu.rows.single['title'], 'Anthropic');
      expect(menu.rows.single['account'], '');
      expect(menu.rows.single['accountKey'], 'aabbccddeeff0011');
    },
  );

  test(
    'unknown, expired and invalid readings never become made-up percentages',
    () async {
      ProviderUsage value = const ProviderUsage(
        provider: UsageProvider.claude,
        status: UsageStatus.signedOut,
      );
      var now = instant;
      final source = _Source(UsageProvider.claude, () async => value);
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => now);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      await menu.refresh();
      expect(menu.rows.single['status'], 'Not signed in');
      for (final next in [
        reading(reset: instant),
        reading(session: double.nan),
        reading(fetched: instant.subtract(const Duration(minutes: 61))),
      ]) {
        value = next;
        now = now.add(const Duration(minutes: 1));
        await menu.refresh();
        expect(menu.rows.single['status'], 'Usage unavailable');
        expect(menu.rows.single['details'].toString(), isNot(contains('%')));
      }
    },
  );

  test(
    'an expired reading says "Checking usage…" while the next read runs',
    () async {
      var now = instant;
      var answer = Completer<ProviderUsage>();
      final source = _Source(UsageProvider.claude, () => answer.future);
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => now);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      final first = menu.refresh();
      answer.complete(reading());
      await first;
      expect(menu.rows.single['status'], '15% remaining');

      now = now.add(const Duration(minutes: 61));
      expect(menu.rows.single['status'], 'Usage unavailable');
      answer = Completer<ProviderUsage>();
      final second = menu.refresh();
      expect(menu.rows.single['status'], 'Checking usage…');
      expect(menu.rows.single['remainingPercent'], isNull);
      answer.complete(reading(fetched: now));
      await second;
      expect(menu.rows.single['status'], '15% remaining');
    },
  );

  test(
    'a cached figure stays for up to an hour and says how old it is',
    () async {
      var now = instant;
      final source = _Source(UsageProvider.claude, () async => reading());
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => now);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      await menu.refresh();
      now = now.add(const Duration(minutes: 30));
      expect(menu.rows.single['status'], '15% remaining');
      expect(menu.rows.single['details'], contains('Read 30 min ago'));
    },
  );

  test('a failed read keeps the last good figure', () async {
    var fail = false;
    final source = _Source(
      UsageProvider.claude,
      () async => fail
          ? const ProviderUsage(
              provider: UsageProvider.claude,
              status: UsageStatus.failed,
            )
          : reading(),
    );
    final usage = UsageController(sources: [source], autoStart: false);
    final menu = ModelsMenuController(usage: usage, now: () => instant);
    addTearDown(usage.dispose);
    addTearDown(menu.dispose);
    await usage.refresh();
    fail = true;
    await usage.refresh();
    expect(source.calls, 2);
    expect(menu.rows.single['status'], '15% remaining');
  });

  test(
    'a positive fraction of remaining usage is not rounded to zero',
    () async {
      final source = _Source(
        UsageProvider.claude,
        () async => reading(session: 99.6),
      );
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => instant);
      addTearDown(usage.dispose);
      addTearDown(menu.dispose);
      await menu.refresh();
      expect(menu.rows.single['status'], '<1% remaining');
    },
  );

  test(
    'source errors and a late response after disposal are contained',
    () async {
      final answer = Completer<ProviderUsage>();
      final source = _Source(UsageProvider.codex, () => answer.future);
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage, now: () => instant);
      addTearDown(usage.dispose);
      var notifications = 0;
      menu.addListener(() => notifications++);
      final request = menu.refresh();
      menu.dispose();
      final count = notifications;
      answer.completeError(StateError('synthetic secret must not reach UI'));
      await request;
      expect(notifications, count);
    },
  );

  testWidgets(
    'View Models refreshes subscriptions only when the shared panel opens',
    (tester) async {
      const channel = MethodChannel('harness/swarm_tabs');
      final messenger = tester.binding.defaultBinaryMessenger;
      final messages = <MethodCall>[];
      messenger.setMockMethodCallHandler(channel, (call) async {
        messages.add(call);
        return true;
      });
      addTearDown(() => messenger.setMockMethodCallHandler(channel, null));
      final source = _Source(
        UsageProvider.codex,
        () async => const ProviderUsage(
          provider: UsageProvider.codex,
          status: UsageStatus.signedOut,
        ),
      );
      final usage = UsageController(sources: [source], autoStart: false);
      final menu = ModelsMenuController(usage: usage);
      final app = createApp();
      final original = app.activeSwarmId;
      final projects = SwarmProjectStore();
      await tester.pumpWidget(
        MaterialApp(
          home: SwarmScreen(
            notifier: app,
            nativeTabs: true,
            projectStore: projects,
            modelsMenu: menu,
          ),
        ),
      );
      expect(source.calls, 0);
      final reply = Completer<void>();
      messenger.handlePlatformMessage(
        channel.name,
        const StandardMethodCodec().encodeMethodCall(
          const MethodCall('models'),
        ),
        (_) => reply.complete(),
      );
      await tester.pumpAndSettle();
      expect(reply.isCompleted, isTrue);
      expect(source.calls, 1);
      expect(app.activeSwarmId, original);
      expect(resourceScope(':'), findsOneWidget);
      expect(find.text('OpenAI'), findsWidgets);
      expect(find.textContaining('Not signed in'), findsWidgets);
      expect(messages.where((c) => c.method == 'modelsState'), isEmpty);
      await tester.sendKeyEvent(LogicalKeyboardKey.escape);
      await tester.pumpAndSettle();
      expect(resourceScope(':'), findsNothing);
      expect(app.activeSwarmId, original);
      await tester.pumpWidget(const SizedBox());
      expect(source.calls, 1);
      expect(messages.where((c) => c.method == 'modelsState'), isEmpty);
      menu.dispose();
      usage.dispose();
      app.dispose();
      projects.dispose();
    },
  );

  /// Mount the swarm screen on [app] and send the native local-model
  /// `runLocalModel` command, with or without a machine.
  Future<void> openGridDoor(
    WidgetTester tester,
    AppNotifier app, {
    String? machineId,
    String command = 'runLocalModel',
  }) async {
    tester.view.physicalSize = const Size(1200, 900);
    tester.view.devicePixelRatio = 1;
    addTearDown(tester.view.reset);
    const channel = MethodChannel('harness/swarm_tabs');
    final messenger = tester.binding.defaultBinaryMessenger;
    messenger.setMockMethodCallHandler(channel, (call) async => true);
    addTearDown(() => messenger.setMockMethodCallHandler(channel, null));
    final projects = SwarmProjectStore();
    addTearDown(projects.dispose);
    await tester.pumpWidget(
      MaterialApp(
        home: SwarmScreen(
          notifier: app,
          nativeTabs: true,
          projectStore: projects,
        ),
      ),
    );
    final reply = Completer<void>();
    messenger.handlePlatformMessage(
      channel.name,
      const StandardMethodCodec().encodeMethodCall(
        MethodCall(
          command,
          machineId == null ? null : {'machineId': machineId},
        ),
      ),
      (_) => reply.complete(),
    );
    if (command == 'runLocalModel') {
      for (var i = 0; i < 15; i++) {
        await tester.pump(const Duration(milliseconds: 50));
      }
      expect(reply.isCompleted, isTrue);
    } else {
      await tester.pumpAndSettle();
    }
  }

  for (final (command, harness, stem, machineId) in [
    ('manageMachines', AppNotifier.machinesHarness, 'machine-monitor', null),
  ]) {
    testWidgets('native $command opens the product dock on $machineId', (
      tester,
    ) async {
      newHarnessOpensInBox = true;
      addTearDown(() => newHarnessOpensInBox = false);
      final app = _gridApp(
        grid: {'m': true, 'other': true},
        secondMachine: true,
        harness: harness,
      );
      addTearDown(app.dispose);
      app.adoptSessionForTest(terminal('source', []));
      final source = app.activeSwarm;
      await openGridDoor(tester, app, machineId: machineId, command: command);
      final box = tester
          .widget<NewHarnessForm>(find.byType(NewHarnessForm))
          .controller;
      expect(box.harnessId, harness);
      expect(box.machineId, machineId ?? 'm');
      expect(box.projectLabel, startsWith('~/harnesses/$stem-'));
      expect(box.placement, HarnessPlacement.newTab);
      expect(find.byType(AlertDialog), findsNothing);
      expect(app.swarms, [source]);
      await tester.sendKeyEvent(LogicalKeyboardKey.escape);
      await tester.pump();
      expect(find.byType(NewHarnessForm), findsNothing);
      expect(app.swarms, [source]);
      if (command == 'manageMachines') {
        await key(tester, LogicalKeyboardKey.keyP, cmd: true, shift: true);
        await tester.enterText(
          find.byKey(const ValueKey('swarm-search-input')),
          '> machine monitor',
        );
        await tester.pump();
        await key(tester, LogicalKeyboardKey.enter);
        expect(
          tester
              .widget<NewHarnessForm>(find.byType(NewHarnessForm))
              .controller
              .harnessId,
          harness,
        );
        expect(app.swarms, [source]);
        await key(tester, LogicalKeyboardKey.escape);
      }
      await tester.pumpWidget(const SizedBox());
      await tester.pump(const Duration(milliseconds: 60));
    });
  }

  for (final remote in [false, true]) {
    testWidgets(
      'native local models opens the overview (remote argument: $remote)',
      (tester) async {
        final connection = ModelManagerConnection();
        final app = ModelManagerTestApp(connection);
        await openGridDoor(tester, app, machineId: remote ? 'other' : null);
        expect(find.byType(AgentPicker), findsNothing);
        expect(find.byType(NewHarnessForm), findsNothing);
        expect(app.activeSwarm.isStore, isFalse);
        expect(app.allPanes, isEmpty);
        expect(resourceScope(':'), findsOneWidget);
        expect(
          tester.widget<TextField>(resourceField).decoration!.hintText,
          'Search models',
        );
        // The title bar's Models opens with nothing typed to delete.
        expect(resourceSearch(tester).query, ':');
        expect(app.sent, isEmpty);
        await tester.pumpWidget(const SizedBox());
        app.dispose();
      },
    );
  }

  testWidgets('native Models opens the overview without creating a session', (
    tester,
  ) async {
    final connection = ModelManagerConnection();
    final app = ModelManagerTestApp(connection);
    await openGridDoor(tester, app, command: 'models');
    expect(resourceScope(':'), findsOneWidget);
    expect(
      tester.widget<TextField>(resourceField).decoration!.hintText,
      'Search models',
    );
    expect(resourceField, findsOneWidget);
    expect(connection.creations, isEmpty);
    await tester.sendKeyEvent(LogicalKeyboardKey.escape);
    await tester.pumpAndSettle();
    expect(resourceScope(':'), findsNothing);
    await tester.pumpWidget(const SizedBox());
    app.dispose();
  });
}