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.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
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();
});
}