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 'dart:async';
import 'dart:convert';
import 'dart:typed_data';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/core/local_key_value_store.dart';
import 'package:harness/e2ee/bytes.dart';
import 'package:harness/e2ee/envelope.dart';
import 'package:harness/e2ee/keys.dart';
import 'package:harness/e2ee/primitives.dart';
import 'package:harness/viewer/group_sync.dart';
import 'package:harness/viewer/viewer_key_store.dart';
import 'package:web_socket_channel/web_socket_channel.dart';
import 'package:harness/ws/ws_conn.dart' show declaredAppVersion;
/// The viewer build's trust-group swap (`lib/viewer/group_sync.dart`) — the same code the phone
/// runs, against a machine end that answers exactly as manager.ts does.
const _machineId = 'machine-1';
final _c = 'c' * 32;
class _Memory implements LocalKeyValueStore {
final values = <String, String>{};
@override
Future<String?> read(String key) async => values[key];
@override
Future<void> write(String key, String value) async => values[key] = value;
@override
Future<void> delete(String key) async => values.remove(key);
}
/// A relay socket whose far end is the test.
class _Socket implements WebSocketChannel {
_Socket(this.onFrame);
final void Function(_Socket socket, Map<String, dynamic> frame) onFrame;
final sent = <Map<String, dynamic>>[];
final _down = StreamController<dynamic>();
late final _sink = _Sink(this);
@override
Future<void> get ready => Future.value();
@override
Stream<dynamic> get stream => _down.stream;
@override
WebSocketSink get sink => _sink;
void emit(Map<String, dynamic> frame) => _down.add(jsonEncode(frame));
/// The address the swap dialled.
Uri? dialled;
WebSocketChannel factory(Uri uri, Iterable<String> _) {
dialled = uri;
return this;
}
@override
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}
class _Sink implements WebSocketSink {
_Sink(this._s);
final _Socket _s;
bool closed = false;
@override
void add(dynamic data) {
final frame = jsonDecode(data as String) as Map<String, dynamic>;
_s.sent.add(frame);
_s.onFrame(_s, frame);
}
@override
Future<void> close([int? closeCode, String? closeReason]) async =>
closed = true;
@override
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}
/// manager.ts `onHello` + `wrapRpcReply`, for one session.
Future<_Socket> _machine(
E2eeIdentity identity,
Map<String, Object?> Function(Map<String, dynamic> request) reply,
) async {
SessionKeys? keys;
var counter = 1;
return _Socket((socket, frame) async {
final payload = frame['payload'] as Map<String, dynamic>;
switch (frame['type']) {
case 'machine_select':
socket.emit({
'type': 'connected',
'payload': {'machineId': _machineId},
});
case 'e2e_hello':
final webEph = b64d(payload['ephPub'] as String);
final eph = await Ephemeral.generate();
final k = keys = sessionKeys(eph, webEph, _machineId, webEph, eph.pub);
final sig = await identity.sign(
lvCat(['e2e-welcome-v1', _machineId, webEph, eph.pub]),
);
final enc = aeadSeal(
k.s2c,
0,
utf8Bytes('e2e-welcome'),
utf8Bytes(
jsonEncode({
'groupKey': b64e(Uint8List(32)),
'epoch': 'e1',
'features': {'strictDown': 1},
}),
),
);
socket.emit({
'type': 'e2e_welcome',
'payload': {
'webEphPub': b64e(webEph),
'ephPub': b64e(eph.pub),
'sig': b64e(sig),
'enc': b64e(enc),
},
});
case 'group_sync':
expect(
isWrapped(payload),
isTrue,
reason: 'the roster must never cross the relay in the clear',
);
final request = unwrapPayload(
keys!.c2s,
payload['__e2e'] as Map<String, dynamic>,
'group_sync',
null,
)!;
socket.emit({
'type': 'group_sync_result',
'payload': wrapPayload(
keys!.s2c,
'p',
counter++,
'group_sync_result',
null,
{'requestId': request['requestId'], ...reply(request)},
),
});
}
});
}
void main() {
test(
'the viewer build swaps rosters sealed, and pins every machine it learns',
() async {
final keys = ViewerKeyStore(storage: _Memory());
final machine = await E2eeIdentity.generate();
final cPub = b64e((await E2eeIdentity.generate()).pub);
await keys.pin(_machineId, machine.pub);
Map<String, dynamic>? seen;
final socket = await _machine(machine, (request) {
seen = request;
return {
'members': [
{
'pub': cPub,
'kind': 'machine',
'machineId': _c,
'label': 'c',
'at': 50,
},
],
'removed': [],
};
});
declaredAppVersion = '1.3.64';
addTearDown(() => declaredAppVersion = null);
final outcome = await syncTrustGroup(
machineId: _machineId,
keys: keys,
accessToken: 't',
wsBaseUrl: 'wss://relay.test',
autonomousEnv: 'prod',
label: 'Studio PC',
socket: socket.factory,
);
expect(seen!['self'], containsPair('kind', 'viewer'));
expect(outcome.pinned, [_c]);
// It says what it is, and which build (WebSocket roadmap Phase 0).
expect(
socket.dialled.toString(),
'wss://relay.test/api/web-ws?autonomousEnv=prod&client=group-sync&v=1.3.64',
);
expect(b64e((await keys.peer(_c))!.pub), cPub);
},
);
test(
'a suspended key is neither pinned nor seeded into the roster',
() async {
final keys = ViewerKeyStore(storage: _Memory());
final machine = await E2eeIdentity.generate();
final cPub = b64e((await E2eeIdentity.generate()).pub);
final dId = 'd' * 32;
final dPub = b64e((await E2eeIdentity.generate()).pub);
await keys.pin(_machineId, machine.pub);
await keys.pin(dId, b64d(dPub)); // a pin the roster does not name yet
Map<String, dynamic>? seen;
final socket = await _machine(machine, (request) {
seen = request;
return {
'members': [
{
'pub': cPub,
'kind': 'machine',
'machineId': _c,
'label': 'c',
'at': 50,
},
],
'removed': [],
};
});
final outcome = await syncTrustGroup(
machineId: _machineId,
keys: keys,
accessToken: 't',
wsBaseUrl: 'wss://relay.test',
autonomousEnv: 'prod',
label: 'Studio PC',
socket: socket.factory,
suspended: () async => {cPub, dPub},
);
expect(outcome.pinned, isEmpty);
expect(await keys.peer(_c), isNull);
expect([
for (final m in seen!['members'] as List) (m as Map)['pub'],
], isNot(contains(dPub)));
},
);
test('a key suspended by the devlog this very exchange carries is not pinned either', () async {
final keys = ViewerKeyStore(storage: _Memory());
final machine = await E2eeIdentity.generate();
final cPub = b64e((await E2eeIdentity.generate()).pub);
await keys.pin(_machineId, machine.pub);
final socket = await _machine(machine, (request) {
return {
'members': [
{
'pub': cPub,
'kind': 'machine',
'machineId': _c,
'label': 'c',
'at': 50,
},
],
'removed': [],
'devlog': {
'head': {'seq': 1, 'hash': 'x'},
},
};
});
final suspendedNow = <String>{};
final outcome = await syncTrustGroup(
machineId: _machineId,
keys: keys,
accessToken: 't',
wsBaseUrl: 'wss://relay.test',
autonomousEnv: 'prod',
label: 'Studio PC',
socket: socket.factory,
onDevlog: (_, _) async => suspendedNow.add(cPub),
suspended: () async => {...suspendedNow},
);
expect(outcome.pinned, isEmpty);
expect(await keys.peer(_c), isNull);
});
test('the merge matches the CLI: tombstones beat older entries, newer links beat tombstones', () async {
final self = b64e((await E2eeIdentity.generate()).pub);
final pub = b64e((await E2eeIdentity.generate()).pub);
final b = GroupMember(
pub: pub,
kind: 'machine',
label: 'b',
at: 10,
machineId: 'b' * 32,
);
final removed = mergeGroupRoster(
GroupRoster([b], const []),
GroupRoster(const [], [GroupTombstone(pub, 10)]),
self,
);
expect(removed.roster.members, isEmpty);
final back = mergeGroupRoster(
removed.roster,
GroupRoster([
GroupMember(
pub: pub,
kind: 'machine',
label: 'b',
at: 11,
machineId: 'b' * 32,
),
], const []),
self,
);
expect(back.roster.members.single.at, 11);
});
}