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:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/auth/auth_session.dart';
import 'package:harness/auth/sign_in_provider.dart';
import 'package:harness/core/config.dart';
import 'package:harness/core/local_key_value_store.dart';
import 'package:harness/viewer/direct_auth.dart';
import 'package:harness/viewer/direct_auth_api.dart';
import 'package:harness/viewer/direct_login.dart';
class _Storage implements LocalKeyValueStore {
final values = <String, String>{};
Completer<void>? nextWrite;
@override
Future<String?> read(String key) async => values[key];
@override
Future<void> write(String key, String value) async {
final wait = nextWrite;
nextWrite = null;
if (wait != null) await wait.future;
values[key] = value;
}
@override
Future<void> delete(String key) async => values.remove(key);
}
class _Api extends DirectAuthApi {
_Api() : super(config: AppConfig.dev);
final refreshes = <Completer<IssuedTokens>>[];
final exchanges = <Completer<IssuedTokens>>[];
final authorizations = <Completer<({String authorizeUrl, String tx})>>[];
final redirects = <String>[];
/// The client each refresh named.
final refreshClients = <String?>[];
/// The refresh token each refresh presented.
final refreshTokens = <String>[];
/// The refresh tokens sign-outs asked the server to revoke.
final revoked = <String>[];
bool revokeFails = false;
@override
Future<bool> revoke(String refreshToken) async {
if (revokeFails) throw const DirectAuthException('unreachable');
revoked.add(refreshToken);
return true;
}
@override
Future<IssuedTokens> refresh(
String refreshToken, {
required String autonomousEnv,
String? clientId,
}) {
final result = Completer<IssuedTokens>();
refreshes.add(result);
refreshClients.add(clientId);
refreshTokens.add(refreshToken);
return result.future;
}
@override
Future<({String authorizeUrl, String tx})> authorizeNative(
String uri, {
SignInProvider? provider,
}) {
redirects.add(uri);
final result = Completer<({String authorizeUrl, String tx})>();
authorizations.add(result);
return result.future;
}
@override
Future<IssuedTokens> exchange({
required String code,
required String state,
required String tx,
Map<String, String> attribution = const {},
}) {
expect(code, 'fixture-code');
expect(state, 'fixture-state');
final result = Completer<IssuedTokens>();
exchanges.add(result);
return result.future;
}
}
const _old = IssuedTokens(token: 'old', refreshToken: 'old-refresh');
const _new = IssuedTokens(token: 'new', refreshToken: 'new-refresh');
const _renewed = IssuedTokens(
token: 'renewed',
refreshToken: 'renewed-refresh',
);
const _rejected = DirectAuthException('Expired.', signedOut: true);
final _authError = isA<DirectAuthException>();
Future<void> _tick() => Future<void>.delayed(Duration.zero);
Future<void> _until(bool Function() ready) async {
for (var attempt = 0; attempt < 100 && !ready(); attempt++) {
await Future<void>.delayed(const Duration(milliseconds: 2));
}
expect(ready(), isTrue);
}
Future<void> _redirect(_Api api, {int index = 0}) async {
final client = HttpClient();
try {
final request = await client.getUrl(
Uri.parse(api.redirects[index]).replace(
queryParameters: {'code': 'fixture-code', 'state': 'fixture-state'},
),
);
final response = await request.close();
expect(response.statusCode, HttpStatus.ok);
await response.drain<void>();
} finally {
client.close(force: true);
}
}
void main() {
late _Storage storage;
late AuthSession session;
late _Api api;
late DirectAuth auth;
setUp(() {
storage = _Storage();
session = AuthSession(storage: storage);
api = _Api();
auth = DirectAuth(session: session, api: api);
});
for (final fails in [false, true]) {
test(
'old refresh ${fails ? 'failure' : 'success'} cannot replace a new account',
() async {
await auth.signIn(_old);
final pending = auth.accessToken(force: true);
final rejected = expectLater(pending, throwsA(_authError));
await _until(() => api.refreshes.isNotEmpty);
await auth.signIn(_new);
if (fails) {
api.refreshes.single.completeError(_rejected);
} else {
api.refreshes.single.complete(_renewed);
}
await rejected;
expect(await auth.accessToken(), 'new');
expect(await session.refreshToken(), 'new-refresh');
},
);
}
test(
'a refresh completed after sign-out cannot restore credentials',
() async {
await auth.signIn(_old);
final pending = auth.accessToken(force: true);
final rejected = expectLater(pending, throwsA(_authError));
await _until(() => api.refreshes.isNotEmpty);
await auth.signOut();
api.refreshes.single.complete(_renewed);
await rejected;
expect(await auth.hasSession(), isFalse);
expect(storage.values, isEmpty);
},
);
test('old refresh completion cannot reset a new refresh in flight', () async {
await auth.signIn(_old);
final old = auth.accessToken(force: true);
final rejected = expectLater(old, throwsA(_authError));
await _until(() => api.refreshes.length == 1);
await auth.signIn(_new);
final current = auth.accessToken(force: true);
await _until(() => api.refreshes.length == 2);
api.refreshes.first.completeError(_rejected);
await rejected;
final joined = auth.accessToken(force: true);
await _tick();
expect(api.refreshes, hasLength(2));
api.refreshes.last.complete(_renewed);
expect(await current, 'renewed');
expect(await joined, 'renewed');
});
test(
'sign-out waits behind a credential write and leaves nothing saved',
() async {
final gate = storage.nextWrite = Completer<void>();
final saving = auth.signIn(_old);
final rejected = expectLater(saving, throwsA(_authError));
await _until(() => storage.nextWrite == null);
final logout = auth.signOut();
gate.complete();
await rejected;
await logout;
expect(storage.values, isEmpty);
},
);
test('a sign-in from before the upgrade stays signed in when its renewal '
'turns it into a Harness session, which renews as one', () async {
// What today's app keeps after an SSO sign-in.
await auth.signIn(_old);
final first = auth.accessToken(force: true);
await _until(() => api.refreshes.isNotEmpty);
api.refreshes.single.complete(
const IssuedTokens(
token: 'hna_1',
refreshToken: 'hnr_1',
expiresIn: 3600,
),
);
expect(await first, 'hna_1');
expect(await session.refreshToken(), 'hnr_1');
expect(await auth.hasSession(), isTrue);
final second = auth.accessToken(force: true);
await _until(() => api.refreshes.length == 2);
api.refreshes.last.complete(const IssuedTokens(token: 'hna_2'));
expect(await second, 'hna_2');
expect(api.refreshTokens, ['old-refresh', 'hnr_1']);
});
test('signing out ends a Harness session on the server; an SSO one asks '
'nothing, and an unreachable server still signs out', () async {
await auth.signIn(
const IssuedTokens(token: 'hna_1', refreshToken: 'hnr_1'),
);
await auth.signOut();
expect(api.revoked, ['hnr_1']);
expect(await auth.hasSession(), isFalse);
await auth.signIn(_old);
await auth.signOut();
expect(api.revoked, ['hnr_1']);
api.revokeFails = true;
await auth.signIn(
const IssuedTokens(token: 'hna_2', refreshToken: 'hnr_2'),
);
await auth.signOut();
expect(await auth.hasSession(), isFalse);
});
test('refreshes coalesce and retain unrotated refresh tokens', () async {
await auth.signIn(_old);
final first = auth.accessToken(force: true);
final second = auth.accessToken(force: true);
await _until(() => api.refreshes.isNotEmpty);
expect(api.refreshes, hasLength(1));
api.refreshes.single.complete(const IssuedTokens(token: 'renewed'));
expect(await first, 'renewed');
expect(await second, 'renewed');
expect(await session.refreshToken(), 'old-refresh');
expect(await auth.accessToken(force: true, failedToken: 'old'), 'renewed');
expect(api.refreshes, hasLength(1));
});
test('a session refreshes as the client it was issued to, and a later '
'sign-in that names none inherits none', () async {
// auth-service refuses a refresh token presented under another client.
await auth.signIn(
const IssuedTokens(
token: 'old',
refreshToken: 'old-refresh',
clientId: 'harness-web',
),
);
final first = auth.accessToken(force: true);
await _until(() => api.refreshes.isNotEmpty);
api.refreshes.single.complete(const IssuedTokens(token: 'renewed'));
expect(await first, 'renewed');
expect(api.refreshClients, ['harness-web']);
// The refresh's answer names no client: the session keeps the one it has.
expect(await session.ssoClientId(), 'harness-web');
// A backend from before the clients were split answers an exchange with none.
await auth.signIn(_old);
final second = auth.accessToken(force: true);
await _until(() => api.refreshes.length == 2);
api.refreshes.last.complete(const IssuedTokens(token: 'renewed-again'));
expect(await second, 'renewed-again');
expect(api.refreshClients, ['harness-web', null]);
});
for (final expires in [false, true]) {
test(
'${expires ? 'expired' : 'temporary'} refresh failure handles saved credentials truthfully',
() async {
await auth.signIn(_old);
final pending = auth.accessToken(force: true);
final rejected = expectLater(pending, throwsA(_authError));
await _until(() => api.refreshes.isNotEmpty);
api.refreshes.single.completeError(
DirectAuthException('Fixture failure.', signedOut: expires),
);
await rejected;
expect(await auth.hasSession(), !expires);
if (!expires) expect(await session.refreshToken(), 'old-refresh');
},
);
}
test(
'cancelling while the callback server binds never opens a browser',
() async {
final login = DirectLogin(auth: auth);
final urls = <String>[];
final pending = login.login(onAuthorizeUrl: urls.add);
final rejected = expectLater(pending, throwsA(_authError));
login.cancel();
// Let a broken implementation complete rather than leave a five-minute wait.
await Future<void>.delayed(const Duration(milliseconds: 30));
if (api.authorizations.isNotEmpty) {
api.authorizations.single.complete((
authorizeUrl: 'https://fixture.invalid',
tx: 'tx',
));
await _tick();
login.cancel();
}
await rejected;
expect(api.authorizations, isEmpty);
expect(urls, isEmpty);
expect(storage.values, isEmpty);
},
);
test('cancelled authorization cannot publish a late browser link', () async {
final login = DirectLogin(auth: auth);
final urls = <String>[];
final pending = login.login(onAuthorizeUrl: urls.add);
final rejected = expectLater(pending, throwsA(_authError));
await _until(() => api.authorizations.isNotEmpty);
login.cancel();
api.authorizations.single.complete((
authorizeUrl: 'https://fixture.invalid',
tx: 'tx',
));
await rejected;
expect(urls, isEmpty);
expect(storage.values, isEmpty);
});
for (final signOut in [false, true]) {
test(
'${signOut ? 'sign-out' : 'cancellation'} during exchange rejects its late credentials',
() async {
final login = DirectLogin(auth: auth);
final pending = login.login(onAuthorizeUrl: (_) {});
final rejected = expectLater(pending, throwsA(_authError));
await _until(() => api.authorizations.isNotEmpty);
api.authorizations.single.complete((
authorizeUrl: 'https://fixture.invalid',
tx: 'tx',
));
await _redirect(api);
await _until(() => api.exchanges.isNotEmpty);
if (signOut) {
await login.logout();
} else {
login.cancel();
}
api.exchanges.single.complete(_old);
await rejected;
expect(storage.values, isEmpty);
},
);
}
test(
'cancellation during persistence removes that incomplete sign-in',
() async {
final login = DirectLogin(auth: auth);
final pending = login.login(onAuthorizeUrl: (_) {});
final rejected = expectLater(pending, throwsA(_authError));
await _until(() => api.authorizations.isNotEmpty);
api.authorizations.single.complete((
authorizeUrl: 'https://fixture.invalid',
tx: 'tx',
));
await _redirect(api);
await _until(() => api.exchanges.isNotEmpty);
final gate = storage.nextWrite = Completer<void>();
api.exchanges.single.complete(_old);
await _until(() => storage.nextWrite == null);
login.cancel();
gate.complete();
await rejected;
expect(storage.values, isEmpty);
},
);
test('a cancelled attempt cannot remove its replacement callback', () async {
final login = DirectLogin(auth: auth);
final urls = <String>[];
final old = login.login(onAuthorizeUrl: urls.add);
final oldRejected = expectLater(old, throwsA(_authError));
await _until(() => api.authorizations.length == 1);
login.cancel();
final current = login.login(onAuthorizeUrl: urls.add);
final currentRejected = expectLater(current, throwsA(_authError));
await _until(() => api.authorizations.length == 2);
api.authorizations.first.complete((
authorizeUrl: 'https://fixture.invalid/old',
tx: 'old',
));
await oldRejected;
api.authorizations.last.complete((
authorizeUrl: 'https://fixture.invalid/new',
tx: 'new',
));
await _until(() => urls.isNotEmpty);
login.cancel();
await currentRejected;
expect(urls, ['https://fixture.invalid/new']);
expect(storage.values, isEmpty);
});
test('token readers wait for the whole saved session', () async {
final gate = storage.nextWrite = Completer<void>();
final saving = auth.signIn(_new);
await _until(() => storage.nextWrite == null);
var read = false;
final reading = auth.accessToken().then((value) {
read = true;
return value;
});
final present = auth.hasSession();
await _tick();
expect(read, isFalse);
gate.complete();
await saving;
expect(await reading, 'new');
expect(await present, isTrue);
expect(await session.refreshToken(), 'new-refresh');
});
test('cancelled persistence cannot clear a replacement sign-in', () async {
var current = true;
final gate = storage.nextWrite = Completer<void>();
final old = auth.signIn(_old, stillCurrent: () => current);
final rejected = expectLater(old, throwsA(_authError));
await _until(() => storage.nextWrite == null);
current = false;
final replacement = auth.signIn(_new);
gate.complete();
await rejected;
await replacement;
expect(await auth.accessToken(), 'new');
expect(await session.refreshToken(), 'new-refresh');
});
test(
'a successful browser exchange saves its session and closes the listener',
() async {
final login = DirectLogin(auth: auth);
final urls = <String>[];
final pending = login.login(onAuthorizeUrl: urls.add);
await _until(() => api.authorizations.isNotEmpty);
api.authorizations.single.complete((
authorizeUrl: 'https://fixture.invalid',
tx: 'tx',
));
await _redirect(api);
await _until(() => api.exchanges.isNotEmpty);
api.exchanges.single.complete(_new);
await pending;
expect(urls, ['https://fixture.invalid']);
expect(await auth.accessToken(), 'new');
// Cancel after completion must leave the saved session alone.
login.cancel();
expect(await auth.accessToken(), 'new');
},
);
}