Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

Sign-in screen: your machines, wherever they are, feeding this one window

0xdiego25935101166e64
diff --git a/desktop/lib/screens/login_screen.dart b/desktop/lib/screens/login_screen.dart
index 67b119efb..f79a46fa7 100644
--- a/desktop/lib/screens/login_screen.dart
+++ b/desktop/lib/screens/login_screen.dart
@@ -1,17 +1,16 @@
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
-
import '../shared/theme/app_theme.dart' as grid;
import '../state/app_state.dart';
+import '../widgets/login_fleet_map.dart';
import '../widgets/login_relay_diagram.dart';
-import '../widgets/welcome_workspace_preview.dart';
/// The sign-in screen.
///
-/// Lead with the work: real agents together in one workspace. A static
-/// example explains a swarm before sign-in; the privacy guarantee stays in the
-/// quiet footer. The preview never creates agents or sends them a task.
+/// Lead with the reach: your machines, wherever they are, feeding this one
+/// window — the picture is [LoginFleetMap], and it moves only where a packet
+/// moves. The privacy guarantee stays in the quiet footer.
///
/// **All four states live here**, in one card, rather than the two screens this
/// used to be. Pressing Sign in swapped the whole window for
@@ -79,19 +78,19 @@ class LoginScreen extends StatelessWidget {
const _AppMark(),
SizedBox(height: gap),
Text(
- 'All your agents, on one screen',
+ 'Your agents, wherever they run',
textAlign: TextAlign.center,
style: Theme.of(context).textTheme.titleLarge,
),
const SizedBox(height: 8),
Text(
- 'Work with Claude Code, Codex and other agents side by side. '
- 'Start with one agent and add panes as your work grows.',
+ 'At home, at the office, in the cloud — every machine you '
+ 'sign in to becomes part of one desk, here.',
textAlign: TextAlign.center,
style: Theme.of(context).textTheme.bodySmall,
),
SizedBox(height: gap),
- const WelcomeWorkspacePreview(),
+ const LoginFleetMap(),
SizedBox(height: gap),
_Action(notifier: notifier, waiting: waiting),
if (notifier.lastError != null) ...[
diff --git a/desktop/lib/widgets/login_fleet_map.dart b/desktop/lib/widgets/login_fleet_map.dart
new file mode 100644
index 000000000..c0eb31252
--- /dev/null
+++ b/desktop/lib/widgets/login_fleet_map.dart
@@ -0,0 +1,629 @@
+import 'dart:math' as math;
+import 'dart:ui' as ui;
+
+import 'package:flutter/material.dart';
+
+import '../shared/theme/app_theme.dart' as grid;
+
+/// The sign-in screen's picture: your machines, wherever they are, feeding
+/// one window — this one.
+///
+/// Four pins on a dotted field — home, the office, a cloud region, a box under
+/// a desk — with an arc from each into the window at the centre. It says
+/// *where* rather than *how many*: distance is the thing a relay exists for,
+/// and the old workspace preview (three agents side by side on one screen)
+/// never hinted that the agents could be on other computers at all.
+///
+/// **Every motion is a packet.** One leaves a pin plain (a grey square — bytes
+/// on hardware you own), rings the pin as it goes, is sealed on the way in
+/// (the square turns accent and grows a halo) and lands in the pane it was
+/// for, which flashes once. Nothing else moves on its own: no drifting dots,
+/// no rotating rims. The four arcs fire a quarter of a cycle apart, so four
+/// moving parts read as one instrument rather than four effects arguing.
+///
+/// Two clocks. [_entrance] runs ONCE, on first build: the window lands, the
+/// pins pop in one after another, and each arc draws itself as its pin
+/// arrives — "linking", said without a word. [_loop] is the heartbeat every
+/// packet is a phase of, and it is the same 3.2 s the relay diagram before it
+/// used, for the same reason: the aurora behind the card breathes at an exact
+/// multiple, so the two never drift into a beat.
+///
+/// Reduce Motion (and a disabled `TickerMode`, which is how the widget tests
+/// keep `pumpAndSettle` from hanging on an endless loop) parks both clocks:
+/// the entrance at its end, so the field is fully drawn, and the loop at a
+/// phase where one packet is sealed and another still plain — the picture
+/// keeps making its point instead of becoming a diagram of nothing happening.
+class LoginFleetMap extends StatefulWidget {
+ const LoginFleetMap({super.key});
+
+ /// The drawing's own aspect, so the caller can size it without guessing.
+ static const double aspectRatio = 512 / 190;
+
+ @override
+ State<LoginFleetMap> createState() => _LoginFleetMapState();
+}
+
+/// The shared heartbeat. Every packet, ring and pane flash is a phase of it.
+const Duration _period = Duration(milliseconds: 3200);
+
+/// How long the field takes to assemble on first sight.
+const Duration _entranceLength = Duration(milliseconds: 1700);
+
+class _LoginFleetMapState extends State<LoginFleetMap>
+ with TickerProviderStateMixin {
+ late final AnimationController _entrance = AnimationController(
+ vsync: this,
+ duration: _entranceLength,
+ );
+ late final AnimationController _loop = AnimationController(
+ vsync: this,
+ duration: _period,
+ );
+
+ @override
+ void didChangeDependencies() {
+ super.didChangeDependencies();
+ final stilled =
+ MediaQuery.disableAnimationsOf(context) ||
+ !TickerMode.valuesOf(context).enabled;
+ if (stilled) {
+ _entrance
+ ..stop()
+ ..value = 1;
+ _loop
+ ..stop()
+ ..value = _reducedPhase;
+ } else {
+ if (!_entrance.isAnimating && _entrance.value < 1) _entrance.forward();
+ if (!_loop.isAnimating) _loop.repeat();
+ }
+ }
+
+ /// Where the loop stops for someone who asked for less motion: a quarter
+ /// past the seal on one arc, so that packet glows while the next one along
+ /// is still a plain grey square mid-flight.
+ static const double _reducedPhase = 0.66;
+
+ @override
+ void dispose() {
+ _entrance.dispose();
+ _loop.dispose();
+ super.dispose();
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ grid.AppTheme.watch(context);
+ // Resolved HERE, not in the painter, which must never read a theme getter
+ // from a paint callback.
+ final palette = _MapPalette(
+ dot: grid.AppPalette.guide,
+ field: grid.AppGlass.surfaceFill,
+ arc: grid.AppPalette.accentOnSurface,
+ pinFill: grid.AppCard.inset,
+ pinRim: grid.AppPalette.textSecondary,
+ ink: grid.AppPalette.textPrimary,
+ ink2: grid.AppPalette.textSecondary,
+ faint: grid.AppPalette.textFaint,
+ windowFill: grid.AppCard.inset,
+ paneFill: grid.AppSurface.recess,
+ hair: grid.AppCard.insetHair,
+ accent: grid.AppPalette.accentOnSurface,
+ raw: grid.AppPalette.textFaint,
+ claude: const Color(0xFFD97757),
+ codex: const Color(0xFF64D2FF),
+ gemini: const Color(0xFFA78BFA),
+ isDark: grid.AppTheme.isDark,
+ sans: grid.AppFont.sans,
+ sansFallback: grid.AppFont.sansFallback,
+ mono: grid.AppFont.mono,
+ monoFallback: grid.AppFont.monoFallback,
+ );
+ return RepaintBoundary(
+ child: AspectRatio(
+ aspectRatio: LoginFleetMap.aspectRatio,
+ child: AnimatedBuilder(
+ animation: Listenable.merge([_entrance, _loop]),
+ builder: (context, _) => CustomPaint(
+ painter: _MapPainter(
+ entrance: Curves.easeOut.transform(_entrance.value),
+ t: _loop.value,
+ palette: palette,
+ ),
+ size: Size.infinite,
+ ),
+ ),
+ ),
+ );
+ }
+}
+
+class _MapPalette {
+ const _MapPalette({
+ required this.dot,
+ required this.field,
+ required this.arc,
+ required this.pinFill,
+ required this.pinRim,
+ required this.ink,
+ required this.ink2,
+ required this.faint,
+ required this.windowFill,
+ required this.paneFill,
+ required this.hair,
+ required this.accent,
+ required this.raw,
+ required this.claude,
+ required this.codex,
+ required this.gemini,
+ required this.isDark,
+ required this.sans,
+ required this.sansFallback,
+ required this.mono,
+ required this.monoFallback,
+ });
+
+ final Color dot;
+ final Color field;
+ final Color arc;
+ final Color pinFill;
+ final Color pinRim;
+ final Color ink;
+ final Color ink2;
+ final Color faint;
+ final Color windowFill;
+ final Color paneFill;
+ final Color hair;
+ final Color accent;
+ final Color raw;
+ final Color claude;
+ final Color codex;
+ final Color gemini;
+ final bool isDark;
+ final String sans;
+ final List<String> sansFallback;
+ final String mono;
+ final List<String> monoFallback;
+
+ /// Glow is tuned per theme rather than scaled: on white it can only be a
+ /// tint before it turns to haze; on charcoal it has room to emit.
+ double get haloAlpha => isDark ? 0.42 : 0.44;
+ double get flowAlpha => isDark ? 0.95 : 0.85;
+}
+
+/// One machine on the field: where its pin sits, what it is called, and the
+/// arc that carries its packets to the window.
+class _Pin {
+ const _Pin({
+ required this.at,
+ required this.name,
+ required this.sub,
+ required this.arc,
+ required this.pane,
+ required this.labelBelow,
+ });
+
+ final Offset at;
+ final String name;
+ final String sub;
+
+ /// Control points of the cubic from the pin to the window's edge.
+ final List<Offset> arc;
+
+ /// Which pane in the window flashes when this machine's packet lands.
+ final int pane;
+
+ /// Whether the label hangs under the pin (top row) or sits over it (bottom
+ /// row), so no label ever runs into the window.
+ final bool labelBelow;
+}
+
+/// [color] at [k] of its OWN opacity. Several tokens here are translucent by
+/// design (a recess is white at 6%, a hairline at 8%), and `withValues(alpha:)`
+/// would replace that with a solid — a 6% white well painted as pure white.
+Color _fade(Color color, double k) => color.withValues(alpha: color.a * k);
+
+/// The drawing, in its own 512×190 space; the canvas is scaled to fit so every
+/// number here is the one from the mockup rather than a fraction to re-derive.
+class _MapPainter extends CustomPainter {
+ _MapPainter({required this.entrance, required this.t, required this.palette});
+
+ /// 0 → 1 over the first sight of the field; 1 forever after.
+ final double entrance;
+
+ /// The loop's phase, 0 → 1, wrapping.
+ final double t;
+ final _MapPalette palette;
+
+ static const Size _design = Size(512, 190);
+
+ /// The window at the centre.
+ static const Rect _window = Rect.fromLTWH(190, 47, 132, 96);
+ static const List<Rect> _panes = [
+ Rect.fromLTWH(197, 66, 58, 32),
+ Rect.fromLTWH(259, 66, 58, 32),
+ Rect.fromLTWH(197, 102, 58, 32),
+ Rect.fromLTWH(259, 102, 58, 32),
+ ];
+
+ static const List<_Pin> _pins = [
+ _Pin(
+ at: Offset(49, 39),
+ name: 'Studio Mac',
+ sub: 'home · claude, codex',
+ arc: [Offset(120, 30), Offset(160, 80), Offset(190, 90)],
+ pane: 0,
+ labelBelow: true,
+ ),
+ _Pin(
+ at: Offset(101, 125),
+ name: 'Mac mini',
+ sub: 'office · codex',
+ arc: [Offset(150, 130), Offset(170, 110), Offset(190, 100)],
+ pane: 1,
+ labelBelow: true,
+ ),
+ _Pin(
+ at: Offset(439, 31),
+ name: 'dev-server',
+ sub: 'us-east · claude, gemini',
+ arc: [Offset(380, 30), Offset(350, 80), Offset(322, 90)],
+ pane: 2,
+ labelBelow: true,
+ ),
+ _Pin(
+ at: Offset(477, 123),
+ name: 'gpu-box',
+ sub: 'under the desk · claude',
+ arc: [Offset(420, 130), Offset(370, 110), Offset(322, 100)],
+ pane: 3,
+ labelBelow: true,
+ ),
+ ];
+
+ /// When, within the entrance, each pin pops and its arc starts drawing.
+ static const List<double> _pinAt = [0.18, 0.36, 0.54, 0.72];
+
+ /// How far along its arc a packet is sealed. Past the field's middle, so
+ /// the halo reads as "on the way in", never "at the pin".
+ static const double _sealAt = 0.58;
+
+ @override
+ void paint(Canvas canvas, Size size) {
+ final scale = size.width / _design.width;
+ canvas.save();
+ canvas.scale(scale);
+ canvas.clipRRect(
+ RRect.fromRectAndRadius(Offset.zero & _design, const Radius.circular(10)),
+ );
+
+ _paintField(canvas);
+ final arcs = [for (final pin in _pins) _arcPath(pin)];
+ _paintArcs(canvas, arcs);
+ _paintWindow(canvas);
+ _paintPins(canvas);
+ if (entrance >= 1) _paintPackets(canvas, arcs);
+
+ canvas.restore();
+ }
+
+ // ── the field ───────────────────────────────────────────────────────────
+
+ void _paintField(Canvas canvas) {
+ final dot = Paint()..color = _fade(palette.dot, 0.55);
+ for (var y = 5.0; y < _design.height; y += 10) {
+ for (var x = 5.0; x < _design.width; x += 10) {
+ canvas.drawCircle(Offset(x, y), 0.8, dot);
+ }
+ }
+ // A vignette to the card's own colour: the dots are a field, not a grid
+ // with edges, and the window in the middle should sit on the brightest
+ // part of it.
+ final centre = (Offset.zero & _design).center;
+ canvas.drawRect(
+ Offset.zero & _design,
+ Paint()
+ ..shader = ui.Gradient.radial(
+ centre,
+ _design.width * 0.62,
+ [_fade(palette.field, 0), _fade(palette.field, 0), palette.field],
+ const [0, 0.42, 1],
+ ),
+ );
+ }
+
+ // ── arcs ────────────────────────────────────────────────────────────────
+
+ Path _arcPath(_Pin pin) => Path()
+ ..moveTo(pin.at.dx, pin.at.dy)
+ ..cubicTo(
+ pin.arc[0].dx,
+ pin.arc[0].dy,
+ pin.arc[1].dx,
+ pin.arc[1].dy,
+ pin.arc[2].dx,
+ pin.arc[2].dy,
+ );
+
+ /// How much of pin [i]'s entrance has played, 0 → 1.
+ double _arrival(int i) {
+ const span = 0.26;
+ return ((entrance - _pinAt[i]) / span).clamp(0.0, 1.0);
+ }
+
+ void _paintArcs(Canvas canvas, List<Path> arcs) {
+ final paint = Paint()
+ ..style = PaintingStyle.stroke
+ ..strokeWidth = 1.2
+ ..strokeCap = StrokeCap.round
+ ..color = palette.arc.withValues(alpha: 0.35);
+ for (var i = 0; i < arcs.length; i++) {
+ final drawn = Curves.easeOut.transform(_arrival(i));
+ if (drawn <= 0) continue;
+ for (final metric in arcs[i].computeMetrics()) {
+ canvas.drawPath(metric.extractPath(0, metric.length * drawn), paint);
+ }
+ }
+ }
+
+ // ── the window ──────────────────────────────────────────────────────────
+
+ void _paintWindow(Canvas canvas) {
+ // Lands first, from slightly below, so the pins have something to aim at.
+ final landed = Curves.easeOut.transform((entrance / 0.3).clamp(0.0, 1.0));
+ if (landed <= 0) return;
+ canvas.save();
+ canvas.translate(0, (1 - landed) * 8);
+ final rrect = RRect.fromRectAndRadius(_window, const Radius.circular(9));
+ // The glow says "here": the one place on the field that is this computer.
+ canvas.drawRRect(
+ rrect.inflate(1),
+ Paint()
+ ..color = palette.accent.withValues(alpha: 0.35 * landed)
+ ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 14),
+ );
+ canvas.drawRRect(rrect, Paint()..color = _fade(palette.windowFill, landed));
+ canvas.drawRRect(
+ rrect,
+ Paint()
+ ..style = PaintingStyle.stroke
+ ..strokeWidth = 1
+ ..color = palette.accent.withValues(alpha: 0.9 * landed),
+ );
+ _text(
+ canvas,
+ '● this Mac · 4 linked',
+ Offset(_window.left + 7, _window.top + 6),
+ size: 9,
+ color: _fade(palette.ink2, landed),
+ );
+ const names = ['Claude', 'Codex', 'Gemini', '+'];
+ final tints = [
+ palette.claude,
+ palette.codex,
+ palette.gemini,
+ palette.faint,
+ ];
+ for (var i = 0; i < _panes.length; i++) {
+ final pane = _panes[i];
+ final pr = RRect.fromRectAndRadius(pane, const Radius.circular(4));
+ canvas.drawRRect(pr, Paint()..color = _fade(palette.paneFill, landed));
+ canvas.drawRRect(
+ pr,
+ Paint()
+ ..style = PaintingStyle.stroke
+ ..strokeWidth = 0.8
+ ..color = _fade(palette.hair, landed),
+ );
+ _text(
+ canvas,
+ names[i],
+ Offset(pane.left + 5, pane.top + 4),
+ size: 8,
+ weight: FontWeight.w600,
+ color: _fade(tints[i], landed),
+ );
+ // The flash: the pane a packet has just landed in, fading over an eighth
+ // of a cycle. Gated on the entrance so nothing flashes before a packet
+ // could have arrived.
+ if (entrance >= 1) {
+ final since = _sinceLanding(i);
+ if (since != null) {
+ canvas.drawRRect(
+ pr,
+ Paint()
+ ..color = palette.accent.withValues(
+ alpha: 0.28 * (1 - Curves.easeOut.transform(since / 0.12)),
+ ),
+ );
+ }
+ }
+ }
+ canvas.restore();
+ }
+
+ /// How far past the landing pin [i]'s packet is, in loop phase, or null if
+ /// it is not within the flash window.
+ double? _sinceLanding(int i) {
+ final phase = _phase(i);
+ // A packet lands at 0.9 of its travel (the last tenth is its fade).
+ final since = phase - 0.9;
+ if (since < 0 || since > 0.12) return null;
+ return since;
+ }
+
+ // ── pins ────────────────────────────────────────────────────────────────
+
+ void _paintPins(Canvas canvas) {
+ for (var i = 0; i < _pins.length; i++) {
+ final pin = _pins[i];
+ final arrived = Curves.easeOutBack.transform(_arrival(i));
+ if (arrived <= 0) continue;
+ final alpha = _arrival(i).clamp(0.0, 1.0);
+ canvas.save();
+ canvas.translate(pin.at.dx, pin.at.dy);
+ canvas.scale(arrived);
+ // The ring: the pin says "a packet just left me". It runs on the loop,
+ // once the field is assembled.
+ if (entrance >= 1) {
+ final phase = _phase(i);
+ if (phase < 0.3) {
+ final k = phase / 0.3;
+ canvas.drawCircle(
+ Offset.zero,
+ 5 + 9 * Curves.easeOut.transform(k),
+ Paint()
+ ..style = PaintingStyle.stroke
+ ..strokeWidth = 1
+ ..color = palette.accent.withValues(alpha: 0.8 * (1 - k)),
+ );
+ }
+ }
+ canvas.drawCircle(Offset.zero, 5, Paint()..color = palette.pinFill);
+ canvas.drawCircle(
+ Offset.zero,
+ 5,
+ Paint()
+ ..style = PaintingStyle.stroke
+ ..strokeWidth = 1.5
+ ..color = palette.pinRim,
+ );
+ canvas.restore();
+
+ // Labels are laid out in unscaled space and only faded, so the text
+ // never renders at a fractional scale mid-pop.
+ final nameWidth = _measure(pin.name, size: 10.5, weight: FontWeight.w500);
+ final subWidth = _measure(pin.sub, size: 8.5, mono: true);
+ final width = math.max(nameWidth, subWidth);
+ // Centred on the pin, but never off the field.
+ final left = (pin.at.dx - width / 2).clamp(
+ 6.0,
+ _design.width - width - 6,
+ );
+ final top = pin.labelBelow ? pin.at.dy + 10 : pin.at.dy - 34;
+ _text(
+ canvas,
+ pin.name,
+ Offset(left + (width - nameWidth) / 2, top),
+ size: 10.5,
+ weight: FontWeight.w500,
+ color: _fade(palette.ink2, alpha),
+ );
+ _text(
+ canvas,
+ pin.sub,
+ Offset(left + (width - subWidth) / 2, top + 13),
+ size: 8.5,
+ mono: true,
+ color: _fade(palette.faint, alpha),
+ );
+ }
+ }
+
+ // ── packets ─────────────────────────────────────────────────────────────
+
+ /// Pin [i]'s place in the loop, a quarter of a cycle behind the one before.
+ double _phase(int i) => (t - i / 4 + 1) % 1;
+
+ void _paintPackets(Canvas canvas, List<Path> arcs) {
+ for (var i = 0; i < arcs.length; i++) {
+ final phase = _phase(i);
+ // The packet is in flight for the first nine tenths and gone for the
+ // last: a beat of nothing before the next one, so a lane is never a
+ // conveyor belt.
+ if (phase > 0.9) continue;
+ final travel = Curves.easeInOut.transform(phase / 0.9);
+ final metric = arcs[i].computeMetrics().first;
+ final tangent = metric.getTangentForOffset(metric.length * travel);
+ if (tangent == null) continue;
+ final at = tangent.position;
+ // In and out over the first and last tenth of the flight.
+ final fade = math.min(phase / 0.09, (0.9 - phase) / 0.09).clamp(0.0, 1.0);
+ final sealed = travel >= _sealAt;
+ final rect = RRect.fromRectAndRadius(
+ Rect.fromCenter(center: at, width: 9, height: 9),
+ const Radius.circular(2),
+ );
+ if (sealed) {
+ // The halo grows over the first stretch after the seal, then holds.
+ final grown = ((travel - _sealAt) / 0.1).clamp(0.0, 1.0);
+ canvas.drawRRect(
+ rect.inflate(3 * grown),
+ Paint()
+ ..color = palette.accent.withValues(
+ alpha: palette.haloAlpha * fade * grown,
+ )
+ ..maskFilter = const MaskFilter.blur(BlurStyle.normal, 5),
+ );
+ canvas.drawRRect(
+ rect,
+ Paint()
+ ..color = palette.accent.withValues(
+ alpha: palette.flowAlpha * fade,
+ ),
+ );
+ } else {
+ canvas.drawRRect(rect, Paint()..color = _fade(palette.raw, 0.9 * fade));
+ }
+ }
+ }
+
+ // ── text ────────────────────────────────────────────────────────────────
+
+ TextPainter _layout(
+ String text, {
+ required double size,
+ FontWeight weight = FontWeight.w400,
+ bool mono = false,
+ Color color = const Color(0xFFFFFFFF),
+ }) {
+ final painter = TextPainter(
+ text: TextSpan(
+ text: text,
+ style: TextStyle(
+ fontFamily: mono ? palette.mono : palette.sans,
+ fontFamilyFallback: mono
+ ? palette.monoFallback
+ : palette.sansFallback,
+ fontSize: size,
+ fontWeight: weight,
+ color: color,
+ height: 1.2,
+ ),
+ ),
+ textDirection: TextDirection.ltr,
+ maxLines: 1,
+ ellipsis: '…',
+ )..layout(maxWidth: 160);
+ return painter;
+ }
+
+ double _measure(
+ String text, {
+ required double size,
+ FontWeight weight = FontWeight.w400,
+ bool mono = false,
+ }) => _layout(text, size: size, weight: weight, mono: mono).width;
+
+ void _text(
+ Canvas canvas,
+ String text,
+ Offset at, {
+ required double size,
+ required Color color,
+ FontWeight weight = FontWeight.w400,
+ bool mono = false,
+ }) {
+ _layout(
+ text,
+ size: size,
+ weight: weight,
+ mono: mono,
+ color: color,
+ ).paint(canvas, at);
+ }
+
+ @override
+ bool shouldRepaint(_MapPainter old) =>
+ old.t != t || old.entrance != entrance || old.palette != palette;
+}
diff --git a/desktop/lib/widgets/welcome_workspace_preview.dart b/desktop/lib/widgets/welcome_workspace_preview.dart
deleted file mode 100644
index a34b2d7a7..000000000
--- a/desktop/lib/widgets/welcome_workspace_preview.dart
+++ /dev/null
@@ -1,134 +0,0 @@
-import 'package:flutter/material.dart';
-
-import '../shared/theme/app_theme.dart' as grid;
-import 'engine_identity.dart';
-import 'swarm_icon.dart';
-
-/// A static example of the workspace. It never creates or contacts an agent.
-class WelcomeWorkspacePreview extends StatelessWidget {
- const WelcomeWorkspacePreview({super.key});
-
- @override
- Widget build(BuildContext context) {
- grid.AppTheme.watch(context);
- final palette = grid.AppTheme.palette.value;
- return Semantics(
- image: true,
- label: 'Example agent group: Claude Code and Codex working side by side.',
- child: ExcludeSemantics(
- child: Container(
- decoration: BoxDecoration(
- color: palette.workspace,
- borderRadius: BorderRadius.circular(10),
- border: Border.all(color: Colors.white12),
- ),
- clipBehavior: Clip.antiAlias,
- child: Column(
- mainAxisSize: MainAxisSize.min,
- children: [
- Container(
- color: palette.tabBar,
- padding: const EdgeInsets.symmetric(
- horizontal: 12,
- vertical: 10,
- ),
- child: const Row(
- children: [
- SwarmIcon(size: 14, color: Colors.white70),
- SizedBox(width: 8),
- Text(
- 'Your project',
- style: TextStyle(fontSize: 12, color: Colors.white),
- ),
- Spacer(),
- Text(
- '2 agents',
- style: TextStyle(fontSize: 11, color: Colors.white70),
- ),
- ],
- ),
- ),
- Padding(
- padding: const EdgeInsets.all(8),
- child: Row(
- children: [
- Expanded(
- child: _AgentExample(
- engine: 'claude',
- title: 'Claude Code',
- task: 'Build the feature',
- color: palette.background,
- ),
- ),
- const SizedBox(width: 8),
- Expanded(
- child: _AgentExample(
- engine: 'codex',
- title: 'Codex',
- task: 'Review the changes',
- color: palette.background,
- ),
- ),
- ],
- ),
- ),
- ],
- ),
- ),
- ),
- );
- }
-}
-
-class _AgentExample extends StatelessWidget {
- const _AgentExample({
- required this.engine,
- required this.title,
- required this.task,
- required this.color,
- });
- final String engine, title, task;
- final Color color;
-
- @override
- Widget build(BuildContext context) => Container(
- padding: const EdgeInsets.all(12),
- decoration: BoxDecoration(
- color: color,
- borderRadius: BorderRadius.circular(6),
- ),
- child: Column(
- crossAxisAlignment: CrossAxisAlignment.start,
- children: [
- Row(
- children: [
- EngineMark(engine: engine, size: 17),
- const SizedBox(width: 7),
- Expanded(
- child: Text(
- title,
- style: const TextStyle(
- fontSize: 12,
- color: Colors.white,
- fontWeight: FontWeight.w500,
- ),
- ),
- ),
- ],
- ),
- const SizedBox(height: 14),
- Text(task, style: const TextStyle(fontSize: 11, color: Colors.white70)),
- const SizedBox(height: 10),
- for (final width in [0.9, 0.65])
- FractionallySizedBox(
- widthFactor: width,
- child: Container(
- height: 3,
- margin: const EdgeInsets.only(bottom: 5),
- color: Colors.white24,
- ),
- ),
- ],
- ),
- );
-}
diff --git a/desktop/test/boot_flow_widget_test.dart b/desktop/test/boot_flow_widget_test.dart
index 4879dbdd7..9d30fa748 100644
--- a/desktop/test/boot_flow_widget_test.dart
+++ b/desktop/test/boot_flow_widget_test.dart
@@ -503,7 +503,7 @@ void main() {
// The card leads with what the app does for you, not with its own name —
// the wordmark left when the screen stopped being a logo over a button.
- expect(find.text('All your agents, on one screen'), findsOneWidget);
+ expect(find.text('Your agents, wherever they run'), findsOneWidget);
expect(find.text('Sign in'), findsOneWidget);
expect(find.byIcon(Icons.login), findsOneWidget);
});
diff --git a/desktop/test/login_screen_test.dart b/desktop/test/login_screen_test.dart
index f07d0cce5..07701815e 100644
--- a/desktop/test/login_screen_test.dart
+++ b/desktop/test/login_screen_test.dart
@@ -8,7 +8,7 @@ import 'package:harness/core/config.dart';
import 'package:harness/screens/login_screen.dart';
import 'package:harness/shared/theme/app_theme.dart' as grid;
import 'package:harness/state/app_state.dart';
-import 'package:harness/widgets/welcome_workspace_preview.dart';
+import 'package:harness/widgets/login_fleet_map.dart';
/// Wraps the screen in the same chrome `main.dart` gives it, at the app's
/// minimum window size — 880×560 — because that is where a card gets cramped
@@ -78,9 +78,9 @@ void main() {
await tester.pumpWidget(_host(app));
await tester.pump(const Duration(milliseconds: 100));
- expect(find.text('All your agents, on one screen'), findsOneWidget);
+ expect(find.text('Your agents, wherever they run'), findsOneWidget);
expect(find.text('Sign in'), findsOneWidget);
- expect(find.byType(WelcomeWorkspacePreview), findsOneWidget);
+ expect(find.byType(LoginFleetMap), findsOneWidget);
// The real mark, from the bundle — `Icons.memory` used to stand here and
// appeared nowhere else in the app.
final logo = tester.widget<Image>(
@@ -95,7 +95,7 @@ void main() {
// The promise the screen exists to make, in words with no jargon in them.
expect(
find.textContaining(
- 'Start with one agent and add panes as your work grows',
+ 'every machine you sign in to becomes part of one desk',
),
findsOneWidget,
);
@@ -114,7 +114,7 @@ void main() {
await tester.pump(const Duration(milliseconds: 100));
// Still the same card — the workspace example never leaves, so the frame can't jump.
- expect(find.byType(WelcomeWorkspacePreview), findsOneWidget);
+ expect(find.byType(LoginFleetMap), findsOneWidget);
expect(find.text('Waiting for your browser'), findsOneWidget);
expect(find.text('Cancel'), findsOneWidget);
// The idle label is gone, so the two states cannot both be on screen.
@@ -168,7 +168,7 @@ void main() {
await tester.pumpAndSettle();
// The example stays visible without depending on animation.
- expect(find.byType(WelcomeWorkspacePreview), findsOneWidget);
+ expect(find.byType(LoginFleetMap), findsOneWidget);
expect(find.text('Sign in'), findsOneWidget);
});
@@ -243,14 +243,14 @@ void main() {
// Just pressed: in flight, no URL yet.
expect(app.pendingAuthorizeUrl, isNull);
expect(find.text('Signing in…'), findsOneWidget);
- expect(find.byType(WelcomeWorkspacePreview), findsOneWidget);
+ expect(find.byType(LoginFleetMap), findsOneWidget);
// The CLI hands one over; nothing about the screen should change.
app.pendingAuthorizeUrl = 'https://auth.example/authorize';
app.notifyListeners();
await tester.pump(const Duration(milliseconds: 100));
expect(find.text('Waiting for your browser'), findsOneWidget);
- expect(find.byType(WelcomeWorkspacePreview), findsOneWidget);
+ expect(find.byType(LoginFleetMap), findsOneWidget);
// Signed in: the URL goes while the restore is still running. The card has
// to hold until the shell is actually ready.
@@ -259,7 +259,7 @@ void main() {
await tester.pump(const Duration(milliseconds: 100));
expect(find.text('Signing in…'), findsOneWidget);
expect(find.text('Copy link'), findsNothing);
- expect(find.byType(WelcomeWorkspacePreview), findsOneWidget);
+ expect(find.byType(LoginFleetMap), findsOneWidget);
});
test('every frame of the diagram carries a sealed packet', () {