Merge branch 'worktree-agent-a2791c24c562412e3'

# Conflicts:
#	app/lib/features/chat/conversation/chat_thread_view.dart
#	internal/protocol/message.go
This commit is contained in:
2026-11-09 22:07:45 +00:00
50 changed files with 5051 additions and 9 deletions
+57
View File
@@ -0,0 +1,57 @@
import 'package:flutter/widgets.dart';
import '../core/api_gateway.dart';
import '../core/servers/chat/chat_server_pool.dart';
import '../features/terminal/terminal_hub.dart';
import '../features/terminal/terminal_layout.dart';
import '../features/terminal/terminal_machines.dart';
import '../features/terminal/terminal_surface.dart';
import '../features/terminal/terminal_toggle_button.dart';
/// The app's machine terminals: one hub over every connected machine (the
/// chat pool's, else the app's own server), kept for the app's lifetime so
/// shells and their output survive navigation and hidden panels.
class AppTerminals {
AppTerminals({
required ChatServerPool? pool,
required Listenable connection,
required bool Function() connected,
required ApiGateway gateway,
required String machineId,
required String machineName,
required this.layout,
}) : machines = pool != null
? PoolTerminalMachines(pool)
: SingleTerminalMachines(
connection: connection,
connected: connected,
machine: TerminalMachine(
id: machineId,
name: machineName,
gateway: gateway,
),
) {
hub = TerminalHub(machines);
}
final ValueNotifier<List<TerminalMachine>> machines;
final TerminalLayout layout;
late final TerminalHub hub;
/// [shell] with the terminal panel, window or page around it.
Widget surround(Widget shell, {required bool cupertino}) => TerminalSurface(
hub: hub,
layout: layout,
cupertino: cupertino,
child: shell,
);
/// The bar button showing or hiding the terminal.
Widget toggle({required bool cupertino}) =>
TerminalToggleButton(layout: layout, cupertino: cupertino);
void dispose() {
hub.dispose();
machines.dispose();
}
}
+3
View File
@@ -1,3 +1,4 @@
import '../features/terminal/terminal_layout.dart';
import '../core/session/server_session.dart';
import '../ui/scale/ui_scale.dart';
import 'package:flutter/foundation.dart';
@@ -60,6 +61,7 @@ Future<void> runPipelinesApp({
// not hold the first frame, and applies when it lands.
final animationSpeed = AnimationSpeedController.instance.restore();
final uiScale = UiScaleController.instance.restore();
final terminalLayout = TerminalLayout.instance.restore();
final quickSwitchAnimation = QuickSwitchAnimationController.instance
.restore();
final font = AppFontController.instance.restore(wait: appFontStartupWait);
@@ -68,6 +70,7 @@ Future<void> runPipelinesApp({
await font;
await animationSpeed;
await uiScale;
await terminalLayout;
await quickSwitchAnimation;
final server = await resolveLaunchServer(
base: base,
+24 -1
View File
@@ -32,6 +32,8 @@ import '../features/updates/launch_update_dialog.dart';
import '../features/updates/web_release.dart';
import '../features/settings/server_connections.dart';
import 'app.dart';
import 'app_terminals.dart';
import '../features/terminal/terminal_layout.dart';
import 'app_route.dart';
import 'app_router.dart';
import 'app_session.dart';
@@ -82,9 +84,13 @@ class PipelinesApp extends StatefulWidget {
this.androidInstaller = downloadAndInstall,
this.webRefresher = refreshWebPage,
this.tabLocationsStore,
this.terminalLayout,
});
final TabLocationsStore? tabLocationsStore;
/// The terminal surface's saved layout; null is the device's own.
final TerminalLayout? terminalLayout;
final ServerEndpoint server;
final PipelinesClient? client;
final bool? cupertino;
@@ -195,6 +201,7 @@ class _PipelinesAppState extends State<PipelinesApp>
},
);
NotificationServiceHandoff? _deliveryHandoff;
late final AppTerminals _terminals;
@override
void initState() {
@@ -213,6 +220,18 @@ class _PipelinesAppState extends State<PipelinesApp>
serverId: widget.serverId,
);
bindServerIdentity(_session.gateway, widget.serverId);
_terminals = AppTerminals(
pool: widget.chatPool,
connection: _session,
connected: () => _session.connected,
gateway: _session.gateway,
machineId: widget.serverId ?? 'server',
machineName:
widget.servers?.catalog.active?.name ??
widget.server.uri?.host ??
'This server',
layout: widget.terminalLayout ?? TerminalLayout.instance,
);
_ownsProvider = widget.routeInformationProvider == null;
_provider =
widget.routeInformationProvider ??
@@ -421,6 +440,7 @@ class _PipelinesAppState extends State<PipelinesApp>
if (_ownsProvider) {
(_provider as PlatformRouteInformationProvider).dispose();
}
_terminals.dispose();
_session.dispose();
super.dispose();
}
@@ -697,7 +717,8 @@ class _PipelinesAppState extends State<PipelinesApp>
Widget _buildShell(BuildContext context, AppRoute route) =>
ValueListenableBuilder<int>(
valueListenable: _attentionCount,
builder: (context, count, _) => _shellFor(route, count),
builder: (context, count, _) =>
_terminals.surround(_shellFor(route, count), cupertino: _cupertino),
);
Widget _shellFor(AppRoute route, int attentionCount) {
@@ -715,6 +736,7 @@ class _PipelinesAppState extends State<PipelinesApp>
final runsRoute = tab(AppDestination.runs);
final chatRoute = tab(AppDestination.chat);
return AdaptiveShell(
barActions: [_terminals.toggle(cupertino: _cupertino)],
attentionCount: attentionCount,
cupertino: _cupertino,
destination: _destinationOf(route.kind),
@@ -803,6 +825,7 @@ class _PipelinesAppState extends State<PipelinesApp>
// Settings is a page of the Pipelines tab (its bar's gear), not a
// tab; the shell shows it with Back to Pipelines.
AppDestination.settings: (_) => SettingsScreen(
terminalLayout: _terminals.layout,
navigationScope: _navigationScope,
client: _session.client,
// A phone signs in at the web login; a browser has its own.
@@ -1,3 +1,4 @@
import '../../terminal/terminal_open_action.dart';
import 'dart:async';
import 'package:flutter/cupertino.dart';
@@ -1412,6 +1413,15 @@ class _ChatThreadViewState extends State<ChatThreadView> {
chatShellRunMenuAction(onPressed: _runShellFromMenu),
if (_shellRuns.finishedIds.isNotEmpty)
chatShellDismissAllMenuAction(onPressed: _dismissFinishedShellRuns),
?terminalOpenMenuAction(
context,
gateway: widget.gateway,
directory: directory,
onRefused: (refusal) => _showCommandNotice(
"Couldn't open a terminal: $refusal",
failed: true,
),
),
],
controls: [
if (hasModel)
+16 -2
View File
@@ -14,6 +14,8 @@ import 'files_upload_notice.dart';
import 'files_viewer.dart';
import 'files_header.dart';
import '../../../ui/layout/app_overflow_menu.dart';
import '../../terminal/terminal_open_action.dart';
import '../../terminal/terminal_scope.dart';
const double filesPanelMinWidth = 280;
const double filesPanelMaxWidth = 420;
@@ -23,8 +25,9 @@ double filesPanelWidth(double available) => (available * filesPanelFraction)
.clamp(filesPanelMinWidth, filesPanelMaxWidth);
/// The actions of an entry's row or tile menu. Open and Download are for
/// files; Rename, Move and Delete apply to files and folders alike.
enum FileAction { open, download, rename, move, delete }
/// files, Open in terminal for folders (where the app has a terminal);
/// Rename, Move and Delete apply to files and folders alike.
enum FileAction { open, download, terminal, rename, move, delete }
class FilesPanel extends StatefulWidget {
const FilesPanel({
@@ -180,6 +183,12 @@ class _FilesPanelState extends State<FilesPanel> {
endpoint: _endpoint,
entry: entry,
),
// A refusal shows in the terminal the surface opens.
FileAction.terminal => openInTerminal(
context,
controller.gateway,
entry.path,
),
FileAction.rename => renameEntry(context, controller, entry),
FileAction.move => moveEntry(context, controller, entry),
FileAction.delete => deleteEntry(context, controller, entry),
@@ -189,6 +198,11 @@ class _FilesPanelState extends State<FilesPanel> {
AppMenuAction(value: FileAction.open, label: 'Open'),
AppMenuAction(value: FileAction.download, label: 'Download'),
],
if (entry.isDir && TerminalScope.maybeOf(context) != null)
const AppMenuAction(
value: FileAction.terminal,
label: terminalOpenActionLabel,
),
const AppMenuAction(value: FileAction.rename, label: 'Rename…'),
const AppMenuAction(value: FileAction.move, label: 'Move…'),
const AppMenuAction(
@@ -28,7 +28,7 @@ class ChatShellTerminals {
final void Function(String runId, Object error) onError;
final Map<String, ChatShellTerminalSession> _sessions = {};
final Map<String, _InputPipe> _inputs = {};
final Map<String, ChatShellInputPipe> _inputs = {};
final Map<String, Timer> _resizes = {};
final Map<String, (int, int)> _sentSizes = {};
bool _disposed = false;
@@ -74,7 +74,7 @@ class ChatShellTerminals {
_inputs
.putIfAbsent(
runId,
() => _InputPipe(
() => ChatShellInputPipe(
(data) => _repository.input(_sessionId, runId, data),
(error) => onError(runId, error),
),
@@ -106,11 +106,12 @@ class ChatShellTerminals {
}
}
/// One run's typed input on its way to the server, in order: what arrives
/// One terminal's typed input on its way to the server (a chat run's or a
/// machine terminal's), in order: what arrives
/// while a request is in flight goes in the next one. Nothing is kept once
/// sent, and a refusal discards what was waiting rather than retyping it.
class _InputPipe {
_InputPipe(this._send, this._failed);
class ChatShellInputPipe {
ChatShellInputPipe(this._send, this._failed);
final Future<void> Function(String data) _send;
final void Function(Object error) _failed;
@@ -1,3 +1,5 @@
import '../terminal/terminal_layout.dart';
import 'settings_terminal_section.dart';
import '../../ui/adaptive/segmented_bar.dart';
import 'dart:async';
@@ -66,12 +68,17 @@ class SettingsScreen extends StatefulWidget {
this.deliveryServiceController,
this.fonts,
this.animationSpeed,
this.terminalLayout,
});
/// The device's interface font; defaults to the app's shared controller.
final AppFontController? fonts;
final AnimationSpeedController? animationSpeed;
/// The terminal surface's layout (its mode is chosen here); null is the
/// device's own.
final TerminalLayout? terminalLayout;
/// Android background delivery; hidden when absent or unsupported.
final NotificationServiceBridge? deliveryService;
final NotificationServiceController? deliveryServiceController;
@@ -0,0 +1,85 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../terminal/terminal_layout.dart';
import 'settings_group.dart';
import 'settings_theme.dart';
/// Appearance → Terminal: whether the terminal docks at the bottom of the
/// window or floats over it (Ctrl+` shows and hides it either way).
class SettingsTerminalSection extends StatelessWidget {
const SettingsTerminalSection({super.key, required this.layout});
final TerminalLayout layout;
@override
Widget build(BuildContext context) => ListenableBuilder(
listenable: layout,
builder: (context, _) {
final cupertino = usesCupertinoControls(context);
final Widget choice = cupertino
? CupertinoSlidingSegmentedControl<TerminalMode>(
groupValue: layout.mode,
children: {
for (final mode in TerminalMode.values)
mode: Padding(
key: ValueKey('settings-terminal-${mode.name}'),
padding: const EdgeInsets.symmetric(horizontal: 8),
child: Text(mode.label),
),
},
onValueChanged: (mode) {
if (mode != null) layout.setMode(mode);
},
)
: SegmentedButton<TerminalMode>(
segments: [
for (final mode in TerminalMode.values)
ButtonSegment(
value: mode,
label: Text(
mode.label,
key: ValueKey('settings-terminal-${mode.name}'),
),
icon: Icon(
mode == TerminalMode.panel
? Icons.call_to_action_outlined
: Icons.picture_in_picture_alt_outlined,
),
),
],
selected: {layout.mode},
onSelectionChanged: (modes) => layout.setMode(modes.first),
);
return SettingsGroup(
title: 'Terminal',
footer: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
const Text(
'Saved on this device. Ctrl+` shows or hides the terminal; on '
'a narrow window it opens full screen. Shells keep running '
'while it is hidden.',
),
if (layout.saveFailed)
Text(
'Could not save; applies until reload.',
style: TextStyle(color: settingsErrorColor(context)),
),
],
),
children: [
SettingsGroupItem(
child: Semantics(
label: 'Terminal placement',
child: Align(
alignment: AlignmentDirectional.centerStart,
child: choice,
),
),
),
],
);
},
);
}
@@ -14,6 +14,9 @@ extension _SettingsTopicPages on _SettingsScreenState {
SettingsFontSection(
controller: widget.fonts ?? AppFontController.instance,
),
SettingsTerminalSection(
layout: widget.terminalLayout ?? TerminalLayout.instance,
),
],
),
SettingsTopic.connection: (_) => SettingsPageBody(
@@ -0,0 +1,126 @@
import 'dart:async';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../chat/shell/chat_shell_terminal_keys.dart';
import '../chat/shell/chat_shell_terminal_view.dart';
import 'terminal_hub.dart';
import 'terminal_tab.dart';
/// The selected terminal: its emulator (focused when shown), what the
/// operator should know about it (ended, machine offline, ends with the
/// server) and, with [keys], the touch key toolbar.
class TerminalBody extends StatelessWidget {
const TerminalBody({
super.key,
required this.hub,
required this.cupertino,
this.keys = false,
});
final TerminalHub hub;
final bool cupertino;
final bool keys;
@override
Widget build(BuildContext context) {
final tab = hub.selected;
if (tab == null) return _empty(context);
final notes = <String>[
if (!tab.connected)
'${tab.machineName} is not connected; the terminal resumes when it is.'
else if (!tab.info.running)
tab.info.endedText
else if (!tab.info.persistent)
'This shell ends if the server on ${tab.machineName} restarts '
'(tmux is not installed there).',
?tab.error,
?hub.error,
];
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Expanded(
child: Padding(
padding: const EdgeInsets.fromLTRB(8, 0, 8, 8),
child: ChatShellTerminalView(
key: ValueKey('terminal-view-${tab.key}'),
session: tab.session,
cupertino: cupertino,
fill: true,
autofocus: true,
),
),
),
for (final note in notes)
Padding(
padding: const EdgeInsets.fromLTRB(12, 0, 12, 8),
child: Text(note, style: _noteStyle(context)),
),
if (keys && tab.session.live && tab.connected)
Padding(
padding: const EdgeInsets.fromLTRB(8, 0, 8, 8),
child: ChatShellTerminalKeys(
session: tab.session,
cupertino: cupertino,
field: chatShellTouchFirst(),
),
),
if (!tab.info.running && tab.connected) _closeEnded(tab),
],
);
}
TextStyle? _noteStyle(BuildContext context) => cupertino
? CupertinoTheme.of(context).textTheme.textStyle.copyWith(
color: CupertinoColors.secondaryLabel.resolveFrom(context),
)
: Theme.of(context).textTheme.bodySmall?.copyWith(
color: Theme.of(context).colorScheme.onSurfaceVariant,
);
Widget _closeEnded(TerminalTab tab) {
void close() => unawaited(hub.close(tab));
return Padding(
padding: const EdgeInsets.fromLTRB(8, 0, 8, 8),
child: Align(
alignment: AlignmentDirectional.centerStart,
child: cupertino
? CupertinoButton(onPressed: close, child: const Text('Close tab'))
: TextButton(onPressed: close, child: const Text('Close tab')),
),
);
}
Widget _empty(BuildContext context) {
final machines = hub.connected;
final text = machines.isEmpty
? 'No machine is connected.'
: 'No terminals are open.';
void open() => unawaited(hub.open());
return Center(
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
Text(text, style: _noteStyle(context)),
if (hub.error case final error?)
Padding(
padding: const EdgeInsets.all(8),
child: Text(error, style: _noteStyle(context)),
),
if (machines.isNotEmpty)
cupertino
? CupertinoButton(
onPressed: open,
child: const Text('New terminal'),
)
: FilledButton.tonal(
onPressed: open,
child: const Text('New terminal'),
),
],
),
);
}
}
@@ -0,0 +1,230 @@
import 'dart:async';
import 'package:flutter/cupertino.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'terminal_body.dart';
import 'terminal_hub.dart';
import 'terminal_layout.dart';
import 'terminal_tab_strip.dart';
/// Margin a maximised window keeps from the edges of the app.
const double terminalFloatMargin = 8;
/// [rect] moved and shrunk to fit inside [bounds], at least the minimum
/// window size where the bounds allow it.
Rect fitTerminalFloat(Rect rect, Size bounds) {
final width = rect.width
.clamp(terminalFloatMinSize.width, double.infinity)
.clamp(0.0, bounds.width);
final height = rect.height
.clamp(terminalFloatMinSize.height, double.infinity)
.clamp(0.0, bounds.height);
final left = rect.left.clamp(0.0, bounds.width - width);
final top = rect.top.clamp(0.0, bounds.height - height);
return Rect.fromLTWH(left, top, width, height);
}
/// The terminal as a window over the app: moved by its title bar, resized
/// from its lower right corner, minimised to its title bar or maximised to
/// the app. Its frame is kept in [layout].
class TerminalFloat extends StatelessWidget {
const TerminalFloat({
super.key,
required this.hub,
required this.layout,
required this.cupertino,
required this.bounds,
});
final TerminalHub hub;
final TerminalLayout layout;
final bool cupertino;
final Size bounds;
/// Where the window is drawn now.
Rect get frame => layout.maximized
? (Offset.zero & bounds).deflate(terminalFloatMargin)
: fitTerminalFloat(layout.floatRect, bounds);
void _move(Offset delta) {
if (layout.maximized) return;
layout.setFloatRect(frame.shift(delta), save: false);
}
void _resize(Offset delta) {
final rect = frame;
layout.setFloatRect(
fitTerminalFloat(
Rect.fromLTWH(
rect.left,
rect.top,
rect.width + delta.dx,
rect.height + delta.dy,
),
bounds,
),
save: false,
);
}
@override
Widget build(BuildContext context) {
final rect = frame;
final title = _titleBar(context);
final Widget window;
if (layout.minimized) {
window = SizedBox(width: rect.width, child: title);
} else {
window = SizedBox.fromSize(
size: rect.size,
child: Stack(
children: [
Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
title,
TerminalTabStrip(
hub: hub,
layout: layout,
cupertino: cupertino,
),
Expanded(
child: TerminalBody(hub: hub, cupertino: cupertino),
),
],
),
if (!layout.maximized)
PositionedDirectional(end: 0, bottom: 0, child: _corner()),
],
),
);
}
return Positioned(
left: rect.left,
top: rect.top,
child: Semantics(
container: true,
label: 'Terminal window',
child: _chrome(context, window),
),
);
}
Widget _chrome(BuildContext context, Widget child) {
if (!cupertino) {
return Material(
elevation: 8,
clipBehavior: Clip.antiAlias,
borderRadius: BorderRadius.circular(12),
color: Theme.of(context).colorScheme.surfaceContainer,
child: child,
);
}
return DecoratedBox(
decoration: BoxDecoration(
color: CupertinoColors.secondarySystemBackground.resolveFrom(context),
borderRadius: BorderRadius.circular(12),
border: Border.all(
color: CupertinoColors.separator.resolveFrom(context),
),
boxShadow: const [BoxShadow(blurRadius: 16, color: Color(0x33000000))],
),
child: ClipRRect(
borderRadius: BorderRadius.circular(12),
child: Material(type: MaterialType.transparency, child: child),
),
);
}
Widget _titleBar(BuildContext context) {
final label = Text(
hub.selected?.title ?? 'Terminal',
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: cupertino
? CupertinoTheme.of(context).textTheme.navTitleTextStyle
: Theme.of(context).textTheme.titleSmall,
);
final drag = MouseRegion(
cursor: layout.maximized
? SystemMouseCursors.basic
: SystemMouseCursors.move,
child: GestureDetector(
key: const ValueKey('terminal-float-title'),
behavior: HitTestBehavior.opaque,
// The window follows the pointer from where it went down.
dragStartBehavior: DragStartBehavior.down,
onPanUpdate: (details) => _move(details.delta),
onPanEnd: (_) => unawaited(layout.save()),
onDoubleTap: () => layout.setMaximized(!layout.maximized),
child: Padding(
padding: const EdgeInsetsDirectional.only(start: 12),
child: Align(
alignment: AlignmentDirectional.centerStart,
child: label,
),
),
),
);
return Row(
children: [
Expanded(child: drag),
_button(
layout.minimized ? 'Restore' : 'Minimise',
layout.minimized ? Icons.expand_less : Icons.minimize,
layout.minimized ? CupertinoIcons.chevron_up : CupertinoIcons.minus,
() => layout.setMinimized(!layout.minimized),
),
_button(
layout.maximized ? 'Restore size' : 'Maximise',
layout.maximized ? Icons.fullscreen_exit : Icons.fullscreen,
layout.maximized
? CupertinoIcons.fullscreen_exit
: CupertinoIcons.fullscreen,
() => layout.setMaximized(!layout.maximized),
),
_button(
'Hide terminal',
Icons.close,
CupertinoIcons.xmark,
layout.hide,
),
],
);
}
Widget _button(
String label,
IconData material,
IconData cupertinoIcon,
VoidCallback onPressed,
) => cupertino
? CupertinoButton(
padding: const EdgeInsets.symmetric(horizontal: 8),
onPressed: onPressed,
child: Icon(cupertinoIcon, semanticLabel: label),
)
: IconButton(tooltip: label, onPressed: onPressed, icon: Icon(material));
Widget _corner() => Semantics(
label: 'Resize terminal window',
child: MouseRegion(
cursor: SystemMouseCursors.resizeDownRight,
child: GestureDetector(
key: const ValueKey('terminal-float-resize'),
behavior: HitTestBehavior.opaque,
dragStartBehavior: DragStartBehavior.down,
onPanUpdate: (details) => _resize(details.delta),
onPanEnd: (_) => unawaited(layout.save()),
child: Padding(
padding: const EdgeInsets.all(4),
child: Icon(
cupertino ? CupertinoIcons.arrow_down_right : Icons.south_east,
),
),
),
),
);
}
+241
View File
@@ -0,0 +1,241 @@
import 'dart:async';
import 'package:flutter/foundation.dart';
import '../../core/api_gateway.dart';
import 'terminal_info.dart';
import 'terminal_machines.dart';
import 'terminal_tab.dart';
/// Every machine terminal the app shows, across the connected machines:
/// the tabs, the selected one, and their link to each machine's socket.
///
/// The hub belongs to the app, not to a view: terminals keep running and
/// keep their output while the panel is hidden or the window is minimised.
/// When a machine connects (first, or again after a drop or a server
/// restart) its terminals are listed, new ones get a tab, and every tab
/// resumes its output from the last byte it holds.
class TerminalHub extends ChangeNotifier {
TerminalHub(this.machines);
final TerminalMachines machines;
final Map<String, _Link> _links = {};
bool _active = false;
final List<TerminalTab> _tabs = [];
String? _selected;
bool _disposed = false;
/// The last refusal of an open or close, in the server's words.
String? error;
List<TerminalTab> get tabs => List.unmodifiable(_tabs);
List<TerminalMachine> get connected => machines.value;
TerminalTab? get selected =>
_tabs.where((tab) => tab.key == _selected).firstOrNull ??
_tabs.firstOrNull;
/// Whether the tabs come from more than one machine (or more than one
/// is connected), so each names its machine.
bool get multiMachine =>
connected.length > 1 ||
_tabs.map((tab) => tab.machineId).toSet().length > 1;
/// Starts following the machines: their terminals are listed now and on
/// every reconnect. The surface calls it the first time the terminal is
/// shown, so an app that never shows it sends no terminal requests (each
/// connection sends one request at a time; the first screen's read goes
/// first).
void activate() {
if (_active || _disposed) return;
_active = true;
machines.addListener(_machinesChanged);
_machinesChanged();
}
bool get active => _active;
void select(TerminalTab tab) {
if (_selected == tab.key) return;
_selected = tab.key;
_notify();
}
/// The machine [gateway] belongs to, if it is connected.
TerminalMachine? machineFor(String? id) =>
connected.where((machine) => machine.id == id).firstOrNull;
/// Opens a shell on [machineId] (the first connected machine when null)
/// in [cwd] (home when empty) and selects its tab. Returns the refusal.
Future<String?> open({String? machineId, String cwd = ''}) async {
activate();
final machine = machineId == null
? connected.firstOrNull
: machineFor(machineId);
if (machine == null) {
return error = 'No machine is connected to open a terminal on.';
}
try {
final reply = await machine.gateway.call('terminal_open', {
'terminal_request': {'cwd': ?(cwd.isEmpty ? null : cwd)},
});
final record = reply['terminal'];
if (record is! Map) throw StateError('The server sent no terminal.');
final tab = _adopt(machine, TerminalInfo.fromJson(record));
_selected = tab.key;
error = null;
_notify();
return null;
} catch (failure) {
error = '$failure';
_notify();
return error;
}
}
/// Ends [tab]'s shell (and its tmux session) and removes the tab. A tab
/// whose machine is not connected cannot be closed yet.
Future<String?> close(TerminalTab tab) async {
if (!tab.connected) {
return error = '${tab.machineName} is not connected.';
}
try {
await tab.gateway.call('terminal_close', {
'terminal_request': {'terminal_id': tab.info.id},
});
_remove(tab.key);
error = null;
return null;
} catch (failure) {
error = '$failure';
_notify();
return error;
}
}
TerminalTab _adopt(TerminalMachine machine, TerminalInfo info) {
final key = terminalKey(machine.id, info.id);
final existing = _tabs.where((tab) => tab.key == key).firstOrNull;
if (existing != null) {
existing.machineName = machine.name;
existing.attach(machine.gateway, info);
return existing;
}
final tab = TerminalTab(
machineId: machine.id,
machineName: machine.name,
gateway: machine.gateway,
info: info,
)..addListener(_notify);
_tabs.add(tab);
unawaited(tab.resume());
return tab;
}
void _remove(String key) {
final index = _tabs.indexWhere((tab) => tab.key == key);
if (index < 0) return;
final tab = _tabs.removeAt(index);
if (_selected == key) {
_selected = _tabs.isEmpty
? null
: _tabs[index.clamp(0, _tabs.length - 1)].key;
}
tab
..removeListener(_notify)
..dispose();
_notify();
}
void _machinesChanged() {
if (_disposed) return;
final ids = {for (final machine in connected) machine.id};
for (final id in _links.keys.where((id) => !ids.contains(id)).toList()) {
_links.remove(id)!.cancel();
for (final tab in _tabs.where((tab) => tab.machineId == id)) {
tab.disconnected();
}
}
for (final machine in connected) {
final link = _links[machine.id];
if (link != null && identical(link.gateway, machine.gateway)) continue;
link?.cancel();
_links[machine.id] = _Link(
machine.gateway,
machine.gateway.frames.listen((frame) => _frame(machine, frame)),
);
unawaited(_sync(machine));
}
_notify();
}
/// Lists [machine]'s terminals: each gets (or keeps) a tab, which then
/// resumes its output; tabs of terminals the machine no longer has go.
Future<void> _sync(TerminalMachine machine) async {
final List<TerminalInfo> infos;
try {
infos = terminalInfos(await machine.gateway.call('terminal_list'));
} catch (failure) {
// A server without terminals answers with an error; its tabs stay.
error = '$failure';
_notify();
return;
}
if (_disposed || !identical(_links[machine.id]?.gateway, machine.gateway)) {
return;
}
final listed = <String>{};
for (final info in infos.where((info) => !info.closed)) {
listed.add(_adopt(machine, info).key);
}
for (final tab in _tabs.toList()) {
if (tab.machineId == machine.id && !listed.contains(tab.key)) {
_remove(tab.key);
}
}
_notify();
}
void _frame(TerminalMachine machine, JsonMap frame) {
if (frame['type'] != 'terminal_event') return;
final event = frame['terminal_event'];
if (event is! Map) return;
final key = terminalKey(machine.id, '${event['terminal_id'] ?? ''}');
final record = event['terminal'];
if (record is Map) {
final info = TerminalInfo.fromJson(record);
if (info.closed) return _remove(key);
// A terminal another client opened appears here too.
if (!_tabs.any((tab) => tab.key == key)) {
_adopt(machine, info);
_notify();
return;
}
}
_tabs.where((tab) => tab.key == key).firstOrNull?.frame(event);
}
void _notify() {
if (!_disposed) notifyListeners();
}
@override
void dispose() {
_disposed = true;
if (_active) machines.removeListener(_machinesChanged);
for (final link in _links.values) {
link.cancel();
}
for (final tab in _tabs) {
tab.dispose();
}
super.dispose();
}
}
class _Link {
_Link(this.gateway, this.frames);
final ApiGateway gateway;
final StreamSubscription<JsonMap> frames;
void cancel() => unawaited(frames.cancel());
}
@@ -0,0 +1,97 @@
import '../../core/api_gateway.dart';
/// One machine terminal as the server records it (`terminal_list`,
/// `terminal_event`): a login shell on that machine, running or ended.
class TerminalInfo {
const TerminalInfo({
required this.id,
required this.cwd,
required this.status,
this.title = '',
this.shell = '',
this.tmux = '',
this.reason = '',
this.exitCode,
this.createdAt = 0,
this.cols = 0,
this.rows = 0,
this.stream = '',
this.outputEnd = 0,
});
factory TerminalInfo.fromJson(Map json) => TerminalInfo(
id: '${json['id'] ?? ''}',
cwd: '${json['cwd'] ?? ''}',
status: '${json['status'] ?? ''}',
title: '${json['title'] ?? ''}',
shell: '${json['shell'] ?? ''}',
tmux: '${json['tmux'] ?? ''}',
reason: '${json['reason'] ?? ''}',
exitCode: (json['exit_code'] as num?)?.toInt(),
createdAt: (json['created_at'] as num?)?.toInt() ?? 0,
cols: (json['cols'] as num?)?.toInt() ?? 0,
rows: (json['rows'] as num?)?.toInt() ?? 0,
stream: '${json['stream'] ?? ''}',
outputEnd: (json['output_end'] as num?)?.toInt() ?? 0,
);
final String id;
final String cwd;
/// running, exited or closed.
final String status;
/// The last window title the shell set, or empty.
final String title;
final String shell;
/// The tmux session keeping the shell alive across server restarts;
/// empty when the shell ends with the server.
final String tmux;
/// Why an ended terminal ended, when it was not its own exit.
final String reason;
final int? exitCode;
final int createdAt;
final int cols;
final int rows;
/// Names the server process's output stream: a restarted server starts
/// a new one, whose byte offsets begin again at zero.
final String stream;
final int outputEnd;
/// This record naming output [stream] (lifecycle frames carry none).
TerminalInfo withStream(String stream) => TerminalInfo(
id: id,
cwd: cwd,
status: status,
title: title,
shell: shell,
tmux: tmux,
reason: reason,
exitCode: exitCode,
createdAt: createdAt,
cols: cols,
rows: rows,
stream: stream,
outputEnd: outputEnd,
);
bool get running => status == 'running';
bool get closed => status == 'closed';
bool get persistent => tmux.isNotEmpty;
/// What an ended terminal shows instead of a prompt.
String get endedText {
if (reason.isNotEmpty) return reason;
final code = exitCode;
return code == null ? 'The shell ended.' : 'The shell exited with $code.';
}
}
/// The terminal records of a `terminal_list` reply.
List<TerminalInfo> terminalInfos(JsonMap reply) => [
for (final value in (reply['terminals'] as List?) ?? const [])
if (value is Map) TerminalInfo.fromJson(value),
];
@@ -0,0 +1,161 @@
import 'dart:async';
import 'dart:convert';
import 'dart:ui';
import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';
const terminalLayoutKey = 'pipelines.terminal-layout.v1';
/// Where the terminal shows on a wide window.
enum TerminalMode {
panel('Bottom panel'),
float('Floating window');
const TerminalMode(this.label);
final String label;
}
/// The default and smallest heights of the bottom panel, and the smallest
/// floating window; layouts clamp to what the window allows.
const double terminalPanelDefaultHeight = 300;
const double terminalPanelMinHeight = 120;
const Size terminalFloatMinSize = Size(320, 200);
const Rect terminalFloatDefaultRect = Rect.fromLTWH(80, 80, 720, 420);
abstract interface class TerminalLayoutStore {
Future<String?> load();
Future<bool> save(String value);
}
class SharedTerminalLayoutStore implements TerminalLayoutStore {
const SharedTerminalLayoutStore();
@override
Future<String?> load() async {
try {
return (await SharedPreferences.getInstance()).getString(
terminalLayoutKey,
);
} catch (_) {
return null;
}
}
@override
Future<bool> save(String value) async {
try {
return await (await SharedPreferences.getInstance()).setString(
terminalLayoutKey,
value,
);
} catch (_) {
return false;
}
}
}
/// The terminal surface's device-local layout: the mode, whether it is
/// shown, the bottom panel's height and the floating window's frame and
/// state. Every change is saved, so a reload reopens it as it was.
class TerminalLayout extends ChangeNotifier {
TerminalLayout({TerminalLayoutStore? store})
: _store = store ?? const SharedTerminalLayoutStore();
static final instance = TerminalLayout();
final TerminalLayoutStore _store;
int _revision = 0;
TerminalMode mode = TerminalMode.panel;
bool visible = false;
double panelHeight = terminalPanelDefaultHeight;
Rect floatRect = terminalFloatDefaultRect;
bool minimized = false;
bool maximized = false;
/// Whether the last change could not be saved.
bool saveFailed = false;
Future<void> restore() async {
final revision = _revision;
final raw = await _store.load();
if (revision != _revision || raw == null) return;
try {
final json = jsonDecode(raw) as Map;
mode = TerminalMode.values.asNameMap()[json['mode']] ?? mode;
visible = json['visible'] == true;
panelHeight = _finite(json['panel_height']) ?? panelHeight;
final rect = json['float'];
if (rect is List && rect.length == 4) {
final values = rect.map(_finite).toList();
if (!values.contains(null)) {
floatRect = Rect.fromLTWH(
values[0]!,
values[1]!,
values[2]!,
values[3]!,
);
}
}
minimized = json['minimized'] == true;
maximized = json['maximized'] == true;
} catch (_) {
return;
}
notifyListeners();
}
void setMode(TerminalMode value) => _change(() => mode = value);
void toggle() => _change(() {
visible = !visible;
if (visible) minimized = false;
});
void show() => _change(() {
visible = true;
minimized = false;
});
void hide() => _change(() => visible = false);
void setPanelHeight(double value, {bool save = true}) =>
_change(() => panelHeight = value, save: save);
void setFloatRect(Rect value, {bool save = true}) =>
_change(() => floatRect = value, save: save);
void setMinimized(bool value) => _change(() {
minimized = value;
if (value) maximized = false;
});
void setMaximized(bool value) => _change(() {
maximized = value;
if (value) minimized = false;
});
/// Saves the current layout (a drag saves once, when it ends).
Future<void> save() async {
final revision = _revision;
final saved = await _store.save(
jsonEncode({
'mode': mode.name,
'visible': visible,
'panel_height': panelHeight,
'float': [
floatRect.left,
floatRect.top,
floatRect.width,
floatRect.height,
],
'minimized': minimized,
'maximized': maximized,
}),
);
if (revision != _revision || saved != saveFailed) return;
saveFailed = !saved;
notifyListeners();
}
void _change(VoidCallback change, {bool save = true}) {
_revision++;
change();
notifyListeners();
if (save) unawaited(this.save());
}
static double? _finite(Object? value) =>
value is num && value.isFinite ? value.toDouble() : null;
}
@@ -0,0 +1,90 @@
import 'package:flutter/foundation.dart';
import '../../core/api_gateway.dart';
import '../../core/servers/chat/chat_server_pool.dart';
/// One connected machine terminals can be opened on.
@immutable
class TerminalMachine {
const TerminalMachine({
required this.id,
required this.name,
required this.gateway,
});
/// The saved machine's identity (the chat pool's server id).
final String id;
final String name;
/// That machine's own authenticated connection.
final ApiGateway gateway;
}
/// The machines connected now, in the saved order.
typedef TerminalMachines = ValueListenable<List<TerminalMachine>>;
/// The chat pool's connected machines: one terminal surface across every
/// saved machine, each terminal on its own machine's socket.
class PoolTerminalMachines extends ValueNotifier<List<TerminalMachine>> {
PoolTerminalMachines(this.pool) : super(const []) {
pool.addListener(_update);
_update();
}
final ChatServerPool pool;
void _update() {
final next = [
for (final machine in pool.machines)
if (machine.connected && machine.adapter != null)
TerminalMachine(
id: machine.server.id,
name: machine.server.name,
gateway: machine.adapter!,
),
];
if (!_same(next, value)) value = next;
}
@override
void dispose() {
pool.removeListener(_update);
super.dispose();
}
}
/// The app's one server, while its connection is up.
class SingleTerminalMachines extends ValueNotifier<List<TerminalMachine>> {
SingleTerminalMachines({
required this.connection,
required this.machine,
required this.connected,
}) : super(const []) {
connection.addListener(_update);
_update();
}
final Listenable connection;
final TerminalMachine machine;
final bool Function() connected;
void _update() {
final next = connected() ? [machine] : const <TerminalMachine>[];
if (!_same(next, value)) value = next;
}
@override
void dispose() {
connection.removeListener(_update);
super.dispose();
}
}
bool _same(List<TerminalMachine> a, List<TerminalMachine> b) =>
a.length == b.length &&
[
for (var i = 0; i < a.length; i++)
a[i].id == b[i].id &&
a[i].name == b[i].name &&
identical(a[i].gateway, b[i].gateway),
].every((same) => same);
@@ -0,0 +1,90 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
/// One choice of a [TerminalMenuButton].
class TerminalChoice<T> {
const TerminalChoice(this.value, this.label, {this.checked, this.key});
final T value;
final String label;
/// Non-null draws the choice as a checkable item.
final bool? checked;
final Key? key;
}
/// An icon button opening the host's menu: a Material popup menu, or a
/// Cupertino action sheet with Cancel.
class TerminalMenuButton<T> extends StatelessWidget {
const TerminalMenuButton({
super.key,
required this.cupertino,
required this.label,
required this.icon,
required this.cupertinoIcon,
required this.choices,
required this.onSelected,
});
final bool cupertino;
final String label;
final IconData icon;
final IconData cupertinoIcon;
final List<TerminalChoice<T>> choices;
final ValueChanged<T> onSelected;
@override
Widget build(BuildContext context) {
if (!cupertino) {
return PopupMenuButton<T>(
tooltip: label,
icon: Icon(icon),
onSelected: onSelected,
itemBuilder: (_) => [
for (final choice in choices)
choice.checked == null
? PopupMenuItem<T>(
key: choice.key,
value: choice.value,
child: Text(choice.label),
)
: CheckedPopupMenuItem<T>(
key: choice.key,
value: choice.value,
checked: choice.checked!,
child: Text(choice.label),
),
],
);
}
return CupertinoButton(
padding: const EdgeInsets.symmetric(horizontal: 8),
onPressed: () => _sheet(context),
child: Icon(cupertinoIcon, semanticLabel: label),
);
}
Future<void> _sheet(BuildContext context) async {
final picked = await showCupertinoModalPopup<T>(
context: context,
builder: (sheet) => CupertinoActionSheet(
title: Text(label),
actions: [
for (final choice in choices)
CupertinoActionSheetAction(
key: choice.key,
isDefaultAction: choice.checked ?? false,
onPressed: () => Navigator.of(sheet).pop(choice.value),
child: Text(
choice.checked ?? false ? '${choice.label} ✓' : choice.label,
),
),
],
cancelButton: CupertinoActionSheetAction(
onPressed: () => Navigator.of(sheet).pop(),
child: const Text('Cancel'),
),
),
);
if (picked != null) onSelected(picked);
}
}
@@ -0,0 +1,50 @@
import 'dart:async';
import 'package:flutter/material.dart';
import '../../core/api_gateway.dart';
import '../../ui/adaptive/segmented_bar_overflow.dart';
import 'terminal_scope.dart';
const String terminalOpenActionLabel = 'Open in terminal';
/// Opens a terminal in [directory] on [gateway]'s machine through the app's
/// terminal surface; a refusal goes to [onRefused]. Does nothing outside a
/// [TerminalScope].
void openInTerminal(
BuildContext context,
ApiGateway gateway,
String directory, {
void Function(String refusal)? onRefused,
}) {
final actions = TerminalScope.maybeOf(context);
if (actions == null) return;
unawaited(
actions.openAt(gateway, directory).then((refusal) {
if (refusal != null) onRefused?.call(refusal);
}),
);
}
/// The chat actions menu's "Open in terminal" for the chat's folder, or
/// null when the app has no terminal surface or the chat no folder.
Widget? terminalOpenMenuAction(
BuildContext context, {
required ApiGateway gateway,
required String directory,
void Function(String refusal)? onRefused,
}) {
if (TerminalScope.maybeOf(context) == null || directory.isEmpty) {
return null;
}
return SegmentedOverflowAction(
key: const ValueKey<String>('chat-open-terminal-action'),
overflowEntry: SegmentedOverflowEntry(
label: terminalOpenActionLabel,
icon: Icons.terminal,
onPressed: () =>
openInTerminal(context, gateway, directory, onRefused: onRefused),
),
child: const SizedBox.shrink(),
);
}
@@ -0,0 +1,71 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'terminal_body.dart';
import 'terminal_hub.dart';
import 'terminal_layout.dart';
import 'terminal_tab_strip.dart';
/// Opens the terminals full screen (a narrow window has no room for a
/// panel or a window), with the touch key toolbar. Resolves when closed;
/// the shells keep running.
Future<void> openTerminalPage(
BuildContext context, {
required TerminalHub hub,
required TerminalLayout layout,
required bool cupertino,
}) {
Widget page(BuildContext _) =>
TerminalPage(hub: hub, layout: layout, cupertino: cupertino);
return Navigator.of(context).push<void>(
cupertino
? CupertinoPageRoute<void>(builder: page)
: MaterialPageRoute<void>(builder: page),
);
}
class TerminalPage extends StatelessWidget {
const TerminalPage({
super.key,
required this.hub,
required this.layout,
required this.cupertino,
});
final TerminalHub hub;
final TerminalLayout layout;
final bool cupertino;
@override
Widget build(BuildContext context) {
final body = ListenableBuilder(
listenable: hub,
builder: (context, _) => SafeArea(
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
TerminalTabStrip(
hub: hub,
layout: layout,
cupertino: cupertino,
showModes: false,
),
Expanded(
child: TerminalBody(hub: hub, cupertino: cupertino, keys: true),
),
],
),
),
);
if (cupertino) {
return CupertinoPageScaffold(
navigationBar: const CupertinoNavigationBar(middle: Text('Terminal')),
child: Material(type: MaterialType.transparency, child: body),
);
}
return Scaffold(
appBar: AppBar(title: const Text('Terminal')),
body: body,
);
}
}
@@ -0,0 +1,159 @@
import 'dart:async';
import 'package:flutter/cupertino.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import '../../ui/adaptive/resize_grip.dart';
import 'terminal_body.dart';
import 'terminal_hub.dart';
import 'terminal_layout.dart';
import 'terminal_tab_strip.dart';
/// Arrow-key step of the panel's resize handle.
const double terminalPanelKeyStep = 24;
/// Space the docked panel always leaves the app above it.
const double terminalPanelAppMin = 160;
/// [height] within what a window [available] tall allows the panel.
double terminalPanelHeight(double height, double available) {
final max = (available - terminalPanelAppMin).clamp(
terminalPanelMinHeight,
double.infinity,
);
return height.clamp(terminalPanelMinHeight, max);
}
/// The terminal docked at the bottom of the window, filling the height its
/// parent gives it (the layout's, see [terminalPanelHeight]): a resize
/// handle on its top edge (drag, or the arrow keys), the tabs and the
/// selected terminal.
class TerminalPanel extends StatefulWidget {
const TerminalPanel({
super.key,
required this.hub,
required this.layout,
required this.cupertino,
required this.available,
});
final TerminalHub hub;
final TerminalLayout layout;
final bool cupertino;
/// The height of the window the panel shares with the app.
final double available;
@override
State<TerminalPanel> createState() => _TerminalPanelState();
}
class _TerminalPanelState extends State<TerminalPanel> {
bool _active = false;
double get _height =>
terminalPanelHeight(widget.layout.panelHeight, widget.available);
void _resize(double height, {bool save = true}) =>
widget.layout.setPanelHeight(
terminalPanelHeight(height, widget.available),
save: save,
);
String _describe(double height) =>
'${terminalPanelHeight(height, widget.available).round()} pixels';
KeyEventResult _key(FocusNode _, KeyEvent event) {
if (event is! KeyDownEvent && event is! KeyRepeatEvent) {
return KeyEventResult.ignored;
}
if (event.logicalKey == LogicalKeyboardKey.arrowUp) {
_resize(_height + terminalPanelKeyStep);
} else if (event.logicalKey == LogicalKeyboardKey.arrowDown) {
_resize(_height - terminalPanelKeyStep);
} else {
return KeyEventResult.ignored;
}
return KeyEventResult.handled;
}
@override
Widget build(BuildContext context) {
final height = _height;
final handle = Semantics(
identifier: 'terminal-panel-resize',
label: 'Terminal height',
hint: 'Drag, or use the arrow keys, to resize the terminal',
slider: true,
value: _describe(height),
increasedValue: _describe(height + terminalPanelKeyStep),
decreasedValue: _describe(height - terminalPanelKeyStep),
onIncrease: () => _resize(height + terminalPanelKeyStep),
onDecrease: () => _resize(height - terminalPanelKeyStep),
child: Focus(
onKeyEvent: _key,
onFocusChange: (value) => setState(() => _active = value),
child: MouseRegion(
cursor: SystemMouseCursors.resizeRow,
child: GestureDetector(
key: const ValueKey('terminal-panel-resize'),
behavior: HitTestBehavior.opaque,
excludeFromSemantics: true,
dragStartBehavior: DragStartBehavior.down,
onVerticalDragStart: (_) => setState(() => _active = true),
onVerticalDragUpdate: (details) =>
_resize(_height - details.delta.dy, save: false),
onVerticalDragEnd: (_) {
setState(() => _active = false);
unawaited(widget.layout.save());
},
child: Padding(
padding: const EdgeInsets.symmetric(vertical: 4),
child: Center(
child: AdaptiveResizeGrip(compact: true, emphasized: _active),
),
),
),
),
),
);
final surface = widget.cupertino
? CupertinoColors.systemBackground.resolveFrom(context)
: Theme.of(context).colorScheme.surfaceContainerLow;
final divider = widget.cupertino
? CupertinoColors.separator.resolveFrom(context)
: Theme.of(context).colorScheme.outlineVariant;
return Semantics(
container: true,
label: 'Terminal panel',
child: DecoratedBox(
decoration: BoxDecoration(
color: surface,
border: Border(top: BorderSide(color: divider)),
),
child: Material(
type: MaterialType.transparency,
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
handle,
TerminalTabStrip(
hub: widget.hub,
layout: widget.layout,
cupertino: widget.cupertino,
),
Expanded(
child: TerminalBody(
hub: widget.hub,
cupertino: widget.cupertino,
),
),
],
),
),
),
);
}
}
@@ -0,0 +1,34 @@
import 'package:flutter/widgets.dart';
import '../../core/api_gateway.dart';
import '../../core/servers/server_scope.dart';
/// What screens below the app's terminal surface may ask of it.
abstract interface class TerminalActions {
/// Shows the terminal (panel, window or page) or hides it.
void toggle();
/// Opens a new terminal in [cwd] on the machine [gateway] belongs to and
/// shows it. Returns the refusal, or null.
Future<String?> openAt(ApiGateway gateway, String cwd);
}
/// Gives screens (a chat's header, the Files panel) the app's terminal
/// surface. Absent in standalone screens and tests, which then offer no
/// terminal actions.
class TerminalScope extends InheritedWidget {
const TerminalScope({super.key, required this.actions, required super.child});
final TerminalActions actions;
static TerminalActions? maybeOf(BuildContext context) =>
context.dependOnInheritedWidgetOfExactType<TerminalScope>()?.actions;
@override
bool updateShouldNotify(TerminalScope oldWidget) =>
oldWidget.actions != actions;
}
/// The machine id [gateway] was bound to, for a terminal opened from a
/// chat or its Files panel.
String? terminalMachineOf(ApiGateway gateway) => serverIdentity(gateway);
@@ -0,0 +1,61 @@
import 'dart:convert';
/// Characters of output one tab holds before its oldest are dropped (about
/// the server's 1 MiB tail).
const int terminalHeldLimit = 1 << 20;
/// The text of [text] after its first [bytes] UTF-8 bytes (a cut inside a
/// character drops that character's remaining bytes).
String terminalSkipBytes(String text, int bytes) {
if (bytes <= 0) return text;
final encoded = utf8.encode(text);
if (bytes >= encoded.length) return '';
var cut = bytes;
while (cut < encoded.length && (encoded[cut] & 0xC0) == 0x80) {
cut++;
}
return utf8.decode(encoded.sublist(cut), allowMalformed: true);
}
/// One terminal's output as the client holds it: the text covering
/// absolute bytes [start, end) of the server's stream named [stream].
class TerminalStream {
String text = '';
int start = 0;
int end = 0;
String stream = '';
/// Whether nothing was received yet.
bool get empty => stream.isEmpty && end == 0;
/// Replaces the held copy with a read of the server's retained tail.
void reset(String output, int outputStart, String name) {
text = output;
start = outputStart;
end = outputStart + utf8.encode(output).length;
stream = name;
_bound();
}
/// Adds the part of [chunk] (covering [offset, chunkEnd)) past [end] and
/// returns it; null when the chunk starts after [end] (a gap).
String? add(String chunk, int offset, int chunkEnd) {
if (chunkEnd <= end) return '';
if (offset > end) return null;
final fresh = terminalSkipBytes(chunk, end - offset);
text += fresh;
end = chunkEnd;
_bound();
return fresh;
}
void _bound() {
if (text.length <= terminalHeldLimit + terminalHeldLimit ~/ 2) return;
var cut = text.length - terminalHeldLimit;
// Never split a surrogate pair.
final unit = text.codeUnitAt(cut);
if (unit >= 0xDC00 && unit <= 0xDFFF) cut++;
text = text.substring(cut);
start = end - utf8.encode(text).length;
}
}
@@ -0,0 +1,181 @@
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import '../../core/api_gateway.dart';
import 'terminal_float.dart';
import 'terminal_hub.dart';
import 'terminal_layout.dart';
import 'terminal_page.dart';
import 'terminal_panel.dart';
import 'terminal_scope.dart';
/// Below this width the terminal opens as a full-screen page.
const double terminalNarrowWidth = 600;
/// Whether [event] is the terminal's toggle shortcut, Ctrl+` on every
/// platform (Cmd+` switches windows on macOS).
bool terminalToggleShortcut(KeyEvent event, HardwareKeyboard keyboard) =>
event is KeyDownEvent &&
event.logicalKey == LogicalKeyboardKey.backquote &&
keyboard.isControlPressed &&
!keyboard.isMetaPressed &&
!keyboard.isAltPressed;
/// The app's one terminal surface around [child] (the shell): the bottom
/// panel or the floating window on a wide window, a full-screen page on a
/// narrow one. It owns the toggle shortcut and gives screens below it
/// [TerminalActions] through [TerminalScope]. [child] keeps its place in
/// the tree whatever is shown, so showing the terminal never rebuilds the
/// app's state.
class TerminalSurface extends StatefulWidget {
const TerminalSurface({
super.key,
required this.hub,
required this.layout,
required this.cupertino,
required this.child,
});
final TerminalHub hub;
final TerminalLayout layout;
final bool cupertino;
final Widget child;
@override
State<TerminalSurface> createState() => _TerminalSurfaceState();
}
class _TerminalSurfaceState extends State<TerminalSurface>
implements TerminalActions {
bool _pageOpen = false;
@override
void initState() {
super.initState();
HardwareKeyboard.instance.addHandler(_key);
widget.layout.addListener(_layoutChanged);
// A terminal left shown before a reload reattaches at once.
WidgetsBinding.instance.addPostFrameCallback((_) => _layoutChanged());
}
@override
void dispose() {
HardwareKeyboard.instance.removeHandler(_key);
widget.layout.removeListener(_layoutChanged);
super.dispose();
}
void _layoutChanged() {
if (mounted && widget.layout.visible && !_narrow) widget.hub.activate();
}
bool get _narrow => MediaQuery.sizeOf(context).width < terminalNarrowWidth;
/// The shortcut is handled before the focused widget, so it toggles even
/// while the terminal itself has the keyboard.
bool _key(KeyEvent event) {
if (!mounted || !terminalToggleShortcut(event, HardwareKeyboard.instance)) {
return false;
}
toggle();
return true;
}
@override
void toggle() {
if (_narrow) {
unawaited(_openPage());
} else {
widget.layout.toggle();
}
}
@override
Future<String?> openAt(ApiGateway gateway, String cwd) async {
final machine = terminalMachineOf(gateway);
final refusal = await widget.hub.open(machineId: machine, cwd: cwd);
if (!mounted) return refusal;
if (_narrow) {
unawaited(_openPage());
} else {
widget.layout.show();
}
return refusal;
}
Future<void> _openPage() async {
widget.hub.activate();
if (_pageOpen) return;
_pageOpen = true;
try {
await openTerminalPage(
context,
hub: widget.hub,
layout: widget.layout,
cupertino: widget.cupertino,
);
} finally {
_pageOpen = false;
}
}
@override
Widget build(BuildContext context) => TerminalScope(
actions: this,
child: ListenableBuilder(
listenable: Listenable.merge([widget.hub, widget.layout]),
builder: (context, child) => LayoutBuilder(
builder: (context, constraints) {
final layout = widget.layout;
final shown = layout.visible && !_narrow;
final panel = shown && layout.mode == TerminalMode.panel;
final float = shown && layout.mode == TerminalMode.float;
final height = panel
? terminalPanelHeight(layout.panelHeight, constraints.maxHeight)
: 0.0;
return Stack(
children: [
Positioned.fill(
bottom: height,
// The app above a docked panel has no system inset below it.
child: MediaQuery.removePadding(
context: context,
removeBottom: panel,
child: child!,
),
),
if (panel)
Positioned(
left: 0,
right: 0,
bottom: 0,
height: height,
child: SafeArea(
top: false,
child: TerminalPanel(
key: const ValueKey('terminal-panel'),
hub: widget.hub,
layout: layout,
cupertino: widget.cupertino,
available: constraints.maxHeight,
),
),
),
if (float)
TerminalFloat(
key: const ValueKey('terminal-float'),
hub: widget.hub,
layout: layout,
cupertino: widget.cupertino,
bounds: constraints.biggest,
),
],
);
},
),
child: widget.child,
),
);
}
+249
View File
@@ -0,0 +1,249 @@
import 'dart:async';
import 'dart:convert';
import 'package:flutter/foundation.dart';
import '../../core/api_gateway.dart';
import '../chat/shell/chat_shell_run.dart';
import '../chat/shell/chat_shell_terminal_session.dart';
import '../chat/shell/chat_shell_terminals.dart';
import 'terminal_info.dart';
import 'terminal_stream.dart';
/// One open machine terminal in the app: its record, the output held for
/// redraws, and the emulator session the panel, window and page draw (the
/// chat shell's own, so typing, links and colours behave the same).
///
/// It outlives every view: hiding the panel keeps it, and reconnecting
/// resumes its output from the last byte it holds.
class TerminalTab extends ChangeNotifier {
TerminalTab({
required this.machineId,
required this.machineName,
required this._gateway,
required this._info,
}) {
session = ChatShellTerminalSession(
_run(),
onInput: _input,
onResize: _resized,
);
session.terminal.onTitleChange = _titled;
}
final String machineId;
String machineName;
ApiGateway _gateway;
TerminalInfo _info;
late final ChatShellTerminalSession session;
final TerminalStream _stream = TerminalStream();
ChatShellInputPipe? _pipe;
Timer? _resize;
(int, int)? _sentSize;
String _oscTitle = '';
bool _disposed = false;
bool _reading = false;
bool _again = false;
/// False while the terminal's machine is not connected.
bool connected = true;
/// The last refusal of input, a resize or a read, in the server's words.
String? error;
String get key => terminalKey(machineId, _info.id);
TerminalInfo get info => _info;
ApiGateway get gateway => _gateway;
/// The window title the shell set (seen in its output or recorded by the
/// server), else the folder it started in.
String get title {
if (_oscTitle.isNotEmpty) return _oscTitle;
if (_info.title.isNotEmpty) return _info.title;
return terminalFolderLabel(_info.cwd);
}
ChatShellRun _run() => ChatShellRun(
id: _info.id,
command: title,
directory: _info.cwd,
status: _info.running ? 'running' : 'exited',
startedAt: _info.createdAt,
output: _stream.text,
outputStart: _stream.start,
outputEnd: _stream.end,
terminal: true,
cols: _info.cols,
rows: _info.rows,
);
/// The machine connected again (or for the first time): requests go
/// through [gateway] and the output resumes from the held end.
void attach(ApiGateway gateway, TerminalInfo info) {
_gateway = gateway;
connected = true;
_sentSize = null;
_update(info);
unawaited(resume());
}
void disconnected() {
connected = false;
_pipe = null;
_notify();
}
/// Reads what the server retains after the held end (all of it on a new
/// stream or after a gap) and subscribes this connection to the rest.
Future<void> resume() async {
if (_disposed) return;
if (_reading) {
_again = true;
return;
}
_reading = true;
try {
do {
_again = false;
final same = !_stream.empty && _info.stream == _stream.stream;
await _read(same ? _stream.end : null);
} while (_again && !_disposed);
error = null;
} catch (failure) {
error = '$failure';
} finally {
_reading = false;
_notify();
}
}
Future<void> _read(int? after) async {
final reply = await _gateway.call('terminal_output', {
'terminal_request': {'terminal_id': _info.id, 'after': ?after},
});
final record = reply['terminal'];
if (_disposed || record is! Map) return;
final info = TerminalInfo.fromJson(record);
_info = info;
if (after != null && info.stream != _stream.stream) {
// The server restarted since: its stream starts again at zero.
return _read(null);
}
final output = '${record['output'] ?? ''}';
final start = (record['output_start'] as num?)?.toInt() ?? 0;
if (after == null || start > _stream.end) {
_stream.reset(output, start, info.stream);
session.replay(_run());
} else {
_append(output, start, start + _byteLength(output));
}
if (!info.running) session.finish(_run());
}
/// One pushed `terminal_event` for this terminal.
void frame(Map event) {
final record = event['terminal'];
if (record is Map) {
_update(TerminalInfo.fromJson(record));
return;
}
final output = '${event['output'] ?? ''}';
final offset = (event['offset'] as num?)?.toInt() ?? 0;
final end = (event['end'] as num?)?.toInt() ?? 0;
_append(output, offset, end);
}
void _append(String output, int offset, int end) {
final before = _stream.end;
final fresh = _stream.add(output, offset, end);
if (fresh == null) {
// Frames were missed: read the retained tail again.
unawaited(resume());
return;
}
if (fresh.isNotEmpty) session.append(_run(), fresh, before, end);
}
void _update(TerminalInfo info) {
final ended = _info.running && !info.running;
// A lifecycle record carries no stream; keep the one the output has.
_info = info.stream.isEmpty ? info.withStream(_stream.stream) : info;
if (ended) {
_resize?.cancel();
_pipe = null;
session.finish(_run());
}
_notify();
}
void _titled(String title) {
if (title == _oscTitle) return;
_oscTitle = title.trim();
_notify();
}
void _input(String data) {
if (_disposed || !connected) return;
final id = _info.id;
final gateway = _gateway;
(_pipe ??= ChatShellInputPipe(
(data) => gateway.call('terminal_input', {
'terminal_request': {'terminal_id': id, 'data': data},
}),
(failure) {
error = '$failure';
_notify();
},
)).add(data);
}
void _resized(int cols, int rows) {
if (_disposed || !_info.running || !connected) return;
_resize?.cancel();
_resize = Timer(chatShellResizeDelay, () {
if (_sentSize == (cols, rows) || !connected) return;
_sentSize = (cols, rows);
_gateway
.call('terminal_resize', {
'terminal_request': {
'terminal_id': _info.id,
'cols': cols,
'rows': rows,
},
})
.catchError((Object failure) {
error = '$failure';
_notify();
return <String, dynamic>{};
});
});
}
void _notify() {
if (!_disposed) notifyListeners();
}
@override
void dispose() {
_disposed = true;
_resize?.cancel();
_pipe = null;
session.terminal.onTitleChange = null;
super.dispose();
}
}
String terminalKey(String machineId, String terminalId) =>
'$machineId/$terminalId';
/// The last folder of [cwd] ("~" for a home directory), for a tab title.
String terminalFolderLabel(String cwd) {
final parts = cwd.split('/').where((part) => part.isNotEmpty).toList();
if (parts.isEmpty) return '/';
if (parts.length == 2 && (parts[0] == 'Users' || parts[0] == 'home')) {
return '~';
}
return parts.last;
}
int _byteLength(String text) => utf8.encode(text).length;
@@ -0,0 +1,181 @@
import 'dart:async';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'terminal_hub.dart';
import 'terminal_layout.dart';
import 'terminal_menu.dart';
import 'terminal_tab.dart';
/// The terminal's header: one tab per terminal (title, and the machine when
/// tabs come from several), New terminal (choosing the machine when more
/// than one is connected), the mode menu, and the host's own [trailing]
/// window buttons.
class TerminalTabStrip extends StatelessWidget {
const TerminalTabStrip({
super.key,
required this.hub,
required this.layout,
required this.cupertino,
this.trailing = const [],
this.showModes = true,
});
final TerminalHub hub;
final TerminalLayout layout;
final bool cupertino;
final List<Widget> trailing;
/// False on the narrow page, which has no panel or window to choose.
final bool showModes;
@override
Widget build(BuildContext context) {
final selected = hub.selected;
return Row(
children: [
Expanded(
child: SingleChildScrollView(
scrollDirection: Axis.horizontal,
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
child: Row(
children: [
for (final (index, tab) in hub.tabs.indexed)
Padding(
padding: const EdgeInsetsDirectional.only(end: 4),
child: Semantics(
identifier: 'terminal-tab-$index',
child: _tab(context, tab, tab == selected),
),
),
],
),
),
),
_newTerminal(context),
if (showModes)
TerminalMenuButton<_Option>(
cupertino: cupertino,
label: 'Terminal options',
icon: Icons.more_vert,
cupertinoIcon: CupertinoIcons.ellipsis,
choices: [
for (final mode in TerminalMode.values)
TerminalChoice(
_Option(mode),
mode.label,
checked: layout.mode == mode,
key: ValueKey('terminal-mode-${mode.name}'),
),
const TerminalChoice(
_Option(null),
'Hide terminal',
key: ValueKey('terminal-hide'),
),
],
onSelected: (option) => option.mode == null
? layout.hide()
: layout.setMode(option.mode!),
),
...trailing,
],
);
}
String _label(TerminalTab tab) =>
hub.multiMachine ? '${tab.title} · ${tab.machineName}' : tab.title;
Widget _tab(BuildContext context, TerminalTab tab, bool selected) {
final label = Text(
_label(tab),
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: tab.info.running
? null
: const TextStyle(fontStyle: FontStyle.italic),
);
void close() => unawaited(hub.close(tab));
if (cupertino) {
final color = selected
? CupertinoTheme.of(context).primaryColor
: CupertinoColors.label.resolveFrom(context);
return Row(
mainAxisSize: MainAxisSize.min,
children: [
CupertinoButton(
padding: const EdgeInsets.symmetric(horizontal: 8),
onPressed: () => hub.select(tab),
child: DefaultTextStyle.merge(
style: TextStyle(
color: color,
fontWeight: selected ? FontWeight.w600 : null,
),
child: label,
),
),
CupertinoButton(
padding: EdgeInsets.zero,
onPressed: close,
child: const Icon(
CupertinoIcons.xmark_circle_fill,
semanticLabel: 'Close terminal',
),
),
],
);
}
return InputChip(
label: label,
selected: selected,
showCheckmark: false,
tooltip: '${tab.machineName}: ${tab.info.cwd}',
onSelected: (_) => hub.select(tab),
onDeleted: close,
deleteButtonTooltipMessage: 'Close terminal',
);
}
Widget _newTerminal(BuildContext context) {
final machines = hub.connected;
if (machines.length > 1) {
return TerminalMenuButton<String>(
cupertino: cupertino,
label: 'New terminal',
icon: Icons.add,
cupertinoIcon: CupertinoIcons.add,
choices: [
for (final machine in machines)
TerminalChoice(
machine.id,
machine.name,
key: ValueKey('terminal-new-${machine.id}'),
),
],
onSelected: (id) => unawaited(hub.open(machineId: id)),
);
}
final enabled = machines.isNotEmpty;
void open() => unawaited(hub.open());
return cupertino
? CupertinoButton(
padding: const EdgeInsets.symmetric(horizontal: 8),
onPressed: enabled ? open : null,
child: const Icon(
CupertinoIcons.add,
semanticLabel: 'New terminal',
),
)
: IconButton(
tooltip: 'New terminal',
onPressed: enabled ? open : null,
icon: const Icon(Icons.add),
);
}
}
/// A mode to switch to, or (null) hiding the terminal.
class _Option {
const _Option(this.mode);
final TerminalMode? mode;
}
@@ -0,0 +1,49 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'terminal_layout.dart';
import 'terminal_scope.dart';
/// The shell bar's Terminal button: shows or hides the terminal (Ctrl+`).
class TerminalToggleButton extends StatelessWidget {
const TerminalToggleButton({
super.key,
required this.layout,
required this.cupertino,
});
final TerminalLayout layout;
final bool cupertino;
static const String label = 'Terminal (Ctrl+`)';
@override
Widget build(BuildContext context) {
final actions = TerminalScope.maybeOf(context);
if (actions == null) return const SizedBox.shrink();
return ListenableBuilder(
listenable: layout,
builder: (context, _) {
final shown = layout.visible;
if (cupertino) {
return CupertinoButton(
key: const ValueKey('shell.terminal'),
padding: EdgeInsets.zero,
onPressed: actions.toggle,
child: Icon(
CupertinoIcons.chevron_left_slash_chevron_right,
semanticLabel: label,
),
);
}
return IconButton(
key: const ValueKey('shell.terminal'),
tooltip: label,
isSelected: shown,
onPressed: actions.toggle,
icon: const Icon(Icons.terminal),
);
},
);
}
}
+6
View File
@@ -25,8 +25,13 @@ class AdaptiveShell extends StatefulWidget {
this.onSearch,
this.attentionCount = 0,
this.listPaneWidthStore = const SharedPreferencesListPaneWidthStore(),
this.barActions = const [],
});
/// Actions every destination's bar ends with (the Terminal toggle), after
/// the screen's own or Search.
final List<Widget> barActions;
/// Where each destination's dragged list-pane width is kept on this device.
final ListPaneWidthStore listPaneWidthStore;
@@ -409,6 +414,7 @@ class _AdaptiveShellState extends State<AdaptiveShell> {
tooltip: 'Search',
icon: const Icon(Icons.search),
),
...widget.barActions,
],
);
}
+208
View File
@@ -0,0 +1,208 @@
# Permanent terminal (bottom panel / floating window)
A full terminal available from every destination, independent of chats. It
keeps running when the panel is hidden, the app navigates or reloads, and
(where tmux is installed) across Pipelines server restarts.
## Behaviour
- **Modes** (Settings → Appearance → Terminal, or the terminal's own ⋮
menu): *Bottom panel* docks under the app (the app shrinks above it,
never hidden under it); *Floating window* is a window over the app. Both
are toggled by the bar's Terminal button (every destination's bar ends
with it) and **Ctrl+`** (Cmd+` is the macOS window switcher). The
shortcut is a global key handler, so it toggles even while the terminal
has the keyboard.
- **Bottom panel:** resized by dragging its top edge (the app's
`AdaptiveResizeGrip`; arrow keys too, slider semantics); its height is
remembered. The panel always leaves the app at least 160 px.
- **Floating window:** dragged by its title bar, resized from its lower
right corner, double-click or Maximise fills the app (8 px margin),
Minimise collapses it to its title bar, × hides it. Frame and state are
remembered.
- **Narrow windows (< 600 px):** the terminal opens as a full-screen page
(Material/Cupertino route) with the chat terminal's key toolbar (Paste,
Enter, Ctrl-C, Tab, Esc, arrows, and the typing field on Android/iOS).
- **Tabs:** one per terminal; the title is the shell's OSC 0/2 title
(followed by the emulator, also recorded by the server for the list),
else the start folder (`~` for home). Ended terminals are italic and show
why they ended with a Close tab button. With more than one machine
connected (or tabs from several) each tab names its machine, and New
terminal (+) asks which machine. ⨯ on a tab closes it, which kills the
shell (and its tmux session).
- **Open in terminal:** the chat header's More menu (the chat's folder,
on the chat's machine) and a folder's ⋮ menu in the Files panel open a
new terminal there and show the surface.
- **Permanence:** the app's `TerminalHub` lives as long as the app; hiding
or minimising never closes a shell. Reopening redraws the same emulator.
The layout (mode, shown, height, frame) is saved per device, so a reload
reopens the terminal, lists the machine's terminals and resumes each
from its retained output. A dropped connection resumes after the last
byte held; a restarted server (new stream) is read again from its start.
- **Keyboard:** a focused terminal gets every key (Ctrl-C, Esc, Tab, arrows,
Ctrl-letters); paste is Cmd-V (Apple) or Ctrl-V/Ctrl-Shift-V. Clicking
elsewhere moves focus away normally.
- No terminal request is sent until the terminal is first shown (or a
terminal is opened): each connection sends one request at a time, so the
first screen's read is never queued behind `terminal_list`.
## Protocol (server)
`internal/protocol/terminal.go`; documented in `docs/cli.md` ("Machine
terminals"). Body `terminal_request {terminal_id?, cwd?, cols?, rows?,
data?, after?}`.
- `terminal_open {cwd, cols, rows}` → `terminal` (subscribes the
connection to its output first).
- `terminal_list` → `terminals` (running and ended, oldest first; live
records carry their current title, size and `stream`).
- `terminal_input {terminal_id, data}` (UTF-8, ≤ 16 KiB, 64-request queue),
`terminal_resize {terminal_id, cols, rows}` (clamped 20–500 × 4–200).
- `terminal_output {terminal_id, after}` → `terminal` with `output`,
`output_start`, `output_end`, `stream`; subscribes the connection.
- `terminal_close {terminal_id}` → the closed record (runs off the read
loop: it waits up to 3 s for the shell).
- Pushed `terminal_event`: output `{terminal_id, output, offset, end}` to
subscribed connections, lifecycle `{terminal_id, terminal}` (opened,
title, exited, closed) to every connection. A slow connection's queue
(256 frames) drops output; the client sees the offset gap and re-reads.
## Persistence
- **tmux present** (looked up on PATH, then /opt/homebrew/bin,
/usr/local/bin, /usr/bin): each shell is `$SHELL -l` (else `/bin/sh`) as
the only pane of session `pipelines-<id>` on a Pipelines-owned tmux
server, `tmux -L pipelines -f /dev/null` (never the operator's own server
or config; `TMUX`/`TMUX_PANE` are stripped). Options: status off, mouse
on (wheel scrolls tmux history), history-limit 10000, escape-time 10,
set-titles on with the pane title. The server shows it through an
ordinary `attach-session` client in a PTY (creack/pty, the chat shell's
`startChatShellTerminal`). On shutdown the client gets SIGHUP and the
session stays; on start `recover` lists the DB's running terminals and
reattaches each whose session is alive (a fresh output stream: tmux
redraws the screen). A client that exits while its session lives is
replaced (up to 5 times).
- **No tmux:** the shell is a direct child; it ends with the server and is
listed as ended with the reason ("tmux is not installed on this
machine"); running tabs say "This shell ends if the server on <machine>
restarts (tmux is not installed there)".
- DB table `terminals` (additive): id, title, cwd, shell, created_at, tmux,
status, ended_at, exit_code, reason, cols, rows. Ended records beyond 16
are pruned. Output stays in memory (1 MiB tail per terminal).
## Security
- Only reachable through the authenticated `/connect` websocket, like chat
shell commands; any connection of that server may list, type into or
close its terminals.
- The start folder must exist inside the operator's home after resolving
symlinks (the Files panel's containment); `~`, `~/sub` and absolute paths
are accepted, `~user` and relative paths refused.
- Input is never logged or stored: the server skips its request log line
for `terminal_input`/`terminal_resize`, nothing is written to the DB, and
the client's input pipe (`ChatShellInputPipe`, shared with chat shells)
keeps nothing once sent.
## Limits and known gaps
- 8 running terminals per machine; 1 MiB retained output per terminal.
- A tmux shell's exit status is not reported (only direct shells have it).
- The client transport sends one request at a time per connection, so a
keystroke waits behind any slower request on the same machine (as chat
shell input already does).
- Opening a terminal elsewhere (another device) adds its tab here too: the
tabs are the machine's terminals.
- After a server restart the reattached output starts with tmux's redraw
of the screen; older lines are in tmux's history (mouse wheel), not in
the emulator's own scrollback.
- Mobile (narrow page, soft-keyboard field) is verified by widget tests and
a narrow Chrome capture only; no device test ran. Android/Linux builds
were not run.
- `test/application` and `test/features/settings` have 51 failures that are
identical on the base commit 8f06f12d (pending `LaunchUpdateChecker`
timers etc.); none is new.
## Files
- Server: `internal/protocol/terminal.go`, `message.go`;
`internal/pipeline/terminals.go`, `store.go`;
`internal/server/terminal_{manager,supervise,process,tmux,clients,title,cwd,handlers}.go`,
`websocket.go`; tests `terminal_ws_test.go`, `terminal_restart_test.go`,
`internal/pipeline/terminals_test.go`; `docs/cli.md`.
- App: `lib/features/terminal/` (`terminal_{info,stream,tab,hub,machines,layout,scope,surface,panel,float,page,body,tab_strip,menu,toggle_button,open_action}.dart`),
`lib/application/app_terminals.dart`, `pipelines_app.dart`,
`bootstrap.dart`, `lib/shell/adaptive_shell.dart` (`barActions`),
`lib/features/settings/settings_terminal_section.dart` (+ screen/topic
pages), `lib/features/chat/conversation/chat_thread_view.dart` (Open in
terminal), `lib/features/chat/files/files_panel.dart` (folder action),
`lib/features/chat/shell/chat_shell_terminals.dart` (`ChatShellInputPipe`
made public). Tests `test/features/terminal/`. Probe fixture
`tool/perf/terminal_fixture.dart` (`?terminals=1`, `?terminal=panel|float`).
## Verification
Go 1.x / Flutter 3.44.6, macOS host, tmux 3.7c (/opt/homebrew/bin/tmux).
- `go test ./internal/protocol ./internal/pipeline ./internal/server -count=1`:
`ok …/protocol 0.188s`, `ok …/pipeline 8.193s`, `ok …/server 69.120s`.
Terminal tests: open/list/input/resize/output-resume/close over the
websocket with two clients; shell exit status; cwd containment, input
bounds, unknown ids, the 8-terminal limit; tmux survives a manager
restart (list running, screen redrawn, shell variable kept, close kills
the session); a killed tmux client is replaced; without tmux the stop and
a crashed record are listed as ended with their reasons; OSC titles.
`-race -count=4` on the terminal tests: ok. Each tmux test uses its own
socket and removes it. `go vet`, `gofmt -l`: clean.
`GOOS=freebsd go build ./internal/server`, `GOOS=linux go test -c`: ok.
- `tool/memwatch/full.sh test/features/terminal`: `PASS: 15 passed`
(hub: lazy activation, ordered output + gap re-read, reconnect resume
and new-stream re-read, open/select/close, foreign open/close frames,
titles and ended reason, input, multi-machine, refusals; surface: Ctrl+`
and button toggle while the terminal has focus, hiding keeps shells,
panel drag-resize remembered and app shrinks, float drag/resize/
minimise/maximise, tabs select/close/new, mode switch from the menu,
Settings mode choice, narrow full-screen page with key toolbar).
- `tool/memwatch/full.sh test/features/chat`: `PASS: 1137 passed, 0 failed`.
- `test/application test/shell test/features/settings`: 129 passed, 51
failed — the same 51 failing tests as the base commit (compared by name).
- `tool/analyze.sh`: clean. `flutter build web`: built.
`FLUTTER_XCODE_ARCHS=arm64 flutter build macos`: built (35.0MB).
- Real Chrome (`tool/capture`, probe `?terminals=1`, 1280x820), inspected:
`/tmp/terminal-panel/panel-{light,dark}/01-panel.png`,
`03-panel-three-tabs.png`, `04-panel-taller.png` (dragged up 200 px);
`/tmp/terminal-panel/typed-{light,dark}/01-panel-tab2-typed.png` (second
tab, `pwd`+Enter typed as key events, focused cursor);
`/tmp/terminal-panel/float-{light,dark}/01-float.png`,
`02-float-moved-resized.png`, `03-float-minimised.png`,
`04-float-maximised.png`;
`/tmp/terminal-panel/settings-light/0{1,2,3}-*.png` (Appearance →
Terminal, choosing Floating window, then the bar button);
`/tmp/terminal-panel/narrow-light/01-narrow-page.png` (560 px page with
key toolbar); `/tmp/terminal-panel/cupertino-dark/0{1,2}-*.png`
(Cupertino, two machines: tabs name their machine, New terminal asks
which); `/tmp/terminal-panel/chat-open/02-chat-opened-terminal.png`
(chat More → Open in terminal opened `/workspace/demo`).
- Scratch server end to end (`go build ./cmd/pipelines-server`; `env -i`
with HOME, XDG_DATA_HOME, DB and `TMUX_TMPDIR` under `/tmp/term-e2e`,
OS-chosen loopback port, `SHELL=/bin/bash`; Node websocket driver
`/tmp/term-e2e/drive.mjs`, script `/tmp/term-e2e/run.sh`; server stopped
and tmux server gone afterwards):
```
opened term_c76697ebb5a10ce7 cwd=/tmp/term-e2e/home shell=/bin/bash tmux=pipelines-term_c76697ebb5a10ce7 size=100x30
typed command ran: before-restart-42 seen
server 94915 stopped
tmux sessions while the server is down:
pipelines-term_c76697ebb5a10ce7 pane_pid=94934
tmux scrollback while the server is down:
line-1 / line-2 / line-3 / before-restart-42
server pid 94951 port 62223
list after restart: term_c76697ebb5a10ce7 running tmux=pipelines-term_c76697ebb5a10ce7 stream=e5cca0de2a86
reattached output (1463 bytes) has earlier lines: line-1=true line-3=true before-restart-42=true
shell state survived: KEEP=kept-across-restart
close: terminal_close status=closed
list after close: 0 terminals
tmux sessions after close: no server running on /private/tmp/term-e2e/tmux/tmux-501/pipelines
input lines logged: 0
KEEP in log: 0
```
@@ -0,0 +1,151 @@
import 'dart:async';
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/terminal/terminal_layout.dart';
import 'package:pipelines_app/features/terminal/terminal_machines.dart';
/// One machine's terminals as a server holds them, answering the terminal
/// requests and pushing frames like the real one.
class TerminalGateway implements ApiGateway {
TerminalGateway({this.stream = 's1'});
final _frames = StreamController<JsonMap>.broadcast();
final List<JsonMap> requests = [];
final Map<String, JsonMap> terminals = {};
final Map<String, String> output = {};
String stream;
int _next = 0;
/// When set, requests of this type fail with this message.
final Map<String, String> refuse = {};
@override
Stream<JsonMap> get frames => _frames.stream;
List<JsonMap> bodies(String type) => [
for (final request in requests)
if (request['type'] == type)
Map<String, dynamic>.from(request['terminal_request'] as Map? ?? {}),
];
JsonMap add(String id, {String cwd = '/Users/op', String text = ''}) {
final record = <String, dynamic>{
'id': id,
'cwd': cwd,
'shell': '/bin/zsh',
'status': 'running',
'tmux': 'pipelines-$id',
'cols': 80,
'rows': 24,
'created_at': 1,
};
terminals[id] = record;
output[id] = text;
return record;
}
JsonMap _record(String id, {bool withOutput = false, int after = 0}) {
final text = output[id] ?? '';
final bytes = utf8.encode(text);
final start = after.clamp(0, bytes.length);
return {
...terminals[id]!,
'stream': stream,
'output_end': bytes.length,
if (withOutput) 'output': utf8.decode(bytes.sublist(start)),
if (withOutput) 'output_start': start,
};
}
/// The shell writes [text]: it is retained and pushed.
void write(String id, String text, {bool push = true}) {
final offset = utf8.encode(output[id] ?? '').length;
output[id] = (output[id] ?? '') + text;
if (push) {
pushOutput(id, text, offset);
}
}
void pushOutput(String id, String text, int offset) => _frames.add({
'type': 'terminal_event',
'terminal_event': {
'terminal_id': id,
'output': text,
'offset': offset,
'end': offset + utf8.encode(text).length,
},
});
void lifecycle(String id, Map<String, dynamic> changes) {
terminals[id] = {...terminals[id]!, ...changes};
_frames.add({
'type': 'terminal_event',
'terminal_event': {'terminal_id': id, 'terminal': _record(id)},
});
}
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
requests.add({'type': type, ...fields});
final refusal = refuse[type];
if (refusal != null) throw StateError(refusal);
final body = (fields['terminal_request'] as Map?) ?? const {};
final id = '${body['terminal_id'] ?? ''}';
switch (type) {
case 'terminal_list':
return {
'type': type,
'terminals': [for (final id in terminals.keys) _record(id)],
};
case 'terminal_open':
final next = 'term_${++_next}';
final cwd = '${body['cwd'] ?? ''}';
add(next, cwd: cwd.isEmpty ? '/Users/op' : cwd, text: r'$ ');
return {'type': type, 'terminal': _record(next)};
case 'terminal_output':
return {
'type': type,
'terminal': _record(
id,
withOutput: true,
after: (body['after'] as num?)?.toInt() ?? 0,
),
};
case 'terminal_close':
final record = {..._record(id), 'status': 'closed'};
terminals.remove(id);
return {'type': type, 'terminal': record};
case 'terminal_input':
return {'type': type};
case 'terminal_resize':
return {'type': type, 'terminal': _record(id)};
}
throw StateError('unexpected $type');
}
Future<void> close() => _frames.close();
}
/// A machine list tests change by hand.
class TestMachines extends ValueNotifier<List<TerminalMachine>> {
TestMachines(super.value);
}
TerminalMachine machine(String id, TerminalGateway gateway, {String? name}) =>
TerminalMachine(id: id, name: name ?? id, gateway: gateway);
/// A layout store kept in memory.
class MemoryLayoutStore implements TerminalLayoutStore {
String? saved;
int saves = 0;
@override
Future<String?> load() async => saved;
@override
Future<bool> save(String value) async {
saved = value;
saves++;
return true;
}
}
@@ -0,0 +1,193 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/terminal/terminal_hub.dart';
import 'package:pipelines_app/features/terminal/terminal_tab.dart';
import 'package:xterm/core.dart';
import 'terminal_fixtures.dart';
String screen(TerminalTab tab) {
final buffer = tab.session.terminal.buffer;
return [
for (var y = 0; y < buffer.height; y++)
buffer.lines[y].getText().trimRight(),
].where((line) => line.isNotEmpty).join('\n');
}
void main() {
late TerminalGateway mac;
late TestMachines machines;
late TerminalHub hub;
setUp(() {
mac = TerminalGateway();
machines = TestMachines([machine('mac', mac, name: 'Mac')]);
hub = TerminalHub(machines);
});
tearDown(() async {
hub.dispose();
await mac.close();
});
Future<void> settle() => Future<void>.delayed(Duration.zero);
test('nothing is requested until the terminal is first shown', () async {
mac.add('term_a', text: 'hello\r\n');
await settle();
expect(mac.requests, isEmpty);
hub.activate();
await settle();
await settle();
expect(mac.requests.map((r) => r['type']), [
'terminal_list',
'terminal_output',
]);
expect(hub.tabs.single.title, '~');
expect(screen(hub.tabs.single), 'hello');
});
test('live output appends in order; a gap reads the tail again', () async {
mac.add('term_a', text: r'$ ');
hub.activate();
await settle();
await settle();
final tab = hub.tabs.single;
mac.write('term_a', 'ls\r\nREADME\r\n');
await settle();
expect(screen(tab), '\$ ls\nREADME');
// A frame the client missed: the next one starts after its end.
mac.write('term_a', 'missed\r\n', push: false);
mac.write('term_a', 'after\r\n');
await settle();
await settle();
expect(screen(tab), '\$ ls\nREADME\nmissed\nafter');
final reads = mac.bodies('terminal_output');
expect(reads.last['after'], greaterThan(0));
});
test('a reconnect resumes after the held end; a restarted server '
'(new stream) is read again from its start', () async {
mac.add('term_a', text: 'one\r\n');
hub.activate();
await settle();
await settle();
final tab = hub.tabs.single;
machines.value = [];
await settle();
expect(tab.connected, isFalse);
mac.write('term_a', 'two\r\n', push: false);
final again = TerminalGateway()
..terminals.addAll(mac.terminals)
..output.addAll(mac.output);
machines.value = [machine('mac', again, name: 'Mac')];
await settle();
await settle();
expect(identical(hub.tabs.single, tab), isTrue);
expect(tab.connected, isTrue);
expect(again.bodies('terminal_output').single['after'], 5);
expect(screen(tab), 'one\ntwo');
// The server restarted: the tmux client redrew the screen into a new
// stream starting at zero.
machines.value = [];
await settle();
final restarted = TerminalGateway(stream: 's2')
..terminals.addAll(mac.terminals)
..output['term_a'] = 'one\r\ntwo\r\n\$ ';
machines.value = [machine('mac', restarted, name: 'Mac')];
await settle();
await settle();
await settle();
expect(
restarted.bodies('terminal_output').last.containsKey('after'),
isFalse,
);
expect(screen(tab), 'one\ntwo\n\$');
await again.close();
await restarted.close();
});
test('open selects a new tab; close removes it; another client\'s '
'terminal appears and its close removes it', () async {
expect(await hub.open(cwd: '/Users/op/src'), isNull);
await settle();
expect(mac.bodies('terminal_open').single['cwd'], '/Users/op/src');
final first = hub.selected!;
expect(first.title, 'src');
expect(await hub.open(), isNull);
await settle();
expect(hub.tabs, hasLength(2));
expect(hub.selected, isNot(first));
hub.select(first);
expect(hub.selected, first);
expect(await hub.close(first), isNull);
expect(hub.tabs, hasLength(1));
mac.add('term_other');
mac.lifecycle('term_other', {});
await settle();
await settle();
expect(hub.tabs, hasLength(2));
mac.lifecycle('term_other', {'status': 'closed'});
await settle();
expect(hub.tabs, hasLength(1));
});
test(
'the shell title wins over the folder; an ended terminal says why',
() async {
mac.add('term_a', text: '\x1b]0;vim notes.md\x07');
hub.activate();
await settle();
await settle();
final tab = hub.tabs.single;
expect(tab.title, 'vim notes.md');
expect(tab.session.live, isTrue);
mac.lifecycle('term_a', {
'status': 'exited',
'reason':
'The Pipelines server restarted and this shell ended with it.',
});
await settle();
expect(tab.session.live, isFalse);
expect(tab.info.endedText, contains('ended with it'));
},
);
test('typed input and the laid-out size go to the server', () async {
mac.add('term_a');
hub.activate();
await settle();
await settle();
final tab = hub.tabs.single;
tab.session.terminal.textInput('ls');
tab.session.terminal.keyInput(TerminalKey.enter);
await settle();
expect(
mac.bodies('terminal_input').map((body) => body['data']).join(),
'ls\r',
);
});
test('several machines: New terminal opens on the chosen one, tabs name '
'their machine', () async {
final linux = TerminalGateway();
machines.value = [
machine('mac', mac, name: 'Mac'),
machine('linux', linux, name: 'Linux'),
];
hub.activate();
await settle();
expect(hub.multiMachine, isTrue);
expect(await hub.open(machineId: 'linux'), isNull);
expect(linux.bodies('terminal_open'), hasLength(1));
expect(mac.bodies('terminal_open'), isEmpty);
expect(hub.selected!.machineName, 'Linux');
expect(await hub.open(machineId: 'gone'), contains('No machine'));
await linux.close();
});
test('a refused open is kept for the surface to show', () async {
mac.refuse['terminal_open'] = 'this machine already has 8 open terminals';
expect(await hub.open(), contains('8 open terminals'));
expect(hub.error, contains('8 open terminals'));
expect(hub.tabs, isEmpty);
});
}
@@ -0,0 +1,252 @@
import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/shell/chat_shell_terminal_keys.dart';
import 'package:pipelines_app/features/settings/settings_terminal_section.dart';
import 'package:pipelines_app/features/terminal/terminal_float.dart';
import 'package:pipelines_app/features/terminal/terminal_hub.dart';
import 'package:pipelines_app/features/terminal/terminal_layout.dart';
import 'package:pipelines_app/features/terminal/terminal_surface.dart';
import 'package:pipelines_app/features/terminal/terminal_toggle_button.dart';
import 'package:xterm/xterm.dart';
import 'terminal_fixtures.dart';
void main() {
late TerminalGateway mac;
late TerminalHub hub;
late MemoryLayoutStore store;
late TerminalLayout layout;
setUp(() {
mac = TerminalGateway()
..add('term_a', cwd: '/Users/op/src', text: 'alpha\r\n')
..add('term_b', cwd: '/Users/op/docs', text: 'beta\r\n');
hub = TerminalHub(TestMachines([machine('mac', mac, name: 'Mac')]));
store = MemoryLayoutStore();
layout = TerminalLayout(store: store);
});
tearDown(() async {
hub.dispose();
await mac.close();
});
Future<void> pumpApp(
WidgetTester tester, {
Size size = const Size(1200, 800),
}) async {
tester.view.physicalSize = size;
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(
MaterialApp(
home: TerminalSurface(
hub: hub,
layout: layout,
cupertino: false,
child: Scaffold(
appBar: AppBar(
title: const Text('App'),
actions: [TerminalToggleButton(layout: layout, cupertino: false)],
),
body: const TextField(key: Key('app-field')),
),
),
),
);
await tester.pump();
}
Future<void> ctrlBacktick(WidgetTester tester) async {
await tester.sendKeyDownEvent(LogicalKeyboardKey.controlLeft);
await tester.sendKeyEvent(LogicalKeyboardKey.backquote);
await tester.sendKeyUpEvent(LogicalKeyboardKey.controlLeft);
await tester.pumpAndSettle();
}
Map<String, dynamic> saved() =>
jsonDecode(store.saved!) as Map<String, dynamic>;
testWidgets('Ctrl+` and the bar button toggle the bottom panel; hiding '
'keeps every shell', (tester) async {
await pumpApp(tester);
expect(find.byKey(const ValueKey('terminal-panel')), findsNothing);
await ctrlBacktick(tester);
expect(find.byKey(const ValueKey('terminal-panel')), findsOneWidget);
expect(find.text('src'), findsOneWidget);
expect(find.text('docs'), findsOneWidget);
expect(saved()['visible'], isTrue);
// The terminal has the keyboard, yet the shortcut still hides it.
await tester.tap(find.byType(TerminalView));
await tester.pump();
await tester.sendKeyEvent(LogicalKeyboardKey.keyX);
await tester.pump();
expect(mac.bodies('terminal_input').last['data'], 'x');
await ctrlBacktick(tester);
expect(find.byKey(const ValueKey('terminal-panel')), findsNothing);
expect(hub.tabs, hasLength(2));
expect(mac.bodies('terminal_close'), isEmpty);
await tester.tap(find.byTooltip(TerminalToggleButton.label));
await tester.pumpAndSettle();
expect(find.byKey(const ValueKey('terminal-panel')), findsOneWidget);
// Reopening draws the same emulator, output and all.
expect(find.byType(TerminalView), findsOneWidget);
});
testWidgets('the panel resizes from its top edge and remembers its height', (
tester,
) async {
await pumpApp(tester);
await ctrlBacktick(tester);
final before = tester
.getSize(find.byKey(const ValueKey('terminal-panel')))
.height;
expect(before, terminalPanelDefaultHeight);
await tester.drag(
find.byKey(const ValueKey('terminal-panel-resize')),
const Offset(0, -120),
);
await tester.pumpAndSettle();
final after = tester
.getSize(find.byKey(const ValueKey('terminal-panel')))
.height;
expect(after, closeTo(before + 120, 1));
expect(saved()['panel_height'], closeTo(after, 1));
// The app above shrinks rather than hiding under it.
final field = tester.getRect(find.byType(Scaffold).first);
expect(field.bottom, closeTo(800 - after, 1));
final restored = TerminalLayout(store: store);
await restored.restore();
expect(restored.panelHeight, closeTo(after, 1));
expect(restored.visible, isTrue);
// The resized terminal tells the server its new size.
await tester.pump(const Duration(milliseconds: 200));
expect(mac.bodies('terminal_resize'), isNotEmpty);
});
testWidgets('the floating window moves, resizes, minimises and maximises', (
tester,
) async {
layout
..setMode(TerminalMode.float)
..show();
await pumpApp(tester);
await tester.pump();
final window = find.byKey(const ValueKey('terminal-float'));
expect(window, findsOneWidget);
final start = layout.floatRect;
await tester.drag(
find.byKey(const ValueKey('terminal-float-title')),
const Offset(60, 40),
);
await tester.pumpAndSettle();
expect(layout.floatRect.topLeft, start.topLeft + const Offset(60, 40));
await tester.drag(
find.byKey(const ValueKey('terminal-float-resize')),
const Offset(80, 50),
);
await tester.pumpAndSettle();
expect(layout.floatRect.size, start.size + const Offset(80, 50));
expect(saved()['float'][2], closeTo(start.width + 80, 1));
await tester.tap(find.byTooltip('Minimise'));
await tester.pumpAndSettle();
expect(find.byType(TerminalView), findsNothing);
expect(hub.tabs, hasLength(2));
await tester.tap(find.byTooltip('Restore'));
await tester.pumpAndSettle();
expect(find.byType(TerminalView), findsOneWidget);
await tester.tap(find.byTooltip('Maximise'));
await tester.pumpAndSettle();
expect(
tester.getRect(
find.descendant(of: window, matching: find.byType(Material)).first,
),
const Rect.fromLTWH(0, 0, 1200, 800).deflate(terminalFloatMargin),
);
await tester.tap(find.byTooltip('Restore size'));
await tester.pumpAndSettle();
expect(layout.maximized, isFalse);
});
testWidgets('tabs select and close their terminals; New terminal opens one', (
tester,
) async {
layout.show();
await pumpApp(tester);
await tester.pumpAndSettle();
expect(hub.selected!.info.id, 'term_a');
await tester.tap(find.text('docs'));
await tester.pumpAndSettle();
expect(hub.selected!.info.id, 'term_b');
await tester.tap(find.byTooltip('New terminal'));
await tester.pumpAndSettle();
expect(mac.bodies('terminal_open'), hasLength(1));
expect(hub.tabs, hasLength(3));
expect(hub.selected!.info.id, 'term_1');
await tester.tap(find.byTooltip('Close terminal').first);
await tester.pumpAndSettle();
expect(mac.bodies('terminal_close').single['terminal_id'], 'term_a');
expect(find.text('src'), findsNothing);
});
testWidgets('the options menu switches between panel and window', (
tester,
) async {
layout.show();
await pumpApp(tester);
await tester.tap(find.byTooltip('Terminal options'));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const ValueKey('terminal-mode-float')));
await tester.pumpAndSettle();
expect(layout.mode, TerminalMode.float);
expect(find.byKey(const ValueKey('terminal-float')), findsOneWidget);
expect(find.byKey(const ValueKey('terminal-panel')), findsNothing);
expect(saved()['mode'], 'float');
await tester.tap(find.byTooltip('Terminal options'));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const ValueKey('terminal-hide')));
await tester.pumpAndSettle();
expect(find.byKey(const ValueKey('terminal-float')), findsNothing);
});
testWidgets('Settings chooses the mode', (tester) async {
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SingleChildScrollView(
child: SettingsTerminalSection(layout: layout),
),
),
),
);
expect(find.text('Terminal'), findsOneWidget);
await tester.tap(find.byKey(const ValueKey('settings-terminal-float')));
await tester.pumpAndSettle();
expect(layout.mode, TerminalMode.float);
await tester.tap(find.byKey(const ValueKey('settings-terminal-panel')));
await tester.pumpAndSettle();
expect(layout.mode, TerminalMode.panel);
});
testWidgets('a narrow window opens the terminal full screen with the key '
'toolbar', (tester) async {
layout.show();
await pumpApp(tester, size: const Size(390, 800));
// The panel is not drawn on a phone even when left shown.
expect(find.byKey(const ValueKey('terminal-panel')), findsNothing);
await tester.tap(find.byTooltip(TerminalToggleButton.label));
await tester.pumpAndSettle();
expect(find.widgetWithText(AppBar, 'Terminal'), findsOneWidget);
expect(find.byType(TerminalView), findsOneWidget);
expect(find.byType(ChatShellTerminalKeys), findsOneWidget);
await tester.tap(find.byKey(const Key('chat-shell-key-ctrl-c')));
await tester.pump();
expect(mac.bodies('terminal_input').last['data'], '\x03');
await tester.pageBack();
await tester.pumpAndSettle();
expect(find.byType(TerminalView), findsNothing);
expect(hub.tabs, hasLength(2));
});
}
+6
View File
@@ -27,6 +27,7 @@ import 'chat_new_session_fixture.dart';
import 'chat_turn_diff_fixture.dart';
import 'chat_question_fixture.dart';
import 'chat_shell_fixture.dart';
import 'terminal_fixture.dart';
import 'chat_shown_fixture.dart';
import 'chat_scroll_fixture.dart';
@@ -42,6 +43,7 @@ void configurePerfFixture(Map<String, String> params) {
configureChatScrollFixture(params);
configureChatQuestionFixture(params);
configureChatShellFixture(params);
configureTerminalFixture(params);
}
int get _hits => int.tryParse(_params['hits'] ?? '') ?? 0;
@@ -132,6 +134,8 @@ bool get _scrollVariety => ['msgs', 'rich', 'older'].any(_params.containsKey);
/// Unsolicited envelopes that follow a reply: the `?quota=` usage frame.
List<JsonMap> perfChatFollowUps(JsonMap request) {
final terminal = terminalFixtureFollowUps(request);
if (terminal.isNotEmpty) return terminal;
final answered = chatQuestionFollowUps(request);
if (answered.isNotEmpty) return answered;
final shell = chatShellFollowUps(request);
@@ -233,6 +237,8 @@ String _answer(int i) =>
/// Chat replies for `?chats=N`, or null to fall through to the fixture.
JsonMap? perfChatReply(JsonMap request) {
final terminal = terminalFixtureReply(request);
if (terminal != null) return terminal;
if (_chats == 0) return null;
final question = chatQuestionReply(request);
if (question != null) return question;
+162
View File
@@ -0,0 +1,162 @@
// Machine terminals for the full-app probe (`?terminals=1`): the machine
// lists two running tmux-backed shells (a coloured `go test` run and a
// home shell) and terminal_open/input/resize/output/close answer as the
// server does, with the output frames that follow. Typed text is echoed and
// Enter prints a fresh prompt. `?terminal=panel` or `?terminal=float` opens
// the terminal at launch in that mode.
import 'dart:convert';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/terminal/terminal_layout.dart';
bool _enabled = false;
final Map<String, JsonMap> _terminals = {};
final Map<String, String> _output = {};
int _opened = 0;
const String _prompt = '\x1b[1;32moperator@mac\x1b[0m:\x1b[1;34m%s\x1b[0m\$ ';
String _promptAt(String folder) => _prompt.replaceFirst('%s', folder);
void configureTerminalFixture(Map<String, String> params) {
_enabled = params['terminals'] == '1';
if (!_enabled) return;
final now = DateTime.now().millisecondsSinceEpoch;
_terminals
..clear()
..['term_build'] = _record(
'term_build',
'/Users/operator/src/pipelines',
now - 600000,
title: 'go test ./internal/server',
)
..['term_home'] = _record('term_home', '/Users/operator', now - 300000);
_output
..clear()
..['term_build'] =
'${_promptAt('~/src/pipelines')}go test ./internal/server -run Terminal\r\n'
'\x1b[32m=== RUN\x1b[0m TestTerminalOverWebsocket\r\n'
'\x1b[32m--- PASS\x1b[0m: TestTerminalOverWebsocket (0.19s)\r\n'
'\x1b[32m=== RUN\x1b[0m TestTerminalTmuxSurvivesRestart\r\n'
'\x1b[32m--- PASS\x1b[0m: TestTerminalTmuxSurvivesRestart (0.27s)\r\n'
'\x1b[33m--- SKIP\x1b[0m: TestTerminalWindows (0.00s)\r\n'
'\x1b[1;32mok\x1b[0m \tgit.a-wan.net/alan/pipelines/internal/server\t2.758s\r\n'
'${_promptAt('~/src/pipelines')}'
..['term_home'] =
'${_promptAt('~')}ls\r\n'
'\x1b[1;34mDesktop\x1b[0m \x1b[1;34mDocuments\x1b[0m '
'\x1b[1;34mDownloads\x1b[0m \x1b[1;34msrc\x1b[0m notes.md\r\n'
'${_promptAt('~')}';
final mode = switch (params['terminal']) {
'panel' => TerminalMode.panel,
'float' => TerminalMode.float,
_ => null,
};
if (mode != null) {
TerminalLayout.instance
..mode = mode
..visible = true;
}
}
JsonMap _record(String id, String cwd, int created, {String title = ''}) => {
'id': id,
'cwd': cwd,
'title': title,
'shell': '/bin/zsh',
'created_at': created,
'tmux': 'pipelines-$id',
'status': 'running',
'cols': 100,
'rows': 24,
};
JsonMap _withOutput(String id, int after) {
final bytes = utf8.encode(_output[id] ?? '');
final start = after.clamp(0, bytes.length);
return {
..._terminals[id]!,
'stream': 'fixture',
'output_end': bytes.length,
'output': utf8.decode(bytes.sublist(start)),
'output_start': start,
};
}
JsonMap _body(JsonMap request) =>
Map<String, dynamic>.from(request['terminal_request'] as Map? ?? {});
JsonMap? terminalFixtureReply(JsonMap request) {
if (!_enabled) return null;
final id = request['id'];
final type = '${request['type']}';
final body = _body(request);
final terminal = '${body['terminal_id'] ?? ''}';
switch (type) {
case 'terminal_list':
return {
'id': id,
'type': type,
'terminals': [
for (final key in _terminals.keys)
{..._terminals[key]!, 'stream': 'fixture'},
],
};
case 'terminal_open':
final next = 'term_new${++_opened}';
final cwd = '${body['cwd'] ?? ''}';
_terminals[next] = _record(
next,
cwd.isEmpty ? '/Users/operator' : cwd,
DateTime.now().millisecondsSinceEpoch,
);
_output[next] = _promptAt(cwd.isEmpty ? '~' : cwd);
return {'id': id, 'type': type, 'terminal': _terminals[next]};
case 'terminal_output':
if (!_terminals.containsKey(terminal)) break;
return {
'id': id,
'type': type,
'terminal': _withOutput(
terminal,
(body['after'] as num?)?.toInt() ?? 0,
),
};
case 'terminal_input':
case 'terminal_resize':
return {'id': id, 'type': type};
case 'terminal_close':
final record = _terminals.remove(terminal);
return {
'id': id,
'type': type,
'terminal': {...?record, 'status': 'closed'},
};
}
return null;
}
/// The output the shell writes after typed input: the echo, and a new
/// prompt on Enter.
List<JsonMap> terminalFixtureFollowUps(JsonMap request) {
if (!_enabled || request['type'] != 'terminal_input') return const [];
final body = _body(request);
final terminal = '${body['terminal_id'] ?? ''}';
if (!_terminals.containsKey(terminal)) return const [];
final data = '${body['data'] ?? ''}';
final folder = terminal == 'term_build' ? '~/src/pipelines' : '~';
final echo = data.replaceAll('\r', '\r\n${_promptAt(folder)}');
final offset = utf8.encode(_output[terminal]!).length;
_output[terminal] = _output[terminal]! + echo;
return [
{
'type': 'terminal_event',
'terminal_event': {
'terminal_id': terminal,
'output': echo,
'offset': offset,
'end': offset + utf8.encode(echo).length,
},
},
];
}
@@ -782,6 +782,8 @@ class _FixtureSink implements WebSocketSink {
/// `?perf=1` prints frame timings (tool/perf/frame_log.dart);
/// `?hits=N`, `?chats=N` and `?graph=1` add bench data
/// (tool/perf/perf_fixture.dart);
/// `?terminals=1` lists two machine terminals, and `?terminal=panel` or
/// `?terminal=float` opens them at launch (tool/perf/terminal_fixture.dart);
/// `?theme=dark` / `?theme=light` pins the platform brightness the app's
/// `ThemeMode.system` follows (omitted: the browser's color scheme).
///
+25
View File
@@ -1291,3 +1291,28 @@ browses `_pipelines._tcp.local` on its own LAN, with a bounded DNS-SD query; it
does not scan arbitrary ports. An unavailable browse returns a protocol error.
The authenticated web front door exposes the same result at `GET /api/discovery`,
including before the browser has opened its application websocket.
### Machine terminals
Interactive login shells on a server's machine, independent of chats (the
app's terminal panel). Every request carries `terminal_request`
`{terminal_id?, cwd?, cols?, rows?, data?, after?}`:
- `terminal_open {cwd, cols, rows}` starts `$SHELL -l` (else `/bin/sh`) in
`cwd` (default home; it must be an existing folder inside home) and replies
with `terminal`. Where `tmux` is installed the shell runs in its own session
of a Pipelines-owned tmux server (`tmux -L pipelines`, never the operator's
own), so it outlives a server restart and the next server reattaches it.
At most 8 running terminals per machine.
- `terminal_list` replies with `terminals` (running and ended, oldest first).
- `terminal_input {terminal_id, data}` writes UTF-8 input (at most 16 KiB);
`terminal_resize {terminal_id, cols, rows}` resizes. Neither is logged.
- `terminal_output {terminal_id, after}` replies with the retained output (1
MiB tail) from byte `after` of the stream named `stream`; a restarted server
starts a new stream at zero. Opening or reading subscribes the connection to
the terminal's output frames.
- `terminal_close {terminal_id}` kills the shell and its tmux session.
- Pushed `terminal_event {terminal_id, output, offset, end}` (output) or
`{terminal_id, terminal}` (opened, title, exited, closed).
See `app/notes/terminal-panel.md`.
+4
View File
@@ -109,6 +109,10 @@ CREATE TABLE IF NOT EXISTS submissions (id INTEGER PRIMARY KEY, name TEXT NOT NU
db.Close()
return nil, err
}
if err := s.initTerminals(); err != nil {
db.Close()
return nil, err
}
if err := s.initAppNotifications(); err != nil {
db.Close()
return nil, err
+88
View File
@@ -0,0 +1,88 @@
package pipeline
import (
"context"
"database/sql"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// initTerminals creates the additive table of machine terminals. It records
// only what a restarted server needs to list and reattach them (id, title,
// cwd, shell, tmux session, status). Output and typed input are never stored.
func (s *Store) initTerminals() error {
_, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS terminals (
id TEXT PRIMARY KEY,
title TEXT NOT NULL DEFAULT '',
cwd TEXT NOT NULL,
shell TEXT NOT NULL DEFAULT '',
created_at INTEGER NOT NULL,
tmux TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL,
ended_at INTEGER NOT NULL DEFAULT 0,
exit_code INTEGER,
reason TEXT NOT NULL DEFAULT '',
cols INTEGER NOT NULL DEFAULT 0,
rows INTEGER NOT NULL DEFAULT 0);`)
return err
}
// SaveTerminal inserts or replaces one terminal. Saving an ended terminal
// prunes the oldest ended ones beyond keep (keep <= 0 keeps everything).
func (s *Store) SaveTerminal(ctx context.Context, t protocol.TerminalRecord, keep int) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
var exit any
if t.ExitCode != nil {
exit = *t.ExitCode
}
if _, err := tx.ExecContext(ctx, `INSERT INTO terminals
(id, title, cwd, shell, created_at, tmux, status, ended_at, exit_code, reason, cols, rows)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET title = excluded.title, status = excluded.status, ended_at = excluded.ended_at,
exit_code = excluded.exit_code, reason = excluded.reason, cols = excluded.cols, rows = excluded.rows`,
t.ID, t.Title, t.Cwd, t.Shell, t.CreatedAt, t.Tmux, t.Status, t.EndedAt, exit, t.Reason, t.Cols, t.Rows); err != nil {
return err
}
if keep > 0 && t.Status != protocol.TerminalRunning {
if _, err := tx.ExecContext(ctx, `DELETE FROM terminals WHERE status != ? AND id NOT IN
(SELECT id FROM terminals WHERE status != ? ORDER BY ended_at DESC, id DESC LIMIT ?)`,
protocol.TerminalRunning, protocol.TerminalRunning, keep); err != nil {
return err
}
}
return tx.Commit()
}
// DeleteTerminal removes one terminal's record.
func (s *Store) DeleteTerminal(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx, `DELETE FROM terminals WHERE id = ?`, id)
return err
}
// Terminals lists every recorded terminal, oldest first.
func (s *Store) Terminals(ctx context.Context) ([]protocol.TerminalRecord, error) {
rows, err := s.db.QueryContext(ctx, `SELECT id, title, cwd, shell, created_at, tmux, status, ended_at, exit_code, reason, cols, rows
FROM terminals ORDER BY created_at, id`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []protocol.TerminalRecord
for rows.Next() {
var t protocol.TerminalRecord
var exit sql.NullInt64
if err := rows.Scan(&t.ID, &t.Title, &t.Cwd, &t.Shell, &t.CreatedAt, &t.Tmux, &t.Status, &t.EndedAt, &exit, &t.Reason, &t.Cols, &t.Rows); err != nil {
return nil, err
}
if exit.Valid {
code := int(exit.Int64)
t.ExitCode = &code
}
out = append(out, t)
}
return out, rows.Err()
}
+54
View File
@@ -0,0 +1,54 @@
package pipeline
import (
"context"
"fmt"
"path/filepath"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func TestTerminalsPersistPruneAndDelete(t *testing.T) {
ctx := context.Background()
path := filepath.Join(t.TempDir(), "terminals.db")
store, err := Open(path)
if err != nil {
t.Fatal(err)
}
live := protocol.TerminalRecord{ID: "term_live", Cwd: "/home/a", Shell: "/bin/zsh", CreatedAt: 1, Tmux: "pipelines-term_live", Status: protocol.TerminalRunning, Cols: 80, Rows: 24}
if err := store.SaveTerminal(ctx, live, 2); err != nil {
t.Fatal(err)
}
code := 0
for i := 0; i < 3; i++ {
ended := protocol.TerminalRecord{ID: fmt.Sprintf("term_%d", i), Cwd: "/home/a", CreatedAt: int64(10 + i), Status: protocol.TerminalExited, EndedAt: int64(20 + i), ExitCode: &code}
if err := store.SaveTerminal(ctx, ended, 2); err != nil {
t.Fatal(err)
}
}
live.Title, live.Cols = "vim", 120
if err := store.SaveTerminal(ctx, live, 2); err != nil {
t.Fatal(err)
}
store.Close()
store, err = Open(path)
if err != nil {
t.Fatal(err)
}
defer store.Close()
list, err := store.Terminals(ctx)
if err != nil {
t.Fatal(err)
}
if len(list) != 3 || list[0].ID != "term_live" || list[0].Title != "vim" || list[0].Cols != 120 || list[0].Tmux != "pipelines-term_live" ||
list[1].ID != "term_1" || list[2].ID != "term_2" || list[2].ExitCode == nil || *list[2].ExitCode != 0 {
t.Fatalf("terminals = %+v", list)
}
if err := store.DeleteTerminal(ctx, "term_live"); err != nil {
t.Fatal(err)
}
if list, _ := store.Terminals(ctx); len(list) != 2 {
t.Fatalf("after delete = %+v", list)
}
}
+6
View File
@@ -283,6 +283,12 @@ type Message struct {
// ChatShellDismissed lists dismissed run ids (chat_shell_dismiss's reply
// and chat_shell_runs' tombstones; chat_shell_dismiss.go).
ChatShellDismissed []string `json:"chat_shell_dismissed,omitempty"`
// Machine terminals (terminal.go): the request body, one terminal, the
// machine's terminals and the pushed change.
TerminalRequest *TerminalRequest `json:"terminal_request,omitempty"`
Terminal *TerminalRecord `json:"terminal,omitempty"`
Terminals []TerminalRecord `json:"terminals,omitempty"`
TerminalEvent *TerminalEventFrame `json:"terminal_event,omitempty"`
// ListDirectory is the list_directory body and DirectoryListing its reply:
// the home-restricted folder picker listing (see directories.go).
ListDirectory *DirectoryListRequest `json:"list_directory,omitempty"`
+113
View File
@@ -0,0 +1,113 @@
package protocol
// Machine terminals: interactive login shells the operator opens on a
// server's machine, independent of any chat. Each runs `$SHELL -l` (else
// /bin/sh) in a pseudo-terminal; where tmux is installed the shell lives in
// a Pipelines-owned tmux server (socket name "pipelines", never the
// operator's own), so it survives a Pipelines server restart and the next
// process reattaches it. Without tmux a shell ends with the server and is
// listed as ended. Typed input is never logged or stored.
const (
// TerminalOpen starts a shell. The body is TerminalRequest (cwd, cols,
// rows); cwd defaults to the operator's home and must be an existing
// directory inside it. The reply carries the new terminal; the
// connection is then subscribed to its terminal_event output frames.
TerminalOpen = "terminal_open"
// TerminalList lists this machine's terminals (running and ended),
// oldest first, without output. The body is optional.
TerminalList = "terminal_list"
// TerminalInput writes Data (UTF-8, control characters included, at most
// ChatShellInputLimit bytes) to a running terminal. No reply body.
TerminalInput = "terminal_input"
// TerminalResize sets a running terminal's size (cols, rows); the reply
// echoes the terminal.
TerminalResize = "terminal_resize"
// TerminalOutput reads one terminal with its retained output from the
// absolute byte After on (all of it when After precedes the retained
// tail; OutputStart says where it starts). It also subscribes the
// connection to the terminal's terminal_event output frames.
TerminalOutput = "terminal_output"
// TerminalClose ends a terminal: its shell (and tmux session) is killed
// and its record removed. The reply echoes the last record.
TerminalClose = "terminal_close"
// TerminalEvent is pushed: an output chunk to the connections subscribed
// to that terminal (Output, Offset, End), or a lifecycle change (Terminal
// set: opened, title, exited, closed) to every connection.
TerminalEvent = "terminal_event"
)
// Terminal status values. Running is the only live status.
const (
TerminalRunning = "running"
TerminalExited = "exited"
TerminalClosed = "closed"
)
// Terminal bounds.
const (
// TerminalOpenLimit bounds the running terminals of one machine.
TerminalOpenLimit = 8
// TerminalRetained is the output tail kept for reconnecting clients.
TerminalRetained = 1 << 20
// TerminalChunkLimit bounds one live output frame.
TerminalChunkLimit = 64 << 10
// TerminalEndedKept bounds the ended terminals still listed.
TerminalEndedKept = 16
// TerminalTmuxHistory is the tmux scrollback of one tmux-backed shell.
TerminalTmuxHistory = 10000
// TerminalTitleLimit bounds a recorded title.
TerminalTitleLimit = 200
)
// TerminalRequest is the body of every terminal request.
type TerminalRequest struct {
TerminalID string `json:"terminal_id,omitempty"`
Cwd string `json:"cwd,omitempty"`
Cols int `json:"cols,omitempty"`
Rows int `json:"rows,omitempty"`
Data string `json:"data,omitempty"`
After int64 `json:"after,omitempty"`
}
// TerminalRecord is one terminal. Output and OutputStart are set only on
// terminal_output replies.
type TerminalRecord struct {
ID string `json:"id"`
// Title is the last terminal title (OSC 0/2) the shell set, or empty;
// clients show the cwd then.
Title string `json:"title,omitempty"`
Cwd string `json:"cwd"`
Shell string `json:"shell"`
CreatedAt int64 `json:"created_at"`
// Tmux is the tmux session name keeping the shell alive across server
// restarts; empty when the shell is a direct child of the server and
// ends with it.
Tmux string `json:"tmux,omitempty"`
Status string `json:"status"`
EndedAt int64 `json:"ended_at,omitempty"`
ExitCode *int `json:"exit_code,omitempty"`
// Reason says why an ended terminal ended when it was not simply its
// shell exiting (the server restarted without tmux, its tmux session
// was gone).
Reason string `json:"reason,omitempty"`
Cols int `json:"cols"`
Rows int `json:"rows"`
// Stream names this server process's output stream of the terminal;
// OutputEnd is the absolute byte count read into it. A restarted server
// that reattaches starts a new stream at zero, so a client holding
// another stream reads the terminal again from its start.
Stream string `json:"stream,omitempty"`
OutputEnd int64 `json:"output_end"`
Output string `json:"output,omitempty"`
OutputStart int64 `json:"output_start,omitempty"`
}
// TerminalEventFrame is one pushed terminal change: either Terminal (a
// lifecycle change) or one output chunk covering bytes [Offset, End).
type TerminalEventFrame struct {
TerminalID string `json:"terminal_id"`
Terminal *TerminalRecord `json:"terminal,omitempty"`
Output string `json:"output,omitempty"`
Offset int64 `json:"offset,omitempty"`
End int64 `json:"end,omitempty"`
}
+91
View File
@@ -0,0 +1,91 @@
package server
import (
"sync"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalClientQueue bounds the frames waiting for one slow connection.
// A full queue drops output frames; the client sees the gap in the next
// frame's offset and reads the retained tail again (terminal_output after).
const terminalClientQueue = 256
// terminalClients delivers terminal_event frames to open connections, in
// order per connection: lifecycle changes to every connection, output only
// to connections subscribed to that terminal (by terminal_open or
// terminal_output). It holds each connection's serialized write function,
// never the socket. The zero value is ready to use.
type terminalClients struct {
mu sync.Mutex
clients map[string]*terminalClient
}
type terminalClient struct {
ch chan protocol.Message
done chan struct{}
subs map[string]bool
}
func (c *terminalClients) attach(clientID string, write func(protocol.Message) error) {
client := &terminalClient{ch: make(chan protocol.Message, terminalClientQueue), done: make(chan struct{}), subs: map[string]bool{}}
c.mu.Lock()
if c.clients == nil {
c.clients = map[string]*terminalClient{}
}
if old := c.clients[clientID]; old != nil {
close(old.done)
}
c.clients[clientID] = client
c.mu.Unlock()
go func() {
for {
select {
case <-client.done:
return
case msg := <-client.ch:
if write(msg) != nil {
return
}
}
}
}()
}
func (c *terminalClients) detach(clientID string) {
c.mu.Lock()
defer c.mu.Unlock()
if client := c.clients[clientID]; client != nil {
close(client.done)
delete(c.clients, clientID)
}
}
// subscribe sends terminalID's output frames to clientID from now on.
func (c *terminalClients) subscribe(clientID, terminalID string) {
c.mu.Lock()
defer c.mu.Unlock()
if client := c.clients[clientID]; client != nil {
client.subs[terminalID] = true
}
}
// publish queues frame for its recipients without blocking: a lifecycle
// change for everyone, output for the terminal's subscribers.
func (c *terminalClients) publish(frame protocol.TerminalEventFrame) {
msg := protocol.Message{Type: protocol.TerminalEvent, TerminalEvent: &frame}
c.mu.Lock()
defer c.mu.Unlock()
for _, client := range c.clients {
if frame.Terminal == nil && !client.subs[frame.TerminalID] {
continue
}
if frame.Terminal != nil && frame.Terminal.Status == protocol.TerminalClosed {
delete(client.subs, frame.TerminalID)
}
select {
case client.ch <- msg:
default:
}
}
}
+41
View File
@@ -0,0 +1,41 @@
package server
import (
"errors"
"os"
"path/filepath"
)
// resolveTerminalCwd is the directory a terminal starts in: requested ("",
// "~", "~/sub" or an absolute path) must be an existing directory inside
// home once every symlink is resolved, the containment the Files panel and
// folder picker apply. It returns the path as the operator sees it, under
// home.
func resolveTerminalCwd(home, requested string) (string, error) {
home = filepath.Clean(home)
realHome, err := filepath.EvalSymlinks(home)
if err != nil {
return "", errors.New("resolve home directory: " + err.Error())
}
target, err := expandHomePath(home, requested)
if err != nil {
return "", err
}
realTarget, err := filepath.EvalSymlinks(target)
if err != nil {
return "", describePathError(target, err)
}
rel, inside := relInside(realHome, realTarget)
if !inside {
return "", errors.New(target + " is outside the home directory " + home + "; a terminal starts only in a folder inside home")
}
shown := filepath.Join(home, rel)
info, err := os.Stat(realTarget)
if err != nil {
return "", describePathError(shown, err)
}
if !info.IsDir() {
return "", errors.New(shown + " is not a directory")
}
return shown, nil
}
+65
View File
@@ -0,0 +1,65 @@
package server
import (
"context"
"errors"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// isTerminalRequest reports the request types handleTerminalRequest answers.
func isTerminalRequest(kind string) bool {
switch kind {
case protocol.TerminalOpen, protocol.TerminalList, protocol.TerminalInput, protocol.TerminalResize,
protocol.TerminalOutput, protocol.TerminalClose:
return true
}
return false
}
// handleTerminalRequest answers one machine-terminal request from an
// authenticated connection. Opening or reading a terminal subscribes the
// connection to its output frames.
func handleTerminalRequest(ctx context.Context, request protocol.Message, m *terminalManager, clientID string, write func(protocol.Message) error) {
fail := func(err error) { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) }
if m == nil {
fail(errors.New("terminals are not configured on this server"))
return
}
body := request.TerminalRequest
if body == nil {
body = &protocol.TerminalRequest{}
}
if request.Type != protocol.TerminalOpen && request.Type != protocol.TerminalList && body.TerminalID == "" {
fail(errors.New("a terminal_id is required"))
return
}
reply := protocol.Message{Type: request.Type, ID: request.ID}
var record protocol.TerminalRecord
var err error
switch request.Type {
case protocol.TerminalOpen:
record, err = m.Open(ctx, clientID, body.Cwd, body.Cols, body.Rows)
case protocol.TerminalList:
var records []protocol.TerminalRecord
records, err = m.List(ctx)
reply.Terminals = records
case protocol.TerminalInput:
err = m.Input(body.TerminalID, body.Data)
case protocol.TerminalResize:
record, err = m.Resize(body.TerminalID, body.Cols, body.Rows)
case protocol.TerminalOutput:
m.clients.subscribe(clientID, body.TerminalID)
record, err = m.Output(ctx, body.TerminalID, body.After)
case protocol.TerminalClose:
record, err = m.Close(ctx, body.TerminalID)
}
if err != nil {
fail(err)
return
}
if record.ID != "" {
reply.Terminal = &record
}
_ = write(reply)
}
+314
View File
@@ -0,0 +1,314 @@
package server
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"log"
"os"
"os/exec"
"sync"
"syscall"
"time"
"unicode/utf8"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalStore persists the machine's terminal list; *pipeline.Store
// implements it.
type terminalStore interface {
SaveTerminal(ctx context.Context, terminal protocol.TerminalRecord, keep int) error
DeleteTerminal(ctx context.Context, id string) error
Terminals(ctx context.Context) ([]protocol.TerminalRecord, error)
}
const (
terminalNoTmuxReason = "The Pipelines server restarted and this shell ended with it (tmux is not installed on this machine, so shells do not outlive the server)."
terminalGoneReason = "Its tmux session ended while the Pipelines server was stopped."
terminalStopReason = "The Pipelines server stopped and this shell ended with it (tmux is not installed on this machine)."
// terminalReattachLimit bounds how often a tmux client that exits while
// its session lives is replaced before the terminal is given up.
terminalReattachLimit = 5
)
// terminalManager owns the machine's terminals (terminal.go in protocol).
type terminalManager struct {
base context.Context
store terminalStore
clients *terminalClients
tmux *terminalTmux
shell func() string
home func() (string, error)
now func() time.Time
flush time.Duration
mu sync.Mutex
terms map[string]*terminalProcess
wg sync.WaitGroup
}
func newTerminalManager(base context.Context, store terminalStore, tmux *terminalTmux) *terminalManager {
return &terminalManager{
base: base, store: store, clients: &terminalClients{}, tmux: tmux,
shell: chatShellProgram, home: OperatorHomeDirectory, now: time.Now, flush: 50 * time.Millisecond,
terms: map[string]*terminalProcess{},
}
}
func newTerminalID() (string, error) {
var b [8]byte
if _, err := rand.Read(b[:]); err != nil {
return "", err
}
return "term_" + hex.EncodeToString(b[:]), nil
}
// Open starts a login shell in cwd at cols x rows and returns its record.
// clientID (when set) is subscribed to its output before the shell writes.
func (m *terminalManager) Open(ctx context.Context, clientID, cwd string, cols, rows int) (protocol.TerminalRecord, error) {
if m.store == nil {
return protocol.TerminalRecord{}, errors.New("terminals need the server's store, which is not configured")
}
if !chatShellTerminals {
return protocol.TerminalRecord{}, errors.New(protocol.ChatShellTerminalUnsupported)
}
home, err := m.home()
if err != nil {
return protocol.TerminalRecord{}, err
}
dir, err := resolveTerminalCwd(home, cwd)
if err != nil {
return protocol.TerminalRecord{}, err
}
id, err := newTerminalID()
if err != nil {
return protocol.TerminalRecord{}, err
}
m.mu.Lock()
defer m.mu.Unlock()
if m.base.Err() != nil {
return protocol.TerminalRecord{}, errors.New("the server is stopping")
}
if running := m.runningLocked(); running >= protocol.TerminalOpenLimit {
return protocol.TerminalRecord{}, fmt.Errorf("this machine already has %d open terminals; close one first", running)
}
cols, rows = chatShellTerminalSize(cols, rows)
shell := m.shell()
record := protocol.TerminalRecord{ID: id, Cwd: dir, Shell: shell, CreatedAt: m.now().UnixMilli(), Status: protocol.TerminalRunning, Cols: cols, Rows: rows}
var cmd *exec.Cmd
if m.tmux != nil {
record.Tmux = terminalTmuxName(id)
if err := m.tmux.create(record.Tmux, dir, shell, cols, rows); err != nil {
return protocol.TerminalRecord{}, fmt.Errorf("could not start the terminal: %v", err)
}
cmd = m.tmux.attach(record.Tmux)
} else {
cmd = exec.Command(shell, "-l")
cmd.Env = terminalEnv(os.Environ(), dir)
}
cmd.Dir = dir
p := newTerminalProcess(record)
terminal, err := p.startAttachment(cmd)
if err == nil {
err = m.store.SaveTerminal(ctx, record, protocol.TerminalEndedKept)
if err != nil {
p.signal(syscall.SIGKILL)
terminal.Close()
_ = cmd.Wait()
}
}
if err != nil {
if record.Tmux != "" {
_ = m.tmux.kill(record.Tmux)
}
return protocol.TerminalRecord{}, fmt.Errorf("could not start the terminal: %v", err)
}
m.terms[id] = p
if clientID != "" {
m.clients.subscribe(clientID, id)
}
m.wg.Add(1)
go m.supervise(p, cmd, terminal)
go p.pumpInput()
m.publishRecord(record)
return record, nil
}
func (m *terminalManager) runningLocked() int {
running := 0
for _, p := range m.terms {
if p.running() {
running++
}
}
return running
}
// List is every recorded terminal, oldest first, with the live state of the
// ones this process holds.
func (m *terminalManager) List(ctx context.Context) ([]protocol.TerminalRecord, error) {
if m.store == nil {
return nil, errors.New("terminals need the server's store, which is not configured")
}
records, err := m.store.Terminals(ctx)
if err != nil {
return nil, err
}
for i, record := range records {
if p := m.process(record.ID); p != nil {
records[i] = p.snapshot(false, 0)
}
}
return records, nil
}
func (m *terminalManager) process(id string) *terminalProcess {
m.mu.Lock()
defer m.mu.Unlock()
return m.terms[id]
}
func (m *terminalManager) live(id string) (*terminalProcess, error) {
p := m.process(id)
if p == nil || !p.running() {
return nil, errors.New("this terminal is not running")
}
return p, nil
}
// Input queues data for a running terminal, in arrival order. It is kept
// nowhere else: what the shell echoes is output.
func (m *terminalManager) Input(id, data string) error {
switch {
case data == "":
return errors.New("input is required")
case len(data) > protocol.ChatShellInputLimit:
return errors.New("the input exceeds 16 KiB; send it in parts")
case !utf8.ValidString(data):
return errors.New("input must be UTF-8 text")
}
p, err := m.live(id)
if err != nil {
return err
}
select {
case <-p.done:
return errors.New("this terminal is not running")
case p.input <- []byte(data):
return nil
default:
return errors.New("the terminal is not reading its input; wait for it or press Ctrl-C")
}
}
// Resize sets a running terminal's size and returns its record.
func (m *terminalManager) Resize(id string, cols, rows int) (protocol.TerminalRecord, error) {
if cols <= 0 || rows <= 0 {
return protocol.TerminalRecord{}, errors.New("positive cols and rows are required")
}
p, err := m.live(id)
if err != nil {
return protocol.TerminalRecord{}, err
}
cols, rows = chatShellTerminalSize(cols, rows)
p.mu.Lock()
p.record.Cols, p.record.Rows = cols, rows
terminal := p.pty
p.mu.Unlock()
if terminal != nil {
if err := resizeChatShellTerminal(terminal, cols, rows); err != nil {
return protocol.TerminalRecord{}, err
}
}
return p.snapshot(false, 0), nil
}
// Output is one terminal with its retained output from byte after on. A
// terminal ended before this process started has no output.
func (m *terminalManager) Output(ctx context.Context, id string, after int64) (protocol.TerminalRecord, error) {
if p := m.process(id); p != nil {
return p.snapshot(true, after), nil
}
records, err := m.List(ctx)
if err != nil {
return protocol.TerminalRecord{}, err
}
for _, record := range records {
if record.ID == id {
return record, nil
}
}
return protocol.TerminalRecord{}, errors.New("this machine has no such terminal")
}
// Close ends a terminal (killing its shell and tmux session) and forgets
// it. It waits briefly for the shell to go and returns the closed record.
func (m *terminalManager) Close(ctx context.Context, id string) (protocol.TerminalRecord, error) {
if m.store == nil {
return protocol.TerminalRecord{}, errors.New("terminals need the server's store, which is not configured")
}
p := m.process(id)
if p != nil && p.running() {
p.mu.Lock()
p.closing = true
name := p.record.Tmux
p.mu.Unlock()
if name != "" && m.tmux != nil {
if err := m.tmux.kill(name); err != nil {
log.Printf("terminal close %s: %v", id, err)
}
}
p.signal(syscall.SIGHUP)
select {
case <-p.done:
case <-time.After(3 * time.Second):
p.signal(syscall.SIGKILL)
<-p.done
}
return p.snapshot(false, 0), nil
}
record, err := m.Output(ctx, id, 0)
if err != nil {
return protocol.TerminalRecord{}, err
}
if record.Tmux != "" && m.tmux != nil && m.tmux.alive(record.Tmux) {
_ = m.tmux.kill(record.Tmux)
}
m.forget(id)
record.Output, record.OutputStart = "", 0
record.Status = protocol.TerminalClosed
m.publishRecord(record)
return record, nil
}
// forget drops a terminal's record and retained output.
func (m *terminalManager) forget(id string) {
m.mu.Lock()
delete(m.terms, id)
m.mu.Unlock()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := m.store.DeleteTerminal(ctx, id); err != nil {
log.Printf("terminal delete %s: %v", id, err)
}
}
func (m *terminalManager) save(record protocol.TerminalRecord) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := m.store.SaveTerminal(ctx, record, protocol.TerminalEndedKept); err != nil {
log.Printf("terminal save %s: %v", record.ID, err)
}
}
func (m *terminalManager) publishRecord(record protocol.TerminalRecord) {
record.Output, record.OutputStart = "", 0
m.clients.publish(protocol.TerminalEventFrame{TerminalID: record.ID, Terminal: &record})
}
// Wait blocks until every supervised terminal has been released (tests,
// shutdown).
func (m *terminalManager) Wait() { m.wg.Wait() }
+178
View File
@@ -0,0 +1,178 @@
package server
import (
"crypto/rand"
"encoding/hex"
"errors"
"os"
"os/exec"
"sync"
"syscall"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalProcess is one terminal this server process holds: running (its
// attachment is the shell itself, or a tmux client showing the shell's
// session) or ended with its output still retained.
type terminalProcess struct {
mu sync.Mutex
record protocol.TerminalRecord
out *chatShellOutput
titles terminalTitles
// cmd and pty are the current attachment; a tmux client that exits while
// its session lives is replaced.
cmd *exec.Cmd
pty *os.File
input chan []byte
done chan struct{}
// closing is set by terminal_close: the end is a close, not an exit.
closing bool
}
func newTerminalProcess(record protocol.TerminalRecord) *terminalProcess {
var stream [6]byte
_, _ = rand.Read(stream[:])
record.Stream = hex.EncodeToString(stream[:])
return &terminalProcess{
record: record,
out: newChatShellOutput(protocol.TerminalRetained),
input: make(chan []byte, protocol.ChatShellInputQueue),
done: make(chan struct{}),
}
}
func (p *terminalProcess) running() bool {
p.mu.Lock()
defer p.mu.Unlock()
return p.record.Status == protocol.TerminalRunning
}
// snapshot is the current record; with output, the retained bytes from
// absolute byte after on.
func (p *terminalProcess) snapshot(output bool, after int64) protocol.TerminalRecord {
p.mu.Lock()
defer p.mu.Unlock()
record := p.record
record.OutputEnd = p.out.total
if output {
text, start := p.out.tail(protocol.TerminalRetained)
if after > start {
skip := min(after-start, int64(len(text)))
cut := runeStartAfter([]byte(text), int(skip))
text, start = text[cut:], start+int64(cut)
}
record.Output, record.OutputStart = text, start
}
return record
}
// startAttachment starts cmd in a fresh pseudo-terminal at the record's
// size and makes it the current attachment.
func (p *terminalProcess) startAttachment(cmd *exec.Cmd) (*os.File, error) {
if !chatShellTerminals {
return nil, errors.New(protocol.ChatShellTerminalUnsupported)
}
p.mu.Lock()
cols, rows := p.record.Cols, p.record.Rows
p.mu.Unlock()
terminal, err := startChatShellTerminal(cmd, cols, rows)
if err != nil {
return nil, err
}
p.mu.Lock()
p.cmd, p.pty = cmd, terminal
p.mu.Unlock()
return terminal, nil
}
// read copies one attachment's stream into the retained output and follows
// the window title; it returns when the attachment's terminal is closed.
func (p *terminalProcess) read(terminal *os.File, titled func(string)) {
buffer := make([]byte, 32<<10)
for {
n, err := terminal.Read(buffer)
if n > 0 {
p.mu.Lock()
p.out.write(buffer[:n])
title, changed := p.titles.feed(buffer[:n])
changed = changed && title != p.record.Title
if changed {
p.record.Title = title
}
p.mu.Unlock()
if changed {
titled(title)
}
}
if err != nil {
return
}
}
}
// pumpInput writes queued input to the current attachment until the
// terminal ends. Input arriving while a tmux client is replaced is dropped.
func (p *terminalProcess) pumpInput() {
for {
select {
case <-p.done:
return
case data := <-p.input:
p.mu.Lock()
terminal := p.pty
p.mu.Unlock()
if terminal != nil {
_, _ = terminal.Write(data)
}
}
}
}
// signal sends sig to the current attachment's process group.
func (p *terminalProcess) signal(sig syscall.Signal) {
p.mu.Lock()
cmd := p.cmd
p.mu.Unlock()
if cmd != nil && cmd.Process != nil {
_ = syscall.Kill(-cmd.Process.Pid, sig)
}
}
// waitAttachment waits for the attachment to exit and its stream to drain
// (a descendant holding the terminal is read briefly, then cut off), then
// kills its group and closes its terminal. It returns the exit error.
func (p *terminalProcess) waitAttachment(cmd *exec.Cmd, terminal *os.File, readDone <-chan struct{}) error {
err := cmd.Wait()
_ = terminal.SetReadDeadline(time.Now().Add(chatShellDrain))
select {
case <-readDone:
case <-time.After(chatShellDrain + chatShellDrain/2):
}
_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
p.mu.Lock()
terminal.Close()
if p.pty == terminal {
p.pty = nil
}
p.mu.Unlock()
return err
}
// exitCode is the shell's exit status, when it exited by itself.
func terminalExitCode(err error) *int {
code := 0
var exitErr *exec.ExitError
switch {
case err == nil:
case errors.As(err, &exitErr):
if status, ok := exitErr.Sys().(syscall.WaitStatus); ok && status.Signaled() {
return nil
}
code = exitErr.ExitCode()
default:
return nil
}
return &code
}
+223
View File
@@ -0,0 +1,223 @@
//go:build darwin || linux
package server
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// testTmux is a tmux server of this test alone, killed afterwards.
func testTmux(t *testing.T) *terminalTmux {
t.Helper()
tmux := findTerminalTmux(fmt.Sprintf("pipelines-test-%d-%d", os.Getpid(), time.Now().UnixNano()))
if tmux == nil {
t.Skip("tmux is not installed")
}
t.Cleanup(func() {
_ = tmux.command("kill-server").Run()
dir := os.Getenv("TMUX_TMPDIR")
if dir == "" {
dir = "/tmp"
}
_ = os.Remove(filepath.Join(dir, fmt.Sprintf("tmux-%d", os.Getuid()), tmux.socket))
})
return tmux
}
// newTestTerminals is one server process's terminal manager over store.
func newTestTerminals(t *testing.T, store *pipeline.Store, tmux *terminalTmux) (*terminalManager, context.CancelFunc) {
t.Helper()
ctx, cancel := context.WithCancel(context.Background())
m := newTerminalManager(ctx, store, tmux)
m.shell = func() string { return "/bin/sh" }
m.recover(ctx)
t.Cleanup(func() { cancel(); m.Wait() })
return m, cancel
}
// waitOutput polls a terminal's retained output until it contains want.
func waitTerminalOutput(t *testing.T, m *terminalManager, id, want string) protocol.TerminalRecord {
t.Helper()
deadline := time.Now().Add(10 * time.Second)
for {
record, err := m.Output(context.Background(), id, 0)
if err != nil {
t.Fatal(err)
}
if strings.Contains(record.Output, want) {
return record
}
if time.Now().After(deadline) {
t.Fatalf("output of %s never contained %q: %q", id, want, record.Output)
}
time.Sleep(50 * time.Millisecond)
}
}
// A tmux-backed shell outlives its server process: the next one lists it as
// running, reattaches, redraws its screen and takes input again. Closing it
// ends the tmux session.
func TestTerminalTmuxSurvivesRestart(t *testing.T) {
terminalHome(t)
tmux := testTmux(t)
store := newOperatorStore(t)
first, stop := newTestTerminals(t, store, tmux)
term, err := first.Open(context.Background(), "", "~", 90, 20)
if err != nil {
t.Fatal(err)
}
if term.Tmux != terminalTmuxName(term.ID) {
t.Fatalf("tmux name = %q", term.Tmux)
}
if err := first.Input(term.ID, "export KEEP=still-here; echo marker-$((6*7))\r"); err != nil {
t.Fatal(err)
}
waitTerminalOutput(t, first, term.ID, "marker-42")
stop()
first.Wait()
if !tmux.alive(term.Tmux) {
t.Fatal("the tmux session ended with the server")
}
second, _ := newTestTerminals(t, store, tmux)
list, err := second.List(context.Background())
if err != nil {
t.Fatal(err)
}
if len(list) != 1 || list[0].ID != term.ID || list[0].Status != protocol.TerminalRunning {
t.Fatalf("list after restart = %+v", list)
}
// The reattached client redraws the screen, earlier output included,
// and the shell keeps its state.
waitTerminalOutput(t, second, term.ID, "marker-42")
if err := second.Input(term.ID, "echo $KEEP\r"); err != nil {
t.Fatal(err)
}
waitTerminalOutput(t, second, term.ID, "still-here")
closed, err := second.Close(context.Background(), term.ID)
if err != nil || closed.Status != protocol.TerminalClosed {
t.Fatalf("close = %+v, %v", closed, err)
}
if tmux.alive(term.Tmux) {
t.Fatal("the tmux session outlived close")
}
if list, _ := second.List(context.Background()); len(list) != 0 {
t.Fatalf("list after close = %+v", list)
}
}
// A tmux client killed while its session lives is replaced.
func TestTerminalTmuxClientReplaced(t *testing.T) {
terminalHome(t)
tmux := testTmux(t)
m, _ := newTestTerminals(t, newOperatorStore(t), tmux)
term, err := m.Open(context.Background(), "", "", 0, 0)
if err != nil {
t.Fatal(err)
}
waitTerminalOutput(t, m, term.ID, "$")
if err := tmux.command("detach-client", "-s", "="+term.Tmux).Run(); err != nil {
t.Fatal(err)
}
time.Sleep(300 * time.Millisecond)
if err := m.Input(term.ID, "echo back-$((1+1))\r"); err != nil {
t.Fatal(err)
}
waitTerminalOutput(t, m, term.ID, "back-2")
if record, _ := m.Output(context.Background(), term.ID, 0); record.Status != protocol.TerminalRunning {
t.Fatalf("record = %+v", record)
}
}
// Without tmux a shell ends with its server: the stop is recorded as
// ended, and a record a crashed server left running is marked ended too.
func TestTerminalWithoutTmuxEndsWithServer(t *testing.T) {
terminalHome(t)
store := newOperatorStore(t)
first, stop := newTestTerminals(t, store, nil)
term, err := first.Open(context.Background(), "", "", 0, 0)
if err != nil {
t.Fatal(err)
}
stop()
first.Wait()
crashed := protocol.TerminalRecord{ID: "term_crashed", Cwd: "/", CreatedAt: 1, Status: protocol.TerminalRunning, Cols: 80, Rows: 24}
gone := protocol.TerminalRecord{ID: "term_gone", Cwd: "/", CreatedAt: 2, Tmux: "pipelines-term_gone", Status: protocol.TerminalRunning}
for _, record := range []protocol.TerminalRecord{crashed, gone} {
if err := store.SaveTerminal(context.Background(), record, 0); err != nil {
t.Fatal(err)
}
}
second, _ := newTestTerminals(t, store, testTmux(t))
list, err := second.List(context.Background())
if err != nil {
t.Fatal(err)
}
reasons := map[string]string{}
for _, record := range list {
if record.Status != protocol.TerminalExited || record.EndedAt == 0 {
t.Fatalf("record = %+v", record)
}
reasons[record.ID] = record.Reason
}
if reasons[term.ID] != terminalStopReason || reasons["term_crashed"] != terminalNoTmuxReason || reasons["term_gone"] != terminalGoneReason {
t.Fatalf("reasons = %+v", reasons)
}
if _, err := second.Close(context.Background(), "term_gone"); err != nil {
t.Fatal(err)
}
if list, _ := second.List(context.Background()); len(list) != 2 {
t.Fatalf("list after closing an ended terminal = %+v", list)
}
}
// The window title the shell sets is followed across reads and recorded.
func TestTerminalTitles(t *testing.T) {
var titles terminalTitles
if _, ok := titles.feed([]byte("plain \x1b[1mtext")); ok {
t.Fatal("title from plain text")
}
if _, ok := titles.feed([]byte("\x1b]0;~/src")); ok {
t.Fatal("title before its end")
}
if title, ok := titles.feed([]byte("/app\x07more")); !ok || title != "~/src/app" {
t.Fatalf("title = %q %v", title, ok)
}
if title, ok := titles.feed([]byte("\x1b]2;vim\x01 x\x1b\\")); !ok || title != "vim x" {
t.Fatalf("ST title = %q %v", title, ok)
}
if _, ok := titles.feed([]byte("\x1b]8;;https://x\x07")); ok {
t.Fatal("a hyperlink is not a title")
}
if title, _ := titles.feed([]byte("\x1b]0;" + strings.Repeat("é", protocol.TerminalTitleLimit) + "\x07")); len(title) > protocol.TerminalTitleLimit {
t.Fatalf("title of %d bytes", len(title))
}
terminalHome(t)
m, _ := newTestTerminals(t, newOperatorStore(t), nil)
term, err := m.Open(context.Background(), "", "", 0, 0)
if err != nil {
t.Fatal(err)
}
if err := m.Input(term.ID, "printf '\\033]0;build-%s\\007' ok\r"); err != nil {
t.Fatal(err)
}
deadline := time.Now().Add(5 * time.Second)
for {
list, _ := m.List(context.Background())
if len(list) == 1 && list[0].Title == "build-ok" {
break
}
if time.Now().After(deadline) {
t.Fatalf("list = %+v", list)
}
time.Sleep(50 * time.Millisecond)
}
}
+169
View File
@@ -0,0 +1,169 @@
package server
import (
"context"
"log"
"os"
"os/exec"
"syscall"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// supervise streams one terminal until it ends: its first attachment is
// cmd on terminal. A tmux client that exits while its session lives (it was
// detached or killed) is replaced; a server shutdown leaves a tmux session
// running for the next server process and ends a direct shell.
func (m *terminalManager) supervise(p *terminalProcess, cmd *exec.Cmd, terminal *os.File) {
defer m.wg.Done()
defer close(p.done)
stopFlush, flushDone := make(chan struct{}), make(chan struct{})
go m.flushLoop(p, stopFlush, flushDone)
titled := func(string) {
record := p.snapshot(false, 0)
m.save(record)
m.publishRecord(record)
}
var waitErr error
shutdown := false
for reattached := 0; ; reattached++ {
readDone := make(chan struct{})
go func(terminal *os.File) {
defer close(readDone)
p.read(terminal, titled)
}(terminal)
attachDone := make(chan error, 1)
go func(cmd *exec.Cmd, terminal *os.File) { attachDone <- p.waitAttachment(cmd, terminal, readDone) }(cmd, terminal)
select {
case waitErr = <-attachDone:
case <-m.base.Done():
p.signal(syscall.SIGHUP)
select {
case waitErr = <-attachDone:
case <-time.After(time.Second):
p.signal(syscall.SIGKILL)
waitErr = <-attachDone
}
}
if m.base.Err() != nil {
shutdown = true
break
}
p.mu.Lock()
closing, name := p.closing, p.record.Tmux
p.mu.Unlock()
if closing || name == "" || m.tmux == nil || reattached >= terminalReattachLimit || !m.tmux.alive(name) {
break
}
cmd = m.tmux.attach(name)
next, err := p.startAttachment(cmd)
if err != nil {
log.Printf("terminal reattach %s: %v", p.record.ID, err)
break
}
terminal = next
}
close(stopFlush)
<-flushDone
m.emit(p, true)
p.mu.Lock()
switch {
case shutdown && p.record.Tmux != "":
// Still running in tmux: the next server process reattaches it.
case p.closing:
p.record.Status = protocol.TerminalClosed
default:
p.record.Status = protocol.TerminalExited
p.record.EndedAt = m.now().UnixMilli()
if shutdown {
p.record.Reason = terminalStopReason
} else if p.record.Tmux == "" {
p.record.ExitCode = terminalExitCode(waitErr)
}
}
p.pty, p.cmd = nil, nil
p.mu.Unlock()
record := p.snapshot(false, 0)
switch record.Status {
case protocol.TerminalClosed:
m.forget(record.ID)
default:
m.save(record)
}
if !shutdown {
m.publishRecord(record)
}
}
// flushLoop pushes new output in batches until stop is closed.
func (m *terminalManager) flushLoop(p *terminalProcess, stop <-chan struct{}, done chan<- struct{}) {
defer close(done)
ticker := time.NewTicker(m.flush)
defer ticker.Stop()
for {
select {
case <-stop:
return
case <-ticker.C:
m.emit(p, false)
}
}
}
// emit pushes the output written since the last frame.
func (m *terminalManager) emit(p *terminalProcess, final bool) {
p.mu.Lock()
text, offset, end, ok := p.out.pending(protocol.TerminalChunkLimit, final)
id := p.record.ID
p.mu.Unlock()
if ok {
m.clients.publish(protocol.TerminalEventFrame{TerminalID: id, Output: text, Offset: offset, End: end})
}
}
// recover lists what a previous server process left running: a tmux-backed
// shell whose session is alive is reattached; any other is recorded as
// ended, saying why.
func (m *terminalManager) recover(ctx context.Context) {
if m.store == nil {
return
}
records, err := m.store.Terminals(ctx)
if err != nil {
log.Printf("terminal recover: %v", err)
return
}
for _, record := range records {
if record.Status != protocol.TerminalRunning {
continue
}
if record.Tmux != "" && m.tmux != nil && m.tmux.alive(record.Tmux) && m.reattach(record) {
continue
}
record.Status, record.EndedAt = protocol.TerminalExited, m.now().UnixMilli()
record.Reason = terminalNoTmuxReason
if record.Tmux != "" {
record.Reason = terminalGoneReason
}
m.save(record)
}
}
// reattach shows a live tmux session in a new client and supervises it.
func (m *terminalManager) reattach(record protocol.TerminalRecord) bool {
cmd := m.tmux.attach(record.Tmux)
p := newTerminalProcess(record)
terminal, err := p.startAttachment(cmd)
if err != nil {
log.Printf("terminal reattach %s: %v", record.ID, err)
return false
}
m.mu.Lock()
m.terms[record.ID] = p
m.mu.Unlock()
m.wg.Add(1)
go m.supervise(p, cmd, terminal)
go p.pumpInput()
return true
}
+90
View File
@@ -0,0 +1,90 @@
package server
import (
"strings"
"unicode/utf8"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalTitles follows a terminal stream across reads and reports the
// window title the program sets (OSC 0 or OSC 2, ended by BEL or ST), so a
// listed terminal keeps a name before any client draws it.
type terminalTitles struct {
state int
osc []byte
}
const (
titleText = iota
titleEscape
titleOSC
titleOSCEscape
)
// feed scans data and returns the last title it completed, if any.
func (t *terminalTitles) feed(data []byte) (string, bool) {
title, found := "", false
for _, b := range data {
switch t.state {
case titleText:
if b == 0x1b {
t.state = titleEscape
}
case titleEscape:
if b == ']' {
t.state, t.osc = titleOSC, t.osc[:0]
} else if b != 0x1b {
t.state = titleText
}
case titleOSC:
switch {
case b == 0x07:
if s, ok := t.finish(); ok {
title, found = s, true
}
case b == 0x1b:
t.state = titleOSCEscape
case len(t.osc) < 4*protocol.TerminalTitleLimit:
t.osc = append(t.osc, b)
}
case titleOSCEscape:
if b == '\\' {
if s, ok := t.finish(); ok {
title, found = s, true
}
} else {
t.state = titleEscape
}
}
}
return title, found
}
func (t *terminalTitles) finish() (string, bool) {
t.state = titleText
body := string(t.osc)
for _, prefix := range []string{"0;", "2;"} {
if strings.HasPrefix(body, prefix) {
return cleanTerminalTitle(body[len(prefix):]), true
}
}
return "", false
}
// cleanTerminalTitle keeps printable text within the title bound.
func cleanTerminalTitle(title string) string {
title = strings.ToValidUTF8(title, "")
title = strings.Map(func(r rune) rune {
if r < 0x20 || r == 0x7f {
return -1
}
return r
}, title)
title = strings.TrimSpace(title)
for len(title) > protocol.TerminalTitleLimit {
_, size := utf8.DecodeLastRuneInString(title)
title = title[:len(title)-size]
}
return title
}
+120
View File
@@ -0,0 +1,120 @@
package server
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalTmuxSocket is the tmux server Pipelines owns (`tmux -L pipelines`):
// its sessions never mix with the operator's own tmux server.
const terminalTmuxSocket = "pipelines"
// terminalTmux runs one Pipelines-owned tmux server. Every terminal shell is
// the only pane of its own session there, so it outlives the Pipelines
// server; the server talks to it through an ordinary attached client in a
// pseudo-terminal.
type terminalTmux struct {
program string
socket string
}
// findTerminalTmux is the tmux on PATH (or the usual package-manager
// locations a service's PATH may lack); nil when none is installed.
func findTerminalTmux(socket string) *terminalTmux {
if socket == "" {
socket = terminalTmuxSocket
}
program, err := exec.LookPath("tmux")
if err != nil {
for _, dir := range []string{"/opt/homebrew/bin", "/usr/local/bin", "/usr/bin"} {
candidate := filepath.Join(dir, "tmux")
if info, statErr := os.Stat(candidate); statErr == nil && !info.IsDir() && info.Mode()&0o111 != 0 {
program, err = candidate, nil
break
}
}
}
if err != nil {
return nil
}
return &terminalTmux{program: program, socket: socket}
}
// terminalTmuxName is the tmux session of terminal id.
func terminalTmuxName(id string) string { return "pipelines-" + id }
// command is one tmux client invocation against the Pipelines server, with
// no configuration file and outside any tmux the server itself runs in.
func (t *terminalTmux) command(args ...string) *exec.Cmd {
cmd := exec.Command(t.program, append([]string{"-L", t.socket, "-f", os.DevNull}, args...)...)
cmd.Env = terminalEnv(os.Environ(), "")
return cmd
}
// create starts session name running shell -l in cwd at cols x rows,
// detached. The first call also starts the tmux server; the options make
// it invisible (no status line), pass the shell's window title through,
// keep a bounded scrollback reachable by the mouse wheel, and leave Esc
// prompt.
func (t *terminalTmux) create(name, cwd, shell string, cols, rows int) error {
cmd := t.command(
"start-server", ";",
"set-option", "-g", "history-limit", strconv.Itoa(protocol.TerminalTmuxHistory), ";",
"set-option", "-g", "status", "off", ";",
"set-option", "-g", "mouse", "on", ";",
"set-option", "-g", "escape-time", "10", ";",
"set-option", "-g", "set-titles", "on", ";",
"set-option", "-g", "set-titles-string", "#{pane_title}", ";",
"new-session", "-d", "-s", name, "-c", cwd, "-x", strconv.Itoa(cols), "-y", strconv.Itoa(rows), "--", shell, "-l", ";",
"select-pane", "-t", "="+name+":", "-T", "",
)
cmd.Dir = cwd
if out, err := cmd.CombinedOutput(); err != nil {
return fmt.Errorf("tmux new-session: %v: %s", err, strings.TrimSpace(string(out)))
}
return nil
}
// alive reports whether session name still exists.
func (t *terminalTmux) alive(name string) bool {
return t.command("has-session", "-t", "="+name).Run() == nil
}
// attach is the client command showing session name in the server's
// pseudo-terminal.
func (t *terminalTmux) attach(name string) *exec.Cmd {
return t.command("attach-session", "-t", "="+name)
}
// kill ends session name and its shell.
func (t *terminalTmux) kill(name string) error {
if out, err := t.command("kill-session", "-t", "="+name).CombinedOutput(); err != nil && t.alive(name) {
return fmt.Errorf("tmux kill-session: %v: %s", err, strings.TrimSpace(string(out)))
}
return nil
}
// terminalEnv is env for a terminal's process: TERM names the emulator the
// clients draw, PWD the start directory (when set), and no TMUX variables
// leak in from a tmux the server runs inside.
func terminalEnv(env []string, cwd string) []string {
out := make([]string, 0, len(env)+2)
for _, entry := range env {
if strings.HasPrefix(entry, "TERM=") || strings.HasPrefix(entry, "TMUX=") || strings.HasPrefix(entry, "TMUX_PANE=") ||
(cwd != "" && strings.HasPrefix(entry, "PWD=")) {
continue
}
out = append(out, entry)
}
out = append(out, "TERM=xterm-256color")
if cwd != "" {
out = append(out, "PWD="+cwd)
}
return out
}
+173
View File
@@ -0,0 +1,173 @@
//go:build darwin || linux
package server
import (
"context"
"path/filepath"
"strings"
"testing"
"github.com/coder/websocket"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// terminalHome points the operator's home at a fresh directory and the
// login shell at /bin/sh, so tests never read the operator's own profile.
func terminalHome(t *testing.T) string {
t.Helper()
home, err := filepath.EvalSymlinks(t.TempDir())
if err != nil {
t.Fatal(err)
}
original := operatorHomeDirectory
operatorHomeDirectory = func() (string, error) { return home, nil }
t.Cleanup(func() { operatorHomeDirectory = original })
t.Setenv("SHELL", "/bin/sh")
t.Setenv("ENV", "")
return home
}
func terminalRequest(kind, id string, body protocol.TerminalRequest) protocol.Message {
return protocol.Message{Type: kind, ID: id, TerminalRequest: &body}
}
// terminalReply sends request and returns its reply (skipping pushes).
func terminalReply(t *testing.T, ctx context.Context, conn *websocket.Conn, request protocol.Message) protocol.Message {
t.Helper()
writeChat(t, ctx, conn, request)
return readShellFrame(t, ctx, conn, func(m protocol.Message) bool { return m.ID == request.ID })
}
// readTerminalUntil reads output frames of id from end on, in order, until
// the collected text contains want; it returns the text and the new end.
func readTerminalUntil(t *testing.T, ctx context.Context, conn *websocket.Conn, id string, end int64, want string) (string, int64) {
t.Helper()
var seen strings.Builder
for !strings.Contains(seen.String(), want) {
frame := readShellFrame(t, ctx, conn, func(m protocol.Message) bool {
return m.Type == protocol.TerminalEvent && m.TerminalEvent.TerminalID == id && m.TerminalEvent.Terminal == nil
}).TerminalEvent
if frame.Offset != end {
t.Fatalf("frame at %d after %d", frame.Offset, end)
}
seen.WriteString(frame.Output)
end = frame.End
}
return seen.String(), end
}
// One client opens a shell, types into it, resizes it; a second client
// lists it, resumes its output by offset and closes it.
func TestTerminalOverWebsocket(t *testing.T) {
home := terminalHome(t)
ctx, _, conns := dialChatConns(t, Options{OperatorRegistry: newOperatorStore(t), TerminalWithoutTmux: true}, 2)
opened := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalOpen, "open", protocol.TerminalRequest{Cols: 80, Rows: 24}))
term := opened.Terminal
if opened.Type != protocol.TerminalOpen || term == nil || term.Cwd != home || term.Status != protocol.TerminalRunning || term.Cols != 80 || term.Tmux != "" || term.Shell != "/bin/sh" {
t.Fatalf("open reply = %+v", opened)
}
if got := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalInput, "in", protocol.TerminalRequest{TerminalID: term.ID, Data: "pwd; echo sum-$((40+2))\r"})); got.Type != protocol.TerminalInput {
t.Fatalf("input reply = %+v", got)
}
_, end := readTerminalUntil(t, ctx, conns[0], term.ID, 0, "sum-42")
resized := terminalReply(t, ctx, conns[1], terminalRequest(protocol.TerminalResize, "size", protocol.TerminalRequest{TerminalID: term.ID, Cols: 120, Rows: 33}))
if resized.Type != protocol.TerminalResize || resized.Terminal.Cols != 120 || resized.Terminal.Rows != 33 {
t.Fatalf("resize reply = %+v", resized)
}
list := terminalReply(t, ctx, conns[1], terminalRequest(protocol.TerminalList, "list", protocol.TerminalRequest{}))
if len(list.Terminals) != 1 || list.Terminals[0].ID != term.ID || list.Terminals[0].Cols != 120 || list.Terminals[0].Output != "" {
t.Fatalf("list = %+v", list.Terminals)
}
// The second client reads everything once, then only what follows.
all := terminalReply(t, ctx, conns[1], terminalRequest(protocol.TerminalOutput, "all", protocol.TerminalRequest{TerminalID: term.ID})).Terminal
if all.OutputStart != 0 || !strings.Contains(all.Output, home) || !strings.Contains(all.Output, "sum-42") {
t.Fatalf("output = %+v", all)
}
terminalReply(t, ctx, conns[1], terminalRequest(protocol.TerminalInput, "in2", protocol.TerminalRequest{TerminalID: term.ID, Data: "stty size\r"}))
readTerminalUntil(t, ctx, conns[0], term.ID, end, "33 120")
resume := terminalReply(t, ctx, conns[1], terminalRequest(protocol.TerminalOutput, "resume", protocol.TerminalRequest{TerminalID: term.ID, After: end})).Terminal
if resume.OutputStart != end || strings.Contains(resume.Output, "sum-42") || !strings.Contains(resume.Output, "33 120") {
t.Fatalf("resume = %+v", resume)
}
closed := terminalReply(t, ctx, conns[1], terminalRequest(protocol.TerminalClose, "close", protocol.TerminalRequest{TerminalID: term.ID}))
if closed.Type != protocol.TerminalClose || closed.Terminal.Status != protocol.TerminalClosed {
t.Fatalf("close reply = %+v", closed)
}
// Every connection hears the close; the list forgets it.
event := readShellFrame(t, ctx, conns[0], func(m protocol.Message) bool {
return m.Type == protocol.TerminalEvent && m.TerminalEvent.Terminal != nil && m.TerminalEvent.Terminal.Status == protocol.TerminalClosed
})
if event.TerminalEvent.TerminalID != term.ID {
t.Fatalf("close event = %+v", event)
}
if list := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalList, "list2", protocol.TerminalRequest{})); len(list.Terminals) != 0 {
t.Fatalf("list after close = %+v", list.Terminals)
}
if got := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalInput, "late", protocol.TerminalRequest{TerminalID: term.ID, Data: "x"})); got.Type != protocol.Error {
t.Fatalf("late input = %+v", got)
}
}
// A shell that exits by itself is listed as exited with its status and
// keeps its output until it is closed.
func TestTerminalShellExit(t *testing.T) {
terminalHome(t)
ctx, _, conns := dialChatConns(t, Options{OperatorRegistry: newOperatorStore(t), TerminalWithoutTmux: true}, 1)
term := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalOpen, "open", protocol.TerminalRequest{})).Terminal
terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalInput, "in", protocol.TerminalRequest{TerminalID: term.ID, Data: "echo bye; exit 3\r"}))
exited := readShellFrame(t, ctx, conns[0], func(m protocol.Message) bool {
return m.Type == protocol.TerminalEvent && m.TerminalEvent.Terminal != nil && m.TerminalEvent.Terminal.Status == protocol.TerminalExited
}).TerminalEvent.Terminal
if exited.ExitCode == nil || *exited.ExitCode != 3 || exited.EndedAt == 0 {
t.Fatalf("exited = %+v", exited)
}
out := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalOutput, "out", protocol.TerminalRequest{TerminalID: term.ID})).Terminal
if !strings.Contains(out.Output, "bye") || out.Status != protocol.TerminalExited {
t.Fatalf("output = %+v", out)
}
if got := terminalReply(t, ctx, conns[0], terminalRequest(protocol.TerminalClose, "close", protocol.TerminalRequest{TerminalID: term.ID})); got.Terminal == nil || got.Terminal.Status != protocol.TerminalClosed {
t.Fatalf("close = %+v", got)
}
}
// Requests outside the bounds are refused: directories outside home or
// missing, input bounds, unknown terminals, the open limit.
func TestTerminalLimitsAndValidation(t *testing.T) {
home := terminalHome(t)
ctx, _, conns := dialChatConns(t, Options{OperatorRegistry: newOperatorStore(t), TerminalWithoutTmux: true}, 1)
conn := conns[0]
for i, cwd := range []string{"/", filepath.Join(home, "missing"), "relative", "~other"} {
if got := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalOpen, "bad", protocol.TerminalRequest{Cwd: cwd})); got.Type != protocol.Error {
t.Fatalf("cwd %d %q = %+v", i, cwd, got)
}
}
if got := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalOutput, "none", protocol.TerminalRequest{TerminalID: "term_nope"})); got.Type != protocol.Error {
t.Fatalf("unknown = %+v", got)
}
if got := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalInput, "noid", protocol.TerminalRequest{Data: "x"})); got.Type != protocol.Error {
t.Fatalf("no id = %+v", got)
}
var ids []string
for i := 0; i < protocol.TerminalOpenLimit; i++ {
got := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalOpen, "open", protocol.TerminalRequest{Cwd: "~"}))
if got.Terminal == nil {
t.Fatalf("open %d = %+v", i, got)
}
ids = append(ids, got.Terminal.ID)
}
over := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalOpen, "over", protocol.TerminalRequest{}))
if over.Type != protocol.Error || !strings.Contains(over.Error, "8 open terminals") {
t.Fatalf("over limit = %+v", over)
}
for _, bad := range []string{"", strings.Repeat("x", protocol.ChatShellInputLimit+1)} {
if got := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalInput, "bad-in", protocol.TerminalRequest{TerminalID: ids[0], Data: bad})); got.Type != protocol.Error {
t.Fatalf("input %q = %+v", bad[:min(len(bad), 4)], got)
}
}
terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalClose, "close", protocol.TerminalRequest{TerminalID: ids[0]}))
if got := terminalReply(t, ctx, conn, terminalRequest(protocol.TerminalOpen, "again", protocol.TerminalRequest{})); got.Terminal == nil {
t.Fatalf("open after close = %+v", got)
}
}
+36 -1
View File
@@ -66,6 +66,12 @@ type Options struct {
// False keeps the previous behaviour (tests, embedded servers): a stopping
// server interrupts its runs and the next start marks them interrupted.
DetachSessions bool
// TerminalTmuxSocket names the Pipelines-owned tmux server machine
// terminals live in (empty: "pipelines"); TerminalWithoutTmux runs
// shells as direct children even where tmux is installed. Tests set
// them so they never share the real server's tmux sessions.
TerminalTmuxSocket string
TerminalWithoutTmux bool
}
// Handler serves the persistent connection with default options. Canceling ctx
@@ -143,6 +149,20 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
} else if store, ok := registry.(chatShellRunStore); ok {
hub.startShellRunner(ctx, store)
}
// Machine terminals are recorded beside the operator sessions, in the
// same store; a previous process's tmux-backed shells are reattached.
var terminalRecords terminalStore
if len(stores) > 0 {
terminalRecords = stores[0]
} else if store, ok := registry.(terminalStore); ok {
terminalRecords = store
}
var terminalTmuxServer *terminalTmux
if !options.TerminalWithoutTmux {
terminalTmuxServer = findTerminalTmux(options.TerminalTmuxSocket)
}
terminals := newTerminalManager(ctx, terminalRecords, terminalTmuxServer)
terminals.recover(ctx)
acks := newAttentionAckHub()
var ackStore attentionAckStore
var notes *appNotifier
@@ -237,6 +257,10 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
// connection the same way.
hub.sessionChanges.attach(clientID, write)
defer hub.sessionChanges.detach(clientID)
// Terminal lifecycle changes reach every connection; output only the
// connections that opened or read that terminal.
terminals.clients.attach(clientID, write)
defer terminals.clients.detach(clientID)
if notes != nil {
defer notes.detach(clientID)
}
@@ -250,7 +274,8 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
if err := wsjson.Read(connCtx, conn, &request); err != nil {
return
}
if request.Type != protocol.ChatShellInput && request.Type != protocol.ChatShellResize {
if request.Type != protocol.ChatShellInput && request.Type != protocol.ChatShellResize &&
request.Type != protocol.TerminalInput && request.Type != protocol.TerminalResize {
// Keystrokes would be one line each; their data is never logged.
log.Printf("command received: client=%s type=%q id=%q pipeline=%d version=%d", r.RemoteAddr, request.Type, request.ID, request.PipelineID, request.Version)
}
@@ -291,6 +316,16 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
}
continue
}
if isTerminalRequest(request.Type) {
// Closing waits for the shell to go; it never delays input
// to the other terminals behind it.
if request.Type == protocol.TerminalClose {
go handleTerminalRequest(connCtx, request, terminals, clientID, write)
} else {
handleTerminalRequest(connCtx, request, terminals, clientID, write)
}
continue
}
if handleDirectoryListing(request, write) {
continue
}