Files
pipelines/app/lib/features/runs/screen.dart
T
alan 8d2ca95057 Open Search artifact hits in the viewer over the run's Artifacts tab
On a phone-width window the open run is its own page pushed on the app
navigator, so RunDetailTabs was not a descendant of the shell's
RunSearchSelectionScope (which wraps only the Runs tab body). The field or
artifact selection was never seen and the run opened at its plain Summary.
The previous widget tests injected the scope directly above RunDetailView at
900 px, where the detail is an inline pane, so they could not catch it.

- RunsScreen relays the shell's search scope into the detail it builds, so
  the pushed page sees the selection too (also fixes field hits on phones).
- An artifact hit now opens the run's Artifacts tab and the gallery opens
  that artifact exactly as a tap there does: selected, scrolled into view
  (ArtifactVisitReveal) and in the viewer. Back returns to the tab with the
  artifact highlighted. An unknown URL leaves the tab open with the existing
  "That artifact is no longer available." notice.
- New test/application/search_artifact_open_test.dart drives the real Search
  tab -> typed query -> result tap -> run read -> viewer on a 390x844 phone,
  Material and Cupertino; it fails without the scope relay.
2026-11-02 18:39:43 +00:00

326 lines
11 KiB
Dart

import 'dart:async';
import 'package:flutter/widgets.dart';
import '../../core/api_gateway.dart';
import '../../shell/destination.dart';
import '../../shell/detail_page.dart';
import '../../shell/empty_detail_pane.dart';
import '../../shell/list_detail.dart';
import '../../ui/adaptive/host.dart';
import '../attention/notify/notification_controller.dart';
import '../../ui/layout/content_width.dart';
import '../attention/runtime/attention_controller.dart';
import '../attention/runtime/attention_store.dart';
import 'actions/decision_action.dart';
import 'data/runs_repository.dart';
import 'data/runs_sort_store.dart';
import 'domain/run_decisions.dart';
import 'ui/run_pipeline_link.dart';
import 'ui/run_detail_view.dart';
import 'ui/run_search_selection.dart';
import 'ui/runs_controller.dart';
import 'ui/runs_list.dart';
/// The runs destination's list/detail switch.
///
/// The controller's `selectedRunId` is the only selection source, so an
/// initial run, a pending detail, a failed detail, Back and a route change all
/// navigate the same way. The shell owns the app bar; this screen adds no
/// second one.
class RunsScreen extends StatefulWidget {
const RunsScreen({
super.key,
required this.gateway,
this.initialRunId,
this.initialPipelineId,
this.initialStageKey,
this.initialVisit,
this.initialDecide = false,
this.syncToken = 0,
this.listRefreshToken = 0,
this.onRunSelected,
this.onBack,
this.onPipelineFilterChanged,
this.onOpenPipeline,
this.attentionStore = const SharedPreferencesAttentionStore(),
this.attentionNow,
this.notifications,
this.attention,
this.sortStore = const SharedPreferencesRunsSortStore(),
});
final ApiGateway gateway;
/// The run the current route names, or null for the list.
final int? initialRunId;
final int? initialPipelineId;
/// The recorded stage visit the route names inside [initialRunId]. The detail
/// applies it once per route target; the feature never invents a visit.
final String? initialStageKey;
final int? initialVisit;
/// The route's `?action=decide`: once the named run's detail is loaded, open
/// the recorded decision prompt when the run is genuinely waiting. Consumed
/// once per route target, so a rebuild or a live re-read never reopens it.
final bool initialDecide;
/// Advances when the shared socket is replaced. The loaded screen refreshes
/// in place instead of being remounted, so its selection survives.
final int syncToken;
/// Advances when a launch accepted outside this screen must be reflected by a
/// fresh `list_runs` read. It never inserts a row of its own.
final int listRefreshToken;
final ValueChanged<int>? onRunSelected;
final ValueChanged<int?>? onBack;
final ValueChanged<int?>? onPipelineFilterChanged;
/// Opens a pipeline from the run detail's pipeline name.
final OpenPipeline? onOpenPipeline;
/// Persisted attention dismissals and the clock for its local-day window.
/// The app uses SharedPreferences; tests and fixtures inject a memory store.
final AttentionStore attentionStore;
final DateTime Function()? attentionNow;
/// App-level notification delivery for live attention transitions.
final NotificationController? notifications;
/// The app's shared attention controller, mirrored on the shell's Runs tab.
final AttentionController? attention;
/// Where the list's sort choice persists; tests inject a memory store.
final RunsSortStore sortStore;
@override
State<RunsScreen> createState() => _RunsScreenState();
}
class _RunsScreenState extends State<RunsScreen> {
late final RunsController controller;
num? _shownRunId;
int? _reportedPipelineId;
bool _applyingRoutePipeline = false;
/// The route's decision request is one-shot: the first loaded detail for the
/// named run consumes it, whether or not that run is waiting.
bool _decideConsumed = false;
/// The open run is its own page over the tabs.
final DetailPageHost _page = DetailPageHost();
@override
void initState() {
super.initState();
controller = RunsController(
RunsRepository(widget.gateway),
sortStore: widget.sortStore,
);
// A deleted open run closes its detail; the route returns to the list.
controller.onOpenRunRemoved = () =>
widget.onBack?.call(controller.pipelineId);
_reportedPipelineId = widget.initialPipelineId;
if (widget.initialPipelineId != null) {
controller.clearFilters();
controller.setPipeline(widget.initialPipelineId);
}
controller.listen(widget.gateway.frames);
controller.addListener(_selectionChanged);
controller.addListener(_pipelineFilterChanged);
controller.addListener(_detailChanged);
controller.load(widget.initialRunId);
}
@override
void didUpdateWidget(covariant RunsScreen oldWidget) {
super.didUpdateWidget(oldWidget);
if (widget.initialRunId != oldWidget.initialRunId ||
widget.initialDecide != oldWidget.initialDecide) {
_decideConsumed = false;
}
if (widget.initialPipelineId != oldWidget.initialPipelineId) {
final id = widget.initialPipelineId;
// A run detail replaces the list URL but retains its active list filter.
// Only a route back to the list can explicitly clear that facet.
if (id != null || widget.initialRunId == null) {
_applyingRoutePipeline = true;
try {
if (id != null) controller.clearFilters();
controller.setPipeline(id);
_reportedPipelineId = id;
} finally {
_applyingRoutePipeline = false;
}
}
}
if (widget.syncToken != oldWidget.syncToken) {
controller.resync();
}
// A launch accepted on another destination invalidates the list only. The
// route change below selects the returned run separately, so this is the
// one fresh server read that makes the new row appear.
if (widget.listRefreshToken != oldWidget.listRefreshToken) {
controller.load();
}
if (widget.initialRunId != oldWidget.initialRunId) {
final id = widget.initialRunId;
if (id == null) {
if (controller.selectedRunId != null) controller.back();
} else if (controller.selectedRunId != id) {
controller.select(id);
}
}
if (widget.initialRunId != oldWidget.initialRunId ||
widget.initialDecide != oldWidget.initialDecide) {
_detailChanged();
}
}
/// Rebuild the switch only when the selection changes. Detail progress and
/// live updates are already watched by [RunDetailView] and [RunsList], so
/// this avoids a second whole-detail rebuild per notification.
void _selectionChanged() {
final selected = controller.selectedRunId;
if (selected == _shownRunId) return;
_shownRunId = selected;
if (mounted) setState(() {});
}
void _pipelineFilterChanged() {
final id = controller.pipelineId;
if (_applyingRoutePipeline) {
_reportedPipelineId = id;
return;
}
if (id == _reportedPipelineId) return;
_reportedPipelineId = id;
if (controller.selectedRunId == null) {
widget.onPipelineFilterChanged?.call(id);
}
}
/// Opens the route's decision prompt after the named detail has arrived.
/// A non-waiting run consumes the request without a prompt, and the prompt
/// itself only closes; the detail underneath is left as it is.
void _detailChanged() {
if (!widget.initialDecide || _decideConsumed) return;
final run = controller.detail;
final selected = controller.selectedRunId;
if (run == null || selected == null || run['id'] != selected) return;
_decideConsumed = true;
if (pendingDecision(run) == null) return;
WidgetsBinding.instance.addPostFrameCallback((_) {
if (!mounted || controller.selectedRunId != selected) return;
final current = controller.detail;
if (current == null || pendingDecision(current) == null) return;
unawaited(
showRunDecisionPrompt(
context: context,
run: current,
gateway: widget.gateway,
onRunChanged: controller.acceptRunDetail,
cupertino: usesCupertinoHost(context),
isCurrent: () => mounted && controller.selectedRunId == selected,
),
);
});
}
void _select(num id) {
controller.select(id);
widget.onRunSelected?.call(id.toInt());
}
void _back() {
controller.back();
widget.onBack?.call(controller.pipelineId);
}
@override
void dispose() {
controller.removeListener(_selectionChanged);
controller.removeListener(_pipelineFilterChanged);
controller.removeListener(_detailChanged);
_page.dispose();
controller.dispose();
super.dispose();
}
/// The shell's pending search selection, read in [build] so this screen
/// rebuilds (and refreshes an open detail page) whenever it changes.
RunSearchSelectionScope? _searchScope;
/// The run detail, under the shell's search selection.
///
/// On a narrow window the detail is its own page on the app's navigator, so
/// it is not a descendant of the shell's [RunSearchSelectionScope]; relaying
/// the scope keeps a field or artifact hit's selection reachable there too.
Widget _detail(VoidCallback onBack) {
final view = RunDetailView(
controller: controller,
gateway: widget.gateway,
onBack: onBack,
onRunOpened: _select,
onOpenPipeline: widget.onOpenPipeline,
initialStageKey: widget.initialStageKey,
initialVisit: widget.initialVisit,
);
final scope = _searchScope;
if (scope == null) return view;
return RunSearchSelectionScope(
selection: scope.selection,
onConsumed: scope.onConsumed,
child: view,
);
}
@override
Widget build(BuildContext context) {
_searchScope = RunSearchSelectionScope.maybeOf(context);
final selected = controller.selectedRunId != null;
// The same adaptive list/detail layout as Pipelines and Chat.
final narrow = !showsListBesideDetail(context);
_page.sync(
context,
selected: selected && narrow,
destination: AppDestination.runs,
onClosed: _back,
builder: (context) => _detail(() => Navigator.of(context).maybePop()),
);
final list = AnimatedBuilder(
animation: controller,
builder: (context, _) => ContentWidth(
child: RunsList(
active: narrow ? !selected : true,
controller: controller,
onSelected: _select,
syncToken: widget.syncToken,
attentionStore: widget.attentionStore,
attentionNow: widget.attentionNow,
notifications: widget.notifications,
attention: widget.attention,
),
),
);
if (narrow) return list;
return ListDetailPanes(
list: list,
detailIdentity: controller.selectedRunId,
detail: selected
? DetailPane(
key: const ValueKey('run-detail-pane'),
destination: AppDestination.runs,
implyBack: false,
builder: (_) => _detail(_back),
)
: const EmptyDetailPane(
destination: AppDestination.runs,
message: 'Select a run to open it here.',
),
);
}
}