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.

7.5 KB
Raw Blame
import 'dart:async';

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness_mobile/core/models.dart';
import 'package:harness_mobile/phone/agent_pane_prune.dart';
import 'package:harness_mobile/phone/agent_swipe.dart';
import 'package:harness_mobile/state/app_state.dart';

import 'agent_pager_fixture.dart';

/// A [PagerConn] already through its handshake. A `terminal_open` waits for the machine's
/// handshake before it goes (`AppNotifier._sendTerminalFrame`), and a fake socket never has one:
/// left to wait, every open below would still be held when the test looks.
class _HandshakenConn extends PagerConn {
  @override
  Future<void> waitUntilReady({required Duration timeout}) async {}
}

/// The pager holds a HANDFUL of agents open — the one being read, the ones a swipe or two away, and
/// the two just left — and hands the rest back a beat after each swipe. See `AgentSwipeHost._keepSet`.
///
/// ⚠️ **Why this has a test of its own.** The daemon keeps a single controller per agent, so an open
/// stream is a claim on that agent's terminal. The pager once kept every agent it had visited, so a
/// lap of the list took them all away from the desktop.
///
/// The fixture's machine predates `terminalNoTakeoverAvailable`, so nothing here is attached AHEAD of
/// a swipe (`AppNotifier.warmAgentPane`): every open below is a page landed on.
void main() {
  /// Longer than the pager's keep-set can cover — its reach either side, and the agents just left —
  /// so swiping through it leaves agents behind to close. [pagerAgentIds] is four agents that wrap,
  /// every one of them always within reach.
  const longList = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'];

  void lengthen(AppNotifier app) => app.stateOf('m')!.agents = [
    for (final id in longList)
      Agent(
        id: id,
        name: id,
        engine: 'claude',
        project: const AgentProject(name: 'work', cwd: '/work'),
        terminalAvailable: true,
      ),
  ];

  Future<(AppNotifier, PagerConn)> pumpPager(
    WidgetTester tester, {
    bool long = false,
  }) async {
    final conn = _HandshakenConn();
    final app = pagerApp(conn);
    addTearDown(app.dispose);
    if (long) lengthen(app);
    final list = pagerList(app);
    await liveAgent(app, 'b');
    await tester.pumpWidget(
      MaterialApp(
        home: AgentSwipeHost(
          notifier: app,
          machineId: 'm',
          agentId: 'b',
          neighbours: list,
        ),
      ),
    );
    await tester.pump();
    return (app, conn);
  }

  /// The same pager PUSHED over a page, which is how search and the machines tab open it.
  ///
  /// The difference is what a page leaving can do: pushed, `_leave()` takes the route — and with it
  /// every page of the pager — down. As a root it can only no-op, so the regression this guards
  /// against is invisible there.
  Future<(AppNotifier, PagerConn)> pushPager(WidgetTester tester) async {
    final conn = _HandshakenConn();
    final app = pagerApp(conn);
    addTearDown(app.dispose);
    final list = pagerList(app);
    await liveAgent(app, 'b');
    final navigator = GlobalKey<NavigatorState>();
    await tester.pumpWidget(
      MaterialApp(
        navigatorKey: navigator,
        home: const Scaffold(body: Text('the list')),
      ),
    );
    unawaited(
      navigator.currentState!.push(
        MaterialPageRoute(
          builder: (_) => AgentSwipeHost(
            notifier: app,
            machineId: 'm',
            agentId: 'b',
            neighbours: list,
          ),
        ),
      ),
    );
    await tester.pumpAndSettle();
    return (app, conn);
  }

  /// A settled swipe, with the page it lands on answering as a machine does — [towards] the next
  /// agent or back to the previous one.
  ///
  /// `pumpAndSettle` is deliberately not used: the page arrived at says "Attaching…" until its
  /// keyframe lands, and that skeleton breathes for ever — see [goLive].
  ///
  /// The pumps run well past [AgentPanePruner.delay], so the agent left behind is closed by the time
  /// this returns.
  Future<void> swipeTo(
    WidgetTester tester,
    AppNotifier app,
    String agentId, {
    double towards = -400,
  }) async {
    await tester.fling(find.byType(PageView), Offset(towards, 0), 1000);
    await tester.pump();
    await tester.pump(const Duration(milliseconds: 500));
    final session = app.paneOfAgent('m', agentId)?.session;
    if (session != null) await goLive(session);
    // Long enough for the keyframe's ack and the view's first resize, twice over: each coalescing
    // window is armed by the frame before it, and the binding fails a test that leaves one pending.
    await tester.pump(const Duration(milliseconds: 100));
    await tester.pump(const Duration(milliseconds: 100));
    // And past the prune, armed by the frame the page landed on.
    await tester.pump(AgentPanePruner.delay);
    await tester.pump();
  }

  testWidgets('leaves the agents either side of the one on screen alone', (
    tester,
  ) async {
    final (app, conn) = await pumpPager(tester);

    // Well past the beat the neighbours were once opened after.
    await tester.pump(const Duration(seconds: 2));
    await tester.pump();

    expect(conn.opens, isEmpty, reason: 'no stream but the agent being read');
    expect(app.paneOfAgent('m', 'a'), isNull);
    expect(app.paneOfAgent('m', 'c'), isNull);
  });

  testWidgets('opens the agent swiped to, and only when it is swiped to', (
    tester,
  ) async {
    final (app, conn) = await pumpPager(tester);

    await swipeTo(tester, app, 'c');

    expect({for (final open in conn.opens) open['agentId']}, {'c'});
    expect(app.paneOfAgent('m', 'c')?.session, isNotNull);
    expect(app.stateOf('m')?.activeAgentId, 'c', reason: 'the agent read');
    expect(app.paneOfAgent('m', 'd'), isNull, reason: 'one swipe ahead');
    expect(app.paneOfAgent('m', 'a'), isNull, reason: 'one swipe behind');
  });

  testWidgets(
    'keeps the agent just left, and closes it once the swipes leave it behind',
    (tester) async {
      final (app, _) = await pumpPager(tester, long: true);
      expect(app.paneOfAgent('m', 'b'), isNotNull, reason: 'the agent read');

      await swipeTo(tester, app, 'c');
      expect(
        app.paneOfAgent('m', 'b'),
        isNotNull,
        reason: 'just left, so going back is instant',
      );
      expect(app.paneOfAgent('m', 'c')?.session, isNotNull);

      for (final agent in ['d', 'e', 'f']) {
        await swipeTo(tester, app, agent);
      }

      expect(
        app.paneOfAgent('m', 'b'),
        isNull,
        reason: 'out of reach and no longer recent: handed back',
      );
      expect(app.paneOfAgent('m', 'f')?.session, isNotNull);
    },
  );

  testWidgets(
    'an agent swiped back onto is attached again, in a pushed pager',
    (tester) async {
      final (app, _) = await pushPager(tester);
      await swipeTo(tester, app, 'c');
      // Closed the way the prune closes it, while the page for b is still mounted beside c.
      releaseAgentPanes(app, [
        (machineId: 'm', agentId: 'b'),
      ], heldElsewhere: (_) => false);
      await tester.pump();
      expect(app.paneOfAgent('m', 'b'), isNull);

      await swipeTo(tester, app, 'b', towards: 400);

      expect(
        find.byType(AgentSwipeHost),
        findsOneWidget,
        reason: 'a pane closed behind the pager is not the agent going away',
      );
      expect(app.paneOfAgent('m', 'b')?.session, isNotNull);
      expect(app.paneOfAgent('m', 'c'), isNotNull, reason: 'just left, kept');
    },
  );
}