diff --git a/app/lib/core/servers/server_catalog.dart b/app/lib/core/servers/server_catalog.dart index 1021653b..559ac64c 100644 --- a/app/lib/core/servers/server_catalog.dart +++ b/app/lib/core/servers/server_catalog.dart @@ -2,13 +2,18 @@ import '../transport/server_url.dart'; /// One logical server; endpoints are primary first, then ordered backups. class SavedServer { - SavedServer._(this.id, this.name, Iterable endpoints) - : endpoints = List.unmodifiable(endpoints); + SavedServer._( + this.id, + this.name, + Iterable endpoints, + this.legacyEndpoint, + ) : endpoints = List.unmodifiable(endpoints); factory SavedServer.validated({ required String id, required String name, required Iterable endpoints, + String? legacyEndpoint, }) { final cleanId = id.trim(); final cleanName = name.trim(); @@ -22,33 +27,45 @@ class SavedServer { if (normalized.isEmpty) { throw const FormatException('A server needs at least one endpoint.'); } - return SavedServer._(cleanId, cleanName, normalized); + return SavedServer._( + cleanId, + cleanName, + normalized, + legacyEndpoint == null ? null : ServerUrl.validate(legacyEndpoint).wsUrl, + ); } final String id; final String name; final List endpoints; + /// Old local pending-run storage pointer, never a network or auth alias. + final String? legacyEndpoint; + Map toJson() => { 'id': id, 'name': name, 'endpoints': endpoints.toList(), + if (legacyEndpoint != null) 'legacyEndpoint': legacyEndpoint, }; factory SavedServer.fromJson(Map json) { final id = json['id']; final name = json['name']; final endpoints = json['endpoints']; + final legacyEndpoint = json['legacyEndpoint']; if (id is! String || name is! String || endpoints is! List || - endpoints.any((endpoint) => endpoint is! String)) { + endpoints.any((endpoint) => endpoint is! String) || + (legacyEndpoint != null && legacyEndpoint is! String)) { throw const FormatException('Invalid saved server.'); } return SavedServer.validated( id: id, name: name, endpoints: endpoints.cast(), + legacyEndpoint: legacyEndpoint as String?, ); } } diff --git a/app/lib/core/servers/server_catalog_store.dart b/app/lib/core/servers/server_catalog_store.dart index 157c64c5..246d2f6d 100644 --- a/app/lib/core/servers/server_catalog_store.dart +++ b/app/lib/core/servers/server_catalog_store.dart @@ -1,30 +1,63 @@ import 'dart:convert'; +import 'dart:math'; import 'package:shared_preferences/shared_preferences.dart'; import 'server_catalog.dart'; +import '../transport/server_url.dart'; const String serverCatalogKey = 'pipelines.next.serverCatalog.v1'; +const String serverCatalogLegacyBindingKey = + 'pipelines.next.serverCatalog.legacyBinding.v1'; abstract interface class ServerCatalogStore { Future load({String legacyEndpoint = ''}); Future save(ServerCatalog catalog); } -ServerCatalog _migrate(String legacyEndpoint) { +ServerCatalog _migrate(String legacyEndpoint, [List? binding]) { if (legacyEndpoint.trim().isEmpty) return ServerCatalog(); + final normalized = ServerUrl.validate(legacyEndpoint).wsUrl; + final canMigrate = binding == null || binding.contains(normalized); + final random = Random.secure(); + final id = canMigrate + ? 'legacy-server' + : 'server-${List.generate(16, (_) => random.nextInt(256).toRadixString(16).padLeft(2, '0')).join()}'; return ServerCatalog( servers: [ SavedServer.validated( - id: 'legacy-server', + id: id, name: 'My server', endpoints: [legacyEndpoint], + legacyEndpoint: canMigrate ? legacyEndpoint : null, ), ], - selectedId: 'legacy-server', + selectedId: id, ); } +List? _readBinding(SharedPreferences preferences) { + if (!preferences.containsKey(serverCatalogLegacyBindingKey)) return null; + final raw = preferences.get(serverCatalogLegacyBindingKey); + if (raw is! String) throw const FormatException('Invalid legacy binding.'); + final json = jsonDecode(raw); + if (json is! Map || json['version'] != 1) { + throw const FormatException('Unsupported legacy binding format.'); + } + return SavedServer.fromJson({ + 'id': 'legacy-server', + 'name': 'Original legacy server', + 'endpoints': json['endpoints'], + }).endpoints; +} + +List? _bindingFor(ServerCatalog catalog) { + for (final server in catalog.servers) { + if (server.id == 'legacy-server') return server.endpoints; + } + return null; +} + /// A single versioned JSON value keeps profiles and selection together. /// /// Load is read-only, including legacy migration. The caller explicitly saves @@ -37,8 +70,9 @@ class SharedPreferencesServerCatalogStore implements ServerCatalogStore { @override Future load({String legacyEndpoint = ''}) async { final preferences = await SharedPreferences.getInstance(); + final binding = _readBinding(preferences); if (!preferences.containsKey(serverCatalogKey)) { - return _migrate(legacyEndpoint); + return _migrate(legacyEndpoint, binding); } final raw = preferences.get(serverCatalogKey); if (raw is! String) { @@ -53,13 +87,36 @@ class SharedPreferencesServerCatalogStore implements ServerCatalogStore { @override Future save(ServerCatalog catalog) async { + SharedPreferences? preferences; try { - final preferences = await SharedPreferences.getInstance(); - return await preferences.setString( + preferences = await SharedPreferences.getInstance(); + // A rejected platform write can still update the plugin's local cache. + // Only durable binding data may authorize reuse of the legacy identity. + await preferences.reload(); + final binding = _readBinding(preferences); + final original = _bindingFor(catalog); + // Bind before publishing a migrated catalog. Retain this independently + // through profile deletion and catalog resets; never widen it on edits. + if (binding == null && original != null) { + final bound = await preferences.setString( + serverCatalogLegacyBindingKey, + jsonEncode({'version': 1, 'endpoints': original}), + ); + if (!bound) { + await preferences.reload(); + return false; + } + } + final saved = await preferences.setString( serverCatalogKey, jsonEncode({'version': 1, ...catalog.toJson()}), ); + if (!saved) await preferences.reload(); + return saved; } catch (_) { + try { + await preferences?.reload(); + } catch (_) {} return false; } } @@ -70,15 +127,17 @@ class MemoryServerCatalogStore implements ServerCatalogStore { MemoryServerCatalogStore({this.catalog}); ServerCatalog? catalog; + List? _legacyBinding; bool failSaves = false; @override Future load({String legacyEndpoint = ''}) async => - catalog ?? _migrate(legacyEndpoint); + catalog ?? _migrate(legacyEndpoint, _legacyBinding); @override Future save(ServerCatalog catalog) async { if (failSaves) return false; + _legacyBinding ??= _bindingFor(catalog); this.catalog = catalog; return true; } diff --git a/app/lib/features/pipelines/pending_run_store.dart b/app/lib/features/pipelines/pending_run_store.dart index 3a41e2e4..78e44d23 100644 --- a/app/lib/features/pipelines/pending_run_store.dart +++ b/app/lib/features/pipelines/pending_run_store.dart @@ -14,8 +14,12 @@ String pendingRunStorageKey(String endpoint, int pipelineId, int version) => 'pipelines.web.pendingRun.v1:$endpoint:$pipelineId:$version'; class SharedPreferencesPendingRunStore implements PendingRunStore { - const SharedPreferencesPendingRunStore(this.endpoint); + const SharedPreferencesPendingRunStore( + this.endpoint, { + this.legacyEndpoints = const [], + }); final String endpoint; + final List legacyEndpoints; Future _preferences() async { try { @@ -31,10 +35,37 @@ class SharedPreferencesPendingRunStore implements PendingRunStore { @override Future read(int pipelineId, int version) async { try { - final raw = (await _preferences())?.getString(_key(pipelineId, version)); + final preferences = await _preferences(); + if (preferences == null) return null; + final stableKey = _key(pipelineId, version); + if (preferences.containsKey(stableKey)) { + return _decode(preferences.getString(stableKey), pipelineId, version); + } + for (final legacy in legacyEndpoints.toSet()) { + final value = preferences.get( + pendingRunStorageKey(legacy, pipelineId, version), + ); + final raw = value is String ? value : null; + final intent = _decode(raw, pipelineId, version); + if (intent == null) continue; + // Best effort copy, never move: preserve the operation on write failure. + try { + await preferences.setString(stableKey, raw!); + } catch (_) {} + return intent; + } + return null; + } catch (_) { + return null; + } + } + + RunPipelineIntent? _decode(String? raw, int pipelineId, int version) { + try { if (raw == null) return null; final intent = RunPipelineIntent.fromJson(jsonDecode(raw)); - return intent?.matches(pipelineId, version) == true ? intent : null; + if (intent == null || intent.requestKey.trim().isEmpty) return null; + return intent.matches(pipelineId, version) ? intent : null; } catch (_) { return null; } @@ -52,9 +83,34 @@ class SharedPreferencesPendingRunStore implements PendingRunStore { @override Future remove(int pipelineId, int version) async { + final preferences = await _preferences(); + if (preferences == null) return; + // Remove legacy copies first. Keep the stable recovery copy if cleanup + // fails, rather than allowing an older legacy operation to resurrect. + for (final legacy in legacyEndpoints.toSet()) { + final key = pendingRunStorageKey(legacy, pipelineId, version); + if (key == _key(pipelineId, version)) continue; + try { + if (preferences.containsKey(key) && !await preferences.remove(key)) { + await preferences.reload(); + return; + } + } catch (_) { + try { + await preferences.reload(); + } catch (_) {} + return; + } + } try { - await (await _preferences())?.remove(_key(pipelineId, version)); - } catch (_) {} + if (!await preferences.remove(_key(pipelineId, version))) { + await preferences.reload(); + } + } catch (_) { + try { + await preferences.reload(); + } catch (_) {} + } } } diff --git a/app/test/core/servers/failing_preferences.dart b/app/test/core/servers/failing_preferences.dart new file mode 100644 index 00000000..5709eafc --- /dev/null +++ b/app/test/core/servers/failing_preferences.dart @@ -0,0 +1,32 @@ +// The existing preferences plugin's platform seam is used only for fault tests. +// ignore: depend_on_referenced_packages +import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +class FailingPreferences extends InMemorySharedPreferencesStore { + FailingPreferences() : super.empty(); + + String? failWriteKey; + String? failRemoveKey; + bool throwWrites = false; + + void install() { + SharedPreferences.resetStatic(); + SharedPreferencesStorePlatform.instance = this; + } + + @override + Future setValue(String valueType, String key, Object value) async { + if (key == 'flutter.$failWriteKey') { + if (throwWrites) throw StateError('Injected write failure'); + return false; + } + return super.setValue(valueType, key, value); + } + + @override + Future remove(String key) async { + if (key == 'flutter.$failRemoveKey') return false; + return super.remove(key); + } +} diff --git a/app/test/core/servers/server_catalog_store_test.dart b/app/test/core/servers/server_catalog_store_test.dart index e965eeb3..06198efd 100644 --- a/app/test/core/servers/server_catalog_store_test.dart +++ b/app/test/core/servers/server_catalog_store_test.dart @@ -5,6 +5,8 @@ import 'package:pipelines_app/core/servers/server_catalog.dart'; import 'package:pipelines_app/core/servers/server_catalog_store.dart'; import 'package:shared_preferences/shared_preferences.dart'; +import 'failing_preferences.dart'; + ServerCatalog fixture() => ServerCatalog( servers: [ SavedServer.validated( @@ -22,6 +24,134 @@ void main() { setUp(() => SharedPreferences.setMockInitialValues({})); + test( + 'binding failure cannot publish catalog; partial save retains binding', + () async { + final disk = FailingPreferences()..install(); + final migrated = await store.load(legacyEndpoint: 'ws://a.test'); + disk.failWriteKey = serverCatalogLegacyBindingKey; + expect(await store.save(migrated), isFalse); + var preferences = await SharedPreferences.getInstance(); + await preferences.reload(); + expect(preferences.containsKey(serverCatalogKey), isFalse); + expect(preferences.containsKey(serverCatalogLegacyBindingKey), isFalse); + disk.failWriteKey = serverCatalogKey; + expect(await store.save(migrated), isFalse); + await preferences.reload(); + expect(preferences.containsKey(serverCatalogKey), isFalse); + expect(preferences.containsKey(serverCatalogLegacyBindingKey), isTrue); + expect( + (await store.load(legacyEndpoint: 'ws://b.test')).active!.id, + isNot('legacy-server'), + ); + disk.failWriteKey = null; + expect(await store.save(migrated), isTrue); + }, + ); + + test( + 'binding prevents legacy credentials reuse after A to B catalog reset', + () async { + final original = await store.load(legacyEndpoint: 'ws://a.test'); + expect(await store.save(original), isTrue); + final preferences = await SharedPreferences.getInstance(); + final binding = preferences.getString(serverCatalogLegacyBindingKey); + expect(binding, isNotNull); + await preferences.setString('pipelines.next.serverUrl.v1', 'ws://b.test'); + await preferences.setString('cookie:legacy-server', 'A-cookie'); + await preferences.remove(serverCatalogKey); + final recovered = await store.load(legacyEndpoint: 'ws://b.test'); + expect(recovered.active!.id, isNot('legacy-server')); + expect(recovered.active!.legacyEndpoint, isNull); + expect(recovered.active!.endpoints, ['ws://b.test/connect']); + expect(preferences.containsKey(serverCatalogKey), isFalse); + expect(preferences.getString('cookie:legacy-server'), 'A-cookie'); + expect( + preferences.getString('pipelines.next.serverUrl.v1'), + 'ws://b.test', + ); + expect(preferences.getString(serverCatalogLegacyBindingKey), binding); + final trusted = await store.load(legacyEndpoint: 'WS://A.TEST/'); + expect(trusted.active!.id, 'legacy-server'); + }, + ); + + test( + 'original trusted aliases stay bound through edits and removal', + () async { + final original = ServerCatalog( + servers: [ + SavedServer.validated( + id: 'legacy-server', + name: 'A', + endpoints: ['ws://a.test', 'wss://a-backup.test'], + legacyEndpoint: 'ws://a.test', + ), + ], + selectedId: 'legacy-server', + ); + expect(await store.save(original), isTrue); + final preferences = await SharedPreferences.getInstance(); + final binding = preferences.getString(serverCatalogLegacyBindingKey); + expect( + await store.save( + original.upsert( + SavedServer.validated( + id: 'legacy-server', + name: 'Changed', + endpoints: ['ws://b.test'], + legacyEndpoint: original.active!.legacyEndpoint, + ), + ), + ), + isTrue, + ); + expect(await store.save(ServerCatalog()), isTrue); + expect(preferences.getString(serverCatalogLegacyBindingKey), binding); + await preferences.remove(serverCatalogKey); + expect( + (await store.load(legacyEndpoint: 'wss://a-backup.test')).active!.id, + 'legacy-server', + ); + expect( + (await store.load(legacyEndpoint: 'ws://b.test')).active!.id, + isNot('legacy-server'), + ); + }, + ); + + test( + 'corrupt binding surfaces even with an existing valid catalog', + () async { + await store.save(fixture()); + final preferences = await SharedPreferences.getInstance(); + final original = preferences.getString(serverCatalogKey); + for (final corrupt in [ + 'bad', + 1, + '{"version":2}', + '{"version":1,"endpoints":[]}', + ]) { + await preferences.remove(serverCatalogLegacyBindingKey); + if (corrupt is String) { + await preferences.setString(serverCatalogLegacyBindingKey, corrupt); + } else { + await preferences.setInt( + serverCatalogLegacyBindingKey, + corrupt as int, + ); + } + await expectLater( + store.load(legacyEndpoint: 'ws://b.test'), + throwsFormatException, + ); + expect(await store.save(ServerCatalog()), isFalse); + expect(preferences.getString(serverCatalogKey), original); + expect(preferences.get(serverCatalogLegacyBindingKey), corrupt); + } + }, + ); + test('empty storage gives empty catalog and never writes on load', () async { expect((await store.load()).servers, isEmpty); final preferences = await SharedPreferences.getInstance(); diff --git a/app/test/core/servers/server_catalog_test.dart b/app/test/core/servers/server_catalog_test.dart index 6d3d5007..f1d3c31e 100644 --- a/app/test/core/servers/server_catalog_test.dart +++ b/app/test/core/servers/server_catalog_test.dart @@ -10,6 +10,43 @@ SavedServer server(String id) => SavedServer.validated( ); void main() { + test( + 'legacy pointer survives alias reordering without becoming an alias', + () { + final original = SavedServer.validated( + id: 'legacy-server', + name: 'Home', + endpoints: ['wss://new.test', 'ws://original.test'], + legacyEndpoint: ' WS://ORIGINAL.test/ ', + ); + final reordered = SavedServer.validated( + id: original.id, + name: original.name, + endpoints: original.endpoints.reversed, + legacyEndpoint: original.legacyEndpoint, + ); + final restored = SavedServer.fromJson(reordered.toJson()); + expect(restored.legacyEndpoint, 'ws://original.test/connect'); + expect(restored.endpoints, reordered.endpoints); + final pointerOnly = SavedServer.validated( + id: 'a', + name: 'A', + endpoints: ['wss://new.test'], + legacyEndpoint: restored.legacyEndpoint, + ); + expect(pointerOnly.endpoints, ['wss://new.test/connect']); + expect( + () => SavedServer.validated( + id: 'a', + name: 'A', + endpoints: ['ws://a.test'], + legacyEndpoint: 'bad', + ), + throwsFormatException, + ); + }, + ); + test('normalizes, deduplicates and retains primary/backup order', () { final value = SavedServer.validated( id: ' home ', diff --git a/app/test/features/pipelines/pending_run_migration_test.dart b/app/test/features/pipelines/pending_run_migration_test.dart new file mode 100644 index 00000000..58346c10 --- /dev/null +++ b/app/test/features/pipelines/pending_run_migration_test.dart @@ -0,0 +1,122 @@ +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/pipelines/pending_run_store.dart'; +import 'package:pipelines_app/features/pipelines/run_pipeline_intent.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import '../../core/servers/failing_preferences.dart'; + +const intent = RunPipelineIntent( + pipelineId: 7, + version: 3, + prompt: 'unknown admission', + workspace: '/work', + notifyMode: RunNotifyMode.notify, + requestKey: 'original-operation-id', +); + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + const legacy = 'ws://original.test/connect'; + final oldKey = pendingRunStorageKey(legacy, 7, 3); + final stableKey = pendingRunStorageKey('profile:legacy-server', 7, 3); + const store = SharedPreferencesPendingRunStore( + 'profile:legacy-server', + legacyEndpoints: [legacy], + ); + setUp(() => SharedPreferences.setMockInitialValues({})); + + test( + 'restores unknown admission under profile with identical operation id', + () async { + final preferences = await SharedPreferences.getInstance(); + final raw = jsonEncode(intent.toJson()); + await preferences.setString(oldKey, raw); + expect((await store.read(7, 3))!.requestKey, intent.requestKey); + expect(preferences.getString(stableKey), raw); + expect(preferences.getString(oldKey), raw); + expect(await store.read(7, 4), isNull); + }, + ); + + test('stable record wins, including corrupt stable data', () async { + final preferences = await SharedPreferences.getInstance(); + await preferences.setString(oldKey, jsonEncode(intent.toJson())); + await preferences.setString(stableKey, 'corrupt'); + expect(await store.read(7, 3), isNull); + expect(preferences.getString(stableKey), 'corrupt'); + await store.write(intent); + expect((await store.read(7, 3))!.requestKey, intent.requestKey); + }); + + test( + 'skips nonmatching fallback and never invents an operation id', + () async { + final preferences = await SharedPreferences.getInstance(); + await preferences.setString( + oldKey, + jsonEncode({...intent.toJson(), 'pipelineId': 8}), + ); + expect(await store.read(7, 3), isNull); + await preferences.setString( + oldKey, + jsonEncode({...intent.toJson(), 'requestKey': ''}), + ); + expect(await store.read(7, 3), isNull); + expect(preferences.containsKey(stableKey), isFalse); + }, + ); + + test( + 'successful remove clears only stable and known legacy copies', + () async { + final preferences = await SharedPreferences.getInstance(); + final raw = jsonEncode(intent.toJson()); + final other = pendingRunStorageKey('ws://other.test', 7, 3); + await preferences.setString(oldKey, raw); + await preferences.setString(other, raw); + await store.read(7, 3); + await store.remove(7, 3); + expect(preferences.containsKey(oldKey), isFalse); + expect(preferences.containsKey(stableKey), isFalse); + expect(preferences.getString(other), raw); + expect(await store.read(7, 3), isNull); + }, + ); + + test( + 'copy failure returns original operation and preserves source on disk', + () async { + for (final throws in [false, true]) { + final disk = FailingPreferences()..install(); + final preferences = await SharedPreferences.getInstance(); + final raw = jsonEncode(intent.toJson()); + await preferences.setString(oldKey, raw); + disk.failWriteKey = stableKey; + disk.throwWrites = throws; + expect((await store.read(7, 3))!.requestKey, intent.requestKey); + await preferences.reload(); + expect(preferences.getString(oldKey), raw); + expect(preferences.containsKey(stableKey), isFalse); + } + }, + ); + + test('partial cleanup failure keeps stable recovery copy', () async { + final disk = FailingPreferences()..install(); + final preferences = await SharedPreferences.getInstance(); + final raw = jsonEncode(intent.toJson()); + await preferences.setString(oldKey, raw); + await store.read(7, 3); + disk.failRemoveKey = oldKey; + await store.remove(7, 3); + await preferences.reload(); + expect(preferences.getString(stableKey), raw); + expect(preferences.getString(oldKey), raw); + disk.failRemoveKey = null; + await store.remove(7, 3); + await preferences.reload(); + expect(await store.read(7, 3), isNull); + }); +}