69ae0519bd
Keep capture and probe tooling on the app's single Material surface by removing obsolete platform switches, hosts, and documentation. Preserve the existing Material routes and fixture behavior while retaining compatibility APIs outside this lane.
963 lines
30 KiB
Dart
963 lines
30 KiB
Dart
import 'package:pipelines_app/core/servers/chat/chat_server_pool.dart';
|
||
import 'package:pipelines_app/core/servers/machine_access.dart';
|
||
import 'package:pipelines_app/core/servers/server_catalog.dart';
|
||
import 'package:pipelines_app/core/servers/server_catalog_store.dart';
|
||
import 'package:pipelines_app/features/settings/server_connections.dart';
|
||
import 'health_probe_fixture.dart';
|
||
import 'package:flutter/foundation.dart' show kIsWeb;
|
||
import 'package:pipelines_app/features/updates/app_updates.dart';
|
||
import 'package:pipelines_app/ui/motion/quick_switch_animation.dart';
|
||
import 'package:pipelines_app/ui/motion/animation_speed.dart';
|
||
// Standalone fixture entry for real-browser Search result-selection evidence.
|
||
//
|
||
// Build and probe (from app/):
|
||
// flutter build web --target tool/search_selection_probe_entry.dart \
|
||
// --output build/probe-search-selection
|
||
// node tool/search_selection_probe.mjs --root build/probe-search-selection \
|
||
// --out build/search-selection-probe
|
||
//
|
||
// This is the normal application composition (`PipelinesApp`) over the shared
|
||
// transport, with the socket replaced by an in-process channel that answers
|
||
// the real `search`, `get_run`, `list_runs`, `list_pipelines`, `get_pipeline`
|
||
// and `ping` requests with server-shaped fixtures. Nothing here opens a
|
||
// network connection or touches a live server; the fixtures exist only so the
|
||
// shell's search → run-detail selection can be rendered and captured.
|
||
import 'dart:async';
|
||
import 'dart:convert';
|
||
|
||
import 'package:pipelines_app/application/app_url_strategy.dart';
|
||
import 'package:pipelines_app/application/pipelines_app.dart';
|
||
import 'package:pipelines_app/application/bootstrap.dart';
|
||
import 'package:pipelines_app/core/api_gateway.dart';
|
||
import 'package:pipelines_app/core/transport/pipelines_client.dart';
|
||
import 'package:pipelines_app/features/search/ui/search_bar_controls.dart'
|
||
show searchFieldKey;
|
||
import 'package:pipelines_app/ui/input/app_search_field.dart';
|
||
import 'package:pipelines_app/ui/theme/app_font.dart';
|
||
import 'package:pipelines_app/ui/theme/app_font_controller.dart';
|
||
import 'package:flutter/widgets.dart';
|
||
import 'package:web_socket_channel/web_socket_channel.dart';
|
||
|
||
import 'fixture_host/fixture_host.dart';
|
||
import 'perf/chat_search_fixture.dart';
|
||
import 'perf/chat_question_fixture.dart';
|
||
import 'capture/window_probe.dart';
|
||
import 'perf/chat_scroll_fixture.dart';
|
||
import 'perf/perf_fixture.dart';
|
||
import 'probe_folder_fixture.dart';
|
||
import 'probe_files_fixture.dart';
|
||
import 'probe_usage_fixture.dart';
|
||
|
||
/// The run every run-scoped hit names. Its recorded sequences are deliberately
|
||
/// not its row indexes (plan 5, build 2, plan 1), exactly like the unit
|
||
/// fixture, so a selection has to resolve the recorded sequence.
|
||
JsonMap probeRunDetail() => {
|
||
'id': 7,
|
||
'title': 'Release train run',
|
||
'name': 'release-train',
|
||
'status': _liveRunStatus ?? 'succeeded',
|
||
'created_at': '2026-10-20T08:12:00Z',
|
||
'finished_at': '2026-10-20T08:42:00Z',
|
||
'workspace': '/srv/probe/release',
|
||
'input': {'prompt': 'ship it'},
|
||
'output': {'result': 'ok'},
|
||
'steps': [
|
||
{
|
||
'stage': 'plan',
|
||
'sequence': 5,
|
||
'status': 'completed',
|
||
'outcome': 'success',
|
||
'target': '#success',
|
||
'started_at': '2026-10-20T08:30:00Z',
|
||
'finished_at': '2026-10-20T08:31:00Z',
|
||
'diagnostic': 'release plan accepted',
|
||
'file_changes': _probeChanges(['docs/release-plan.md']),
|
||
},
|
||
{
|
||
'stage': 'build',
|
||
'sequence': 2,
|
||
'status': 'completed',
|
||
'outcome': 'success',
|
||
'target': 'plan',
|
||
'started_at': '2026-10-20T08:16:00Z',
|
||
'finished_at': '2026-10-20T08:24:00Z',
|
||
'artifacts': [
|
||
{
|
||
'name': 'release-report.txt',
|
||
'content_type': 'text/plain',
|
||
'size_bytes': 12,
|
||
'url': '/artifacts/7/2/release-report.txt',
|
||
},
|
||
if (_htmlArtifact)
|
||
{
|
||
'name': 'release-dashboard.html',
|
||
'content_type': 'text/html',
|
||
'size_bytes': 4096,
|
||
'url': '/artifacts/7/2/release-dashboard.html',
|
||
},
|
||
if (_turnFiles)
|
||
for (final name in _turnFileNames)
|
||
{
|
||
'name': name,
|
||
'content_type': 'text/markdown',
|
||
'size_bytes': 640,
|
||
'url': '/artifacts/7/2/',
|
||
'group': 'debug',
|
||
},
|
||
],
|
||
'file_changes': _probeChanges([
|
||
'lib/release/train.dart',
|
||
'lib/release/notes.dart',
|
||
'test/release/train_test.dart',
|
||
]),
|
||
},
|
||
{
|
||
'stage': 'plan',
|
||
'sequence': 1,
|
||
'status': 'completed',
|
||
'outcome': 'success',
|
||
'target': 'build',
|
||
'started_at': '2026-10-20T08:12:00Z',
|
||
'finished_at': '2026-10-20T08:14:00Z',
|
||
},
|
||
..._fillerSteps(),
|
||
],
|
||
if (perfRunGraph) 'graph': perfRunGraphFixture(),
|
||
};
|
||
|
||
/// A complete change capture modifying [paths], so Changes shows visit pages
|
||
/// and each file opens a paged diff.
|
||
JsonMap _probeChanges(List<String> paths) => {
|
||
'status': 'complete',
|
||
'scope': 'Git tracked and nonignored files in the run directory',
|
||
'skipped': 0,
|
||
'omitted': 0,
|
||
'diagnostic': '',
|
||
'files': [
|
||
for (final path in paths)
|
||
{
|
||
'path': path,
|
||
'kind': 'modified',
|
||
'patch':
|
||
'--- "a/$path"\n'
|
||
'+++ "b/$path"\n'
|
||
'@@ -1,3 +1,3 @@\n'
|
||
' // Release train\n'
|
||
'-const stage = \'draft\';\n'
|
||
'+const stage = \'shipped\';\n'
|
||
' // end\n',
|
||
},
|
||
],
|
||
};
|
||
|
||
/// Extra rows for scroll-performance captures (`?runs=N`, `?steps=N`). Both
|
||
/// default to none, so every other capture sees the fixture unchanged.
|
||
int _fillerRunCount = 0;
|
||
int _fillerStepCount = 0;
|
||
|
||
/// `?running=1`: run 8 executes, started 3m 50s before the page loaded, so a
|
||
/// capture shows its duration ticking. Absent by default.
|
||
DateTime? _runningSince;
|
||
String? _liveRunStatus;
|
||
|
||
/// `?html=1` adds `release-dashboard.html` to run 7's build visit; the capture
|
||
/// serves its bytes from the build directory (see notes/artifact-fullscreen.md).
|
||
bool _htmlArtifact = false;
|
||
bool _warnings = false;
|
||
|
||
/// `?turn=1` adds the runner-internal turn files the server records for a model
|
||
/// visit (group `debug`) to run 7's build visit, so the Artifacts tab's hidden
|
||
/// Debugging files group can be reviewed.
|
||
bool _turnFiles = false;
|
||
const List<String> _turnFileNames = [
|
||
'input.md',
|
||
'memory.md',
|
||
'history.md',
|
||
'output.md',
|
||
'private/build-log.md',
|
||
];
|
||
|
||
List<JsonMap> _fillerSteps() => [
|
||
for (var i = 0; i < _fillerStepCount; i++)
|
||
{
|
||
'stage': i.isEven ? 'build' : 'plan',
|
||
'sequence': 100 + i,
|
||
'status': 'completed',
|
||
'outcome': 'success',
|
||
'target': i.isEven ? 'plan' : 'build',
|
||
'started_at': '2026-10-20T08:32:00Z',
|
||
'finished_at': '2026-10-20T08:33:00Z',
|
||
'diagnostic': 'filler step $i for scroll captures',
|
||
},
|
||
];
|
||
|
||
List<JsonMap> _fillerRuns() => [
|
||
for (var i = 0; i < _fillerRunCount; i++)
|
||
{
|
||
'id': 1000 + i,
|
||
'title': 'Filler run $i for scroll captures',
|
||
'name': 'filler-$i',
|
||
'status': i % 3 == 0 ? 'failed' : 'succeeded',
|
||
'created_at': '2026-10-18T08:12:00Z',
|
||
'finished_at': '2026-10-18T08:42:00Z',
|
||
'pipeline_id': i.isEven ? 24 : 22,
|
||
},
|
||
];
|
||
|
||
List<JsonMap> probeRuns() => [
|
||
if (_runningSince != null)
|
||
{
|
||
'id': 8,
|
||
'title': 'Live deploy run',
|
||
'name': 'release-train',
|
||
'status': 'running',
|
||
'executing': true,
|
||
'current_stage': 'deploy',
|
||
'completed_steps': 2,
|
||
'created_at': _runningSince!.toUtc().toIso8601String(),
|
||
'finished_at': '',
|
||
'pipeline_id': 24,
|
||
},
|
||
{
|
||
'id': 7,
|
||
'title': 'Release train run',
|
||
'name': 'release-train',
|
||
'status': _liveRunStatus ?? 'succeeded',
|
||
'created_at': '2026-10-20T08:12:00Z',
|
||
'finished_at': '2026-10-20T08:42:00Z',
|
||
'pipeline_id': 24,
|
||
},
|
||
{
|
||
'id': 6,
|
||
'title': 'Nightly docs run',
|
||
'name': 'nightly-docs',
|
||
'status': 'failed',
|
||
'created_at': '2026-10-19T22:00:00Z',
|
||
'finished_at': '2026-10-19T22:03:00Z',
|
||
'pipeline_id': 22,
|
||
},
|
||
..._fillerRuns(),
|
||
];
|
||
|
||
/// Pipelines this fixture session archived, with their archive time.
|
||
final _probeArchived = <int, String>{};
|
||
|
||
List<JsonMap> probePipelines() => [
|
||
for (final pipeline in _probePipelineRows())
|
||
{
|
||
...pipeline,
|
||
if (_probeArchived[pipeline['id']] != null)
|
||
'archived_at': _probeArchived[pipeline['id']],
|
||
},
|
||
];
|
||
|
||
List<JsonMap> _probePipelineRows() => [
|
||
{
|
||
'id': 24,
|
||
'name': 'Release train',
|
||
'version': 5,
|
||
'stages': 2,
|
||
'created_at': '2026-09-28T10:12:00',
|
||
'updated_at': '2026-10-20T09:18:00',
|
||
'scheduled': false,
|
||
'schedule_count': 0,
|
||
'enabled_schedule_count': 0,
|
||
},
|
||
{
|
||
'id': 22,
|
||
'name': 'Nightly documentation',
|
||
'version': 6,
|
||
'stages': 1,
|
||
'created_at': '2026-10-02T18:20:00',
|
||
'updated_at': '2026-10-18T16:05:00',
|
||
'scheduled': true,
|
||
'schedule_count': 1,
|
||
'enabled_schedule_count': 1,
|
||
},
|
||
];
|
||
|
||
const _releaseSource =
|
||
'name: Release train\n'
|
||
'stages:\n'
|
||
' plan:\n'
|
||
' type: model\n'
|
||
' output: plan\n'
|
||
' build:\n'
|
||
' type: model\n'
|
||
' output: release\n';
|
||
|
||
JsonMap probePipelineDetail(int id, int requestedVersion) {
|
||
final summary = probePipelines().firstWhere(
|
||
(pipeline) => pipeline['id'] == id,
|
||
orElse: () => probePipelines().first,
|
||
);
|
||
final latest = summary['version'] as int;
|
||
final version = requestedVersion > 0 ? requestedVersion : latest;
|
||
return {
|
||
...summary,
|
||
'version': version,
|
||
'latest_version': latest,
|
||
'version_created_at': '2026-10-18T16:05:00',
|
||
'content_hash': 'sha256:probe-$id-v$version',
|
||
'source': _releaseSource,
|
||
'versions': [
|
||
for (var v = 1; v <= latest; v++)
|
||
{
|
||
'version': v,
|
||
'stages': summary['stages'],
|
||
'created_at': '2026-10-0${v}T10:00:00',
|
||
},
|
||
],
|
||
};
|
||
}
|
||
|
||
/// One recorded hit per result kind, each with the text a server would have
|
||
/// matched (`haystack`). The payloads are server-shaped `search_results` rows:
|
||
/// the `target` tokens are the ones `internal/protocol/search.go` records.
|
||
///
|
||
/// `release` matches every kind once; `retired` matches only the retired-field
|
||
/// hit; `missing` matches only an artifact whose recorded visit (sequence 9)
|
||
/// the run never recorded; `first` matches only the plan visit 1 step hit.
|
||
const List<({String haystack, JsonMap hit})> probeHits = [
|
||
(
|
||
haystack: 'Release train pipeline definition',
|
||
hit: {
|
||
'kind': 'pipeline',
|
||
'target': 'pipeline:24',
|
||
'score': 3,
|
||
'recency': '2026-10-20T09:18:00Z',
|
||
'pipeline': {
|
||
'id': 24,
|
||
'name': 'Release train',
|
||
'version': 5,
|
||
'stages': 2,
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'name: Nightly documentation release notes',
|
||
hit: {
|
||
'kind': 'version',
|
||
'target': 'pipeline:22:v6',
|
||
'score': 2,
|
||
'recency': '2026-10-18T16:05:00Z',
|
||
'version': {
|
||
'pipeline_id': 22,
|
||
'version': 6,
|
||
'content_hash': '9f2c1ad',
|
||
'created_at': '2026-10-18T16:05:00Z',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'Release train run',
|
||
hit: {
|
||
'kind': 'run',
|
||
'target': 'run:7',
|
||
'score': 2,
|
||
'recency': '2026-10-20T08:42:00Z',
|
||
'run': {
|
||
'id': 7,
|
||
'pipeline_name': 'Release train',
|
||
'status': 'succeeded',
|
||
'workspace': '/srv/probe/release',
|
||
'created_at': '2026-10-20T08:12:00Z',
|
||
'finished_at': '2026-10-20T08:42:00Z',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'release plan accepted',
|
||
hit: {
|
||
'kind': 'step',
|
||
'target': 'run:7:5',
|
||
'score': 1,
|
||
'recency': '2026-10-20T08:31:00Z',
|
||
'step': {
|
||
'run_id': 7,
|
||
'sequence': 5,
|
||
'stage': 'plan',
|
||
'visit': 2,
|
||
'outcome': 'success',
|
||
'target': '#success',
|
||
'diagnostic': 'release plan accepted',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'ship the release',
|
||
hit: {
|
||
'kind': 'field',
|
||
'target': 'run:7:5:output',
|
||
'score': 1,
|
||
'matched_field': 'output',
|
||
'recency': '2026-10-20T08:31:00Z',
|
||
'field': {
|
||
'run_id': 7,
|
||
'sequence': 5,
|
||
'field': 'output',
|
||
'snippet': 'ship the release',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'release-report.txt',
|
||
hit: {
|
||
'kind': 'artifact',
|
||
'target': '/artifacts/7/2/release-report.txt',
|
||
'score': 1,
|
||
'recency': '2026-10-20T08:24:00Z',
|
||
'artifact': {
|
||
'run_id': 7,
|
||
'sequence': 2,
|
||
'name': 'release-report.txt',
|
||
'content_type': 'text/plain',
|
||
'size_bytes': 12,
|
||
'url': '/artifacts/7/2/release-report.txt',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'retired evidence note',
|
||
hit: {
|
||
'kind': 'field',
|
||
'target': 'run:7:5:evidence',
|
||
'score': 1,
|
||
'matched_field': 'evidence',
|
||
'recency': '2026-10-20T08:31:00Z',
|
||
'field': {
|
||
'run_id': 7,
|
||
'sequence': 5,
|
||
'field': 'evidence',
|
||
'snippet': 'retired evidence note',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'missing.log',
|
||
hit: {
|
||
'kind': 'artifact',
|
||
'target': '/artifacts/7/9/missing.log',
|
||
'score': 1,
|
||
'recency': '2026-10-20T08:40:00Z',
|
||
'artifact': {
|
||
'run_id': 7,
|
||
'sequence': 9,
|
||
'name': 'missing.log',
|
||
'content_type': 'text/plain',
|
||
'size_bytes': 4096,
|
||
'url': '/artifacts/7/9/missing.log',
|
||
},
|
||
},
|
||
),
|
||
(
|
||
haystack: 'first plan visit',
|
||
hit: {
|
||
'kind': 'step',
|
||
'target': 'run:7:1',
|
||
'score': 1,
|
||
'recency': '2026-10-20T08:14:00Z',
|
||
'step': {
|
||
'run_id': 7,
|
||
'sequence': 1,
|
||
'stage': 'plan',
|
||
'visit': 1,
|
||
'outcome': 'success',
|
||
'target': 'build',
|
||
},
|
||
},
|
||
),
|
||
];
|
||
|
||
/// Answers one decoded request envelope with the server-shaped reply, or null
|
||
/// for a send-only request the real server does not acknowledge.
|
||
JsonMap? probeReply(JsonMap request) {
|
||
final id = request['id'];
|
||
final type = '${request['type']}';
|
||
JsonMap error(String message) => {
|
||
'id': id,
|
||
'type': 'error',
|
||
'error': message,
|
||
};
|
||
final perf = perfChatReply(request);
|
||
if (perf != null) return perf;
|
||
switch (type) {
|
||
case 'list_directory':
|
||
return probeFilesReply(request);
|
||
case 'subscribe':
|
||
case 'unsubscribe':
|
||
return null;
|
||
case 'ping':
|
||
return {
|
||
'id': id,
|
||
'type': 'pong',
|
||
'build': {'version': 'Search selection probe fixture'},
|
||
'time': '2026-10-20T09:00:00Z',
|
||
};
|
||
case 'server_stats':
|
||
return {
|
||
'id': id,
|
||
'type': 'server_stats_result',
|
||
'server_stats': healthProbeSnapshot(),
|
||
};
|
||
case 'list_runs':
|
||
return {
|
||
'id': id,
|
||
'type': 'runs',
|
||
'runs': probeRuns().map(withProbeUsage).toList(),
|
||
'usage': null,
|
||
};
|
||
case 'get_run':
|
||
if (request['run_id'] != 7) {
|
||
return error('Fixture run ${request['run_id']} is unavailable');
|
||
}
|
||
final detail = withProbeUsage(probeRunDetail());
|
||
return {
|
||
'id': id,
|
||
'type': 'run',
|
||
'run_detail': {
|
||
...detail,
|
||
if (_warnings)
|
||
'warnings': [
|
||
'build visit 1: final result required one repair follow-up.',
|
||
],
|
||
'steps': [
|
||
for (final step in detail['steps'] as List)
|
||
withProbeStepUsage(step as JsonMap),
|
||
],
|
||
},
|
||
};
|
||
case 'list_pipelines':
|
||
return {'id': id, 'type': 'pipelines', 'pipelines': probePipelines()};
|
||
case 'validate':
|
||
return {
|
||
'id': id,
|
||
'type': 'validated',
|
||
if (_warnings)
|
||
'warnings': ['Review prompt repeats runner instructions.'],
|
||
};
|
||
case 'get_pipeline':
|
||
final pipelineId = request['pipeline_id'];
|
||
if (pipelineId is! int ||
|
||
!probePipelines().any((pipeline) => pipeline['id'] == pipelineId)) {
|
||
return error('Fixture pipeline $pipelineId is unavailable');
|
||
}
|
||
final version = request['version'];
|
||
return {
|
||
'id': id,
|
||
'type': 'pipeline',
|
||
'detail': probePipelineDetail(pipelineId, version is int ? version : 0),
|
||
};
|
||
case 'archive_pipeline':
|
||
case 'unarchive_pipeline':
|
||
// Mirrors the server: an enabled schedule blocks archiving.
|
||
final pipelineId = request['pipeline_id'];
|
||
final row = probePipelines().where((p) => p['id'] == pipelineId);
|
||
if (row.isEmpty) return error('pipeline not found');
|
||
final archive = type == 'archive_pipeline';
|
||
if (archive && (row.first['enabled_schedule_count'] as int) > 0) {
|
||
return error(
|
||
'pipeline "${row.first['name']}" has enabled schedule(s) '
|
||
'"Nightly docs" (#3); pause or repoint them before archiving',
|
||
);
|
||
}
|
||
if (archive) {
|
||
_probeArchived[pipelineId as int] = '2026-10-20T09:30:00Z';
|
||
} else {
|
||
_probeArchived.remove(pipelineId);
|
||
}
|
||
return {
|
||
'id': id,
|
||
'type': archive ? 'pipeline_archived' : 'pipeline_unarchived',
|
||
'detail': probePipelineDetail(pipelineId as int, 0),
|
||
};
|
||
case 'search':
|
||
// The app must send exactly the browser's SearchRequest body; anything
|
||
// else is answered with a visible refusal so the capture cannot pass.
|
||
final search = request['search'];
|
||
if (search is! Map ||
|
||
search.length != 3 ||
|
||
search['query'] is! String ||
|
||
search['kind'] is! String ||
|
||
search['limit'] != 0) {
|
||
return error('Fixture refused a malformed search request: $search');
|
||
}
|
||
final query = (search['query'] as String).trim().toLowerCase();
|
||
final kind = search['kind'] as String;
|
||
if (kind == 'chat') {
|
||
// The server answers chats as their own request (search_chats.go).
|
||
return {
|
||
'id': id,
|
||
'type': 'search_results',
|
||
'search_results': {
|
||
'query': search['query'],
|
||
'kind': kind,
|
||
'results': perfChatSearchHits(query),
|
||
'truncated': false,
|
||
'scanned_steps': 0,
|
||
'scanned_bytes': 0,
|
||
'cap': 50,
|
||
'scan_bound_bytes': 1048576,
|
||
'scanned_chats': 3,
|
||
},
|
||
};
|
||
}
|
||
final results = [
|
||
for (final entry in probeHits)
|
||
if ((kind.isEmpty || entry.hit['kind'] == kind) &&
|
||
(query.isEmpty || entry.haystack.toLowerCase().contains(query)))
|
||
entry.hit,
|
||
...perfSearchHits(query, kind),
|
||
];
|
||
return {
|
||
'id': id,
|
||
'type': 'search_results',
|
||
'search_results': {
|
||
'query': search['query'],
|
||
'kind': kind,
|
||
'results': results,
|
||
'truncated': false,
|
||
'scanned_steps': 3,
|
||
'scanned_bytes': 2048,
|
||
'cap': 50,
|
||
'scan_bound_bytes': 1048576,
|
||
},
|
||
};
|
||
default:
|
||
return probeFolderReply(request) ??
|
||
error('Fixture does not implement $type');
|
||
}
|
||
}
|
||
|
||
/// An in-process websocket channel: every frame the client sends is decoded
|
||
/// and answered asynchronously with [probeReply], as the server would over the
|
||
/// wire. `ready` completes at once so the shared client reports connected.
|
||
/// The capture fixture's stand-in for the chat pool: the Mac is connected,
|
||
/// the Linux desktop still wants its password, and any machine added during
|
||
/// the capture asks for `fixture-pass`.
|
||
class _FixtureAuthenticator extends ChangeNotifier
|
||
implements MachineAuthenticator {
|
||
final _verdicts = <String, MachineAccessResult>{
|
||
'mac': const MachineAccessResult(MachineAccess.connected),
|
||
'linux': const MachineAccessResult(MachineAccess.needsPassword),
|
||
};
|
||
|
||
@override
|
||
MachineAccessResult? status(String id) => _verdicts[id];
|
||
|
||
@override
|
||
Future<MachineAccessResult> probe(SavedServer server) async {
|
||
await Future<void>.delayed(const Duration(milliseconds: 400));
|
||
return _verdicts[server.id] ??= const MachineAccessResult(
|
||
MachineAccess.needsPassword,
|
||
);
|
||
}
|
||
|
||
@override
|
||
Future<String?> authenticate(SavedServer server, String password) async {
|
||
await Future<void>.delayed(const Duration(milliseconds: 400));
|
||
if (password != 'fixture-pass') return 'Wrong password.';
|
||
_verdicts[server.id] = const MachineAccessResult(MachineAccess.connected);
|
||
notifyListeners();
|
||
return null;
|
||
}
|
||
}
|
||
|
||
class _FixtureChannel implements WebSocketChannel {
|
||
_FixtureChannel();
|
||
|
||
final _incoming = StreamController<dynamic>();
|
||
Timer? _runCompletion;
|
||
late final _FixtureSink _sink = _FixtureSink(this);
|
||
|
||
@override
|
||
Stream<dynamic> get stream => _incoming.stream;
|
||
|
||
@override
|
||
WebSocketSink get sink => _sink;
|
||
|
||
@override
|
||
Future<void> get ready => Future<void>.value();
|
||
|
||
@override
|
||
String? get protocol => null;
|
||
|
||
@override
|
||
int? get closeCode => null;
|
||
|
||
@override
|
||
String? get closeReason => null;
|
||
|
||
void receive(dynamic data) {
|
||
if (data is! String) return;
|
||
final decoded = jsonDecode(data);
|
||
if (decoded is! Map<String, dynamic>) return;
|
||
if (_liveRunStatus == 'running' && decoded['type'] == 'list_runs') {
|
||
_runCompletion ??= Timer(const Duration(seconds: 7), () {
|
||
_liveRunStatus = 'succeeded';
|
||
if (!_incoming.isClosed) {
|
||
_incoming.add(
|
||
jsonEncode({
|
||
'type': 'run_event',
|
||
'run_event': {
|
||
'run_id': 7,
|
||
'status': 'succeeded',
|
||
'executing': false,
|
||
'completed_steps': 3,
|
||
'finished_at': '2026-10-20T08:42:00Z',
|
||
},
|
||
}),
|
||
);
|
||
}
|
||
});
|
||
}
|
||
final reply = probeReply(decoded);
|
||
final followUps = perfChatFollowUps(decoded);
|
||
final subscribe = decoded['chat_subscribe'];
|
||
if (subscribe is Map) {
|
||
void emit(JsonMap frame) {
|
||
if (!_incoming.isClosed) _incoming.add(jsonEncode(frame));
|
||
}
|
||
|
||
chatScrollStream('${subscribe['session_id'] ?? ''}', emit);
|
||
chatQuestionStream('${subscribe['session_id'] ?? ''}', emit);
|
||
}
|
||
if (reply == null && followUps.isEmpty) return;
|
||
Future<void>.delayed(const Duration(milliseconds: 120), () {
|
||
if (_incoming.isClosed) return;
|
||
if (reply != null) _incoming.add(jsonEncode(reply));
|
||
for (final frame in followUps) {
|
||
_incoming.add(jsonEncode(frame));
|
||
}
|
||
});
|
||
}
|
||
|
||
Future<void> close() async {
|
||
_runCompletion?.cancel();
|
||
if (!_incoming.isClosed) await _incoming.close();
|
||
}
|
||
|
||
@override
|
||
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||
}
|
||
|
||
class _FixtureSink implements WebSocketSink {
|
||
_FixtureSink(this.channel);
|
||
|
||
final _FixtureChannel channel;
|
||
|
||
@override
|
||
void add(dynamic event) => channel.receive(event);
|
||
|
||
@override
|
||
void addError(Object error, [StackTrace? stackTrace]) => throw error;
|
||
|
||
@override
|
||
Future<void> addStream(Stream<dynamic> stream) async {
|
||
await for (final item in stream) {
|
||
add(item);
|
||
}
|
||
}
|
||
|
||
@override
|
||
Future<void> close([int? closeCode, String? closeReason]) => channel.close();
|
||
|
||
@override
|
||
Future<void> get done => channel._incoming.done;
|
||
|
||
@override
|
||
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||
}
|
||
|
||
/// Static-server capture flags, so a plain file server (no index.html
|
||
/// fallback for `/runs/7`) can still open a deep location:
|
||
///
|
||
/// `?route=/runs/7/stage/build%3Fvisit%3D1` opens that app location;
|
||
/// `?runs=200` / `?steps=60` append filler runs / run-7 steps for scroll
|
||
/// performance captures;
|
||
/// `?running=1` adds an executing run 8 whose duration ticks;
|
||
/// `?html=1` adds an HTML artifact to run 7 (`release-dashboard.html`);
|
||
/// `?turn=1` adds run 7's debug turn files (input/memory/history/output.md);
|
||
/// `?q=release` types that query into Search once its field is shown;
|
||
/// `?perf=1` prints frame timings (tool/perf/frame_log.dart);
|
||
/// `?hits=N`, `?chats=N` and `?graph=1` add bench data
|
||
/// (tool/perf/perf_fixture.dart);
|
||
/// `?terminals=1` lists two machine terminals, and `?terminal=panel` or
|
||
/// `?terminal=float` opens them at launch (tool/perf/terminal_fixture.dart);
|
||
/// `?windows=N` opens N floating probe windows whose content opens every
|
||
/// kind of popup and a pushed page (tool/capture/window_probe.dart);
|
||
/// `?theme=dark` / `?theme=light` pins the platform brightness the app's
|
||
/// `ThemeMode.system` follows (omitted: the browser's color scheme).
|
||
///
|
||
/// app/tool/capture/ drives this entry generically; see its README.
|
||
Future<void> main() async {
|
||
WidgetsFlutterBinding.ensureInitialized();
|
||
await Future.wait([
|
||
QuickSwitchAnimationController.instance.restore(),
|
||
AnimationSpeedController.instance.restore(),
|
||
]);
|
||
final params = fixtureParams();
|
||
if (params['liveRun'] == '1') _liveRunStatus = 'running';
|
||
installHostProbes(params);
|
||
// `?connect=1` (native only) opens the real launch flow with no saved
|
||
// server, so the Connect screen can be reviewed without any server.
|
||
if (params['connect'] == '1') {
|
||
runPipelinesApp(configured: '');
|
||
return;
|
||
}
|
||
configurePerfFixture(params);
|
||
if (params['files'] == '1') installFilesFixture();
|
||
// `?font=inter` chooses a font as Settings would; otherwise the stored one.
|
||
final font = params['font'];
|
||
unawaited(
|
||
font == null
|
||
? AppFontController.instance.restore()
|
||
: AppFontController.instance.select(AppFont.fromId(font)),
|
||
);
|
||
_fillerRunCount = int.tryParse(params['runs'] ?? '') ?? 0;
|
||
_fillerStepCount = int.tryParse(params['steps'] ?? '') ?? 0;
|
||
if (params['running'] == '1') {
|
||
_runningSince = DateTime.now().subtract(
|
||
const Duration(minutes: 3, seconds: 50),
|
||
);
|
||
}
|
||
probeUsage = params['usage'] == '1';
|
||
_htmlArtifact = params['html'] == '1';
|
||
_warnings = params['warnings'] == '1';
|
||
_turnFiles = params['turn'] == '1';
|
||
final route = params['route'];
|
||
final opensRoute = route != null && route.startsWith('/');
|
||
if (opensRoute) openFixtureRoute(route);
|
||
final query = params['q'];
|
||
if (query != null && query.isNotEmpty) _typeSearchWhenShown(query);
|
||
useAppUrlStrategy();
|
||
ServerConnections? machines;
|
||
if (params['machines'] == '1' || params['federated'] == '1') {
|
||
machines = ServerConnections(
|
||
store: MemoryServerCatalogStore(
|
||
catalog: ServerCatalog(
|
||
servers: [
|
||
SavedServer.validated(
|
||
id: 'mac',
|
||
name: 'Alan’s Mac',
|
||
endpoints: ['ws://mac.fixture/connect'],
|
||
),
|
||
SavedServer.validated(
|
||
id: 'linux',
|
||
name: 'Linux desktop',
|
||
endpoints: ['ws://linux.fixture/connect'],
|
||
),
|
||
],
|
||
selectedId: 'mac',
|
||
),
|
||
),
|
||
onSelected: (_) async {},
|
||
);
|
||
await machines.load();
|
||
// Settings shows each machine's own sign-in state; a new machine asks
|
||
// for its password (`fixture-pass`) like the real chat pool does.
|
||
machines.authenticator = _FixtureAuthenticator();
|
||
}
|
||
final pool = params['federated'] == '1' && machines != null
|
||
? ChatServerPool(
|
||
machines,
|
||
connect: (machine) async {
|
||
final client = PipelinesClient(
|
||
channelFactory: (_) => _FixtureChannel(),
|
||
);
|
||
await client.connect(Uri.parse(machine.endpoints.first));
|
||
return ChatMachineConnection(
|
||
gateway: client,
|
||
endpoint: () => client.endpoint.toString(),
|
||
connected: () => true,
|
||
states: client.states,
|
||
close: client.dispose,
|
||
retry: () => client.connect(Uri.parse(machine.endpoints.first)),
|
||
);
|
||
},
|
||
)
|
||
: null;
|
||
final app = PipelinesApp(
|
||
serverId: machines?.catalog.active?.id,
|
||
servers: machines,
|
||
chatPool: pool,
|
||
server: fixtureServer(params),
|
||
webPlatform: params['nativeUpdate'] == null ? kIsWeb : false,
|
||
androidSupported: params['nativeUpdate'] == null ? null : true,
|
||
installedVersionReader: () async => 1,
|
||
androidFeedReader: (base) async => AppUpdate(
|
||
versionCode: 2,
|
||
versionName: '0.1.2',
|
||
apk: base.resolve('Pipelines.zip'),
|
||
platform: params['nativeUpdate'] ?? 'android',
|
||
sourceName: 'Home Linux',
|
||
),
|
||
client: PipelinesClient(channelFactory: (_) => _FixtureChannel()),
|
||
routeInformationProvider: fixtureRouteProvider(opensRoute ? route : null),
|
||
windows: probeWindows(params),
|
||
);
|
||
final brightness = switch (params['theme']) {
|
||
'dark' => Brightness.dark,
|
||
'light' => Brightness.light,
|
||
_ => null,
|
||
};
|
||
runFixtureApp(
|
||
brightness == null
|
||
? app
|
||
: _PinnedBrightness(brightness: brightness, child: app),
|
||
params,
|
||
);
|
||
}
|
||
|
||
/// Pins the platform brightness below it. The app's own `MediaQuery.fromView`
|
||
/// takes platform fields from this ambient query, so `ThemeMode.system` resolves
|
||
/// to [brightness] while size, padding and text scale still follow the real view.
|
||
class _PinnedBrightness extends StatelessWidget {
|
||
const _PinnedBrightness({required this.brightness, required this.child});
|
||
|
||
final Brightness brightness;
|
||
final Widget child;
|
||
|
||
@override
|
||
Widget build(BuildContext context) => MediaQuery.fromView(
|
||
view: View.of(context),
|
||
child: Builder(
|
||
builder: (context) => MediaQuery(
|
||
data: MediaQuery.of(context).copyWith(platformBrightness: brightness),
|
||
child: child,
|
||
),
|
||
),
|
||
);
|
||
}
|
||
|
||
/// Types [query] into Search's field once it is shown, through the field's
|
||
/// own change and submit callbacks, exactly as typing would.
|
||
void _typeSearchWhenShown(String query) {
|
||
void attempt(Duration _) {
|
||
AppSearchField? found;
|
||
void visit(Element element) {
|
||
if (found != null) return;
|
||
final widget = element.widget;
|
||
if (widget is AppSearchField && widget.fieldKey == searchFieldKey) {
|
||
found = widget;
|
||
return;
|
||
}
|
||
element.visitChildren(visit);
|
||
}
|
||
|
||
WidgetsBinding.instance.rootElement?.visitChildren(visit);
|
||
final field = found;
|
||
if (field == null) {
|
||
WidgetsBinding.instance.addPostFrameCallback(attempt);
|
||
WidgetsBinding.instance.scheduleFrame();
|
||
return;
|
||
}
|
||
field.controller.text = query;
|
||
field.onChanged?.call(query);
|
||
field.onSubmitted?.call(query);
|
||
}
|
||
|
||
WidgetsFlutterBinding.ensureInitialized();
|
||
WidgetsBinding.instance.addPostFrameCallback(attempt);
|
||
}
|