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.

20.8 KB
Raw Blame
import 'dart:typed_data';

import 'package:flutter_test/flutter_test.dart';
import 'package:harness_mobile/state/app_state.dart';
import 'package:harness_mobile/terminal/terminal_binary.dart';
import 'package:harness_mobile/terminal/terminal_session.dart';

import 'viewer_app_fixture.dart';
import 'voice_fakes.dart' show MemoryKeyValueStore;

/// The terminals a phone holds open: the one a person opened, the ones the
/// pager opened ahead of the thumb, and what happens to each when the machine,
/// the stream or the person does something.
void main() {
  List<Map<String, dynamic>> opensFor(ViewerRig rig, String agentId) => [
    for (final open in rig.conn('m').opens)
      if (open['agentId'] == agentId) open,
  ];

  /// Everything on [session]'s screen, as text.
  String screenOf(TerminalSession session) {
    final lines = session.terminal.buffer.lines;
    return [
      for (var i = 0; i < lines.length; i++) lines[i].toString().trimRight(),
    ].join('\n');
  }

  /// How long an open the machine has said nothing to waits before its
  /// watchdog gives up on the socket — `TerminalSession._openSilentPatience`,
  /// private there. Real time: the watchdog reads the wall clock.
  const silentPatience = Duration(seconds: 10);

  /// The pager warming [agentId] on `m`, its parked page measuring itself.
  Future<void> warm(ViewerRig rig, String agentId) async {
    final warming = rig.app.warmAgentPane('m', agentId);
    await settle();
    rig.app.paneOfAgent('m', agentId)?.session?.reportViewport(80, 24);
    await warming;
  }

  group('opening an agent', () {
    test('takes its terminal, says who is asking, and selects it', () async {
      final rig = await signedInWith({
        'm': ['a', 'b'],
      });
      addTearDown(rig.app.dispose);

      final session = await openAgent(rig, 'm', 'a');

      final open = opensFor(rig, 'a').single;
      expect(open.containsKey('takeover'), isFalse, reason: 'absent is take');
      expect((open['client'] as Map)['kind'], 'phone');
      expect(open['cols'], 80);
      expect(session.status, TerminalSessionStatus.controlling);
      expect(rig.app.stateOf('m')!.activeAgentId, 'a');
      expect(rig.app.selectedMachineId, 'm');
      expect(rig.app.focusedPane?.agentId, 'a');
    });

    test('an agent already live is only focused, not opened again', () async {
      final rig = await signedInWith({
        'm': ['a', 'b'],
      });
      addTearDown(rig.app.dispose);
      await openAgent(rig, 'm', 'a');
      await openAgent(rig, 'm', 'b');

      await rig.app.selectAgent('m', 'a');

      expect(opensFor(rig, 'a'), hasLength(1));
      expect(rig.app.focusedPane?.agentId, 'a');
    });

    test(
      'an agent taken by another app is asked for again on arrival',
      () async {
        final rig = await signedInWith({
          'm': ['a'],
        });
        addTearDown(rig.app.dispose);
        final session = await openAgent(rig, 'm', 'a');
        await push(rig, 'm', 'terminal_closed', {
          'streamId': session.streamId,
          'code': 'TERMINAL_TAKEN_OVER',
          'takenBy': {'kind': 'desktop', 'name': 'MacBook Pro'},
        });
        expect(session.status, TerminalSessionStatus.takenOver);
        expect(session.errorMessage, 'MacBook Pro connected to this terminal.');

        await rig.app.selectAgent('m', 'a');

        expect(opensFor(rig, 'a'), hasLength(2));
        expect(opensFor(rig, 'a').last.containsKey('takeover'), isFalse);
      },
    );

    test(
      'a watcher promoted by a person reopens to take the keyboard',
      () async {
        final rig = await signedInWith({
          'm': ['a'],
        });
        addTearDown(rig.app.dispose);
        await warm(rig, 'a');
        final session = rig.app.paneOfAgent('m', 'a')!.session!;
        await settle();
        await push(rig, 'm', 'terminal_ready', {
          'requestId': opensFor(rig, 'a').single['requestId'],
          'agentId': 'a',
          'protocolVersion': TerminalSession.protocolVersion,
          'streamId': newStreamId(),
          'readOnly': true,
          'heldBy': {'kind': 'desktop', 'name': 'Studio'},
        });
        expect(session.watching, isTrue);
        expect(session.heldBy?.name, 'Studio');
        expect(session.acceptsInput, isFalse);

        await rig.app.selectAgent('m', 'a');

        expect(opensFor(rig, 'a'), hasLength(2));
        expect(opensFor(rig, 'a').last.containsKey('takeover'), isFalse);
        expect(rig.app.paneOfAgent('m', 'a')!.warm, isFalse);
      },
    );

    test('a dead stream is reopened in place, keeping its screen', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      final session = await openAgent(rig, 'm', 'a');
      session.transportLost('gone');

      await rig.app.selectAgent('m', 'a');

      expect(opensFor(rig, 'a'), hasLength(2));
      expect(
        identical(rig.app.paneOfAgent('m', 'a')!.session, session),
        isTrue,
      );
      expect(session.status, TerminalSessionStatus.opening);
    });

    test('on a machine that is off, the page waits and remembers it', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      await push(rig, 'm', 'node_status', {'online': false});

      await rig.app.selectAgent('m', 'a');

      expect(rig.app.paneOfAgent('m', 'a'), isNotNull);
      expect(rig.app.paneOfAgent('m', 'a')!.session, isNull);
      expect(rig.app.stateOf('m')!.pendingOfflineAgentId, 'a');
      expect(opensFor(rig, 'a'), isEmpty);
    });

    test('on a machine with no terminal protocol, nothing is opened', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      rig.app.stateOf('m')!.terminalCapabilityAvailable = false;

      await rig.app.selectAgent('m', 'a');

      expect(rig.app.paneOfAgent('m', 'a')!.session, isNull);
      expect(opensFor(rig, 'a'), isEmpty);
    });

    test('an agent the machine does not list is not opened at all', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);

      await rig.app.selectAgent('m', 'ghost');
      await rig.app.selectAgent('ghost', 'a');

      expect(rig.app.allPanes, isEmpty);
    });

    test('a page waiting for its terminal is opened by the next tap', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      rig.app.stateOf('m')!.terminalCapabilityAvailable = false;
      await rig.app.selectAgent('m', 'a');
      rig.app.stateOf('m')!.terminalCapabilityAvailable = true;

      final opening = rig.app.selectAgent('m', 'a');
      await settle();
      rig.app.paneOfAgent('m', 'a')!.session!.reportViewport(80, 24);
      await opening;

      expect(opensFor(rig, 'a'), hasLength(1));
    });

    test(
      'names this phone after the person when the device has no name',
      () async {
        final rig = await signedInWith({
          'm': ['a'],
        });
        addTearDown(rig.app.dispose);

        final descriptor = rig.app.phoneClientDescriptor();

        expect(descriptor.kind, 'phone');
        expect(descriptor.name, "Pat's phone");
      },
    );
  });

  group('the pager opening ahead of the thumb', () {
    test('never on a machine that would take the terminal to do it', () async {
      final rig = await signedInWith({
        'm': ['a'],
      }, noTakeover: false);
      addTearDown(rig.app.dispose);

      await rig.app.warmAgentPane('m', 'a');

      expect(rig.app.allPanes, isEmpty);
      expect(opensFor(rig, 'a'), isEmpty);
    });

    test('politely, without moving focus or the saved layout', () async {
      final storage = MemoryKeyValueStore();
      final rig = await signedInWith({
        'm': ['a', 'b'],
      }, storage: storage);
      addTearDown(rig.app.dispose);
      await openAgent(rig, 'm', 'a');
      await rig.app.flushPaneLayout();
      final saved = storage.values['swarm_layout_v1'];

      await warm(rig, 'b');
      await rig.app.flushPaneLayout();

      final pane = rig.app.paneOfAgent('m', 'b')!;
      expect(pane.warm, isTrue);
      expect(opensFor(rig, 'b').single['takeover'], isFalse);
      expect(rig.app.focusedPane?.agentId, 'a');
      expect(rig.app.stateOf('m')!.activeAgentId, 'a');
      expect(storage.values['swarm_layout_v1'], saved);
    });

    test('a guess that comes true joins the layout', () async {
      final storage = MemoryKeyValueStore();
      final rig = await signedInWith({
        'm': ['a', 'b'],
      }, storage: storage);
      addTearDown(rig.app.dispose);
      await warm(rig, 'b');

      await rig.app.selectAgent('m', 'b');
      await rig.app.flushPaneLayout();

      expect(rig.app.paneOfAgent('m', 'b')!.warm, isFalse);
      expect(storage.values['swarm_layout_v1'], contains('"agentId":"b"'));
    });

    test(
      'a warm page with a dead stream is reopened; a live one is left',
      () async {
        final rig = await signedInWith({
          'm': ['a'],
        });
        addTearDown(rig.app.dispose);
        await warm(rig, 'a');
        await rig.app.warmAgentPane('m', 'a');
        expect(opensFor(rig, 'a'), hasLength(1));

        rig.app.paneOfAgent('m', 'a')!.session!.transportLost('gone');
        await rig.app.warmAgentPane('m', 'a');

        expect(opensFor(rig, 'a'), hasLength(2));
        expect(opensFor(rig, 'a').last['takeover'], isFalse);
      },
    );

    test('a page a person has looked at is not reopened by a guess', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      final session = await openAgent(rig, 'm', 'a');
      session.transportLost('gone');

      await rig.app.warmAgentPane('m', 'a');

      expect(opensFor(rig, 'a'), hasLength(1));
    });

    test(
      'a refused polite open waits for a person, not a retry loop',
      () async {
        final rig = await signedInWith({
          'm': ['a'],
        });
        addTearDown(rig.app.dispose);
        await warm(rig, 'a');
        final session = rig.app.paneOfAgent('m', 'a')!.session!;

        await push(rig, 'm', 'terminal_error', {
          'requestId': opensFor(rig, 'a').single['requestId'],
          'code': 'CONTROL_LEASE_HELD',
        });
        expect(session.status, TerminalSessionStatus.takenOver);

        // The machine's list landing again reattaches what needs it — not this.
        await rig.app.reloadMachineData('m');
        await settle();
        expect(opensFor(rig, 'a'), hasLength(1));
      },
    );
  });

  group('closing a page', () {
    test(
      'closes its stream, and shows its last screen when it is back',
      () async {
        final rig = await signedInWith({
          'm': ['a'],
        });
        addTearDown(rig.app.dispose);
        final session = await openAgent(rig, 'm', 'a');
        await session.close();
        await session.reopen();
        await answerOpen(rig, session, screen: 'last words here');
        final streamId = session.streamId;

        await rig.app.closePane(rig.app.paneOfAgent('m', 'a')!.id);

        expect(rig.app.paneOfAgent('m', 'a'), isNull);
        expect(
          rig
              .conn('m')
              .frames
              .where(
                (f) => f.$1 == 'terminal_close' && f.$2['streamId'] == streamId,
              ),
          hasLength(1),
        );

        final reopening = rig.app.selectAgent('m', 'a');
        await settle();
        final again = rig.app.paneOfAgent('m', 'a')!.session!;
        expect(again.showingKeptScreen, isTrue);
        expect(again.hasScreen, isTrue);
        expect(
          screenOf(again),
          contains('last words here'),
          reason: 'the stand-in is what the reader last saw, not a blank page',
        );
        again.reportViewport(80, 24);
        await reopening;
        expect(screenOf(again), contains('last words here'));
        await answerOpen(rig, again, screen: 'fresh');
        expect(again.showingKeptScreen, isFalse);
        expect(screenOf(again), contains('fresh'));
      },
    );

    test('a page closed before it drew anything keeps nothing', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      final opening = rig.app.selectAgent('m', 'a');
      await settle();
      rig.app.paneOfAgent('m', 'a')!.session!.reportViewport(80, 24);
      await opening;

      await rig.app.closePane(rig.app.paneOfAgent('m', 'a')!.id);
      final reopening = rig.app.selectAgent('m', 'a');
      await settle();

      expect(rig.app.paneOfAgent('m', 'a')!.session!.hasScreen, isFalse);
      rig.app.paneOfAgent('m', 'a')!.session!.reportViewport(80, 24);
      await reopening;
    });

    test('only the last few screens are kept', () async {
      final rig = await signedInWith({
        'm': ['a', 'b', 'c', 'd'],
      });
      addTearDown(rig.app.dispose);
      for (final id in ['a', 'b', 'c', 'd']) {
        await openAgent(rig, 'm', id);
        await rig.app.closePane(rig.app.paneOfAgent('m', id)!.id);
      }

      final reopening = rig.app.selectAgent('m', 'a');
      await settle();
      expect(rig.app.paneOfAgent('m', 'a')!.session!.hasScreen, isFalse);
      rig.app.paneOfAgent('m', 'a')!.session!.reportViewport(80, 24);
      await reopening;
    });

    test('an unknown page is nothing to close', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);

      await rig.app.closePane(999);

      expect(rig.app.allPanes, isEmpty);
    });
  });

  group('frames from the machine', () {
    test(
      'a frame that cannot be decoded takes down every stream on its machine',
      () async {
        final rig = await signedInWith({
          'm': ['a', 'b'],
        });
        addTearDown(rig.app.dispose);
        final a = await openAgent(rig, 'm', 'a');
        final b = await openAgent(rig, 'm', 'b');

        await rig.app.handleTerminalBinaryForTest(
          'm',
          Uint8List.fromList([1, 2, 3]),
        );

        expect(a.status, TerminalSessionStatus.error);
        expect(b.status, TerminalSessionStatus.error);
      },
    );

    test('a frame reaches only the stream it names', () async {
      final rig = await signedInWith({
        'm': ['a', 'b'],
      });
      addTearDown(rig.app.dispose);
      final a = await openAgent(rig, 'm', 'a');
      final b = await openAgent(rig, 'm', 'b');
      final before = b.outputTicks.value;

      await rig.app.handleTerminalBinaryForTest(
        'm',
        encodeTerminalLocal(
          TerminalBinaryFrame(
            kind: TerminalBinaryKind.output,
            streamId: a.streamId!,
            seq: 1,
            bytes: Uint8List.fromList('hello'.codeUnits),
            compressed: false,
          ),
        )!,
      );

      expect(a.outputTicks.value, greaterThan(0));
      expect(b.outputTicks.value, before);
    });

    test('a frame for a machine with nothing open is dropped', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);

      await rig.app.handleTerminalBinaryForTest(
        'm',
        Uint8List.fromList([1, 2, 3]),
      );

      expect(rig.app.allPanes, isEmpty);
    });

    test('what is typed is sent down the machine\'s socket, encoded', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      final session = await openAgent(rig, 'm', 'a');

      session.terminal.textInput('ls\r');
      await settle();

      final input = rig
          .conn('m')
          .binaries
          .map(decodeTerminalLocal)
          .whereType<TerminalBinaryFrame>()
          .where((frame) => frame.kind == TerminalBinaryKind.input)
          .toList();
      expect(String.fromCharCodes(input.expand((f) => f.bytes)), 'ls\r');
      expect(input.first.streamId, session.streamId);
    });

    test('an open that stalls on a live socket redials it once', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      final opening = rig.app.selectAgent('m', 'a');
      await settle();
      final session = rig.app.paneOfAgent('m', 'a')!.session!;
      session.reportViewport(80, 24);
      await opening;

      // No terminal_ready, and not a word from the machine: past the session's
      // watchdog the open is still waited on — a slow relay is not a dead one…
      await Future<void>.delayed(
        session.resyncTimeout + const Duration(milliseconds: 100),
      );
      expect(rig.conn('m').redials, 0);

      // …until the machine has been silent for as long as an open waits.
      await Future<void>.delayed(silentPatience - session.resyncTimeout);

      expect(rig.conn('m').redials, 1);
      expect(opensFor(rig, 'a'), hasLength(2), reason: 'the same open, again');
      expect(
        opensFor(rig, 'a').last['requestId'],
        opensFor(rig, 'a').first['requestId'],
      );
    });

    test('an open on a socket still shaking hands is not redialled', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      rig.conn('m').ready = false;
      final opening = rig.app.selectAgent('m', 'a');
      await settle();
      final session = rig.app.paneOfAgent('m', 'a')!.session!;
      session.reportViewport(80, 24);
      await opening;

      // Given up on once a silent machine would be — but the dial in progress
      // is left to finish.
      await Future<void>.delayed(
        silentPatience + const Duration(milliseconds: 100),
      );

      expect(rig.conn('m').redials, 0);
      expect(session.status, TerminalSessionStatus.error);
    });
  });

  group('a machine dropping out with several pages open', () {
    test('the page being read is the one recovery brings back', () async {
      final rig = await signedInWith({
        'm': ['a', 'b'],
      }, noTakeover: false);
      addTearDown(rig.app.dispose);
      await openAgent(rig, 'm', 'a');
      await openAgent(rig, 'm', 'b');
      // `b` is focused, but `a` comes first in the list.
      expect(rig.app.focusedPane?.agentId, 'b');

      await push(rig, 'm', 'node_status', {'online': false});

      expect(rig.app.stateOf('m')!.pendingOfflineAgentId, 'b');
    });

    test('a page someone else took is not recorded to be taken back', () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      final session = await openAgent(rig, 'm', 'a');
      await push(rig, 'm', 'terminal_closed', {
        'streamId': session.streamId,
        'code': 'TERMINAL_TAKEN_OVER',
      });

      await push(rig, 'm', 'node_status', {'online': false});

      expect(rig.app.stateOf('m')!.pendingOfflineAgentId, isNull);
      expect(session.status, TerminalSessionStatus.takenOver);
    });
  });

  group('the layout across launches', () {
    test('a page opened on one launch is waiting on the next', () async {
      final storage = MemoryKeyValueStore();
      final first = await signedInWith({
        'm': ['a', 'b'],
      }, storage: storage);
      await openAgent(first, 'm', 'b');
      await first.app.flushPaneLayout();
      first.app.dispose();

      final next = viewerApp(storage: storage);
      addTearDown(next.app.dispose);
      await next.app.restorePaneLayoutForTest();

      final restored = next.app.allPanes.single;
      expect((restored.machineId, restored.agentId), ('m', 'b'));
      expect(restored.session, isNull, reason: 'intent, until m answers');
    });

    test('a layout that cannot be read is a first launch', () async {
      final storage = MemoryKeyValueStore()
        ..values['swarm_layout_v1'] = '{not json';
      final rig = viewerApp(storage: storage);
      addTearDown(rig.app.dispose);

      await rig.app.restorePaneLayoutForTest();

      expect(rig.app.allPanes, isEmpty);
    });

    test('an older build\'s single list of tiles is read too', () async {
      final storage = MemoryKeyValueStore()
        ..values['terminal_pane_layout'] =
            '[{"machineId":"m","agentId":"a"},{"machineId":"m","agentId":"a"}]';
      final rig = viewerApp(storage: storage);
      addTearDown(rig.app.dispose);

      await rig.app.restorePaneLayoutForTest();

      expect(rig.app.allPanes.map((p) => p.agentId), ['a']);
      expect(rig.app.focusedPane?.agentId, 'a');
    });
  });

  test(
    'an agent on a machine the phone signs out of is not reopened',
    () async {
      final rig = await signedInWith({
        'm': ['a'],
      });
      addTearDown(rig.app.dispose);
      await openAgent(rig, 'm', 'a');

      await rig.app.logout();

      expect(rig.app.allPanes, isEmpty);
      expect(rig.app.stateOf('m'), isNull);
      expect(rig.app.status, AppStatus.unauthenticated);
      expect(
        rig.conn('m').frames.where((f) => f.$1 == 'terminal_close'),
        hasLength(1),
        reason: 'its stream is let go of properly',
      );
      expect(rig.app.machines, isEmpty);
    },
  );
}