diff --git a/app/PARITY.md b/app/PARITY.md new file mode 100644 index 00000000..a9e3a727 --- /dev/null +++ b/app/PARITY.md @@ -0,0 +1,75 @@ +# Flutter port acceptance + +Target: current `web/src/` behavior and latest entries in `web/PARITY.md`, NOT +web CSS. Native Material/Cupertino controls, typography, semantic colours and +content-driven sizing take precedence over visual-review styling suggestions. +`WORK.md` is the run/commit queue; this file tracks what remains for a full port. + +## Evidence vocabulary + +- **Preview**: registered in the normal app and published to8096, with fixture + browser interaction/captures. This does NOT imply live production mutations. +- **Source**: landed/tested reusable code, not a delivered screen. +- **Active**: assigned implementation, not accepted or deployed. +- **Missing**: still required; no implied fallback or scope waiver. + +Live authenticated data, OS sharing/notifications and Android/iOS device behavior +remain unverified unless explicitly recorded. Test mutations use isolated fakes +or scratch servers only, never real operator sessions/runs/workflows. + +## Functional inventory + +| Area | Current state | Remaining acceptance | +| --- | --- | --- | +| Shared transport/settings connection | Preview | foreground recovery, persisted endpoint boot, protocol warning, complete refresh semantics | +| Native shell/run URLs | Preview | pipeline/version/stage/template/chat URLs, action/visit queries and native deep-link handling | +| Pipeline list/filter/sort/detail/source/versions | Preview | latest summary metadata/miniatures, pinned detail URLs | +| Definition graph | Source nodes/layout/routes/edges; active canvas71 | compose measured native nodes+labels, graph tab, pan/zoom, expanded view, definition stage pane | +| Start a pipeline | Missing | native prompt/workspace/notify dialog, exact pinned run request, response-loss intent | +| Templates | Source repository; active create dialog73 | gallery/detail/source, Settings entry, validate/create-only dialog integration and refresh | +| Runs list/filter/sort/live fold | Preview | full time/status/provenance filters, recency/day groups, shell live/attention state | +| Run detail/input/output/copy/metrics | Preview | latest summary tabs/fields and exact empty/unknown states | +| Rename run | Preview | verified exact accepted title fold; no live production mutation tested | +| Cancel run | Preview | exact confirm/server-accepted detail+list fold; production cancellation not tested | +| Retry/restart | Source actions/dialogs | actual detail controls, accepted new-run navigation, stale/refusal handling | +| Human decisions | Preview waiting card/native prompt/exact accepted reply | attention/action URL entry; no production decision answered during tests | +| Run graph | Source projection/visits | executed/unvisited routes, live activity, graph clicks open latest RECORDED visit, no definition by default | +| Timeline/recorded visit pane | Preview text rows only | visit selection, status/outcome/duration/model/target/verdict, artifacts/session/input/output/definition tabs | +| Changes/diffs | Source; active detail wiring67 | settled-run aggregate gate, per-visit capture, paging/raw/rendered/copy and keyboard/back routes | +| Artifact groups | Source model/list | actual visit/run gallery integration and truthful unavailable capture facts | +| Artifact preview | Missing | image-primary in-app viewer, video/doc/text/markdown, paging, focus/back, authenticated fetch errors | +| Artifact actions | Source safe URL resolution | separate external-open/copy/download; SHARE REAL NAMED MIME FILES, not links; slow activation/cancel/errors | +| Session audit/export repair facts | Missing UI | session.html read-only open, partial/missing/skipped/repair choices without fabricating complete evidence | +| Chat session management | Source | normal Chat destination, directory groups/history/search, shared rename/star/close/reopen/create, local hide/undo/seen state | +| Chat history/live transport | Source controller72 + pure fold | integrate authoritative reconnect/paging/live-failure status and stable session navigation | +| Chat message surfaces | Active native body70 | integrate thread, markdown (safe links/headings/lists/tables/fences), exact attachments and unknown-part retention | +| Chat activity/reasoning/tools | Source raw fields only | one activity line, compaction, native reasoning/tools overlays, lifecycle/input/output/error/duration/edit diff | +| Chat composer | Missing | per-chat persisted drafts, Enter newline/Ctrl-Cmd+Enter send, Send beside Stop, optimistic identity, queued/refused restore | +| Chat attachments | Source request facade | picker/paste, latest1MiB total wire bound, base64 files, removable named chips, exact history reconciliation | +| Chat permissions/questions | Source request facade | native approval/risk cards and form option/free-text answers; pending/resolved/stale/error states | +| Chat model/Info/background tasks | Source request facade | current-model selection, numeric Info modal (unknown !=0), bounded running shell pages | +| Chat commands/notices/scroll | Missing | slash palette/actions, unknown-command send-as-message, dismissible local notices, saved scroll/follow intent | +| Saved schedule list | Source | pipeline entry and route registration, exact timer provenance vocabulary | +| Schedule editor | Source lossless draft74 + identity/CAS guard | native fields, stable create key, edit/pause/delete, conflict keeps draft, Schedule this run seed | +| Search | Source screen | shell entry, close/focus/selection retention, exact pipeline/version/run/field/visit/artifact target routing | +| Needs you | Missing | derived failed/waiting counts, native list/sheet, open/dismiss/clear snapshot, persisted identities | +| Notifications | Missing | explicit permission/rationale, secure/unsupported/denied states, transition-only dedupe, background question notices | +| Mobile replacement build | Scaffold only | Android build at end; all source portable to iOS, isolated IDs; device/OS behavior clearly separate | + +## Current-reference corrections + +Latest behavior supersedes older parity rows: Enter inserts a newline and +Ctrl/Cmd+Enter sends; chat rename/star are server-shared; chat usage is behind +Info; graph clicks open recorded visits; image artifacts preview internally; +artifact Share carries bytes as a named file, never a URL; attachments use the +latest bounded attachment envelope. Native layout differences are intentional; +missing behavior is not a native-layout difference. + +## Completion gate + +Every row must have actual normal-app registration, request/state regression +coverage, and real-browser evidence for visible/interactive states. Recheck +integrated analysis/tests/build and publish the verified preview. Produce the +requested Android testing build only after development acceptance; do not use +the personal delivery device for tests. Distinguish code, landing, publication, +authenticated smoke, native build and device/OS verification in the final report. diff --git a/app/WORK.md b/app/WORK.md index daaff8af..f443d516 100644 --- a/app/WORK.md +++ b/app/WORK.md @@ -18,7 +18,7 @@ All work under app/. Existing applications remain running and unchanged. | R1 | Run list/detail/live timeline | controller43 + list48 + detail46 +35a8aab | manager checked retained candidate and real browser captures | merged main; ancestry verified | built into8096 preview | | D1 | Recorded changes/diff viewer | run39 /15cca17 + manager32e1cac | manager rejected bundled font/fixed palette; corrected to host typography/native semantic colors,47 tests + fresh18 browser captures pass | merged main; ancestry verified | run-detail wiring pending | | R2a | Human-decision native confirm | run47 / commit42b21b8 | manager inspected source + reran 7 exact-confirm/refusal/native tests + analyze, pass | main3e6f950, ancestry verified | reusable component only; wiring/browser pending | -| R2b | Native cancel-run confirmation | run51 →52 / correction5449370 | manager reran23 action tests + analyze, pass; known refusal now immediate and dismissible while resync pending | merged main; ancestry verified | reusable component only; wiring/browser pending | +| R2b | Native cancel-run confirmation | run51 →52 + managere20ac9f | actual detail wiring, accepted lifecycle/list fold;601 integrated tests +23 normal-app browser captures pass | merged main | published8096; no production cancellation tested | | X1 | Native search and result targets | run49 / commit51140cd | manager reran36 tests, checked native browser evidence + source; all pass | merged main, ancestry verified | standalone screen; shell wiring pending | | I1 | App-owned socket/session + live Runs shell registration | run50 timeout → manager finish /35a8aab |68 focused tests; integrated375 tests; clean analyze/build; normal-entry browser probe passed18 captures incl deep links/history/reconnect | merged main; ancestry verified |8096 bundle rebuilt, auth preserved; live authenticated smoke not verified | | E1 | Narrow authorized server export-bound fix | run53 / source22801a9 / deployb4627e2 | bounded regressions + full isolated Go suite pass; exact installed revision verified | source merged; deployed minimal patch on original server revision | installed; seven exact exports complete, Review resumed | @@ -36,7 +36,12 @@ All work under app/. Existing applications remain running and unchanged. | A1-list | One read-only artifact visit-group list | run65 /596365d9 | manager inspected231-line source + dark Cupertino PNG;11 focused tests pass;59min MISSED20min target | merged main; ancestry verified | run-detail wiring/preview pending | | D1-wire | Open existing ChangesViewer from run detail | run67 /flutter/d1-wire | Task v6 Flash; one native button/recorded-steps route, no viewer rewrite | running | pending | | R2-title-wire | Existing Rename action into detail/controller | run68 /3d3ee3a3 |19min total MET target; manager reviewed source/server-reply fold, focused tests + normal-app browser7 captures pass | merged main; ancestry verified | published8096 with Runs/Settings | -| P1-wire | Register pipeline browser in actual app shell | run69 /flutter/p1-wire | small shared-session/embedded/native-host/reconnect integration only, no graph renderer | running | pending | +| P1-wire | Register pipeline browser in actual app shell | run69 /8476cfd7 | manager reviewed, focused tests;599 integrated tests + actual app browser25 checks/9 PNGs pass;27min missed20min target | merged main; ancestry verified | published8096 | +| C2-message | Native chat message body | run70 /flutter/chat-messages | pure native text/unknown-part disclosure, no network; focused tests/captures required | running | component first | +| P2-canvas | Measured definition graph composition | run71 /flutter/graph-canvas | existing node/layout/routes/edge layer, actual measurements, no invented visits | running | graph hook next | +| C2-thread | Chat paging/live controller | run72 /flutter/chat-thread | existing repository/fold, opaque cursors and reconnect; no UI/network ownership changes | running | conversation integration next | +| T1-create | Native template create-only dialog | run73 /flutter/template-create | validate before submit, no production authoring; no gallery scope | running | gallery integration next | +| S1-draft | Lossless schedule editor draft | run74 /flutter/schedule-draft | pure validation/CAS-preserving copy; no CRUD/timer engine | running | editor next | ## Next ready work ### Current execution target (user correction) @@ -85,6 +90,28 @@ override, server edit or shell-write bypass was used by the manager. Allowed pipeline models: Luna or DeepSeek V4.1 Flash; current runs use Luna. ## Latest integration check +The user directs continued work until the whole client is ported, not just +components. app/PARITY.md now enumerates the entire remaining behavior inventory +against latest web behavior, distinguishing preview/source/active/missing. + +Pipeline browser69 landed and was tested against the normal app build in real +Chrome:25 checks/9 PNGs, actual dark Cupertino detail inspected; existing Runs/ +Settings regression20 captures pass. Published without service restart; previous +bundle kept at build/web-before-pipelines-1792609054. + +Then manager wired existing CancelRunAction alongside Rename. New native-screen +tests failed before wiring and pass after; accepted server state updates list +lifecycle too, not just title, invalidating stale detail requests. Full suite601 +tests pass; clean analysis/build. Extended normal-app CDP probe23 captures verifies +Cupertino confirm/Keep sends nothing, Material confirm sends exactly one run_id4 +to its isolated fixture, and accepted canceled detail/list. Both new native +captures inspected; no real run canceled. Preview includes this verified bundle +(e20ac9f), rollback build/web-before-cancel-1792609492, JS SHA256 +60391291f5086fbef409399ee0660801c887e5891d37b35f02519dc56af9205b; +authentication401 preserved. No shared service restarted. Five independent +micro-slices70–74 started in parallel with individual background waits;67 Changes +wiring continues independently. No workflow authored or modified. + Integrated main592 tests pass; analyze and normal web build clean. P1 candidate correction removed491 lines of custom measured control code/test expectations: all widths keep actual native segmented controls, scaled labels scroll whole and diff --git a/app/lib/application/connection_status.dart b/app/lib/application/connection_status.dart new file mode 100644 index 00000000..bbe57b46 --- /dev/null +++ b/app/lib/application/connection_status.dart @@ -0,0 +1,195 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../core/transport/connection_state.dart'; +import 'app_session.dart'; +import 'server_endpoint.dart'; + +/// The full connection screen shown before a destination has ever loaded. +/// +/// A missing native endpoint is a configuration state, not a server failure, +/// so it is explained without opening a socket. Otherwise the screen reports +/// connecting, then an honest unavailable state with a native Retry action. +class ConnectionGate extends StatelessWidget { + const ConnectionGate({ + super.key, + required this.session, + required this.server, + required this.cupertino, + }); + + final AppSession session; + final ServerEndpoint server; + final bool cupertino; + + @override + Widget build(BuildContext context) { + final state = session.connection; + if (server.requiresConfiguration) { + return _status( + context, + title: 'Server endpoint not configured', + detail: + 'Build the native app with an explicit Pipelines endpoint, for ' + 'example --dart-define=PIPELINES_SERVER_URL=ws://host:port/connect.', + ); + } + if (server.error != null) { + return _status(context, title: server.error!, detail: ''); + } + // Only the very first attempt is "connecting". A failed attempt keeps the + // same honest unavailable state while the client retries behind it, so the + // screen no longer flickers between unavailable and connecting. + if (state.kind == ConnectionKind.connecting && state.attempt <= 1) { + return _status( + context, + title: 'Connecting to Pipelines…', + detail: '', + progress: true, + ); + } + return _status( + context, + title: 'Pipelines server unavailable', + detail: state.retrying + ? 'Retrying automatically. Check that the Pipelines server is running.' + : 'Check that the Pipelines server is running, then try again.', + onRetry: session.retry, + ); + } + + Widget _status( + BuildContext context, { + required String title, + required String detail, + bool progress = false, + VoidCallback? onRetry, + }) { + final theme = Theme.of(context); + return Center( + child: SingleChildScrollView( + padding: const EdgeInsets.all(24), + child: Column( + mainAxisSize: MainAxisSize.min, + children: [ + if (progress) + Padding( + padding: const EdgeInsets.only(bottom: 12), + child: cupertino + ? const CupertinoActivityIndicator() + : const CircularProgressIndicator(), + ), + Semantics( + liveRegion: true, + child: Text( + title, + textAlign: TextAlign.center, + style: cupertino + ? CupertinoTheme.of(context).textTheme.navTitleTextStyle + : theme.textTheme.titleMedium, + ), + ), + if (detail.isNotEmpty) ...[ + const SizedBox(height: 8), + Text( + detail, + textAlign: TextAlign.center, + style: cupertino ? null : theme.textTheme.bodyMedium, + ), + ], + if (onRetry != null) ...[ + const SizedBox(height: 16), + if (cupertino) + CupertinoButton(onPressed: onRetry, child: const Text('Retry')) + else + FilledButton(onPressed: onRetry, child: const Text('Retry')), + ], + ], + ), + ), + ); + } +} + +/// A compact status bar above retained content after the first connection. +class ConnectionBanner extends StatelessWidget { + const ConnectionBanner({ + super.key, + required this.session, + required this.cupertino, + }); + + final AppSession session; + final bool cupertino; + + @override + Widget build(BuildContext context) { + final state = session.connection; + final refused = session.subscription == RunSubscriptionState.refused; + final reconnecting = + !session.connected && + (state.kind == ConnectionKind.connecting || state.retrying); + final String title; + final String detail; + final VoidCallback onRetry; + if (session.connected && refused) { + title = 'Not live — run updates are unavailable.'; + detail = session.subscriptionError; + onRetry = session.resubscribe; + } else if (reconnecting) { + title = 'Reconnecting to Pipelines…'; + detail = ''; + onRetry = session.retry; + } else { + title = 'Not live — Pipelines server unavailable.'; + detail = 'Check that the Pipelines server is running.'; + onRetry = session.retry; + } + final textStyle = cupertino + ? CupertinoTheme.of(context).textTheme.textStyle + : Theme.of(context).textTheme.bodyMedium; + return ColoredBox( + color: cupertino + ? CupertinoDynamicColor.resolve(CupertinoColors.systemGrey5, context) + : Theme.of(context).colorScheme.surfaceContainerHighest, + child: Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), + child: Row( + children: [ + if (reconnecting) ...[ + cupertino + ? const CupertinoActivityIndicator(radius: 7) + : const SizedBox( + width: 14, + height: 14, + child: CircularProgressIndicator(strokeWidth: 2), + ), + const SizedBox(width: 10), + ], + Expanded( + child: Semantics( + liveRegion: true, + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(title, style: textStyle), + if (detail.isNotEmpty) Text(detail, style: textStyle), + ], + ), + ), + ), + const SizedBox(width: 8), + if (cupertino) + CupertinoButton( + padding: EdgeInsets.zero, + onPressed: onRetry, + child: const Text('Retry'), + ) + else + TextButton(onPressed: onRetry, child: const Text('Retry')), + ], + ), + ), + ); + } +} diff --git a/app/lib/application/pipelines_app.dart b/app/lib/application/pipelines_app.dart index f9c02e35..e5de270d 100644 --- a/app/lib/application/pipelines_app.dart +++ b/app/lib/application/pipelines_app.dart @@ -11,6 +11,7 @@ import 'app.dart'; import 'app_route.dart'; import 'app_router.dart'; import 'app_session.dart'; +import 'pipelines_destination.dart'; import 'runs_destination.dart'; import 'server_endpoint.dart'; @@ -100,6 +101,8 @@ class _PipelinesAppState extends State { onDestinationSelected: (destination) => _delegate.goTo(_routeOf(destination)), destinationBodies: { + AppDestination.pipelines: (_) => + PipelinesDestination(session: _session, server: widget.server), AppDestination.runs: (_) => RunsDestination( session: _session, server: widget.server, diff --git a/app/lib/application/pipelines_destination.dart b/app/lib/application/pipelines_destination.dart new file mode 100644 index 00000000..d9b3c603 --- /dev/null +++ b/app/lib/application/pipelines_destination.dart @@ -0,0 +1,61 @@ +import 'package:flutter/material.dart'; + +import '../features/pipelines/screen.dart'; +import '../ui/adaptive/host.dart'; +import 'app_session.dart'; +import 'connection_status.dart'; +import 'server_endpoint.dart'; + +/// The Pipelines destination: the read-only browser plus honest status. +/// +/// Before the shared socket accepts its first connection nothing is requested, +/// so an offline launch cannot look like an empty pipeline list. After that the +/// browser stays mounted through drops; a reconnect advances [syncToken] so the +/// list and the open detail refresh in place instead of losing the selection. +class PipelinesDestination extends StatelessWidget { + const PipelinesDestination({ + super.key, + required this.session, + required this.server, + }); + + final AppSession session; + final ServerEndpoint server; + + @override + Widget build(BuildContext context) => AnimatedBuilder( + animation: session, + builder: (context, _) { + final cupertino = usesCupertinoHost(context); + if ((server.requiresConfiguration || server.error != null) && + session.endpoint == null) { + return ConnectionGate( + session: session, + server: server, + cupertino: cupertino, + ); + } + if (!session.everConnected) { + if (session.connected) return _pipelinesScreen(); + return ConnectionGate( + session: session, + server: server, + cupertino: cupertino, + ); + } + return Column( + children: [ + if (!session.connected) + ConnectionBanner(session: session, cupertino: cupertino), + Expanded(child: _pipelinesScreen()), + ], + ); + }, + ); + + Widget _pipelinesScreen() => PipelinesScreen( + gateway: session.gateway, + embedded: true, + syncToken: session.connectionEpoch, + ); +} diff --git a/app/lib/application/runs_destination.dart b/app/lib/application/runs_destination.dart index ca4e5481..67f01461 100644 --- a/app/lib/application/runs_destination.dart +++ b/app/lib/application/runs_destination.dart @@ -1,10 +1,9 @@ -import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; -import '../core/transport/connection_state.dart'; import '../features/runs/screen.dart'; import '../ui/adaptive/host.dart'; import 'app_session.dart'; +import 'connection_status.dart'; import 'server_endpoint.dart'; /// The Runs destination: the loaded screen plus an honest connection status. @@ -36,7 +35,7 @@ class RunsDestination extends StatelessWidget { final cupertino = usesCupertinoHost(context); if ((server.requiresConfiguration || server.error != null) && session.endpoint == null) { - return _ConnectionScreen( + return ConnectionGate( session: session, server: server, cupertino: cupertino, @@ -44,7 +43,7 @@ class RunsDestination extends StatelessWidget { } if (!session.everConnected) { if (session.connected) return _runsScreen(); - return _ConnectionScreen( + return ConnectionGate( session: session, server: server, cupertino: cupertino, @@ -54,7 +53,7 @@ class RunsDestination extends StatelessWidget { children: [ if (!session.connected || session.subscription == RunSubscriptionState.refused) - _ConnectionBanner(session: session, cupertino: cupertino), + ConnectionBanner(session: session, cupertino: cupertino), Expanded(child: _runsScreen()), ], ); @@ -69,182 +68,3 @@ class RunsDestination extends StatelessWidget { onBack: onBack, ); } - -class _ConnectionScreen extends StatelessWidget { - const _ConnectionScreen({ - required this.session, - required this.server, - required this.cupertino, - }); - - final AppSession session; - final ServerEndpoint server; - final bool cupertino; - - @override - Widget build(BuildContext context) { - final state = session.connection; - if (server.requiresConfiguration) { - return _status( - context, - title: 'Server endpoint not configured', - detail: - 'Build the native app with an explicit Pipelines endpoint, for ' - 'example --dart-define=PIPELINES_SERVER_URL=ws://host:port/connect.', - ); - } - if (server.error != null) { - return _status(context, title: server.error!, detail: ''); - } - // Only the very first attempt is "connecting". A failed attempt keeps the - // same honest unavailable state while the client retries behind it, so the - // screen no longer flickers between unavailable and connecting. - if (state.kind == ConnectionKind.connecting && state.attempt <= 1) { - return _status( - context, - title: 'Connecting to Pipelines…', - detail: '', - progress: true, - ); - } - return _status( - context, - title: 'Pipelines server unavailable', - detail: state.retrying - ? 'Retrying automatically. Check that the Pipelines server is running.' - : 'Check that the Pipelines server is running, then try again.', - onRetry: session.retry, - ); - } - - Widget _status( - BuildContext context, { - required String title, - required String detail, - bool progress = false, - VoidCallback? onRetry, - }) { - final theme = Theme.of(context); - return Center( - child: SingleChildScrollView( - padding: const EdgeInsets.all(24), - child: Column( - mainAxisSize: MainAxisSize.min, - children: [ - if (progress) - Padding( - padding: const EdgeInsets.only(bottom: 12), - child: cupertino - ? const CupertinoActivityIndicator() - : const CircularProgressIndicator(), - ), - Semantics( - liveRegion: true, - child: Text( - title, - textAlign: TextAlign.center, - style: cupertino - ? CupertinoTheme.of(context).textTheme.navTitleTextStyle - : theme.textTheme.titleMedium, - ), - ), - if (detail.isNotEmpty) ...[ - const SizedBox(height: 8), - Text( - detail, - textAlign: TextAlign.center, - style: cupertino ? null : theme.textTheme.bodyMedium, - ), - ], - if (onRetry != null) ...[ - const SizedBox(height: 16), - if (cupertino) - CupertinoButton(onPressed: onRetry, child: const Text('Retry')) - else - FilledButton(onPressed: onRetry, child: const Text('Retry')), - ], - ], - ), - ), - ); - } -} - -/// A compact status bar above the retained Runs screen. -class _ConnectionBanner extends StatelessWidget { - const _ConnectionBanner({required this.session, required this.cupertino}); - - final AppSession session; - final bool cupertino; - - @override - Widget build(BuildContext context) { - final state = session.connection; - final refused = session.subscription == RunSubscriptionState.refused; - final reconnecting = - !session.connected && - (state.kind == ConnectionKind.connecting || state.retrying); - final String title; - final String detail; - final VoidCallback onRetry; - if (session.connected && refused) { - title = 'Not live — run updates are unavailable.'; - detail = session.subscriptionError; - onRetry = session.resubscribe; - } else if (reconnecting) { - title = 'Reconnecting to Pipelines…'; - detail = ''; - onRetry = session.retry; - } else { - title = 'Not live — Pipelines server unavailable.'; - detail = 'Check that the Pipelines server is running.'; - onRetry = session.retry; - } - final textStyle = cupertino - ? CupertinoTheme.of(context).textTheme.textStyle - : Theme.of(context).textTheme.bodyMedium; - return ColoredBox( - color: cupertino - ? CupertinoDynamicColor.resolve(CupertinoColors.systemGrey5, context) - : Theme.of(context).colorScheme.surfaceContainerHighest, - child: Padding( - padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8), - child: Row( - children: [ - if (reconnecting) ...[ - cupertino - ? const CupertinoActivityIndicator(radius: 7) - : const SizedBox( - width: 14, - height: 14, - child: CircularProgressIndicator(strokeWidth: 2), - ), - const SizedBox(width: 10), - ], - Expanded( - child: Semantics( - liveRegion: true, - child: Column( - crossAxisAlignment: CrossAxisAlignment.start, - children: [ - Text(title, style: textStyle), - if (detail.isNotEmpty) Text(detail, style: textStyle), - ], - ), - ), - ), - const SizedBox(width: 8), - if (cupertino) - CupertinoButton( - padding: EdgeInsets.zero, - onPressed: onRetry, - child: const Text('Retry'), - ) - else - TextButton(onPressed: onRetry, child: const Text('Retry')), - ], - ), - ), - ); - } -} diff --git a/app/lib/features/chat/conversation/chat_thread_controller.dart b/app/lib/features/chat/conversation/chat_thread_controller.dart new file mode 100644 index 00000000..d5c5b9a1 --- /dev/null +++ b/app/lib/features/chat/conversation/chat_thread_controller.dart @@ -0,0 +1,236 @@ +import 'dart:async'; + +import 'package:flutter/foundation.dart'; + +import '../../../core/api_gateway.dart'; +import '../data/chat_repository.dart'; +import '../domain/chat_transcript.dart'; + +/// One open conversation's transcript and live turn state. +/// +/// The controller attaches to exactly one session: it subscribes that session +/// with `chat_subscribe`, then reads the newest history page. Pushed frames for +/// any other session are ignored, a superseded or disposed read never lands, and +/// a reconnect/resync replaces the held turn with the newest authoritative page +/// instead of merging stale state. The server detaches subscriptions when the +/// socket closes, so disposal only cancels the local stream (there is no +/// `chat_unsubscribe`). +class ChatThreadController extends ChangeNotifier { + ChatThreadController(this.gateway, this.sessionId) { + _subscription = gateway.frames.listen(_onFrame); + } + + final ApiGateway gateway; + final String sessionId; + late final ChatRepository _repository = ChatRepository(gateway); + StreamSubscription? _subscription; + + List _messages = const []; + bool _running = false; + bool _loaded = false; + bool _loading = false; + bool _hasMore = false; + String _cursor = ''; + String _nativeTurnId = ''; + String? _error; + + bool _subscribed = false; + String? _subscriptionError; + bool _disposed = false; + int _generation = 0; + bool _resyncing = false; + bool _resyncAgain = false; + + List get messages => _messages; + bool get running => _running; + bool get loaded => _loaded; + bool get loading => _loading; + bool get hasMore => _hasMore; + + /// The server's opaque older-page cursor. Never interpreted, only passed back. + String get cursor => _cursor; + String? get error => _error; + bool get subscribed => _subscribed; + String? get subscriptionError => _subscriptionError; + + /// Subscribes this session, then loads its newest history page. + Future load() async { + if (_disposed) return; + final token = ++_generation; + _loading = true; + _error = null; + _notify(); + await _attach(); + if (!_owned(token)) return; + await _readNewest(token, replaceHeldTurn: false); + } + + /// Reads the next older page. Only offered while the server says `has_more`; + /// the cursor is the server's own `next_cursor`, passed back verbatim. + Future loadOlder() async { + if (_disposed || _loading || !_hasMore) return; + final token = ++_generation; + _loading = true; + _error = null; + _notify(); + try { + final page = await _repository.history( + sessionId, + cursor: _cursor, + limit: 200, + ); + if (!_owned(token)) return; + final merged = mergeChatHistory( + {'messages': _messages}, + page, + older: true, + ); + _applyPage(merged); + } catch (error) { + if (!_owned(token)) return; + _loading = false; + _error = '$error'; + } + _notify(); + } + + /// The reconnect/resync repair: settle the held turn, re-attach the session, + /// then replace the conversation with the newest authoritative page. Activity + /// replayed while re-attaching (a running step) is fresh native state + /// and survives the replacement. A resync frame also lands here. + Future resync() async { + if (_disposed) return; + if (_resyncing) { + _resyncAgain = true; + return; + } + _resyncing = true; + do { + _resyncAgain = false; + await _resyncOnce(); + } while (_resyncAgain && !_disposed); + _resyncing = false; + } + + Future _resyncOnce() async { + final token = ++_generation; + _loading = true; + // A socket drop removed the frames feeding the turn, so no held turn may + // keep claiming to run until the re-subscribe proves otherwise. + _running = false; + _nativeTurnId = ''; + _notify(); + await _attach(force: true); + if (!_owned(token)) return; + await _readNewest(token, replaceHeldTurn: true); + } + + Future _readNewest(int token, {required bool replaceHeldTurn}) async { + try { + final page = await _repository.history(sessionId, limit: 200); + if (!_owned(token)) return; + if (replaceHeldTurn) { + _messages = (page['messages'] as List? ?? const []) + .whereType() + .map((message) => Map.from(message)) + .toList(); + _cursor = '${page['nextCursor'] ?? ''}'; + _hasMore = page['hasMore'] == true; + } else { + // A live frame may have arrived while the page was loading; merge it + // over the held transcript instead of replacing it. + _applyPage(mergeChatHistory({'messages': _messages}, page)); + } + _loaded = true; + _loading = false; + _error = null; + } catch (error) { + if (!_owned(token)) return; + // A refused read is not an empty successful history: the reason stays + // visible and the held transcript is kept. + _loaded = true; + _loading = false; + _error = '$error'; + } + _notify(); + } + + /// Attaches the session stream once per connection. A refusal leaves history + /// usable (the live stream is simply not attached) and is retried on resync. + Future _attach({bool force = false}) async { + if (_disposed || (_subscribed && !force)) return; + try { + await _repository.subscribe(sessionId); + if (_disposed) return; + _subscribed = true; + _subscriptionError = null; + } catch (error) { + // History stays usable, but the UI must report that live updates failed. + if (_disposed) return; + _subscribed = false; + _subscriptionError = '$error'; + } + } + + void _onFrame(JsonMap envelope) { + if (_disposed) return; + final body = _eventBody(envelope); + if (body == null || body['session_id'] != sessionId) return; + if (body['kind'] == 'resync') { + unawaited(resync()); + return; + } + final current = _thread; + final next = applyChatEvent(current, body); + if (identical(next, current)) return; + _messages = (next['messages'] as List? ?? const []) + .whereType() + .map((message) => Map.from(message)) + .toList(); + _running = next['running'] == true; + _nativeTurnId = '${next['nativeTurnId'] ?? ''}'; + _notify(); + } + + /// The pushed envelope body, or null for another message type. The server + /// wraps `chat_event` in the typed envelope; domain code never sees the + /// transport fields. + JsonMap? _eventBody(JsonMap envelope) { + if (envelope['type'] != 'chat_event') return null; + final body = envelope['chat_event']; + if (body is! Map) return null; + return Map.from(body); + } + + JsonMap get _thread => { + 'sessionId': sessionId, + 'messages': _messages, + 'running': _running, + 'nativeTurnId': _nativeTurnId, + }; + + void _applyPage(JsonMap page) { + _messages = (page['messages'] as List? ?? const []) + .whereType() + .map((message) => Map.from(message)) + .toList(); + _cursor = '${page['nextCursor'] ?? ''}'; + _hasMore = page['hasMore'] == true; + _loaded = true; + _loading = false; + } + + bool _owned(int token) => !_disposed && token == _generation; + + void _notify() { + if (!_disposed) notifyListeners(); + } + + @override + void dispose() { + _disposed = true; + _generation++; + unawaited(_subscription?.cancel()); + super.dispose(); + } +} diff --git a/app/lib/features/pipelines/screen.dart b/app/lib/features/pipelines/screen.dart index ae6dc3f5..94807ad8 100644 --- a/app/lib/features/pipelines/screen.dart +++ b/app/lib/features/pipelines/screen.dart @@ -21,18 +21,31 @@ const double kPipelinesWideBreakpoint = 720; /// /// [graphBuilder] is the optional integration hook for the later graph item. /// Without it the Graph tab states that graph rendering is pending. +/// +/// Standalone use keeps the screen's own native scaffolding. The application +/// shell sets [embedded] because it already owns the one navigation bar, and +/// supplies [syncToken] so a reconnect refreshes in place. class PipelinesScreen extends StatefulWidget { const PipelinesScreen({ super.key, required this.gateway, this.graphBuilder, this.onStageSelected, + this.embedded = false, + this.syncToken = 0, }); final ApiGateway gateway; final PipelineGraphBuilder? graphBuilder; final ValueChanged? onStageSelected; + /// True under the application shell, which owns the single navigation bar. + final bool embedded; + + /// Advances when the shared socket is replaced. The mounted controller + /// reloads the list and the selected detail without losing the selection. + final int syncToken; + @override State createState() => _PipelinesScreenState(); } @@ -54,6 +67,10 @@ class _PipelinesScreenState extends State { _controller.dispose(); _controller = PipelinesController(PipelinesRepository(widget.gateway)) ..load(); + } else if (oldWidget.syncToken != widget.syncToken) { + // The socket was replaced; re-read through the existing controller so the + // selected pipeline and requested version survive the reconnect. + _controller.load(); } } @@ -102,6 +119,7 @@ class _PipelinesScreenState extends State { ); }, ); + if (widget.embedded) return _embeddedBody(context, body); return useCupertinoControls(context) ? _cupertinoShell(context, body) : _materialShell(context, body); @@ -109,6 +127,43 @@ class _PipelinesScreenState extends State { ); } + /// The shell owns the navigation bar here, so the content keeps a native + /// Refresh action without adding a second bar. + Widget _embeddedBody(BuildContext context, Widget body) { + return Column( + crossAxisAlignment: CrossAxisAlignment.stretch, + children: [ + Align( + alignment: AlignmentDirectional.centerEnd, + child: Padding( + padding: const EdgeInsets.symmetric(horizontal: 8), + child: _refreshButton(context), + ), + ), + Expanded(child: body), + ], + ); + } + + Widget _refreshButton(BuildContext context) { + if (useCupertinoControls(context)) { + return Semantics( + button: true, + label: 'Refresh', + child: CupertinoButton( + padding: EdgeInsets.zero, + onPressed: _controller.load, + child: const Icon(CupertinoIcons.refresh), + ), + ); + } + return IconButton( + tooltip: 'Refresh', + onPressed: _controller.load, + icon: const Icon(Icons.refresh), + ); + } + Widget _divider(BuildContext context) { if (useCupertinoControls(context)) { return Container( @@ -123,13 +178,7 @@ class _PipelinesScreenState extends State { return Scaffold( appBar: AppBar( title: const Text('Pipelines'), - actions: [ - IconButton( - tooltip: 'Refresh', - onPressed: _controller.load, - icon: const Icon(Icons.refresh), - ), - ], + actions: [_refreshButton(context)], ), body: SafeArea(child: body), ); @@ -139,15 +188,7 @@ class _PipelinesScreenState extends State { return CupertinoPageScaffold( navigationBar: CupertinoNavigationBar( middle: const Text('Pipelines'), - trailing: Semantics( - button: true, - label: 'Refresh', - child: CupertinoButton( - padding: EdgeInsets.zero, - onPressed: _controller.load, - child: const Icon(CupertinoIcons.refresh), - ), - ), + trailing: _refreshButton(context), ), child: SafeArea(top: false, child: body), ); diff --git a/app/lib/features/runs/ui/run_decision_notice.dart b/app/lib/features/runs/ui/run_decision_notice.dart new file mode 100644 index 00000000..cbd474f2 --- /dev/null +++ b/app/lib/features/runs/ui/run_decision_notice.dart @@ -0,0 +1,54 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../../../core/api_gateway.dart'; +import '../../../ui/adaptive/host.dart'; +import '../actions/decision_action.dart'; +import '../actions/decision_wording.dart'; +import '../domain/run_decisions.dart'; + +/// A recorded human checkpoint, never an audit-export/resource wait. +class RunDecisionNotice extends StatelessWidget { + const RunDecisionNotice({ + super.key, + required this.run, + required this.gateway, + required this.onRunChanged, + }); + final JsonMap run; + final ApiGateway gateway; + final ValueChanged onRunChanged; + + @override + Widget build(BuildContext context) { + final pending = pendingDecision(run); + if (pending == null) return const SizedBox.shrink(); + final content = Padding( + padding: const EdgeInsets.all(16), + child: Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Semantics(header: true, child: const Text(decisionWaitingTitle)), + Text(decisionMeta(pending)), + HumanDecisionAction( + run: run, + gateway: gateway, + onRunChanged: onRunChanged, + ), + ], + ), + ); + if (usesCupertinoHost(context)) { + return CupertinoListSection.insetGrouped( + children: [ + DefaultTextStyle( + style: CupertinoTheme.of(context).textTheme.textStyle, + child: content, + ), + ], + ); + } + return Card(child: content); + } +} diff --git a/app/lib/features/runs/ui/run_detail_actions.dart b/app/lib/features/runs/ui/run_detail_actions.dart new file mode 100644 index 00000000..699f734c --- /dev/null +++ b/app/lib/features/runs/ui/run_detail_actions.dart @@ -0,0 +1,44 @@ +import 'package:flutter/widgets.dart'; + +import '../../../core/api_gateway.dart'; +import '../actions/cancel_run_action.dart'; +import '../actions/title_action.dart'; +import 'run_decision_notice.dart'; + +/// Native actions on the loaded run, all using the app's one gateway and +/// applying only accepted server detail through the same controller callback. +class RunDetailActions extends StatelessWidget { + const RunDetailActions({ + super.key, + required this.run, + required this.gateway, + required this.onRunChanged, + }); + + final JsonMap run; + final ApiGateway gateway; + final ValueChanged onRunChanged; + + @override + Widget build(BuildContext context) => Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Wrap( + children: [ + RunTitleAction( + run: run, + gateway: gateway, + onRunChanged: onRunChanged, + ), + CancelRunAction( + run: run, + gateway: gateway, + onRunChanged: onRunChanged, + ), + ], + ), + RunDecisionNotice(run: run, gateway: gateway, onRunChanged: onRunChanged), + ], + ); +} diff --git a/app/lib/features/runs/ui/run_detail_cupertino.dart b/app/lib/features/runs/ui/run_detail_cupertino.dart index cf8388fd..12a48c8a 100644 --- a/app/lib/features/runs/ui/run_detail_cupertino.dart +++ b/app/lib/features/runs/ui/run_detail_cupertino.dart @@ -10,7 +10,7 @@ import 'run_detail_content.dart'; Widget buildCupertinoRunDetail({ required BuildContext context, required JsonMap run, - required Widget titleAction, + required Widget headerActions, required bool detailLoading, required String? error, required bool copying, @@ -65,7 +65,7 @@ Widget buildCupertinoRunDetail({ padding: const EdgeInsetsDirectional.fromSTEB(16, 8, 16, 0), child: Align( alignment: AlignmentDirectional.centerStart, - child: titleAction, + child: headerActions, ), ), if (detailLoading) const _CupertinoNotice('Refreshing run details…'), diff --git a/app/lib/features/runs/ui/run_detail_material.dart b/app/lib/features/runs/ui/run_detail_material.dart index 6ced0428..654a1561 100644 --- a/app/lib/features/runs/ui/run_detail_material.dart +++ b/app/lib/features/runs/ui/run_detail_material.dart @@ -8,7 +8,7 @@ import 'run_detail_content.dart'; Widget buildMaterialRunDetail({ required BuildContext context, required JsonMap run, - required Widget titleAction, + required Widget headerActions, required bool detailLoading, required String? error, required bool copying, @@ -42,7 +42,7 @@ Widget buildMaterialRunDetail({ Chip(label: Text(runStatusLabel(run))), Text('Run ${run['id']}'), Text('Pipeline ${detailPipeline(run)}'), - titleAction, + headerActions, ], ), if (detailLoading) const _Notice('Refreshing run details…'), diff --git a/app/lib/features/runs/ui/run_detail_view.dart b/app/lib/features/runs/ui/run_detail_view.dart index da808dc2..f6982913 100644 --- a/app/lib/features/runs/ui/run_detail_view.dart +++ b/app/lib/features/runs/ui/run_detail_view.dart @@ -4,7 +4,7 @@ import 'package:flutter/services.dart'; import '../../../core/api_gateway.dart'; import '../../../ui/adaptive/host.dart'; -import '../actions/title_action.dart'; +import 'run_detail_actions.dart'; import 'run_detail_content.dart'; import 'run_detail_cupertino.dart'; import 'run_detail_material.dart'; @@ -40,7 +40,7 @@ class _RunDetailViewState extends State { final run = widget.controller.detail; if (run == null) return _placeholder(context, cupertino: cupertino); final prompt = detailPrompt(run); - final titleAction = RunTitleAction( + final headerActions = RunDetailActions( run: run, gateway: widget.gateway, onRunChanged: widget.controller.acceptRunDetail, @@ -49,7 +49,7 @@ class _RunDetailViewState extends State { ? buildCupertinoRunDetail( context: context, run: run, - titleAction: titleAction, + headerActions: headerActions, detailLoading: widget.controller.detailLoading, error: widget.controller.error, copying: _copying, @@ -60,7 +60,7 @@ class _RunDetailViewState extends State { : buildMaterialRunDetail( context: context, run: run, - titleAction: titleAction, + headerActions: headerActions, detailLoading: widget.controller.detailLoading, error: widget.controller.error, copying: _copying, diff --git a/app/lib/features/runs/ui/runs_controller.dart b/app/lib/features/runs/ui/runs_controller.dart index a01ecab5..72ed9b5d 100644 --- a/app/lib/features/runs/ui/runs_controller.dart +++ b/app/lib/features/runs/ui/runs_controller.dart @@ -114,12 +114,32 @@ class RunsController extends ChangeNotifier { if (id == null) return; var changed = false; if (detail?['id'] == id) { + ++_detailGeneration; + _cancelDetailRefresh(); detail = run; + detailLoading = false; + error = null; changed = true; } final index = runs.indexWhere((row) => row['id'] == id); if (index >= 0) { - runs = [...runs]..[index] = {...runs[index], 'title': run['title'] ?? ''}; + // A cancel/decision reply changes lifecycle fields as well as title. + // Keep sparse/unknown summary fields, without copying bulky detail-only + // payloads into the held list or inventing missing values. + const detailOnly = { + 'steps', + 'input', + 'output', + 'graph', + 'usage', + 'notifications', + }; + runs = [...runs] + ..[index] = { + ...runs[index], + for (final entry in run.entries) + if (!detailOnly.contains(entry.key)) entry.key: entry.value, + }; changed = true; } if (changed) notifyListeners(); diff --git a/app/lib/features/schedules/domain/editor/schedule_draft.dart b/app/lib/features/schedules/domain/editor/schedule_draft.dart new file mode 100644 index 00000000..a07edc97 --- /dev/null +++ b/app/lib/features/schedules/domain/editor/schedule_draft.dart @@ -0,0 +1,223 @@ +import '../../../../core/api_gateway.dart'; +import '../saved_schedule.dart'; +import '../schedule_rule.dart'; + +/// Which half of the timer rule the editor is writing. +enum ScheduleTimerMode { interval, clock } + +/// Either a ready-to-send `save_schedule` record or field errors keyed by the +/// draft field the control binds to. [record] is null when any field fails, so +/// an invalid draft can never be mistaken for a save payload. +class ScheduleSaveResult { + ScheduleSaveResult(this.record, this.errors); + + final JsonMap? record; + final Map errors; + + bool get isValid => record != null; +} + +/// Core editor state for one saved schedule, mirroring the web editor draft. +/// +/// Pure draft only: no network, timer calculation or timezone conversion. +/// [build] mirrors `serializeSchedule` in `web/src/schedules.js` for name, +/// prompt, pinned version, server workspace, timer rule, weekdays and +/// timezone. It starts from a deep copy of the server record, so unknown +/// record/input/rule/run-option fields and the exact revision survive an edit. +class ScheduleDraft { + ScheduleDraft._(this.source, this.pipelineId); + + /// The record this draft edits; null for a create. + final SavedSchedule? source; + final int? pipelineId; + + String name = ''; + String prompt = ''; + String version = ''; + String workspace = ''; + bool enabled = true; + ScheduleTimerMode mode = ScheduleTimerMode.interval; + String every = '24h'; + String times = ''; + List days = []; + String timezone = ''; + String notifyMode = 'auto'; + + /// New schedule: the server's create sentinel is `id: 0` with no revision. + factory ScheduleDraft.create({ + required int pipelineId, + String version = '', + String workspace = '', + String timezone = '', + }) => ScheduleDraft._(null, pipelineId) + ..version = version + ..workspace = workspace + ..timezone = timezone; + + /// Existing record: every field starts from the server value, never from a + /// default that could overwrite it. + factory ScheduleDraft.fromSchedule(SavedSchedule s, {int? pipelineId}) { + final rule = s.rule; + return ScheduleDraft._(s, s.pipelineId ?? pipelineId) + ..name = s.name + ..prompt = s.prompt + ..version = s.version?.toString() ?? '' + ..workspace = s.workspace + ..enabled = s.raw['enabled'] is bool ? s.enabled : true + ..mode = rule.isClock + ? ScheduleTimerMode.clock + : ScheduleTimerMode.interval + ..every = rule.raw['every'] is String ? rule.every : '24h' + ..times = rule.times.join(', ') + ..days = [...rule.days] + ..timezone = rule.timezone + ..notifyMode = s.raw['notify_mode'] is String ? s.notifyMode : 'auto'; + } + + /// Validates every field and assembles the exact `save_schedule` record. + /// The draft and the source snapshot are never mutated. + ScheduleSaveResult build() { + final errors = {}; + void fail(String field, String message) => + errors.putIfAbsent(field, () => message); + + final selectedPipeline = source?.pipelineId ?? pipelineId; + if (!_validIdentity(selectedPipeline)) { + fail('pipelineId', 'Choose a valid pipeline.'); + } + if (source != null && + (!_validIdentity(source!.id) || !_validIdentity(source!.revision))) { + fail( + 'record', + 'Schedule identity or revision is missing. Refresh before editing.', + ); + } + + if (name.trim().isEmpty) fail('name', 'Enter a schedule name.'); + if (prompt.trim().isEmpty) fail('prompt', 'Enter a prompt.'); + final pinned = int.tryParse(version); + if (!_digits.hasMatch(version) || + pinned == null || + pinned < 1 || + pinned > _maxSafeInteger) { + fail('version', 'Choose a positive pinned version, not latest (0).'); + } + if (!workspace.startsWith('/') || _workspaceBreaks.hasMatch(workspace)) { + fail('workspace', 'Enter an absolute workspace path on the server.'); + } + if (!const {'auto', 'on', 'off'}.contains(notifyMode)) { + fail('notifyMode', 'Choose a notification mode.'); + } + if (days.any((day) => !scheduleDays.contains(day)) || + days.toSet().length != days.length) { + fail('days', 'Choose valid, distinct weekdays.'); + } + List? clock; + if (mode == ScheduleTimerMode.interval) { + if (!_validDuration(every)) { + fail( + 'every', + 'Interval must be at least 1m (for example 24h or 1h30m).', + ); + } + } else { + clock = [for (final time in times.split(',')) time.trim()]; + if (clock.any((time) => !_timeOfDay.hasMatch(time)) || + clock.toSet().length != clock.length) { + fail('times', 'Enter distinct 24-hour times, such as 09:00, 17:30.'); + } + } + if (!_validTimezone(timezone.trim())) { + fail('timezone', 'Enter a valid IANA timezone.'); + } + if (errors.isNotEmpty) return ScheduleSaveResult(null, errors); + + final record = source?.toJson() ?? {}; + if (source == null) record['id'] = 0; + record['name'] = name.trim(); + record['pipeline_id'] = selectedPipeline; + record['version'] = pinned; + record['enabled'] = enabled; + record['input'] = (source?.input ?? {}) + ..['prompt'] = prompt; + // Untrimmed like `workspace: draft.workspace`; validation also runs on the + // untrimmed value, so a valid workspace is sent exactly as the operator + // entered it. + record['workspace'] = workspace; + + final rule = source?.rule.toJson() ?? {}; + for (final key in const ['every', 'times', 'days', 'timezone']) { + rule.remove(key); + } + if (mode == ScheduleTimerMode.interval) { + rule['every'] = every.trim(); + } else { + rule['times'] = clock; + } + if (days.isNotEmpty) { + final prior = source?.rule.days ?? const []; + final unchanged = + prior.length == days.length && prior.every(days.contains); + rule['days'] = unchanged ? [...prior] : [...days]; + } + if (timezone.trim().isNotEmpty) rule['timezone'] = timezone.trim(); + record['rule'] = rule; + record['notify_mode'] = notifyMode; + return ScheduleSaveResult(record, const {}); + } +} + +const _maxSafeInteger = 9007199254740991; +bool _validIdentity(int? value) => + value != null && value > 0 && value <= _maxSafeInteger; +final _digits = RegExp(r'^\d+$'); +final _timeOfDay = RegExp(r'^([01]\d|2[0-3]):[0-5]\d$'); +final _workspaceBreaks = RegExp(r'[\x00\r\n]'); +final _zonePart = RegExp(r'^[A-Za-z0-9_+\-]+$'); +const _durationPart = r'((?:\d+(?:\.\d*)?|\.\d+))(ms|us|µs|ns|h|m|s)'; +final _areas = + 'Africa America Antarctica Arctic Asia Atlantic Australia ' + 'Brazil Canada Chile Etc Europe Indian Mexico Pacific US' + .split(' '); +final _singleZones = + 'UTC GMT UCT Zulu Universal Greenwich CET EET EST HST ' + 'MST WET GB NZ PRC ROC ROK W-SU Egypt Eire Iceland Iran Israel Jamaica ' + 'Japan Kwajalein Libya Navajo Poland Portugal Singapore Turkey Cuba ' + 'Hongkong' + .split(' '); + +double? _unit(String unit) => switch (unit) { + 'h' => 3600000, + 'm' => 60000, + 's' => 1000, + 'ms' => 1, + 'us' || 'µs' => .001, + 'ns' => .000001, + _ => null, +}; + +/// Go-style compound duration, at least one minute, as the web client accepts. +bool _validDuration(String text) { + final every = text.trim(); + final parts = RegExp(_durationPart).allMatches(every).toList(); + final duration = parts.fold( + 0, + (sum, part) => sum + double.parse(part[1]!) * _unit(part[2]!)!, + ); + return parts.map((part) => part[0]!).join() == every && + duration.isFinite && + duration >= 60000; +} + +/// Structural IANA check. Dart carries no timezone database, so a known area +/// plus a well-formed location is the strongest pure check; the server stays +/// the final validator. +bool _validTimezone(String value) { + if (value.isEmpty || value == 'Local' || _singleZones.contains(value)) { + return true; + } + final parts = value.split('/'); + return parts.length > 1 && + _areas.contains(parts.first) && + parts.every(_zonePart.hasMatch); +} diff --git a/app/notes/C2-thread.md b/app/notes/C2-thread.md new file mode 100644 index 00000000..a5a48aba --- /dev/null +++ b/app/notes/C2-thread.md @@ -0,0 +1,44 @@ +# C2 — Chat thread controller + +Manager integration follow-up: exposes subscribed/subscriptionError separately +from history errors, so readable stored history cannot hide a refused live watch. +Resync marks history loading while retaining the current transcript. A focused +regression covers refused subscribe + successful history, then successful resync. +The controller does not claim to fold form events; those are a separate UI slice. + +`lib/features/chat/conversation/chat_thread_controller.dart` owns one open +conversation without any UI. It is constructed with the shared `ApiGateway` and +one `sessionId`, reuses `ChatRepository` for the wire and +`domain/chat_transcript.dart` for the fold, and exposes `messages`, `running`, +`loaded`, `loading`, `hasMore`, `cursor` and `error` through +`ChangeNotifier`. + +Behaviour: + +- `load()` calls `chat_subscribe` with the exact session body, then reads the + newest `chat_messages` page with `limit: 200` and an empty cursor. A refused + subscribe leaves history usable. +- `loadOlder()` is explicit only, requires `hasMore`, passes the server's opaque + `next_cursor` back verbatim, and prepends the older page by id. +- Only `chat_event` envelopes for this session are folded; replayed/live + text, reasoning, tool, step and user frames use the existing domain fold, so + unknown message and part fields survive. +- `resync()` settles the held turn, re-subscribes, then replaces the transcript, + cursor and `hasMore` with the newest authoritative page. Activity replayed + while re-attaching (for example a running step) survives the replacement. A + pushed `resync` event invokes the same path. +- History failures set `error` and keep the held transcript; they are never + reported as an empty success. Superseded reads and replies after disposal are + ignored. +- Disposal cancels only the local stream subscription. There is no + `chat_unsubscribe` request. + +Checks (run from `app/`): + +- `flutter test test/features/chat/conversation` — 10 tests passed. +- `flutter test test/features/chat` — 43 tests passed. +- `flutter analyze lib/features/chat test/features/chat` — no issues. + +Not done: the controller is not yet wired to a screen, so there is no rendered +or browser change to capture; mobile builds and device verification were not +performed. No shared domain, shell, main, pubspec or server files changed. diff --git a/app/notes/P1-wire.md b/app/notes/P1-wire.md new file mode 100644 index 00000000..1adaf349 --- /dev/null +++ b/app/notes/P1-wire.md @@ -0,0 +1,174 @@ +# P1 wire — Pipelines destination on the shared session + +## Implemented + +- `lib/application/pipelines_destination.dart` registers the landed + `PipelinesScreen` on the existing `/pipelines` route through `AppSession`. + It reuses the session's single socket and gateway; no second connection, + fake rows or hidden request path was added. +- Before the first accepted connection the destination mounts no screen and + sends no `list_pipelines`, `list_runs` or `get_pipeline`. The full gate says + `Connecting to Pipelines…` or `Pipelines server unavailable`, with an + explicit native `Retry` and the existing missing-endpoint explanation. +- After the first connection the screen stays mounted through drops. A + status banner reports `Reconnecting to Pipelines…`; a reconnect advances + `syncToken`, and `PipelinesScreen.didUpdateWidget` calls the existing + `controller.load()` so the list and the selected detail refresh in place. + Selection (pipeline id and requested version) is preserved; there is no + remount and no return to the empty list. +- `PipelinesScreen` gained `embedded` and `syncToken`. Embedded mode skips its + own Material `Scaffold`/`AppBar` or Cupertino `CupertinoPageScaffold`/ + `CupertinoNavigationBar`, because the shell already owns the single bar. + A native refresh action stays in the content (`IconButton`/`CupertinoButton` + with the same `Refresh` wording), using the real host selection. +- The connection gate and banner moved verbatim from `runs_destination.dart` + to `lib/application/connection_status.dart`, so Runs and Pipelines share one + implementation and one wording. Runs behavior is unchanged. +- Registration is a tiny entry in the existing `destinationBodies` map in + `lib/application/pipelines_app.dart`. +- No graph rendering, actions, templates, schedules, route expansion, native + control replacement, fixed component size/font/colour override, server, + web, legacy, Android or pubspec change was made. Graph still shows + `Graph rendering is pending (P2).` + +## Files + +Production: + +- `lib/application/connection_status.dart` (new, moved shared chrome) +- `lib/application/pipelines_destination.dart` (new) +- `lib/application/pipelines_app.dart` (registration and import) +- `lib/application/runs_destination.dart` (uses the shared chrome) +- `lib/features/pipelines/screen.dart` (embedded framing, content refresh, + reconnect sync token) + +Tests: + +- `test/application/pipelines_destination_test.dart` (new) +- `test/application/pipelines_registration_test.dart` (new) +- `test/application/pipelines_replies.dart` (new serialized reply helper) +- `test/application/pipelines_app_test.dart` (route now renders the real list) +- `test/application/settings_registration_test.dart` (answers the mounted + Pipelines reads before visiting Settings) +- `test/features/pipelines/pipelines_screen_test.dart` (embedded framing and + content refresh) + +Browser tooling (isolated, pure loopback fixtures): + +- `tool/pipelines_wiring_probe_entry.dart` — exact `runPipelinesApp()` + composition +- `tool/pipelines_wiring_probe_server.mjs` — static bundle plus loopback + websocket fixture with drop/refuse/accept/state endpoints +- `tool/pipelines_wiring_probe.mjs` — real Chrome DevTools probe + +## Checks actually run + +| Check | Result | +| --- | --- | +| `flutter analyze` | `No issues found!` | +| `flutter test` | **595 passed** | +| `flutter test test/application` | **33 passed** | +| `flutter test test/features/pipelines` | **49 passed** | +| `flutter test test/features/pipelines/pipelines_screen_test.dart` | **6 passed** | +| `dart format --output=none --set-exit-if-changed lib test tool/pipelines_wiring_probe_entry.dart` | 273 files, 0 changed | +| `node --check` on both probe scripts | passed | +| `flutter build web` (default `lib/main.dart`) | `✓ Built build/web` | +| `flutter build web -t tool/pipelines_wiring_probe_entry.dart` | `✓ Built` | +| `node tool/pipelines_wiring_probe.mjs ` | exit 0, 25 checks, 9 captures, `probe.json` has no error | + +Coverage added: + +- missing native endpoint never opens a socket; +- connecting gate sends no list request; the screen mounts only after the + shared socket accepts; +- refused first connection is friendly, names no transport exception and + offers Retry; +- a drop retains the loaded rows and detail, then reconnect re-reads list and + the open detail without losing the selected row; +- the registered `/pipelines` route renders real rows, detail content hash and + source with exactly one Material or Cupertino bar, one socket; +- Cupertino host builds no `Material` widget; +- embedded framing adds no second bar and keeps a working content Refresh. + +## Browser evidence (real Chrome, normal composition) + +Directory: `/Users/alan/.local/share/pipelines/data/artifacts/69/public/p1-wire-captures` + +- `01-gate-refused-material.png` — first connection refused: honest gate, + `Retry`, shell nav present, zero list requests recorded by the fixture. +- `02-list-material.png` — Material shell below its single bar with the real + `Release verification` / `Nightly documentation` rows. +- `03-detail-material.png` — selected pipeline Summary with + `sha256:fixture-3-v3`, versions and metadata. +- `04-source-material.png` — Source tab with the real fixture source text. +- `05-drop-detail-retained-material.png` — socket dropped: `Reconnecting to + Pipelines…` banner while the open detail stays visible at `/pipelines`. +- `06-reconnect-detail-refreshed-material.png` — after Retry: banner gone, + list and open detail re-read (fixture counters advanced for `list_pipelines` + and `get_pipeline`), same selection. +- `07-list-cupertino-dark.png` — macOS/dark host: Cupertino global bar and tab + bar, inset grouped rows, `Release verification` present. +- `08-detail-cupertino-dark.png` — Cupertino dark detail with content hash, + versions and native segmented tabs. +- `09-source-cupertino-dark.png` — Cupertino dark Source with source text. +- `probe.json` — fixture URL, 25 checks, captures and final counters. + +The probe starts the fixture with websocket upgrades refused, asserts the gate +and that `listPipelines`, `listRuns` and `getPipeline` are all 0, then accepts +and drives the normal app. Hosts are selected through the browser platform +user agent (Linux for Material, macOS for Cupertino), which is what the normal +composition reads. OCR asserts the real row, content hash and source; the +captures were inspected to confirm one bar and Cupertino dark styling. + +Reproduce: + +```sh +flutter build web -t tool/pipelines_wiring_probe_entry.dart -o +node tool/pipelines_wiring_probe.mjs +``` + +## Explicitly not done / unverified + +- Graph rendering and graph nodes/edges remain P2; the existing pending notice + is unchanged. +- No action, template, schedule, route expansion or navigation redesign. +- No production server, real operator chat/run or authenticated preview was + touched; all browser data comes from the isolated loopback fixture. +- Android and iOS were not built, installed or run; mobile remains unverified. +- No push, deployment or preview-service change was made. The Land stage + committed the reviewed candidate on `flutter/p1-wire` and merged `main` + into it (see Landing below). +- No Material/Cupertino fixed sizes, palette or font overrides were added. + The only fixed breakpoint remains the existing `kPipelinesWideBreakpoint`. + +## Diff + +Tracked changes (`git diff --numstat`): + +``` +3 0 app/lib/application/pipelines_app.dart +4 184 app/lib/application/runs_destination.dart +57 16 app/lib/features/pipelines/screen.dart +26 5 app/test/application/pipelines_app_test.dart +3 0 app/test/application/settings_registration_test.dart +26 0 app/test/features/pipelines/pipelines_screen_test.dart +``` + +New files: `connection_status.dart` (195), `pipelines_destination.dart` (61), +three test files and three probe files. Net production change is ~120 added +lines after moving the shared chrome out of `runs_destination.dart`. + +## Landing + +- Committed the reviewed work as `8476cfd7 feat(app): wire the native + pipelines browser on the shared session` (15 paths, no unrelated files). +- Merged local `main` (`7be4456f`) into `flutter/p1-wire` with no conflicts; + the merge brought in the native run rename work only (`app/WORK.md`, + `lib/features/runs/**`, `notes/R2-title-wire.md`, its tests and probe). +- Post-merge checks on the merged candidate: `flutter analyze` clean, + `flutter test` **599 passed**, `dart format` 274 files 0 changed, + `node --check` on both probe scripts, `flutter build web` built, and the + Chrome wiring probe again reported **25 checks, 9 captures**, no error, + final `{subscribed:3, listPipelines:3, listRuns:3, getPipeline:3, + dropped:1, connections:1}`. The 595 in the table above is the pre-merge + branch count; the extra 4 tests are the merged rename coverage. diff --git a/app/notes/R2-cancel-wire.md b/app/notes/R2-cancel-wire.md new file mode 100644 index 00000000..6a1529b7 --- /dev/null +++ b/app/notes/R2-cancel-wire.md @@ -0,0 +1,23 @@ +# Cancel from the actual run detail + +The loaded detail's native action row reuses CancelRunAction alongside Rename. +No new confirmation or protocol implementation: Keep sends nothing, only Confirm +sends the exact run_id, and no canceled state appears before server acceptance. +The accepted run detail now folds lifecycle fields into the held list row as well +as the detail (the previous title-only update was insufficient for Cancel). +Detail-only payloads are not duplicated into the summary list; pending old detail +refreshes are invalidated after acceptance. Foreign run replies cannot replace +the open detail. Native controls still own sizing and appearance. + +## Actual checks + +- New normal-screen Material/Cupertino tests failed before registration, then + passed: Keep/no request, Confirm exact id, delayed accepted canceled state, + action disappears, Back shows canceled list row. +- 601 integrated tests pass; analyzer and normal web build pass. +- Normal-app real Chrome fixture probe passes23 captures, including Cupertino + confirm/Keep, Material confirm and accepted detail/list. The fixture records + exactly one cancel_run for its own synthetic run4. No real run was canceled. +- Fresh Cupertino-confirm and Material-accepted PNGs inspected in approved + temp/cancel-wired-browser. Existing history/reconnect/Settings checks pass too. +- Mobile and authenticated production mutations remain unverified. diff --git a/app/notes/R2-decision-wire.md b/app/notes/R2-decision-wire.md new file mode 100644 index 00000000..56aed422 --- /dev/null +++ b/app/notes/R2-decision-wire.md @@ -0,0 +1,19 @@ +# Recorded human decisions in run detail + +RunDecisionNotice reuses pendingDecision and HumanDecisionAction. A standard +Material card or Cupertino section names the recorded checkpoint and offers +Decide. The existing native prompt owns option/feedback/confirmation/refusal +semantics; export/resource waits do not become invented human checkpoints. +Accepted server detail flows through the same lifecycle/list update as Cancel. + +New actual-screen tests failed before wiring and now pass on both hosts: recorded +instructions, selection sends nothing, exact run/stage/option and trimmed feedback +only on confirmation, accepted result removes the card. Integrated614 tests pass; +analysis and normal web build are clean. + +Real normal-app browser fixture passes28 captures, including actual Cupertino +waiting card and prompt, Material card/prompt/accepted result, Cancel/Keep and +the existing history/reconnect/Settings checks. The fixture records one exact +decide_run for its synthetic run5; opening/Cancel send nothing. Card and prompt +PNGs inspected in approved temp/decision-wired-browser. No production decision +was answered; mobile and live authenticated mutations remain unverified. diff --git a/app/notes/S1-draft.md b/app/notes/S1-draft.md new file mode 100644 index 00000000..57fa7d2c --- /dev/null +++ b/app/notes/S1-draft.md @@ -0,0 +1,140 @@ +# S1-draft — pure saved-schedule editor draft and validation + +Manager integration guard: invalid pipeline IDs and edited records without a +positive exact server identity/revision cannot build save payloads. This prevents +a malformed/historical edit from becoming a create or bypassing CAS. Three new +regressions failed against the original draft and pass after the fail-closed +guard. The original snapshot remains unchanged; no production save was tested. + +## What changed + +New files only; no existing feature, shell, transport, `main` or pubspec source +edited: + +| File | Lines | Responsibility | +| --- | --- | --- | +| `lib/features/schedules/domain/editor/schedule_draft.dart` | 210 | mutable editor draft over `SavedSchedule`/`ScheduleRule`, web-mirrored validation, `save_schedule` record assembly | +| `test/features/schedules/domain/editor/draft_fixtures.dart` | 42 | shared server-record fixture and deep-copy helper | +| `test/features/schedules/domain/editor/schedule_draft_test.dart` | 134 | create/edit record assembly, CAS, unknown fields, workspace, source immutability | +| `test/features/schedules/domain/editor/schedule_draft_validation_test.dart` | 130 | timer/day/timezone/core field validation and invalid-field behavior | + +The production file is one cohesive file (below the 220-line slice budget) and +keeps the existing domain pattern: `SavedSchedule` and `ScheduleRule` are +read-only views, `ScheduleDraft` is the separate editable state. Tests are split +by responsibility (record assembly vs. validation) so neither file exceeds the +working agreement's ~250-line aim. + +## Review fix — workspace is now written into the record + +Review visit 1 found that `build()` validated `workspace` but never wrote it, so +creates were refused by `save_schedule` and workspace edits were dropped. The +fix writes `record['workspace'] = workspace;` beside `name`/`version`/`enabled`, +untrimmed to match `workspace: draft.workspace` in `web/src/schedules.js` +(validation also runs on the untrimmed value). Direct probe against the real +classes: + +``` +create keys: enabled, id, input, name, notify_mode, pipeline_id, rule, version, workspace +create: {"id":0,...,"workspace":"/srv","rule":{"every":"24h","timezone":"UTC"},"notify_mode":"auto"} +edit workspace: /new (source /old) +edit revision: 13 +``` + +New assertions cover the create record, an unchanged edit, a changed edit and +the untrimmed value. + +## Behavior copied from `web/src/schedules.js` + +`ScheduleDraft.build()` returns `ScheduleSaveResult(null, errors)` while any +field is invalid, so an invalid draft cannot yield a save payload. Errors are a +field-name → message map using the web editor's exact words: + +- name `Enter a schedule name.` (stored trimmed, as the web record is) +- prompt `Enter a prompt.` (stored untrimmed) +- pinned version: digits only, safe integer, at least 1 — `Choose a positive + pinned version, not latest (0).` +- workspace must start with `/` and contain no NUL/CR/LF — `Enter an absolute + workspace path on the server.` +- interval is Go-style compound duration (`24h`, `1h30m`, `.5h`, `1.5m`) whose + matched text covers the whole value and totals at least one minute — + `Interval must be at least 1m (for example 24h or 1h30m).` +- clock times are comma-separated, trimmed, distinct `HH:mm` in 00:00–23:59 — + `Enter distinct 24-hour times, such as 09:00, 17:30.` +- weekday keys must be distinct values from `scheduleDays` — + `Choose valid, distinct weekdays.` +- notification mode is `auto`, `on` or `off` — `Choose a notification mode.` +- timezone is blank, `Local`, a known single-zone alias or a well-formed + `Area/Location` — `Enter a valid IANA timezone.` + +Rule assembly mirrors the web editor: the prior rule is copied, `every`, +`times`, `days` and `timezone` are removed, then only the selected timer shape +is written. Empty weekdays mean every day (the key stays absent). A weekday set +that is unchanged keeps the server's original order (the web editor does this +so editing only a prompt does not reorder days). A blank timezone is omitted. + +## Losslessness and CAS + +- Edits start from `SavedSchedule.toJson()` (a deep copy): unknown top-level, + `input`, `rule` and run-option fields (`model`, `stage_models`, `write_paths`, + `allow_tools`, `title`, `output_format`, `next_due`, timestamps, future + fields) survive untouched. +- `input` keeps every unknown key and replaces only `prompt`. +- **Every build starts from a fresh copy**, so the source snapshot and the + draft are not mutated or aliased by a returned payload. +- The edit record keeps the exact server `revision`; it is never incremented, + invented or defaulted. An edit never rewrites `id`. +- A create has no source: it emits the web sentinel `id: 0`, no `revision`, no + unknown/run-option leftovers, `pipeline_id` from the caller, `enabled`, + `input: {prompt}`, `rule`, and `notify_mode`. +- `notify_mode` and `enabled` default the same way as the web draft when absent + from a malformed older record, but an existing non-default string/boolean is + preserved and validated rather than silently replaced. + +## Checks actually run + +``` +flutter pub get +dart format lib/features/schedules/domain/editor test/features/schedules/domain/editor +flutter analyze # No issues found! (1.1s) +flutter test test/features/schedules/domain/editor # 9 passed +flutter test test/features/schedules # 56 passed +``` + +Focused coverage maps to the requested acceptance: + +- create: sentinel `id: 0`, no revision, pipeline/version/prompt/workspace/rule; +- lossless edit: id 9/revision 13, unknown record/input/rule/run options, + workspace from the source, original map and `SavedSchedule` snapshot + unchanged, returned payload not aliased; +- changed workspace is written untrimmed, matching the web serializer; +- prompt-only edit keeps the server weekday order and clock rule; +- clock ↔ interval switching removes the other timer key and keeps unknown + rule fields; +- invalid timers (`59s`, `NaN`, `-1h`, `1.1x`, `Infinityh`, mixed text) and + valid parity cases (`.5h`, `1h30m`, `24h`); +- invalid clock times, duplicate weekdays, bad notification mode, invalid + timezones, bad name/prompt/version/workspace; +- invalid draft mutates nothing and has no record. + +## Honest limits + +- **Scope is the core editor slice.** Name, prompt, pinned version, workspace, + timer mode/every/times, weekdays, timezone, enabled and notification mode are + editable. Advanced JSON run options (`otherInput`, `stage models`, write + paths, model, title, output format) and tools are **preserved exactly but not + editable in this slice**; no control or parser for them was invented here. +- **Timezone is structural.** Dart ships no IANA database, so the check accepts + blank/`Local`, known single-zone aliases and a known area plus a well-formed + location (e.g. `Europe/London`, `Etc/GMT+5`). It rejects clearly malformed + values such as `Nowhere/Invalid` and `Europe/`, but cannot prove that every + location in an accepted area exists. The server remains the final validator. + This is documented at the function. +- **No UI, network, CRUD, run dispatch, polling or scheduling engine.** The + draft only assembles a record; the existing repository owns `save_schedule`, + and no server was contacted. +- **No browser capture applies.** This is a nonvisual pure domain item; there + is no rendered change, so no fixture or screenshot was produced. +- **Mobile unverified.** Only web-targeted Flutter tests and analysis ran. No + Android/iOS build, emulator, ADB or device was used; the code is pure Dart. +- **Not committed.** This stage forbids commit, push and deploy, so the + candidate remains in the `flutter/schedule-draft` worktree for the manager. diff --git a/app/test/application/pipelines_app_test.dart b/app/test/application/pipelines_app_test.dart index b92c3b41..81e526d8 100644 --- a/app/test/application/pipelines_app_test.dart +++ b/app/test/application/pipelines_app_test.dart @@ -5,8 +5,11 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/application/pipelines_app.dart'; import 'package:pipelines_app/application/server_endpoint.dart'; import 'package:pipelines_app/core/transport/pipelines_client.dart'; +import 'package:pipelines_app/features/pipelines/screen.dart'; import '../core/transport/pipelines_client_test.dart' show FakeChannel; +import '../features/pipelines/fixtures.dart'; +import 'pipelines_replies.dart'; ServerEndpoint webServer() => ServerEndpoint.resolve( base: Uri.parse('http://127.0.0.1:8096/'), @@ -125,18 +128,32 @@ void main() { await pumpApp(tester, channel: channel, client: client, provider: provider); expect(provider.value.uri.path, '/pipelines'); + final fixture = PipelineFixture(); + await replyPipelines(tester, channel, fixture); + final pipelinesRunsId = + pipelineRequest(channel, 'list_runs')!['id'] as String; await tester.tap(find.text('Runs').last); await tester.pump(); expect(provider.value.uri.path, '/runs'); - await replyList( + final runsRequest = await waitForLaterRequest( tester, channel, - runs: [ - {'id': 2, 'name': 'Beta run', 'status': 'failed'}, - ], + 'list_runs', + pipelinesRunsId, ); + channel.incoming.add( + jsonEncode({ + 'id': runsRequest['id'], + 'type': 'runs', + 'runs': [ + {'id': 2, 'name': 'Beta run', 'status': 'failed'}, + ], + }), + ); + await tester.pump(); + await tester.pump(); await tester.tap(find.text('Beta run')); await tester.pump(); expect(provider.value.uri.path, '/runs/2'); @@ -172,6 +189,10 @@ void main() { await pumpApp(tester, channel: channel, client: client, provider: provider); expect(provider.value.uri.path, '/pipelines'); - expect(find.text('Pipelines — Not implemented'), findsOneWidget); + await replyPipelines(tester, channel, PipelineFixture()); + expect(find.byType(PipelinesScreen), findsOneWidget); + expect(find.text('Pipelines — Not implemented'), findsNothing); + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); }); } diff --git a/app/test/application/pipelines_destination_test.dart b/app/test/application/pipelines_destination_test.dart new file mode 100644 index 00000000..65010f09 --- /dev/null +++ b/app/test/application/pipelines_destination_test.dart @@ -0,0 +1,237 @@ +import 'dart:convert'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/application/app_session.dart'; +import 'package:pipelines_app/application/pipelines_destination.dart'; +import 'package:pipelines_app/application/server_endpoint.dart'; +import 'package:pipelines_app/core/transport/pipelines_client.dart'; +import 'package:pipelines_app/features/pipelines/screen.dart'; + +import '../core/transport/pipelines_client_test.dart' show FakeChannel; +import '../features/pipelines/fixtures.dart'; + +ServerEndpoint webServer() => ServerEndpoint.resolve( + base: Uri.parse('http://127.0.0.1:8096/'), + web: true, +); + +Map? requestOf(FakeChannel channel, String type) => channel + .outgoing + .map((frame) => jsonDecode(frame as String) as Map) + .where((frame) => frame['type'] == type) + .firstOrNull; + +Widget materialApp(AppSession session, ServerEndpoint server) => MaterialApp( + home: Scaffold( + body: PipelinesDestination(session: session, server: server), + ), +); + +Future waitFor( + WidgetTester tester, + bool Function() check, + String label, +) async { + for (var attempt = 0; attempt < 60 && !check(); attempt++) { + await tester.pump(const Duration(milliseconds: 10)); + } + expect(check(), isTrue, reason: 'Timed out waiting for $label'); +} + +Future replyList( + WidgetTester tester, + FakeChannel channel, + PipelineFixture fixture, +) async { + await waitFor( + tester, + () => requestOf(channel, 'list_pipelines') != null, + 'list_pipelines', + ); + final pipelines = requestOf(channel, 'list_pipelines')!; + channel.incoming.add( + jsonEncode({ + 'id': pipelines['id'], + 'type': 'pipelines', + 'pipelines': fixture.summaries, + }), + ); + await tester.pump(); + await waitFor( + tester, + () => requestOf(channel, 'list_runs') != null, + 'list_runs', + ); + final runs = requestOf(channel, 'list_runs')!; + channel.incoming.add( + jsonEncode({'id': runs['id'], 'type': 'runs', 'runs': fixture.runs}), + ); + await tester.pump(); +} + +Future replyDetail( + WidgetTester tester, + FakeChannel channel, + PipelineFixture fixture, + int id, +) async { + await waitFor( + tester, + () => requestOf(channel, 'get_pipeline') != null, + 'get_pipeline', + ); + final request = requestOf(channel, 'get_pipeline')!; + final detail = fixture.detailFor( + request['pipeline_id'] as int, + request['version'] as int, + )!; + channel.incoming.add( + jsonEncode({'id': request['id'], 'type': 'pipeline', 'detail': detail}), + ); + await tester.pump(); +} + +void main() { + testWidgets('missing native configuration never opens a socket', ( + tester, + ) async { + final channel = FakeChannel(); + final client = PipelinesClient(channelFactory: (_) => channel); + final server = ServerEndpoint.resolve( + base: Uri.parse('http://127.0.0.1:8096/'), + web: false, + ); + final session = AppSession(endpoint: server.uri, client: client); + addTearDown(session.dispose); + + await tester.pumpWidget(materialApp(session, server)); + expect(find.text('Server endpoint not configured'), findsOneWidget); + expect(find.textContaining('PIPELINES_SERVER_URL'), findsOneWidget); + expect(find.byType(PipelinesScreen), findsNothing); + expect(channel.outgoing, isEmpty); + }); + + testWidgets('the list is only requested after the first connection', ( + tester, + ) async { + final fixture = PipelineFixture(); + final channel = FakeChannel(); + final client = PipelinesClient(channelFactory: (_) => channel); + final server = webServer(); + final session = AppSession(endpoint: server.uri, client: client); + addTearDown(session.dispose); + + final starting = session.start(); + await tester.pumpWidget(materialApp(session, server)); + await tester.pump(); + expect(find.text('Connecting to Pipelines…'), findsOneWidget); + expect(find.byType(PipelinesScreen), findsNothing); + expect(requestOf(channel, 'list_pipelines'), isNull); + expect(channel.outgoing, isEmpty); + + channel.readyCompleter.complete(); + await starting; + await tester.pump(); + await replyList(tester, channel, fixture); + await tester.pump(); + + expect(find.byType(PipelinesScreen), findsOneWidget); + expect(find.text('Alpha review'), findsOneWidget); + expect(requestOf(channel, 'list_pipelines'), isNotNull); + }); + + testWidgets('an unavailable first connection is honest and retryable', ( + tester, + ) async { + final channel = FakeChannel(); + final client = PipelinesClient( + channelFactory: (_) => channel, + backoffBase: const Duration(hours: 1), + backoffMax: const Duration(hours: 1), + ); + final server = webServer(); + final session = AppSession(endpoint: server.uri, client: client); + addTearDown(session.dispose); + + final starting = session.start(); + channel.readyCompleter.completeError(StateError('Failed to connect')); + await starting; + await tester.pumpWidget(materialApp(session, server)); + await tester.pump(); + + expect(find.text('Pipelines server unavailable'), findsOneWidget); + expect(find.textContaining('Failed to connect'), findsNothing); + expect(find.widgetWithText(FilledButton, 'Retry'), findsOneWidget); + expect(find.byType(PipelinesScreen), findsNothing); + expect(channel.outgoing, isEmpty); + // The client keeps retrying by design; end its backoff timer explicitly. + session.dispose(); + }); + + testWidgets('reconnect refreshes the list and the open detail in place', ( + tester, + ) async { + tester.view.physicalSize = const Size(1100, 900); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + + final fixture = PipelineFixture(); + final first = FakeChannel()..readyCompleter.complete(); + final second = FakeChannel()..readyCompleter.complete(); + var sockets = 0; + final client = PipelinesClient( + channelFactory: (_) => sockets++ == 0 ? first : second, + backoffBase: const Duration(milliseconds: 10), + ); + final server = webServer(); + final session = AppSession(endpoint: server.uri, client: client); + addTearDown(session.dispose); + + await session.start(); + await tester.pumpWidget(materialApp(session, server)); + await tester.pump(); + await replyList(tester, first, fixture); + await tester.pump(); + expect(find.text('Alpha review'), findsOneWidget); + + await tester.tap(find.byKey(const Key('pipeline-row-1'))); + await tester.pump(); + await replyDetail(tester, first, fixture, 1); + await tester.pump(); + expect(find.text('hash-alpha'), findsOneWidget); + expect( + tester.widget(find.byKey(const Key('pipeline-row-1'))).selected, + isTrue, + ); + + first.incoming.addError(StateError('network drop')); + await tester.pump(); + expect(find.byType(PipelinesScreen), findsOneWidget); + expect(find.text('Reconnecting to Pipelines…'), findsOneWidget); + expect(find.text('hash-alpha'), findsOneWidget); + + await waitFor( + tester, + () => requestOf(second, 'list_pipelines') != null, + 'reconnected list request', + ); + await replyList(tester, second, fixture); + await waitFor( + tester, + () => requestOf(second, 'get_pipeline') != null, + 'reconnected detail request', + ); + await replyDetail(tester, second, fixture, 1); + await tester.pump(); + + expect(find.text('Reconnecting to Pipelines…'), findsNothing); + expect(find.text('hash-alpha'), findsOneWidget); + expect( + tester.widget(find.byKey(const Key('pipeline-row-1'))).selected, + isTrue, + reason: 'A reconnect must not remount the screen or drop the selection.', + ); + }); +} diff --git a/app/test/application/pipelines_registration_test.dart b/app/test/application/pipelines_registration_test.dart new file mode 100644 index 00000000..19a9d6e3 --- /dev/null +++ b/app/test/application/pipelines_registration_test.dart @@ -0,0 +1,94 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/application/pipelines_app.dart'; +import 'package:pipelines_app/core/transport/pipelines_client.dart'; + +import '../core/transport/pipelines_client_test.dart' show FakeChannel; +import '../features/pipelines/fixtures.dart'; +import '../features/pipelines/test_helpers.dart' show selectableText; +import 'pipelines_app_test.dart' show webServer; +import 'pipelines_replies.dart'; + +void main() { + for (final cupertino in [false, true]) { + testWidgets( + 'the /pipelines route renders real rows, detail and source ($cupertino)', + (tester) async { + tester.view.physicalSize = const Size(1100, 900); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + if (cupertino) { + tester.platformDispatcher.platformBrightnessTestValue = + Brightness.dark; + addTearDown( + tester.platformDispatcher.clearPlatformBrightnessTestValue, + ); + } + + final fixture = PipelineFixture(); + final channel = FakeChannel()..readyCompleter.complete(); + var sockets = 0; + final client = PipelinesClient( + channelFactory: (_) { + sockets++; + return channel; + }, + ); + final provider = PlatformRouteInformationProvider( + initialRouteInformation: RouteInformation( + uri: Uri.parse('/pipelines'), + ), + ); + addTearDown(provider.dispose); + + await tester.pumpWidget( + PipelinesApp( + server: webServer(), + client: client, + cupertino: cupertino, + routeInformationProvider: provider, + ), + ); + await tester.pump(); + await replyPipelines(tester, channel, fixture); + await tester.pump(); + + expect(find.text('Alpha review'), findsOneWidget); + expect(find.text('id 1 · v2 · 2 stages'), findsOneWidget); + expect(find.text('Pipelines — Not implemented'), findsNothing); + expect(sockets, 1); + + // The shell owns the only navigation bar; the embedded screen adds no + // second AppBar or CupertinoNavigationBar. + if (cupertino) { + expect(find.byType(CupertinoNavigationBar), findsOneWidget); + expect(find.byType(CupertinoPageScaffold), findsOneWidget); + expect(find.byType(Material), findsNothing); + } else { + expect(find.byType(AppBar), findsOneWidget); + expect(find.byType(Scaffold), findsOneWidget); + } + + await tester.tap(find.byKey(const Key('pipeline-row-1'))); + await tester.pump(); + await replyPipelineDetail(tester, channel, fixture); + await tester.pump(); + expect(find.text('hash-alpha'), findsOneWidget); + + await tester.tap(find.text('Source')); + await tester.pump(); + expect( + selectableText( + 'name: Alpha review\nstages:\n review:\n type: model', + ), + findsOneWidget, + ); + + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); + }, + ); + } +} diff --git a/app/test/application/pipelines_replies.dart b/app/test/application/pipelines_replies.dart new file mode 100644 index 00000000..9c5b2f5d --- /dev/null +++ b/app/test/application/pipelines_replies.dart @@ -0,0 +1,93 @@ +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; + +import '../core/transport/pipelines_client_test.dart' show FakeChannel; +import '../features/pipelines/fixtures.dart'; + +Map? pipelineRequest(FakeChannel channel, String type) => + channel.outgoing + .map((frame) => jsonDecode(frame as String) as Map) + .where((frame) => frame['type'] == type) + .firstOrNull; + +Future waitForRequest( + WidgetTester tester, + FakeChannel channel, + String type, +) async { + for ( + var attempt = 0; + attempt < 60 && pipelineRequest(channel, type) == null; + attempt++ + ) { + await tester.pump(const Duration(milliseconds: 10)); + } + expect( + pipelineRequest(channel, type), + isNotNull, + reason: 'Timed out waiting for $type', + ); +} + +/// Waits for a later request of [type] than [afterId]. The transport serializes +/// requests, so a destination that mounts later issues its read only after the +/// previous reply arrives. +Future> waitForLaterRequest( + WidgetTester tester, + FakeChannel channel, + String type, + String afterId, +) async { + Map? later() => channel.outgoing + .map((frame) => jsonDecode(frame as String) as Map) + .where((frame) => frame['type'] == type && frame['id'] != afterId) + .firstOrNull; + for (var attempt = 0; attempt < 60 && later() == null; attempt++) { + await tester.pump(const Duration(milliseconds: 10)); + } + expect(later(), isNotNull, reason: 'Timed out waiting for later $type'); + return later()!; +} + +Future replyPipelines( + WidgetTester tester, + FakeChannel channel, + PipelineFixture fixture, +) async { + await waitForRequest(tester, channel, 'list_pipelines'); + final pipelines = pipelineRequest(channel, 'list_pipelines')!; + channel.incoming.add( + jsonEncode({ + 'id': pipelines['id'], + 'type': 'pipelines', + 'pipelines': fixture.summaries, + }), + ); + await tester.pump(); + await waitForRequest(tester, channel, 'list_runs'); + final runs = pipelineRequest(channel, 'list_runs')!; + channel.incoming.add( + jsonEncode({'id': runs['id'], 'type': 'runs', 'runs': fixture.runs}), + ); + await tester.pump(); + await tester.pump(); +} + +Future replyPipelineDetail( + WidgetTester tester, + FakeChannel channel, + PipelineFixture fixture, +) async { + await waitForRequest(tester, channel, 'get_pipeline'); + final request = pipelineRequest(channel, 'get_pipeline')!; + final detail = fixture.detailFor( + request['pipeline_id'] as int, + request['version'] as int, + )!; + channel.incoming.add( + jsonEncode({'id': request['id'], 'type': 'pipeline', 'detail': detail}), + ); + await tester.pump(); + await tester.pump(); +} diff --git a/app/test/application/settings_registration_test.dart b/app/test/application/settings_registration_test.dart index 238287ab..d54304be 100644 --- a/app/test/application/settings_registration_test.dart +++ b/app/test/application/settings_registration_test.dart @@ -8,7 +8,9 @@ import 'package:pipelines_app/core/transport/pipelines_client.dart'; import 'package:shared_preferences/shared_preferences.dart'; import '../core/transport/pipelines_client_test.dart' show FakeChannel; +import '../features/pipelines/fixtures.dart'; import 'pipelines_app_test.dart' show webServer, requestOf; +import 'pipelines_replies.dart'; void main() { for (final cupertino in [false, true]) { @@ -46,6 +48,7 @@ void main() { isNull, reason: 'Unvisited settings must not issue hidden requests', ); + await replyPipelines(tester, channel, PipelineFixture()); await tester.tap(find.text('Settings').last); await tester.pump(); diff --git a/app/test/features/chat/conversation/chat_thread_controller_test.dart b/app/test/features/chat/conversation/chat_thread_controller_test.dart new file mode 100644 index 00000000..d429a8ae --- /dev/null +++ b/app/test/features/chat/conversation/chat_thread_controller_test.dart @@ -0,0 +1,154 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_thread_controller.dart'; + +import 'chat_thread_fixtures.dart'; + +void main() { + late FakeChatGateway gateway; + late ChatThreadController controller; + + setUp(() { + gateway = FakeChatGateway(); + controller = ChatThreadController(gateway, 's'); + }); + + tearDown(() { + controller.dispose(); + gateway.close(); + }); + + test( + 'subscribes the exact session, then reads newest history with all data', + () async { + final unknown = chatMessage( + 'a', + 'assistant', + parts: [ + { + 'type': 'future_part', + 'id': 'p1', + 'payload': {'nested': true}, + 'unknown_field': 7, + }, + ], + )..['future_message_field'] = 'keep'; + gateway.history = (_) async => + chatPage([unknown], cursor: 'opaque/next?x=1', hasMore: true); + + await controller.load(); + + expect(gateway.calls.map((call) => call.type), [ + 'chat_subscribe', + 'chat_messages', + ]); + expect(gateway.calls.first.fields, { + 'chat_subscribe': {'session_id': 's'}, + }); + expect(gateway.calls.last.fields['chat_query'], { + 'session_id': 's', + 'limit': 200, + 'cursor': '', + }); + expect(controller.loaded, isTrue); + expect(controller.loading, isFalse); + expect(controller.error, isNull); + expect(controller.running, isFalse); + expect(controller.hasMore, isTrue); + expect(controller.cursor, 'opaque/next?x=1'); + expect(controller.messages.single, unknown); + expect(controller.messages.single['future_message_field'], 'keep'); + }, + ); + + test( + 'loadOlder passes the opaque cursor back and prepends the page', + () async { + gateway.history = (_) async => chatPage( + [chatMessage('b', 'user')], + cursor: 'older-1', + hasMore: true, + ); + await controller.load(); + + final olderReply = Completer(); + gateway.history = (_) => olderReply.future; + final loadingStates = []; + controller.addListener(() => loadingStates.add(controller.loading)); + final older = controller.loadOlder(); + + expect(gateway.calls.last.fields['chat_query'], { + 'session_id': 's', + 'limit': 200, + 'cursor': 'older-1', + }); + expect(controller.loading, isTrue); + expect(loadingStates, [true]); + olderReply.complete( + chatPage( + [chatMessage('a', 'assistant')], + cursor: 'last', + hasMore: false, + ), + ); + await older; + + expect(controller.messages.map((item) => item['id']), ['a', 'b']); + expect(controller.cursor, 'last'); + expect(controller.hasMore, isFalse); + expect(controller.loading, isFalse); + }, + ); + + test( + 'a superseded history reply never replaces the newer transcript', + () async { + final first = Completer(); + final second = Completer(); + var request = 0; + gateway.history = (_) => request++ == 0 ? first.future : second.future; + + final stale = controller.load(); + await pumpEventQueue(); + final current = controller.load(); + await pumpEventQueue(); + second.complete(chatPage([chatMessage('new', 'user')])); + await current; + expect(controller.messages.single['id'], 'new'); + + first.complete(chatPage([chatMessage('old', 'user')])); + await stale; + expect(controller.messages.single['id'], 'new'); + expect(controller.loaded, isTrue); + expect(controller.loading, isFalse); + }, + ); + + test( + 'a failed history read reports the error, never an empty success', + () async { + gateway.history = (_) => Future.error(StateError('history unavailable')); + + await controller.load(); + + expect(controller.error, contains('history unavailable')); + expect(controller.error, isNot('')); + expect(controller.messages, isEmpty); + expect(controller.loading, isFalse); + expect(controller.loaded, isTrue); + }, + ); + + test('a refused subscribe leaves history usable', () async { + gateway.subscribe = () => Future.error(StateError('not live')); + gateway.history = (_) async => chatPage([chatMessage('a', 'user')]); + + await controller.load(); + + expect(controller.messages.single['id'], 'a'); + expect(controller.error, isNull); + expect(controller.loaded, isTrue); + }); +} diff --git a/app/test/features/chat/conversation/chat_thread_fixtures.dart b/app/test/features/chat/conversation/chat_thread_fixtures.dart new file mode 100644 index 00000000..94cdaf46 --- /dev/null +++ b/app/test/features/chat/conversation/chat_thread_fixtures.dart @@ -0,0 +1,73 @@ +import 'dart:async'; + +import 'package:pipelines_app/core/api_gateway.dart'; + +/// A fake gateway whose subscribe/history replies the test controls. +class FakeChatGateway implements ApiGateway { + final calls = <({String type, JsonMap fields})>[]; + final historyRequests = >[]; + final _frames = StreamController.broadcast(); + Future Function(JsonMap fields)? history; + Future Function()? subscribe; + void Function()? onSubscribe; + + @override + Future call(String type, [JsonMap fields = const {}]) async { + calls.add((type: type, fields: fields)); + switch (type) { + case 'chat_subscribe': + onSubscribe?.call(); + return subscribe == null ? {} : subscribe!(); + case 'chat_messages': + final completer = Completer(); + historyRequests.add(completer); + if (history != null) return history!(fields); + return completer.future; + } + return {}; + } + + @override + Stream get frames => _frames.stream; + + void emitEvent(JsonMap body) { + _frames.add({'type': 'chat_event', 'chat_event': body}); + } + + void emitRaw(JsonMap envelope) => _frames.add(envelope); + + void close() => _frames.close(); +} + +JsonMap chatPage( + List messages, { + String cursor = '', + bool hasMore = false, +}) => { + 'chat_history': { + 'messages': messages, + 'next_cursor': cursor, + 'has_more': hasMore, + }, +}; + +JsonMap chatMessage(String id, String role, {List parts = const []}) => + {'id': id, 'role': role, 'parts': parts}; + +JsonMap chatTextFrame( + String text, { + String session = 's', + String messageId = 'a', +}) => { + 'session_id': session, + 'message_id': messageId, + 'kind': 'text', + 'part': {'id': 'p', 'type': 'text'}, + 'delta': text, +}; + +JsonMap chatStepFrame(String status, {String session = 's'}) => { + 'session_id': session, + 'kind': 'step', + 'step': {'status': status, 'turn_id': 'turn', 'intermediate': false}, +}; diff --git a/app/test/features/chat/conversation/chat_thread_live_test.dart b/app/test/features/chat/conversation/chat_thread_live_test.dart new file mode 100644 index 00000000..436260a6 --- /dev/null +++ b/app/test/features/chat/conversation/chat_thread_live_test.dart @@ -0,0 +1,188 @@ +import 'dart:async'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_thread_controller.dart'; + +import 'chat_thread_fixtures.dart'; + +void main() { + late FakeChatGateway gateway; + late ChatThreadController controller; + + setUp(() { + gateway = FakeChatGateway(); + controller = ChatThreadController(gateway, 's'); + }); + + tearDown(() { + controller.dispose(); + gateway.close(); + }); + + test('folds own session frames only and keeps live turn activity', () async { + gateway.history = (_) async => chatPage([ + chatMessage( + 'a', + 'assistant', + parts: [ + {'type': 'reasoning', 'id': 'r', 'text': 'held'}, + ], + ), + ]); + await controller.load(); + var notifications = 0; + controller.addListener(() => notifications++); + + gateway.emitEvent(chatTextFrame('foreign', session: 'other')); + gateway.emitEvent(chatTextFrame('nodata')..remove('session_id')); + gateway.emitRaw({'type': 'run_event', 'session_id': 's'}); + await pumpEventQueue(); + expect(notifications, 0); + expect(controller.messages.single['parts'], [ + {'type': 'reasoning', 'id': 'r', 'text': 'held'}, + ]); + expect(controller.running, isFalse); + + gateway.emitEvent(chatTextFrame('one')); + gateway.emitEvent(chatTextFrame(' two')); + await pumpEventQueue(); + expect(controller.running, isTrue); + expect(controller.messages.single['parts'], [ + {'type': 'reasoning', 'id': 'r', 'text': 'held'}, + {'type': 'text', 'id': 'p', 'text': 'one two'}, + ]); + + gateway.emitEvent(chatStepFrame('ended')); + await pumpEventQueue(); + expect(controller.running, isFalse); + expect(notifications, greaterThan(0)); + }); + + test( + 'resync re-subscribes, settles the held turn, and replaces it with the page', + () async { + gateway.history = (_) async => chatPage( + [ + chatMessage('stale-user', 'user'), + chatMessage('stale-assistant', 'assistant'), + ], + cursor: 'stale-cursor', + hasMore: true, + ); + await controller.load(); + gateway.emitEvent(chatTextFrame('still running')); + await pumpEventQueue(); + expect(controller.running, isTrue); + + gateway.onSubscribe = () { + // Settled before the re-attach, then replay proves the fresh turn. + expect(controller.running, isFalse); + gateway.emitEvent(chatStepFrame('started')); + }; + gateway.history = (_) async => chatPage( + [ + chatMessage('fresh-user', 'user'), + chatMessage('fresh-assistant', 'assistant'), + ], + cursor: 'fresh-cursor', + hasMore: false, + ); + + await controller.resync(); + await pumpEventQueue(); + + expect( + gateway.calls.where((call) => call.type == 'chat_subscribe').length, + 2, + ); + expect( + gateway.calls.where((call) => call.type == 'chat_messages').length, + 2, + ); + expect(gateway.calls.last.fields['chat_query'], { + 'session_id': 's', + 'limit': 200, + 'cursor': '', + }); + expect(controller.messages.map((item) => item['id']), [ + 'fresh-user', + 'fresh-assistant', + ]); + expect(controller.cursor, 'fresh-cursor'); + expect(controller.hasMore, isFalse); + expect(controller.running, isTrue); + expect(controller.error, isNull); + }, + ); + + test( + 'a failed resync keeps replayed activity and reports the error', + () async { + var attempt = 0; + gateway.history = (_) async { + attempt++; + if (attempt == 1) return chatPage([chatMessage('held', 'user')]); + throw StateError('resync unavailable'); + }; + await controller.load(); + gateway.onSubscribe = () { + gateway.emitEvent(chatStepFrame('started')); + }; + + await controller.resync(); + await pumpEventQueue(); + + expect(controller.messages.single['id'], 'held'); + expect(controller.running, isTrue); + expect(controller.error, contains('resync unavailable')); + expect(controller.loading, isFalse); + }, + ); + + test( + 'a resync frame reattaches and replaces the new authoritative page', + () async { + var attempt = 0; + gateway.history = (_) async => attempt++ == 0 + ? chatPage([chatMessage('held', 'user')], hasMore: true) + : chatPage([chatMessage('fresh', 'assistant')]); + await controller.load(); + + gateway.emitEvent({'session_id': 's', 'kind': 'resync'}); + await pumpEventQueue(); + + expect( + gateway.calls.where((call) => call.type == 'chat_subscribe').length, + 2, + ); + expect(controller.messages.single['id'], 'fresh'); + expect(controller.hasMore, isFalse); + }, + ); + + test( + 'disposal ignores a late reply and never invents an unsubscribe', + () async { + final pending = Completer(); + gateway.history = (_) => pending.future; + var notifications = 0; + controller.addListener(() => notifications++); + final load = controller.load(); + await pumpEventQueue(); + final before = notifications; + + controller.dispose(); + pending.complete(chatPage([chatMessage('late', 'user')])); + await load; + + expect(notifications, before); + expect( + gateway.calls.where((call) => call.type == 'chat_unsubscribe'), + isEmpty, + ); + // Keep tearDown's dispose idempotent. + controller = ChatThreadController(gateway, 's'); + }, + ); +} diff --git a/app/test/features/chat/conversation/chat_thread_subscription_test.dart b/app/test/features/chat/conversation/chat_thread_subscription_test.dart new file mode 100644 index 00000000..d8bc18b3 --- /dev/null +++ b/app/test/features/chat/conversation/chat_thread_subscription_test.dart @@ -0,0 +1,27 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/chat/conversation/chat_thread_controller.dart'; + +import 'chat_thread_fixtures.dart'; + +void main() { + test('readable history never hides a refused live subscription', () async { + final gateway = FakeChatGateway(); + gateway.subscribe = () async { + throw StateError('live watch denied'); + }; + gateway.history = (_) async => + chatPage([chatMessage('stored', 'assistant')]); + addTearDown(gateway.close); + final controller = ChatThreadController(gateway, 's'); + addTearDown(controller.dispose); + await controller.load(); + expect(controller.messages.single['id'], 'stored'); + expect(controller.error, isNull); + expect(controller.subscribed, isFalse); + expect(controller.subscriptionError, contains('live watch denied')); + gateway.subscribe = () async => {}; + await controller.resync(); + expect(controller.subscribed, isTrue); + expect(controller.subscriptionError, isNull); + }); +} diff --git a/app/test/features/pipelines/pipelines_screen_test.dart b/app/test/features/pipelines/pipelines_screen_test.dart index 957d4e16..b5db966e 100644 --- a/app/test/features/pipelines/pipelines_screen_test.dart +++ b/app/test/features/pipelines/pipelines_screen_test.dart @@ -128,6 +128,32 @@ void main() { expect(find.text('Alpha review'), findsOneWidget); }); + testWidgets('embedded framing adds no bar and keeps a content refresh', ( + tester, + ) async { + final fixture = PipelineFixture(); + final gateway = gatewayFor(fixture); + await tester.pumpWidget( + MaterialApp( + home: Scaffold( + appBar: AppBar(title: const Text('Host bar')), + body: PipelinesScreen(gateway: gateway, embedded: true), + ), + ), + ); + await tester.pumpAndSettle(); + + expect(find.byType(AppBar), findsOneWidget); + expect(find.text('Host bar'), findsOneWidget); + expect(find.text('Pipelines'), findsNothing); + expect(find.text('Alpha review'), findsOneWidget); + + final lists = gateway.callsOf('list_pipelines').length; + await tester.tap(find.byTooltip('Refresh')); + await tester.pumpAndSettle(); + expect(gateway.callsOf('list_pipelines').length, lists + 1); + }); + testWidgets('graph tab states it is pending without a hook', (tester) async { final fixture = PipelineFixture(); await pumpWide(tester, gatewayFor(fixture)); diff --git a/app/test/features/runs/ui/run_cancel_wiring_test.dart b/app/test/features/runs/ui/run_cancel_wiring_test.dart new file mode 100644 index 00000000..5677ab93 --- /dev/null +++ b/app/test/features/runs/ui/run_cancel_wiring_test.dart @@ -0,0 +1,93 @@ +import 'dart:async'; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/runs/actions/cancel_wording.dart'; +import 'package:pipelines_app/features/runs/screen.dart'; + +class _Gateway implements ApiGateway { + final events = StreamController.broadcast(); + final requests = <({String type, JsonMap fields})>[]; + final canceled = Completer(); + final JsonMap run = { + 'id': 7, + 'title': 'Controlled run', + 'name': 'fixture', + 'status': 'running', + 'executing': true, + 'steps': [], + }; + + @override + Stream get frames => events.stream; + + @override + Future call(String type, [JsonMap fields = const {}]) { + requests.add((type: type, fields: fields)); + return switch (type) { + 'list_runs' => Future.value({ + 'runs': [Map.of(run)], + }), + 'get_run' => Future.value({'run_detail': Map.of(run)}), + 'cancel_run' => canceled.future, + _ => Future.error(UnsupportedError(type)), + }; + } +} + +void main() { + for (final cupertino in [false, true]) { + testWidgets( + 'actual detail confirms cancel and folds accepted state ($cupertino)', + (tester) async { + final gateway = _Gateway(); + addTearDown(gateway.events.close); + final screen = RunsScreen(gateway: gateway, initialRunId: 7); + await tester.pumpWidget( + cupertino + ? CupertinoApp(home: CupertinoPageScaffold(child: screen)) + : MaterialApp(home: Scaffold(body: screen)), + ); + await tester.pumpAndSettle(); + await tester.tap(find.byKey(cancelActionKey)); + await tester.pumpAndSettle(); + expect(find.text('Cancel run 7?'), findsOneWidget); + expect(gateway.requests.where((r) => r.type == 'cancel_run'), isEmpty); + await tester.tap(find.byKey(cancelKeepKey)); + await tester.pumpAndSettle(); + expect(gateway.requests.where((r) => r.type == 'cancel_run'), isEmpty); + + await tester.tap(find.byKey(cancelActionKey)); + await tester.pumpAndSettle(); + await tester.tap(find.byKey(cancelConfirmKey)); + await tester.pump(); + expect( + gateway.requests.where((r) => r.type == 'cancel_run').single.fields, + {'run_id': 7}, + ); + expect(find.text('canceled'), findsNothing); + gateway.canceled.complete({ + 'run_detail': { + ...gateway.run, + 'status': 'canceled', + 'executing': false, + }, + }); + await tester.pumpAndSettle(); + expect(find.byKey(cancelActionKey), findsNothing); + expect(find.text('canceled'), findsOneWidget); + await tester.tap(find.text(cupertino ? 'Back' : 'Back to list')); + await tester.pumpAndSettle(); + expect( + find.textContaining('canceled'), + findsWidgets, + reason: + 'The accepted server state must also update the held list row', + ); + await tester.pumpWidget(const SizedBox.shrink()); + }, + ); + } +} diff --git a/app/test/features/runs/ui/run_decision_wiring_test.dart b/app/test/features/runs/ui/run_decision_wiring_test.dart new file mode 100644 index 00000000..9d29e537 --- /dev/null +++ b/app/test/features/runs/ui/run_decision_wiring_test.dart @@ -0,0 +1,109 @@ +import 'dart:async'; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/runs/actions/decision_wording.dart'; +import 'package:pipelines_app/features/runs/screen.dart'; + +class _DecisionGateway implements ApiGateway { + final events = StreamController.broadcast(); + final decisions = []; + final reply = Completer(); + final JsonMap run = { + 'id': 9, + 'title': 'Human checkpoint', + 'name': 'fixture', + 'status': 'waiting', + 'executing': false, + 'current_stage': 'gate', + 'graph': { + 'stages': [ + { + 'key': 'gate', + 'type': 'human', + 'edges': {'approve': '#success'}, + }, + ], + }, + 'steps': [ + { + 'sequence': 1, + 'stage': 'gate', + 'status': 'waiting', + 'output': { + 'prompt': 'Please review this recorded checkpoint.', + 'options': ['approve'], + }, + }, + ], + }; + + @override + Stream get frames => events.stream; + @override + Future call(String type, [JsonMap fields = const {}]) => + switch (type) { + 'list_runs' => Future.value({ + 'runs': [run], + }), + 'get_run' => Future.value({'run_detail': run}), + 'decide_run' => _decide(fields), + _ => Future.error(UnsupportedError(type)), + }; + Future _decide(JsonMap fields) { + decisions.add(fields); + return reply.future; + } +} + +void main() { + for (final cupertino in [false, true]) { + testWidgets( + 'actual detail exposes and confirms recorded decision ($cupertino)', + (tester) async { + final gateway = _DecisionGateway(); + addTearDown(gateway.events.close); + final screen = RunsScreen(gateway: gateway, initialRunId: 9); + await tester.pumpWidget( + cupertino + ? CupertinoApp(home: CupertinoPageScaffold(child: screen)) + : MaterialApp(home: Scaffold(body: screen)), + ); + await tester.pumpAndSettle(); + expect(find.text(decisionWaitingTitle), findsOneWidget); + await tester.tap(find.byKey(decisionActionKey)); + await tester.pumpAndSettle(); + expect( + find.text('Please review this recorded checkpoint.'), + findsOneWidget, + ); + await tester.tap(find.text('approve')); + await tester.enterText(find.byKey(decisionFeedbackKey), ' checked '); + await tester.pump(); + expect(gateway.decisions, isEmpty); + await tester.tap(find.text(decisionConfirmLabel)); + await tester.pump(); + expect(gateway.decisions.single, { + 'run_id': 9, + 'stage': 'gate', + 'option': 'approve', + 'feedback': 'checked', + }); + gateway.reply.complete({ + 'run_detail': { + ...gateway.run, + 'status': 'succeeded', + 'executing': false, + }, + }); + await tester.pumpAndSettle(); + expect(find.byKey(decisionActionKey), findsNothing); + expect(find.text(decisionWaitingTitle), findsNothing); + expect(find.text('succeeded'), findsOneWidget); + await tester.pumpWidget(const SizedBox.shrink()); + }, + ); + } +} diff --git a/app/test/features/schedules/domain/editor/draft_fixtures.dart b/app/test/features/schedules/domain/editor/draft_fixtures.dart new file mode 100644 index 00000000..a5cb6406 --- /dev/null +++ b/app/test/features/schedules/domain/editor/draft_fixtures.dart @@ -0,0 +1,42 @@ +import 'dart:convert'; + +import 'package:pipelines_app/core/api_gateway.dart'; + +JsonMap deepCopy(JsonMap value) => jsonDecode(jsonEncode(value)) as JsonMap; + +/// A server record with every editable field plus unknown record, input, rule +/// and run-option keys this slice must preserve. +JsonMap completeRecord() => { + 'id': 9, + 'revision': 13, + 'name': 'Saved topic', + 'pipeline_id': 4, + 'version': 2, + 'enabled': true, + 'input': { + 'prompt': 'Topic', + 'count': 4, + 'flag': false, + 'nested': { + 'list': [null, 2], + }, + }, + 'workspace': '/srv/research', + 'rule': { + 'times': ['09:00', '17:30'], + 'days': ['fri', 'mon'], + 'timezone': '', + 'future': 'keep', + }, + 'model': 'provider/model', + 'stage_models': {'research': 'provider/other'}, + 'write_paths': ['src/file.go'], + 'allow_tools': true, + 'title': 'Saved title', + 'output_format': 'json', + 'notify_mode': 'off', + 'next_due': '2026-10-22T09:00:00Z', + 'server_extra': { + 'keep': [1, true], + }, +}; diff --git a/app/test/features/schedules/domain/editor/schedule_draft_identity_test.dart b/app/test/features/schedules/domain/editor/schedule_draft_identity_test.dart new file mode 100644 index 00000000..d3512fd8 --- /dev/null +++ b/app/test/features/schedules/domain/editor/schedule_draft_identity_test.dart @@ -0,0 +1,30 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/schedules/domain/editor/schedule_draft.dart'; +import 'package:pipelines_app/features/schedules/domain/saved_schedule.dart'; + +import 'draft_fixtures.dart'; + +void main() { + test('an invalid pipeline identity cannot become a create payload', () { + final draft = + ScheduleDraft.create(pipelineId: 0, version: '1', workspace: '/srv') + ..name = 'Topic' + ..prompt = 'Research this'; + expect(draft.build().record, isNull); + expect(draft.build().errors, contains('pipelineId')); + }); + + for (final missing in ['id', 'revision']) { + test( + 'missing $missing never turns an edit into an unconditional create', + () { + final raw = completeRecord()..remove(missing); + final source = SavedSchedule(raw); + final draft = ScheduleDraft.fromSchedule(source); + expect(draft.build().record, isNull); + expect(draft.build().errors, contains('record')); + expect(source.raw.containsKey(missing), isFalse); + }, + ); + } +} diff --git a/app/test/features/schedules/domain/editor/schedule_draft_test.dart b/app/test/features/schedules/domain/editor/schedule_draft_test.dart new file mode 100644 index 00000000..228e76f7 --- /dev/null +++ b/app/test/features/schedules/domain/editor/schedule_draft_test.dart @@ -0,0 +1,134 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/schedules/domain/editor/schedule_draft.dart'; +import 'package:pipelines_app/features/schedules/domain/saved_schedule.dart'; + +import 'draft_fixtures.dart'; + +void main() { + test('a new schedule snapshots prompt, pipeline, workspace and version', () { + final draft = + ScheduleDraft.create( + pipelineId: 42, + version: '7', + workspace: '/srv/research', + timezone: 'UTC', + ) + ..name = 'AI news' + ..prompt = 'Research AI news'; + final result = draft.build(); + + expect(result.isValid, isTrue); + expect(result.errors, isEmpty); + final record = result.record!; + expect(record['id'], 0); + expect(record.containsKey('revision'), isFalse); + expect(record['pipeline_id'], 42); + expect(record['version'], 7); + expect(record['enabled'], isTrue); + expect(record['name'], 'AI news'); + expect(record['workspace'], '/srv/research'); + expect(record['input'], {'prompt': 'Research AI news'}); + expect(record['rule'], {'every': '24h', 'timezone': 'UTC'}); + expect(record['notify_mode'], 'auto'); + }); + + test('an edit preserves CAS, unknown fields and untouched run options', () { + final original = completeRecord(); + final snapshot = deepCopy(original); + final schedule = SavedSchedule(original); + final draft = ScheduleDraft.fromSchedule(schedule)..prompt = 'Changed'; + final result = draft.build(); + + expect(result.isValid, isTrue); + final record = result.record!; + expect(record['id'], 9); + expect(record['revision'], 13); + expect(record['workspace'], '/srv/research'); + expect(record['server_extra'], snapshot['server_extra']); + expect(record['next_due'], snapshot['next_due']); + expect(record['model'], 'provider/model'); + expect(record['stage_models'], {'research': 'provider/other'}); + expect(record['write_paths'], ['src/file.go']); + expect(record['allow_tools'], isTrue); + expect(record['title'], 'Saved title'); + expect(record['output_format'], 'json'); + expect(record['notify_mode'], 'off'); + expect((record['input'] as JsonMap)['count'], 4); + expect((record['input'] as JsonMap)['nested'], { + 'list': [null, 2], + }); + expect((record['input'] as JsonMap)['prompt'], 'Changed'); + expect((record['rule'] as JsonMap)['future'], 'keep'); + expect((record['rule'] as JsonMap)['days'], ['fri', 'mon']); + + // Neither the server map nor the SavedSchedule snapshot was mutated. + expect(original, snapshot); + expect(schedule.toJson(), snapshot); + ((record['input'] as JsonMap)['nested'] as JsonMap)['extra'] = true; + expect(schedule.input['nested'], { + 'list': [null, 2], + }); + }); + + test( + 'an edit writes the changed workspace, untrimmed like the web client', + () { + final record = (ScheduleDraft.fromSchedule( + SavedSchedule(completeRecord()), + )..workspace = '/srv/other').build().record!; + expect(record['workspace'], '/srv/other'); + + final untrimmed = (ScheduleDraft.fromSchedule( + SavedSchedule(completeRecord()), + )..workspace = '/srv/dir ').build().record!; + expect(untrimmed['workspace'], '/srv/dir '); + }, + ); + + test('a prompt-only edit keeps the existing weekday order', () { + final original = completeRecord(); + final draft = ScheduleDraft.fromSchedule(SavedSchedule(original)) + ..prompt = 'New topic' + ..days = ['mon', 'fri']; + final record = draft.build().record!; + + expect((record['rule'] as JsonMap)['days'], ['fri', 'mon']); + expect((record['rule'] as JsonMap)['times'], ['09:00', '17:30']); + expect((record['rule'] as JsonMap)['timezone'], isNull); + }); + + test('switching modes removes the other timer shape and keeps unknowns', () { + final original = completeRecord(); + final clock = ScheduleDraft.fromSchedule(SavedSchedule(original)) + ..mode = ScheduleTimerMode.clock + ..times = '09:00, 23:59'; + final clockRule = clock.build().record!['rule'] as JsonMap; + expect(clockRule['times'], ['09:00', '23:59']); + expect(clockRule.containsKey('every'), isFalse); + expect(clockRule['future'], 'keep'); + + final interval = + ScheduleDraft.fromSchedule(SavedSchedule(clock.build().record!)) + ..mode = ScheduleTimerMode.interval + ..every = '1.5m'; + final intervalRule = interval.build().record!['rule'] as JsonMap; + expect(intervalRule['every'], '1.5m'); + expect(intervalRule.containsKey('times'), isFalse); + expect(intervalRule['future'], 'keep'); + }); + + test('the source record is never aliased by a built payload', () { + final original = completeRecord(); + final schedule = SavedSchedule(original); + final first = (ScheduleDraft.fromSchedule(schedule)).build(); + expect(first.record, isNotNull); + expect(schedule.toJson(), original); + + final second = (ScheduleDraft.fromSchedule( + schedule, + )..prompt = 'Other').build(); + expect((second.record!['input'] as JsonMap)['prompt'], 'Other'); + expect(schedule.input['prompt'], 'Topic'); + }); +} diff --git a/app/test/features/schedules/domain/editor/schedule_draft_validation_test.dart b/app/test/features/schedules/domain/editor/schedule_draft_validation_test.dart new file mode 100644 index 00000000..dd69b4a3 --- /dev/null +++ b/app/test/features/schedules/domain/editor/schedule_draft_validation_test.dart @@ -0,0 +1,130 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/schedules/domain/editor/schedule_draft.dart'; +import 'package:pipelines_app/features/schedules/domain/saved_schedule.dart'; + +import 'draft_fixtures.dart'; + +void main() { + test('invalid intervals are field errors and never a record', () { + for (final every in [ + '', + '59s', + 'NaN', + '-1h', + '1.1x', + 'Infinityh', + '1m2h x', + ]) { + final draft = + ScheduleDraft.create(pipelineId: 4, version: '2', workspace: '/srv') + ..name = 'Timer' + ..prompt = 'Prompt' + ..every = every; + final result = draft.build(); + expect(result.record, isNull, reason: every); + expect( + result.errors['every'], + 'Interval must be at least 1m (for example 24h or 1h30m).', + reason: every, + ); + } + for (final every in ['1m', '.5h', '1h30m', '24h']) { + final draft = + ScheduleDraft.create(pipelineId: 4, version: '2', workspace: '/srv') + ..name = 'Timer' + ..prompt = 'Prompt' + ..every = every; + final result = draft.build(); + expect(result.record, isNotNull, reason: every); + expect((result.record!['rule'] as JsonMap)['every'], every); + } + }); + + test('invalid clock times, weekdays and timezones are field errors', () { + final draft = + ScheduleDraft.create(pipelineId: 4, version: '2', workspace: '/srv') + ..name = 'Timer' + ..prompt = 'Prompt' + ..mode = ScheduleTimerMode.clock + ..times = '24:00' + ..days = ['mon', 'mon'] + ..timezone = 'Nowhere/Invalid' + ..notifyMode = 'sometimes'; + final result = draft.build(); + + expect(result.record, isNull); + expect( + result.errors['times'], + 'Enter distinct 24-hour times, such as 09:00, 17:30.', + ); + expect(result.errors['days'], 'Choose valid, distinct weekdays.'); + expect(result.errors['timezone'], 'Enter a valid IANA timezone.'); + expect(result.errors['notifyMode'], 'Choose a notification mode.'); + + for (final times in ['', '9:00', '09:60', '09:00,09:00']) { + final invalid = + ScheduleDraft.fromSchedule(SavedSchedule(completeRecord())) + ..mode = ScheduleTimerMode.clock + ..times = times; + expect(invalid.build().errors['times'], isNotNull, reason: times); + } + for (final timezone in ['Europe', 'Europe/', '/London']) { + final invalid = + ScheduleDraft.create(pipelineId: 4, version: '2', workspace: '/srv') + ..name = 'Timer' + ..prompt = 'Prompt' + ..timezone = timezone; + expect(invalid.build().errors['timezone'], isNotNull, reason: timezone); + } + for (final timezone in ['Local', 'UTC', 'Asia/Tokyo', 'Etc/GMT+5']) { + final valid = + ScheduleDraft.create(pipelineId: 4, version: '2', workspace: '/srv') + ..name = 'Timer' + ..prompt = 'Prompt' + ..timezone = timezone; + expect(valid.build().isValid, isTrue, reason: timezone); + } + }); + + test('invalid core fields report every error without mutating the draft', () { + final draft = ScheduleDraft.create(pipelineId: 4) + ..prompt = ' ' + ..version = '7junk' + ..workspace = '/srv\npath'; + final before = { + 'name': draft.name, + 'prompt': draft.prompt, + 'version': draft.version, + 'workspace': draft.workspace, + }; + final result = draft.build(); + + expect(result.record, isNull); + expect(result.errors, { + 'name': 'Enter a schedule name.', + 'prompt': 'Enter a prompt.', + 'version': 'Choose a positive pinned version, not latest (0).', + 'workspace': 'Enter an absolute workspace path on the server.', + }); + expect({ + 'name': draft.name, + 'prompt': draft.prompt, + 'version': draft.version, + 'workspace': draft.workspace, + }, before); + + for (final version in ['0', '-1', '1.2', 'Infinity']) { + final invalid = ScheduleDraft.fromSchedule( + SavedSchedule(completeRecord()), + )..version = version; + expect(invalid.build().errors['version'], isNotNull, reason: version); + } + for (final workspace in ['', 'relative', '~/repo']) { + final invalid = ScheduleDraft.fromSchedule( + SavedSchedule(completeRecord()), + )..workspace = workspace; + expect(invalid.build().errors['workspace'], isNotNull, reason: workspace); + } + }); +} diff --git a/app/tool/pipelines_wiring_probe.mjs b/app/tool/pipelines_wiring_probe.mjs new file mode 100644 index 00000000..a87ee614 --- /dev/null +++ b/app/tool/pipelines_wiring_probe.mjs @@ -0,0 +1,236 @@ +// Real-Chrome acceptance for the Pipelines destination in the normal app. +// +// The bundle is `tool/pipelines_wiring_probe_entry.dart`, i.e. the same +// composition as main; the isolated loopback fixture answers the protocol. +// Both native hosts are exercised by changing the browser platform user agent. +// +// Usage: node tool/pipelines_wiring_probe.mjs +import { execFile } from 'node:child_process'; +import { mkdir, writeFile } from 'node:fs/promises'; +import { tmpdir } from 'node:os'; +import { join, resolve } from 'node:path'; +import { promisify } from 'node:util'; + +import { + connect, + launchChrome, + sleep, + waitForPage, + waitForPort, +} from './pipelines_probe_cdp_lib.mjs'; +import { + assertName, + axNodes, + capture, + click, + enableSemantics, + waitFor, +} from './pipelines_probe_cdp_input.mjs'; +import { startWiringFixture } from './pipelines_wiring_probe_server.mjs'; + +const CHROME = + process.env.CHROME_PATH ?? + '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'; +const buildDir = resolve(process.argv[2] ?? 'build/wiring_web'); +const captureDir = resolve(process.argv[3] ?? 'p1-wire-captures'); +const fixture = await startWiringFixture({ root: buildDir, refuse: true }); +await mkdir(captureDir, { recursive: true }); +const profile = join(tmpdir(), `pipelines-wiring-chrome-${process.pid}`); +const chrome = launchChrome(CHROME, profile, 'about:blank'); +let connection; +const log = { url: fixture.url, captures: [], checks: [], states: [] }; + +const semanticText = () => + connection.evaluate(`(() => { + const chunks = []; + for (const el of document.querySelectorAll('flt-semantics')) { + const label = el.getAttribute('aria-label'); + if (label) chunks.push(label); + if (!el.children.length && el.innerText) chunks.push(el.innerText); + } + if (document.body?.innerText) chunks.push(document.body.innerText); + return [...new Set(chunks)].join('\\n'); + })()`); + +const assertBody = async (text) => { + const ok = await waitFor( + async () => (await semanticText()).includes(text), + 12000, + ); + if (!ok) { + throw new Error(`Missing text ${JSON.stringify(text)}:\n${(await semanticText()).slice(0, 3000)}`); + } + log.checks.push(`text: ${text}`); +}; + +const noBody = async (text) => { + if ((await semanticText()).includes(text)) { + throw new Error(`Unexpected text ${JSON.stringify(text)}`); + } + log.checks.push(`absent: ${text}`); +}; + +const state = async () => fixture.state(); + +const waitForState = async (check, label) => { + const value = await waitFor(async () => { + const current = await state(); + return check(current) ? current : false; + }, 12000); + if (!value) throw new Error(`Timed out waiting for ${label}: ${JSON.stringify(await state())}`); + log.states.push({ label, ...value }); + return value; +}; + +const ocr = async (path) => { + const { stdout } = await promisify(execFile)('tesseract', [path, 'stdout']); + return stdout; +}; + +const assertOcr = async (name, text) => { + const read = await ocr(join(captureDir, `${name}.png`)); + if (!read.toLowerCase().includes(text.toLowerCase())) { + throw new Error(`OCR of ${name} lacks ${JSON.stringify(text)}:\n${read.slice(0, 3000)}`); + } + log.checks.push(`ocr ${name}: ${text}`); +}; + +const navigate = async (url) => { + await connection.send('Page.navigate', { url }); + await waitFor( + () => connection.evaluate("document.querySelector('flutter-view') !== null"), + 20000, + ); + await sleep(1200); + await enableSemantics(connection); +}; + +try { + const devtoolsPort = await waitForPort(join(profile, 'DevToolsActivePort')); + const target = await waitForPage(devtoolsPort); + connection = await connect(target.webSocketDebuggerUrl); + await connection.send('Page.enable'); + await connection.send('Runtime.enable'); + await connection.send('DOM.enable'); + await connection.send('Accessibility.enable'); + await connection.send('Emulation.setDeviceMetricsOverride', { + width: 1200, + height: 900, + deviceScaleFactor: 1, + mobile: false, + }); + + // Material host: Linux platform, light mode. + await connection.send('Emulation.setUserAgentOverride', { + userAgent: + 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 ' + + '(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36', + platform: 'Linux x86_64', + }); + await navigate(`${fixture.url}/pipelines`); + + // The first connection is refused: the honest gate must appear and nothing + // may be requested while there is no socket. + await assertBody('Pipelines server unavailable'); + const initial = await state(); + if (initial.listPipelines !== 0 || initial.listRuns !== 0 || initial.getPipeline !== 0) { + throw new Error(`Premature requests before connection: ${JSON.stringify(initial)}`); + } + log.checks.push('no requests before first connection'); + await capture(connection, captureDir, log, '01-gate-refused-material'); + await assertOcr('01-gate-refused-material', 'Pipelines server unavailable'); + + await fetch(`${fixture.url}/fixture/accept`, { method: 'POST' }); + await click(connection, 'Retry'); + await assertName(connection, 'Release verification', 'real pipeline row', log); + await assertName(connection, 'Nightly documentation', 'second real row', log); + await noBody('Pipelines — Not implemented'); + const loaded = await waitForState( + (value) => value.listPipelines >= 1 && value.listRuns >= 1, + 'pipeline list after retry', + ); + log.checks.push('shell lists real rows'); + await capture(connection, captureDir, log, '02-list-material'); + await assertOcr('02-list-material', 'Release verification'); + + await click(connection, 'Release verification'); + await assertName(connection, 'Content hash', 'real pipeline detail', log); + await capture(connection, captureDir, log, '03-detail-material'); + await assertOcr('03-detail-material', 'sha256:fixture-3-v3'); + + await click(connection, 'Source'); + await capture(connection, captureDir, log, '04-source-material'); + await assertOcr('04-source-material', 'name: Release verification'); + await assertOcr('04-source-material', 'type: model'); + await click(connection, 'Summary'); + await assertName(connection, 'Content hash', 'summary restored', log); + + // A drop keeps the open detail visible and, once the socket returns, the + // same list and detail are re-read without remounting or losing selection. + await fetch(`${fixture.url}/fixture/refuse`, { method: 'POST' }); + await assertBody('Reconnecting to Pipelines…'); + await assertName(connection, 'Content hash', 'detail retained after drop', log); + if ((await connection.evaluate('location.pathname')) !== '/pipelines') { + throw new Error(`Drop moved the route to ${await connection.evaluate('location.pathname')}`); + } + await capture(connection, captureDir, log, '05-drop-detail-retained-material'); + + await fetch(`${fixture.url}/fixture/accept`, { method: 'POST' }); + await click(connection, 'Retry'); + await waitForState( + (value) => + value.listPipelines > loaded.listPipelines && + value.getPipeline > loaded.getPipeline, + 'reconnect reload of list and open detail', + ); + await assertName(connection, 'Content hash', 'detail refreshed in place', log); + await noBody('Pipelines server unavailable'); + await capture(connection, captureDir, log, '06-reconnect-detail-refreshed-material'); + + // Cupertino host: macOS platform, dark appearance. + await connection.send('Emulation.setUserAgentOverride', { + userAgent: + 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' + + '(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36', + platform: 'MacIntel', + }); + await connection.send('Emulation.setEmulatedMedia', { + features: [{ name: 'prefers-color-scheme', value: 'dark' }], + }); + await navigate(`${fixture.url}/pipelines`); + await assertName(connection, 'Release verification', 'cupertino dark row', log); + await noBody('Pipelines — Not implemented'); + await capture(connection, captureDir, log, '07-list-cupertino-dark'); + await assertOcr('07-list-cupertino-dark', 'Release verification'); + + await click(connection, 'Release verification'); + await assertName(connection, 'Content hash', 'cupertino dark detail', log); + await capture(connection, captureDir, log, '08-detail-cupertino-dark'); + await assertOcr('08-detail-cupertino-dark', 'Content hash'); + + await click(connection, 'Source'); + await capture(connection, captureDir, log, '09-source-cupertino-dark'); + await assertOcr('09-source-cupertino-dark', 'name: Release verification'); + await assertOcr('09-source-cupertino-dark', 'type: model'); + + const final = await state(); + if (final.connections < 1) throw new Error('No shared socket'); + log.checks.push('both native hosts rendered real rows, detail and source'); + log.final = final; +} catch (error) { + log.error = String(error?.stack ?? error); + try { + log.failureAx = (await axNodes(connection)) + .filter((node) => node.name?.value) + .map((node) => `${node.role?.value}: ${node.name.value}`) + .slice(0, 120); + } catch { + // The browser may already be gone; the error itself is still recorded. + } + process.exitCode = 1; +} finally { + await writeFile(join(captureDir, 'probe.json'), JSON.stringify(log, null, 2)); + connection?.close(); + chrome.kill('SIGTERM'); + await fixture.close(); +} diff --git a/app/tool/pipelines_wiring_probe_entry.dart b/app/tool/pipelines_wiring_probe_entry.dart new file mode 100644 index 00000000..b237c09a --- /dev/null +++ b/app/tool/pipelines_wiring_probe_entry.dart @@ -0,0 +1,8 @@ +import 'package:pipelines_app/application/bootstrap.dart'; + +/// Browser acceptance entrypoint for the Pipelines destination wiring. +/// +/// It is exactly the normal application composition; every reply comes from the +/// isolated loopback fixture in `tool/pipelines_wiring_probe_server.mjs`, not +/// from app-side fake data and not from a production server. +void main() => runPipelinesApp(); diff --git a/app/tool/pipelines_wiring_probe_server.mjs b/app/tool/pipelines_wiring_probe_server.mjs new file mode 100644 index 00000000..22f003b2 --- /dev/null +++ b/app/tool/pipelines_wiring_probe_server.mjs @@ -0,0 +1,394 @@ +import { createHash } from 'node:crypto'; +import { createServer } from 'node:http'; +import { readFile, realpath, stat } from 'node:fs/promises'; +import { extname, join, resolve, sep } from 'node:path'; +import { once } from 'node:events'; + +// Isolated loopback fixture for the Pipelines wiring probe. It serves the +// normal application composition and answers the read-only protocol with +// deterministic data. No production server, database or operator data. + +const MIME = { + '.html': 'text/html; charset=utf-8', + '.js': 'text/javascript; charset=utf-8', + '.mjs': 'text/javascript; charset=utf-8', + '.json': 'application/json; charset=utf-8', + '.wasm': 'application/wasm', + '.css': 'text/css; charset=utf-8', + '.png': 'image/png', + '.svg': 'image/svg+xml', + '.ico': 'image/x-icon', + '.ttf': 'font/ttf', + '.otf': 'font/otf', + '.woff': 'font/woff', + '.woff2': 'font/woff2', +}; + +const PIPELINES = [ + { + id: 3, + name: 'Release verification', + version: 3, + stages: 4, + created_at: '2026-09-28T10:12:00', + updated_at: '2026-10-21T09:40:00', + scheduled: true, + schedule_count: 2, + enabled_schedule_count: 1, + }, + { + id: 7, + name: 'Nightly documentation', + version: 1, + stages: 2, + created_at: '2026-10-02T18:20:00', + updated_at: '2026-10-20T22:05:00', + scheduled: true, + schedule_count: 1, + enabled_schedule_count: 1, + }, +]; + +const RUNS = [ + { + id: 488, + pipeline_id: 3, + status: 'succeeded', + created_at: '2026-10-21T09:30:00', + finished_at: '2026-10-21T09:34:12', + executing: false, + }, + { + id: 487, + pipeline_id: 7, + status: 'running', + created_at: '2026-10-21T09:20:00', + finished_at: '', + executing: true, + }, +]; + +const VERSIONS = [ + { version: 1, stages: 2, created_at: '2026-09-28T10:12:00' }, + { version: 2, stages: 3, created_at: '2026-10-08T15:44:00' }, + { version: 3, stages: 4, created_at: '2026-10-21T09:12:00' }, +]; + +const SOURCE = `name: Release verification +stages: + inspect: + type: model + output: report + verify: + type: model + output: verdict +`; + +const SOURCE_V2 = `${SOURCE} # selected version 2 +`; + +function detail(id, requestedVersion) { + const summary = PIPELINES.find((pipeline) => pipeline.id === id) ?? PIPELINES[0]; + const versions = id === 3 ? VERSIONS : VERSIONS.slice(0, 1); + const latest = versions[versions.length - 1].version; + const version = requestedVersion > 0 ? requestedVersion : latest; + return { + ...summary, + version, + stages: versions.find((row) => row.version === version)?.stages ?? summary.stages, + latest_version: id === 3 ? latest : 1, + version_created_at: + versions.find((row) => row.version === version)?.created_at ?? summary.created_at, + content_hash: `sha256:fixture-${id}-v${version}`, + source: id === 3 && version === 2 ? SOURCE_V2 : SOURCE, + versions, + }; +} + +function accept(key) { + return createHash('sha1') + .update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`) + .digest('base64'); +} + +function frame(opcode, payload) { + const length = payload.length; + let header; + if (length < 126) { + header = Buffer.from([0x80 | opcode, length]); + } else if (length < 65536) { + header = Buffer.alloc(4); + header[0] = 0x80 | opcode; + header[1] = 126; + header.writeUInt16BE(length, 2); + } else { + header = Buffer.alloc(10); + header[0] = 0x80 | opcode; + header[1] = 127; + header.writeBigUInt64BE(BigInt(length), 2); + } + return Buffer.concat([header, payload]); +} + +class Connection { + constructor(socket, owner) { + this.socket = socket; + this.owner = owner; + this.buffer = Buffer.alloc(0); + this.fragments = []; + this.fragmentOpcode = 0; + } + + push(chunk) { + if (chunk?.length) this.buffer = Buffer.concat([this.buffer, chunk]); + this.parse(); + } + + parse() { + while (this.buffer.length >= 2) { + const first = this.buffer[0]; + const second = this.buffer[1]; + const fin = (first & 0x80) !== 0; + const opcode = first & 0x0f; + const masked = (second & 0x80) !== 0; + let length = second & 0x7f; + let offset = 2; + if (length === 126) { + if (this.buffer.length < 4) return; + length = this.buffer.readUInt16BE(2); + offset = 4; + } else if (length === 127) { + if (this.buffer.length < 10) return; + length = Number(this.buffer.readBigUInt64BE(2)); + offset = 10; + } + const maskOffset = offset; + if (masked) { + if (this.buffer.length < offset + 4) return; + offset += 4; + } + if (this.buffer.length < offset + length) return; + let payload = Buffer.from(this.buffer.subarray(offset, offset + length)); + if (masked) { + const mask = this.buffer.subarray(maskOffset, maskOffset + 4); + for (let index = 0; index < payload.length; index++) { + payload[index] ^= mask[index % 4]; + } + } + this.buffer = this.buffer.subarray(offset + length); + this.handleFrame(fin, opcode, payload); + } + } + + handleFrame(fin, opcode, payload) { + if (opcode === 0x8) return this.close(); + if (opcode === 0x9) return void this.socket.write(frame(0x0a, payload)); + if (opcode === 0x0a) return; + if (opcode === 0x0) { + this.fragments.push(payload); + if (fin) { + const data = Buffer.concat(this.fragments); + this.fragments = []; + this.message(this.fragmentOpcode, data); + } + return; + } + if (opcode !== 0x1) return; + if (!fin) { + this.fragmentOpcode = opcode; + this.fragments = [payload]; + return; + } + this.message(opcode, payload); + } + + message(_opcode, payload) { + let request; + try { + request = JSON.parse(payload.toString('utf8')); + } catch { + return; + } + this.owner.onMessage(this, request); + } + + send(value) { + if (!this.socket.destroyed) { + this.socket.write(frame(0x1, Buffer.from(JSON.stringify(value)))); + } + } + + close() { + if (!this.socket.destroyed) this.socket.end(); + } +} + +async function staticFile(base, pathname, req, res) { + let file = resolve(base, `.${pathname}`); + if (file !== base && !file.startsWith(base + sep)) { + res.writeHead(403).end(); + return; + } + try { + if ((await stat(file)).isDirectory()) file = join(file, 'index.html'); + } catch { + if (extname(pathname)) { + res.writeHead(404).end('not found'); + return; + } + file = join(base, 'index.html'); + } + try { + const body = await readFile(file); + res + .writeHead(200, { + 'content-type': MIME[extname(file)] ?? 'application/octet-stream', + 'cache-control': 'no-store', + }) + .end(req.method === 'HEAD' ? undefined : body); + } catch { + res.writeHead(404).end('not found'); + } +} + +export async function startWiringFixture({ root, refuse = false }) { + const base = await realpath(root); + const connections = new Set(); + const sockets = new Set(); + const counts = { subscribed: 0, listPipelines: 0, listRuns: 0, getPipeline: 0, dropped: 0 }; + let refusing = refuse; + + const dropConnections = () => { + for (const connection of connections) connection.close(); + connections.clear(); + counts.dropped++; + }; + + const server = createServer(async (req, res) => { + const pathname = new URL(req.url, 'http://fixture').pathname; + if (pathname === '/fixture/drop' && req.method === 'POST') { + dropConnections(); + res.writeHead(200).end('{"ok":true}'); + return; + } + if (pathname === '/fixture/refuse' && req.method === 'POST') { + refusing = true; + dropConnections(); + res.writeHead(200).end('{"ok":true}'); + return; + } + if (pathname === '/fixture/accept' && req.method === 'POST') { + refusing = false; + res.writeHead(200).end('{"ok":true}'); + return; + } + if (pathname === '/fixture/state') { + res + .writeHead(200, { 'content-type': 'application/json' }) + .end(JSON.stringify({ ...counts, connections: connections.size, refusing })); + return; + } + if (req.method !== 'GET' && req.method !== 'HEAD') { + res.writeHead(405).end(); + return; + } + await staticFile(base, pathname, req, res); + }); + + server.on('upgrade', (req, socket, head) => { + if (refusing) { + socket.end('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n'); + return; + } + const url = new URL(req.url, 'http://fixture'); + if ( + url.pathname !== '/connect' || + req.headers.upgrade?.toLowerCase() !== 'websocket' || + !req.headers['sec-websocket-key'] + ) { + socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n'); + return; + } + socket.write( + 'HTTP/1.1 101 Switching Protocols\r\n' + + 'Upgrade: websocket\r\n' + + 'Connection: Upgrade\r\n' + + `Sec-WebSocket-Accept: ${accept(req.headers['sec-websocket-key'])}\r\n\r\n`, + ); + const connection = new Connection(socket, { + onMessage: (client, request) => { + switch (request.type) { + case 'subscribe': + counts.subscribed++; + return; + case 'unsubscribe': + return; + case 'list_pipelines': + counts.listPipelines++; + client.send({ id: request.id, type: 'pipelines', pipelines: PIPELINES }); + return; + case 'list_runs': + counts.listRuns++; + client.send({ id: request.id, type: 'runs', runs: RUNS }); + return; + case 'get_pipeline': { + counts.getPipeline++; + const id = request.pipeline_id; + if (!PIPELINES.some((pipeline) => pipeline.id === id)) { + client.send({ + id: request.id, + type: 'error', + error: `Fixture pipeline ${id} is unavailable`, + }); + return; + } + client.send({ + id: request.id, + type: 'pipeline', + detail: detail(id, request.version), + }); + return; + } + case 'ping': + client.send({ + id: request.id, + type: 'pong', + build: { version: 'Fixture wiring build' }, + time: '2026-10-21T12:00:00Z', + }); + return; + default: + client.send({ + id: request.id, + type: 'error', + error: `Fixture does not implement ${request.type}`, + }); + } + }, + }); + connections.add(connection); + socket.on('data', (chunk) => connection.push(chunk)); + socket.on('close', () => connections.delete(connection)); + socket.on('error', () => connections.delete(connection)); + connection.push(head); + }); + + server.listen(0, '127.0.0.1'); + await once(server, 'listening'); + server.on('connection', (socket) => { + sockets.add(socket); + socket.on('close', () => sockets.delete(socket)); + }); + + return { + server, + url: `http://127.0.0.1:${server.address().port}`, + state: async () => (await fetch(`http://127.0.0.1:${server.address().port}/fixture/state`)).json(), + close: () => + new Promise((resolveClose) => { + for (const connection of connections) connection.close(); + server.close(() => resolveClose()); + for (const socket of sockets) socket.destroy(); + }), + }; +} diff --git a/app/tool/runs_probe.mjs b/app/tool/runs_probe.mjs index 4d816d2e..846cc110 100644 --- a/app/tool/runs_probe.mjs +++ b/app/tool/runs_probe.mjs @@ -110,7 +110,7 @@ try { const semanticText = () => evaluate(`(() => { const chunks = []; - for (const el of document.querySelectorAll('flt-semantics')) { + for (const el of document.querySelectorAll('flt-semantics, [aria-label], [aria-valuetext]')) { const label = el.getAttribute('aria-label'); if (label) chunks.push(label); const value = el.getAttribute('aria-valuetext'); @@ -153,7 +153,7 @@ try { return label === wanted || (${contains} && label.includes(wanted)); }); const interactive = candidates.find((el) => - ['button', 'tab', 'link', 'checkbox', 'menuitem'].includes(el.getAttribute('role')), + ['button', 'tab', 'link', 'checkbox', 'radio', 'menuitem'].includes(el.getAttribute('role')), ); const target = interactive ?? candidates[0]; if (!target) return false; @@ -377,6 +377,25 @@ try { if ((await path()) !== '/settings') throw new Error('Settings did not update route'); captures.push(await capture('settings-cupertino-registered-phone')); + await clickText('Runs'); + await clickText('Fixture cancel run', { contains: true }); + await assertBody('Original prompt'); + await clickText('Cancel run'); + await assertBody('Cancel run 4?'); + captures.push(await capture('cancel-cupertino-confirm')); + await clickText('Keep'); + await assertBody('Original prompt'); + const kept = await (await fetch(`${fixture.url}/fixture/state`)).json(); + if (kept.cancelRequests.length) throw new Error('Keep sent a cancellation'); + await clickText('Back', { contains: true }); + await clickText('Fixture human run', { contains: true }); + captures.push(await capture('decision-cupertino-card')); + await assertBody('Waiting for your decision'); + await clickText('Decide'); + await assertBody('Please review this recorded checkpoint.'); + captures.push(await capture('decision-cupertino-confirm')); + await clickText('Cancel'); + // Material host: the same deep link and route must render standard Material // controls (the Cupertino host was selected by the macOS browser above). await send( @@ -408,7 +427,46 @@ try { } captures.push(await capture('settings-material-registered-phone')); + await clickText('Runs'); + await clickText('Fixture cancel run', { contains: true }); + await assertBody('Original prompt'); + await clickText('Cancel run'); + await assertBody('Cancel run 4?'); + captures.push(await capture('cancel-material-confirm')); + await clickText('Cancel run'); + await assertBody('canceled'); + captures.push(await capture('cancel-material-accepted')); + await clickText('Back to list'); + await assertBody('Fixture cancel run'); + await assertBody('canceled'); + + await clickText('Fixture human run', { contains: true }); + await assertBody('Waiting for your decision'); + captures.push(await capture('decision-material-card')); + await clickText('Decide'); + await assertBody('Please review this recorded checkpoint.'); + captures.push(await capture('decision-material-confirm')); + const pendingDecision = await (await fetch(`${fixture.url}/fixture/state`)).json(); + if (pendingDecision.decisionRequests.length) throw new Error('Opening decision sent a reply'); + await clickText('approve', { contains: true }); + await clickText('Confirm decision'); + await assertBody('succeeded'); + if ((await semanticText()).includes('Waiting for your decision')) { + throw new Error('Accepted human decision left the waiting card behind'); + } + captures.push(await capture('decision-material-accepted')); + await clickText('Back to list'); + await assertBody('Fixture cancel run'); + await assertBody('canceled'); + const fixtureState = await (await fetch(`${fixture.url}/fixture/state`)).json(); + if (JSON.stringify(fixtureState.decisionRequests) !== + JSON.stringify([{ run_id: 5, stage: 'gate', option: 'approve' }])) { + throw new Error('Decision sent the wrong payload or repeated the request'); + } + if (JSON.stringify(fixtureState.cancelRequests) !== JSON.stringify([{ run_id: 4 }])) { + throw new Error('Cancel sent the wrong payload or repeated the request'); + } if (fixtureState.subscribed < 2) throw new Error(`App never resubscribed: ${JSON.stringify(fixtureState)}`); if (fixtureState.listRuns < 2) throw new Error(`App never reloaded: ${JSON.stringify(fixtureState)}`); if (fixtureState.getRun < 2) throw new Error(`Detail was not rehydrated: ${JSON.stringify(fixtureState)}`); diff --git a/app/tool/runs_probe_server.mjs b/app/tool/runs_probe_server.mjs index 79160044..b9ece509 100644 --- a/app/tool/runs_probe_server.mjs +++ b/app/tool/runs_probe_server.mjs @@ -45,8 +45,30 @@ const RUNS = [ created_at: '2026-10-21T10:00:00Z', pipeline_id: 10, }, + { + id: 4, title: 'Fixture cancel run', name: 'fixture-cancel', + status: 'running', executing: true, + created_at: '2026-10-21T09:00:00Z', pipeline_id: 10, + }, + { + id: 5, title: 'Fixture human run', name: 'fixture-human', + status: 'waiting', executing: false, + created_at: '2026-10-21T08:00:00Z', pipeline_id: 10, + }, ]; +function humanDetail(accepted) { + return { + ...RUNS.find((run) => run.id === 5), + status: accepted ? 'succeeded' : 'waiting', current_stage: 'gate', + input: { prompt: 'Fixture human decision' }, + graph: { stages: [{ key: 'gate', type: 'human', edges: { approve: '#success' } }] }, + steps: [{ sequence: 1, stage: 'gate', status: accepted ? 'completed' : 'waiting', + output: { prompt: 'Please review this recorded checkpoint.', options: ['approve'] }, + }], + }; +} + const LIVE_EVENT = { type: 'run_event', run_id: 1, @@ -57,13 +79,15 @@ const LIVE_EVENT = { finished_at: '2026-10-21T12:05:00Z', }; -function detail(id, live) { - const status = id === 1 && live ? 'succeeded' : id === 3 ? 'failed' : 'running'; +function detail(id, live, canceled = false) { + const status = canceled ? 'canceled' + : id === 1 && live ? 'succeeded' : id === 3 ? 'failed' : 'running'; return { id, title: RUNS.find((run) => run.id === id)?.title ?? `Run ${id}`, name: 'fixture-pipeline', status, + executing: status === 'running', input: { prompt: ' fixture prompt with spaces ', note: 'input payload', @@ -260,6 +284,10 @@ export async function startFixture({ root }) { let dropped = 0; let listRuns = 0; let getRun = 0; + const canceled = new Set(); + const cancelRequests = []; + let decisionAccepted = false; + const decisionRequests = []; const dropConnections = () => { for (const connection of connections) connection.close(); @@ -306,6 +334,8 @@ export async function startFixture({ root }) { dropped, listRuns, getRun, + cancelRequests, + decisionRequests, })); return; } @@ -355,7 +385,9 @@ export async function startFixture({ root }) { } if (request.type === 'list_runs') { listRuns++; - client.send({ id: request.id, type: 'runs', runs: RUNS, usage: null }); + client.send({ id: request.id, type: 'runs', runs: RUNS.map((run) => + canceled.has(run.id) ? { ...run, status: 'canceled', executing: false } + : run.id === 5 && decisionAccepted ? { ...run, status: 'succeeded' } : run), usage: null }); return; } if (request.type === 'get_run') { @@ -377,7 +409,22 @@ export async function startFixture({ root }) { }); return; } - client.send({ id: request.id, type: 'run', run_detail: detail(id, live) }); + client.send({ id: request.id, type: 'run', run_detail: id === 5 + ? humanDetail(decisionAccepted) : detail(id, live, canceled.has(id)) }); + return; + } + if (request.type === 'cancel_run' && request.run_id === 4) { + cancelRequests.push({ run_id: request.run_id }); + canceled.add(4); + client.send({ id: request.id, type: 'run', run_detail: detail(4, live, true) }); + return; + } + if (request.type === 'decide_run' && request.run_id === 5 && + request.stage === 'gate' && request.option === 'approve') { + decisionRequests.push({ run_id: request.run_id, stage: request.stage, + option: request.option, ...(request.feedback ? { feedback: request.feedback } : {}) }); + decisionAccepted = true; + client.send({ id: request.id, type: 'run', run_detail: humanDetail(true) }); return; } client.send({