claude: Bash live-tail detection + read-only file follower (T-325, core)

The detection/follow core for the live-tail sub-card, with the UI wiring to follow. Claude Code runs every Bash tool itself and clide only sees the final tool_result block — we can't mirror the running process, so instead we detect a file-backed source the command follows and open our own read-only follower on the same file. - bash_tail_source.dart: detectBashTailSource() parses a Bash command for a single, safe, file-backed source (tail/cat/less with one file arg, inside the workspace via resolveUnderRoot). Returns null for a pipe-into-tail, a redirect, two files, or a path outside the repo — the caller then shows a "nothing to follow" note. bashHasTailIntent() gates WHEN the segment appears: v1 triggers on `tail`/follow-flags only, so ordinary cat/ls/git cards stay clean (cat/less remain detectable for later). - file_tail_follower.dart: a polling, read-only `tail -f`-style follower (no subprocess, no touching Claude's command) that emits the trailing window then appended deltas, and re-reads from the top on truncation. Tested: 19 parser cases (incl. the `git push | tail -25` and outside- workspace null cases), the intent predicate, and the follower (initial window / appended delta / missing file / rotation / start / stop). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-11 17:12:53 +02:00
parent d43ddfed9c
commit 898a0316e5
10 changed files with 510 additions and 0 deletions
@@ -0,0 +1,80 @@
+/// Read-only file follower for the Bash live-tail sub-card (T-325).
+///
+/// clide can't see a running Bash command's stdout (Claude Code owns the
+/// process), so to "watch the same output" we open our OWN read-only follower
+/// on the file the command tails. This never spawns a process and never
+/// touches Claude's command — it just reads the file as it grows, like
+/// `tail -f`, and hands new bytes to [onData].
+///
+/// Pure dart:io/dart:async (no Flutter) so it's unit-testable. Polls rather
+/// than using a watcher so it works uniformly across platforms and survives
+/// truncation/rotation (size shrinking → re-read from the top).
+library;
+
+import 'dart:async';
+import 'dart:io';
+import 'dart:typed_data';
+
+class FileTailFollower {
+  FileTailFollower(this.path, {required this.onData, this.tailBytes = 16384, this.interval = const Duration(milliseconds: 300)});
+
+  /// Absolute path of the file to follow.
+  final String path;
+
+  /// New bytes appended since the last read (or the initial tail window).
+  final void Function(Uint8List bytes) onData;
+
+  /// On first read, start this many bytes from the end (a `tail -c` window)
+  /// rather than dumping the whole file.
+  final int tailBytes;
+
+  final Duration interval;
+
+  int _pos = 0;
+  bool _primed = false;
+  bool _stopped = false;
+  Timer? _timer;
+
+  /// Begin following: emit the initial tail window, then poll for growth.
+  Future<void> start() async {
+    await pollOnce();
+    if (_stopped) return;
+    _timer = Timer.periodic(interval, (_) => pollOnce());
+  }
+
+  /// One read cycle. Public so tests can drive it deterministically without
+  /// waiting on the timer. Reads any bytes appended since the last position
+  /// (or, on the first call, the trailing [tailBytes]); resets to the top if
+  /// the file shrank (truncated/rotated).
+  Future<void> pollOnce() async {
+    if (_stopped) return;
+    final file = File(path);
+    if (!await file.exists()) return; // not created yet — keep waiting
+    final length = await file.length();
+
+    if (!_primed) {
+      _pos = length > tailBytes ? length - tailBytes : 0;
+      _primed = true;
+    } else if (length < _pos) {
+      _pos = 0; // truncated / rotated → re-read from the top
+    }
+    if (length <= _pos) return;
+
+    final raf = await file.open();
+    try {
+      await raf.setPosition(_pos);
+      final bytes = await raf.read(length - _pos);
+      _pos = length;
+      if (!_stopped && bytes.isNotEmpty) onData(Uint8List.fromList(bytes));
+    } finally {
+      await raf.close();
+    }
+  }
+
+  /// Stop following and release the timer. Idempotent.
+  void stop() {
+    _stopped = true;
+    _timer?.cancel();
+    _timer = null;
+  }
+}