collin/browser-terminal-extension · b9b5b120

Initial commit: terminal sidebar extension and termbridge daemon

Collin Richards · 2026-08-12 09:23 UTC · b9b5b120efbd61817fb954ea0574156d8e39a302 · browse files

added.gitignore+2 −0

addedREADME.md+495 −0

addedTODO.md+1 −0

addedassets/make-icons.py+98 −0

addedbuild.sh+24 −0

addeddaemon/.gitignore+1 −0

addeddaemon/Cargo.lock+1124 −0

addeddaemon/Cargo.toml+20 −0

addeddaemon/src/agents.rs+352 −0

addeddaemon/src/auth.rs+151 −0

addeddaemon/src/control.rs+219 −0

addeddaemon/src/lib.rs+12 −0

addeddaemon/src/main.rs+250 −0

addeddaemon/src/paths.rs+189 −0

addeddaemon/src/pty.rs+359 −0

addeddaemon/src/rewind.rs+87 −0

addeddaemon/src/server.rs+917 −0

addeddaemon/src/status.rs+205 −0

addeddaemon/src/tls.rs+219 −0

addeddaemon/src/window_status.rs+167 −0

addeddaemon/tests/pty_e2e.rs+559 −0

addeddaemon/tests/security.rs+548 −0

addeddaemon/tests/tls.rs+285 −0

addedextension/icons/icon128.pngbinary

Binary file

addedextension/icons/icon16.pngbinary

Binary file

addedextension/icons/icon32.pngbinary

Binary file

addedextension/icons/icon48.pngbinary

Binary file

addedextension/icons/icon96.pngbinary

Binary file

addedextension/jsconfig.base.json+23 −0

addedextension/jsconfig.json+10 −0

addedextension/jsconfig.sw.json+13 −0

addedextension/lib/sanitize.js+85 −0

addedextension/lib/sanitize.test.js+114 −0

addedextension/lib/shot.js+175 −0

addedextension/lib/theme.js+127 −0

addedextension/lib/theme.test.js+137 −0

addedextension/manifest.chrome.json+55 −0

addedextension/manifest.firefox.json+60 −0

addedextension/picker.js+255 −0

addedextension/sidebar.css+414 −0

addedextension/sidebar.html+184 −0

addedextension/sidebar.js+1383 −0

addedextension/sw.js+66 −0

addedextension/types/globals.d.ts+255 −0

addedextension/types/worker.d.ts+7 −0

addedextension/vendor/addon-fit.js+2 −0

addedextension/vendor/xterm.css+285 −0

addedextension/vendor/xterm.js+2 −0

addedpackage-lock.json+391 −0

addedpackage.json+13 −0

addedrun.sh+16 −0

1	+	#!/usr/bin/env python3
2	+	"""Generate the extension icons.
3	+
4	+	Design: a dark terminal tile with a green `>_` prompt, and a thin accent bar
5	+	down the right side standing for the sidebar the terminal lives in. The prompt
6	+	is the part that has to survive 16px, so at small sizes the accent bar and the
7	+	corner rounding are simplified rather than shrunk into mush.
8	+
9	+	Colours come from the dark theme in extension/lib/theme.js.
10	+
11	+	python3 assets/make-icons.py
12	+	"""
13	+
14	+	from PIL import Image, ImageDraw
15	+
16	+	BG = (20, 22, 26, 255) # --bg #14161a
17	+	EDGE = (45, 49, 56, 255) # --border #2d3138
18	+	GREEN = (110, 193, 119, 255) # ok #6ec177
19	+	FG = (215, 218, 224, 255) # --fg #d7dae0
20	+	ACCENT = (59, 110, 165, 255) # --accent #3b6ea5
21	+
22	+	# Draw everything on a 128-unit grid at 8x, then downsample.
23	+	GRID = 128
24	+	SS = 8
25	+
26	+	SIZES = [16, 32, 48, 96, 128]
27	+
28	+
29	+	def draw_icon(size: int) -> Image.Image:
30	+	small = size <= 20
31	+	w = GRID * SS
32	+	img = Image.new("RGBA", (w, w), (0, 0, 0, 0))
33	+	d = ImageDraw.Draw(img)
34	+
35	+	def u(v: float) -> float:
36	+	"""Grid units -> supersampled pixels."""
37	+	return v * SS
38	+
39	+	# --- tile ---------------------------------------------------------------
40	+	# Less rounding at 16px: a large radius eats the glyph's breathing room.
41	+	radius = 20 if small else 27
42	+	d.rounded_rectangle(
43	+	[u(2), u(2), u(GRID - 2), u(GRID - 2)],
44	+	radius=u(radius),
45	+	fill=BG,
46	+	outline=EDGE,
47	+	width=int(u(2)),
48	+	)
49	+
50	+	# --- sidebar accent bar -------------------------------------------------
51	+	# Dropped at 16px, where it would be a single muddy pixel column.
52	+	if not small:
53	+	d.rounded_rectangle(
54	+	[u(102), u(34), u(109), u(94)],
55	+	radius=u(3.5),
56	+	fill=ACCENT,
57	+	)
58	+
59	+	# --- prompt: >_ ---------------------------------------------------------
60	+	# Shifted right slightly when there's no accent bar, to stay centred.
61	+	dx = 6 if small else 0
62	+	stroke = int(u(11 if small else 10))
63	+
64	+	d.line(
65	+	[(u(30 + dx), u(44)), (u(53 + dx), u(65)), (u(30 + dx), u(86))],
66	+	fill=GREEN,
67	+	width=stroke,
68	+	joint="curve",
69	+	)
70	+	# Round the ends by hand; PIL only rounds joints, not caps.
71	+	r = stroke / 2
72	+	for px, py in [(u(30 + dx), u(44)), (u(30 + dx), u(86))]:
73	+	d.ellipse([px - r, py - r, px + r, py + r], fill=GREEN)
74	+
75	+	# Underscore / cursor.
76	+	bar_left, bar_right = u(62 + dx), u(92 + dx if not small else 96)
77	+	d.rounded_rectangle(
78	+	[bar_left, u(78), bar_right, u(88)],
79	+	radius=u(5),
80	+	fill=FG,
81	+	)
82	+
83	+	return img.resize((size, size), Image.LANCZOS)
84	+
85	+
86	+	def main() -> None:
87	+	import pathlib
88	+
89	+	out = pathlib.Path(__file__).resolve().parent.parent / "extension" / "icons"
90	+	out.mkdir(parents=True, exist_ok=True)
91	+	for size in SIZES:
92	+	path = out / f"icon{size}.png"
93	+	draw_icon(size).save(path)
94	+	print(f"wrote {path.relative_to(out.parent.parent)}")
95	+
96	+
97	+	if __name__ == "__main__":
98	+	main()

1	+	#!/usr/bin/env bash
2	+	# Assemble unpacked extensions for both browsers.
3	+	set -euo pipefail
4	+	cd "$(dirname "$0")"
5	+
6	+	for browser in chrome firefox; do
7	+	out="dist/$browser"
8	+	rm -rf "$out"; mkdir -p "$out"
9	+	cp extension/sidebar.html extension/sidebar.js extension/sidebar.css extension/picker.js "$out/"
10	+	mkdir -p "$out/lib" && cp extension/lib/sanitize.js extension/lib/theme.js extension/lib/shot.js "$out/lib/"
11	+	cp -r extension/vendor extension/icons "$out/"
12	+	cp "extension/manifest.$browser.json" "$out/manifest.json"
13	+	cp extension/sw.js "$out/" # both browsers now run a background script
14	+	echo "built $out"
15	+	done
16	+
17	+	cat <<'EOF'
18	+
19	+	Load them:
20	+	Chrome chrome://extensions -> Developer mode -> Load unpacked -> dist/chrome
21	+	Firefox about:debugging#/runtime/this-firefox -> Load Temporary Add-on -> dist/firefox/manifest.json
22	+
23	+	Then open the sidebar and follow the three steps in it.
24	+	EOF

1	+	[package]
2	+	name = "termbridge"
3	+	version = "0.1.0"
4	+	edition = "2024"
5	+
6	+	[dependencies]
7	+	futures-util = { version = "0.3.33", default-features = false, features = ["std", "sink"] }
8	+	getrandom = "0.4.3"
9	+	portable-pty = "0.9.0"
10	+	rcgen = { version = "0.14.8", default-features = false, features = ["pem", "ring"] }
11	+	serde = { version = "1.0.229", features = ["derive"] }
12	+	serde_json = "1.0.151"
13	+	sha2 = "0.11.0"
14	+	subtle = "2.6.1"
15	+	tokio = { version = "1.53.1", features = ["rt-multi-thread", "macros", "net", "io-util", "time", "sync", "process"] }
16	+	tokio-rustls = { version = "0.26.4", default-features = false, features = ["ring", "tls12", "logging"] }
17	+	tokio-tungstenite = "0.30.0"
18	+
19	+	[dev-dependencies]
20	+	tempfile = "3.27.0"

1	+	//! Handshake authorization: Origin allowlist, Host validation, token compare.
2	+	//!
3	+	//! Why both an origin check and a token:
4	+	//!
5	+	//! - `Origin` is set by the browser and cannot be forged from page JS, so it is
6	+	//! a real defense against a hostile web page (WebSocket has no CORS — any
7	+	//! page can open a socket to 127.0.0.1). It is useless against a local
8	+	//! process, which can set any header it likes.
9	+	//! - The token defends against local processes belonging to other uids, via
10	+	//! the 0600 file mode. It does nothing against a hostile page, which would
11	+	//! happily send a token it stole.
12	+	//!
13	+	//! Neither is sufficient alone. Both are required.
14	+
15	+	use subtle::ConstantTimeEq;
16	+
17	+	#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18	+	pub enum Denied {
19	+	/// No Origin header at all (a non-browser client, or a browser context we
20	+	/// don't understand). Rejected: pairing is keyed on origin.
21	+	MissingOrigin,
22	+	/// Origin is well-formed but the user has not paired it.
23	+	UnpairedOrigin,
24	+	/// Host header points somewhere other than loopback — the signature of a
25	+	/// DNS-rebinding attempt, where `evil.com` resolves to 127.0.0.1.
26	+	ForeignHost,
27	+	/// Wrong token in the auth frame.
28	+	BadToken,
29	+	/// No auth frame arrived inside the deadline.
30	+	AuthTimeout,
31	+	/// Auth frame was not the expected shape.
32	+	MalformedAuth,
33	+	/// Too many recent failures.
34	+	RateLimited,
35	+	/// The request never was a WebSocket upgrade — a plain HTTP request, a TLS
36	+	/// ClientHello, or a proxy in the way. Nothing to do with auth.
37	+	NotAWebSocketUpgrade,
38	+	/// The client opened with a TLS ClientHello but we have no TLS identity.
39	+	TlsAttempted,
40	+	/// TLS negotiation failed — usually the browser refusing our self-signed
41	+	/// certificate because no exception has been added yet.
42	+	TlsHandshakeFailed,
43	+	}
44	+
45	+	impl Denied {
46	+	/// HTTP status used when we can still reject during the handshake.
47	+	pub fn status(self) -> u16 {
48	+	match self {
49	+	Denied::RateLimited => 429,
50	+	Denied::NotAWebSocketUpgrade => 400,
51	+	Denied::TlsAttempted => 400,
52	+	Denied::TlsHandshakeFailed => 400,
53	+	_ => 403,
54	+	}
55	+	}
56	+
57	+	pub fn reason(self) -> &'static str {
58	+	match self {
59	+	Denied::MissingOrigin => "missing Origin header",
60	+	Denied::UnpairedOrigin => "origin not paired",
61	+	Denied::ForeignHost => "Host header is not loopback",
62	+	Denied::BadToken => "invalid token",
63	+	Denied::AuthTimeout => "auth timeout",
64	+	Denied::MalformedAuth => "malformed auth frame",
65	+	Denied::RateLimited => "too many failed attempts",
66	+	Denied::NotAWebSocketUpgrade => "not a WebSocket upgrade request",
67	+	Denied::TlsAttempted => "client spoke TLS but no certificate is configured",
68	+	Denied::TlsHandshakeFailed => "TLS handshake failed (certificate not trusted yet?)",
69	+	}
70	+	}
71	+	}
72	+
73	+	/// Hostnames we accept in the `Host` header. Anything else means the client
74	+	/// reached us under a name that isn't loopback.
75	+	const LOOPBACK_HOSTS: &[&str] = &["127.0.0.1", "localhost", "[::1]", "::1"];
76	+
77	+	pub fn host_is_loopback(host_header: &str) -> bool {
78	+	let h = host_header.trim().to_ascii_lowercase();
79	+	// Strip the port. Bracketed IPv6 literals need care: "[::1]:7681".
80	+	let hostname = if let Some(rest) = h.strip_prefix('[') {
81	+	match rest.split_once(']') {
82	+	Some((inner, _)) => format!("[{inner}]"),
83	+	None => return false,
84	+	}
85	+	} else {
86	+	h.split(':').next().unwrap_or("").to_string()
87	+	};
88	+	LOOPBACK_HOSTS.contains(&hostname.as_str())
89	+	}
90	+
91	+	pub fn origin_is_paired(origin: &str, paired: &[String]) -> bool {
92	+	let o = origin.trim().to_ascii_lowercase();
93	+	if o.is_empty() \|\| o == "null" {
94	+	return false;
95	+	}
96	+	paired.iter().any(\|p\| p == &o)
97	+	}
98	+
99	+	/// Constant-time token comparison. A byte-by-byte `==` leaks the length of the
100	+	/// matching prefix through timing, which is enough to recover a token given
101	+	/// enough attempts from a local process.
102	+	pub fn token_matches(presented: &str, expected: &str) -> bool {
103	+	let a = presented.trim().as_bytes();
104	+	let b = expected.trim().as_bytes();
105	+	if a.len() != b.len() {
106	+	// Length is not secret-dependent in a useful way here (the token is a
107	+	// fixed 64 hex chars), but still burn a comparison so the fast path
108	+	// isn't obviously distinguishable.
109	+	let _ = b.ct_eq(b);
110	+	return false;
111	+	}
112	+	a.ct_eq(b).into()
113	+	}
114	+
115	+	/// Validate the parts of the request we can see before the upgrade completes.
116	+	pub fn check_handshake(
117	+	origin: Option<&str>,
118	+	host: Option<&str>,
119	+	paired: &[String],
120	+	) -> Result<(), Denied> {
121	+	// Host first: a rebinding attempt should not even reach origin logic.
122	+	match host {
123	+	Some(h) if host_is_loopback(h) => {}
124	+	_ => return Err(Denied::ForeignHost),
125	+	}
126	+	match origin {
127	+	None => Err(Denied::MissingOrigin),
128	+	Some(o) if origin_is_paired(o, paired) => Ok(()),
129	+	Some(_) => Err(Denied::UnpairedOrigin),
130	+	}
131	+	}
132	+
133	+	/// Parse the first frame, which must be `{"type":"auth","token":"..."}`.
134	+	///
135	+	/// Note there is deliberately no way to authenticate via the URL query string.
136	+	/// Query strings leak into logs, crash dumps and devtools history, and the
137	+	/// browser WebSocket API makes it tempting to put the token there.
138	+	pub fn check_auth_frame(text: &str, expected_token: &str) -> Result<(), Denied> {
139	+	let v: serde_json::Value = serde_json::from_str(text).map_err(\|_\| Denied::MalformedAuth)?;
140	+	if v.get("type").and_then(\|t\| t.as_str()) != Some("auth") {
141	+	return Err(Denied::MalformedAuth);
142	+	}
143	+	let Some(tok) = v.get("token").and_then(\|t\| t.as_str()) else {
144	+	return Err(Denied::MalformedAuth);
145	+	};
146	+	if token_matches(tok, expected_token) {
147	+	Ok(())
148	+	} else {
149	+	Err(Denied::BadToken)
150	+	}
151	+	}

1	+	pub mod agents;
2	+	pub mod auth;
3	+	pub mod control;
4	+	pub mod paths;
5	+	pub mod pty;
6	+	pub mod rewind;
7	+	pub mod status;
8	+	pub mod tls;
9	+	pub mod window_status;
10	+	pub mod server;
11	+
12	+	pub use server::{Config, Event, Server};

1	+	//! Claude Code session state, published by Claude Code's own hook interface.
2	+	//!
3	+	//! Claude runs `termbridge hook` on the events it documents, each of which
4	+	//! arrives as JSON on stdin. We keep one record per Claude session under
5	+	//! `<config>/agents/<session_id>.json` and update it in place. The daemon reads
6	+	//! those records; nothing here parses a terminal screen, so a UI change in
7	+	//! Claude cannot silently turn the status wrong.
8	+	//!
9	+	//! The link back to tmux is `$TMUX_PANE`, which Claude's process inherits and
10	+	//! passes on to the hook. It is the pane id (`%3`) and is what lets the sidebar
11	+	//! say which pane is waiting on you.
12	+
13	+	use std::collections::HashMap;
14	+	use std::fs;
15	+	use std::io;
16	+	use std::path::PathBuf;
17	+
18	+	use serde::{Deserialize, Serialize};
19	+
20	+	/// What a Claude session is doing. Derived from the hook event, never guessed.
21	+	#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
22	+	#[serde(rename_all = "lowercase")]
23	+	pub enum State {
24	+	/// Mid-turn: thinking, or running a tool.
25	+	Working,
26	+	/// Blocked on the user — a permission prompt or an elicitation dialog.
27	+	Waiting,
28	+	/// Turn finished, prompt is yours.
29	+	Idle,
30	+	}
31	+
32	+	impl State {
33	+	pub fn as_str(self) -> &'static str {
34	+	match self {
35	+	State::Working => "working",
36	+	State::Waiting => "waiting",
37	+	State::Idle => "idle",
38	+	}
39	+	}
40	+	}
41	+
42	+	#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
43	+	pub struct Record {
44	+	pub session_id: String,
45	+	/// tmux pane id (`%3`) from `$TMUX_PANE`. Absent when Claude runs outside
46	+	/// tmux, in which case the sidebar has nothing to attach the status to.
47	+	#[serde(default, skip_serializing_if = "Option::is_none")]
48	+	pub pane: Option<String>,
49	+	pub cwd: String,
50	+	pub state: State,
51	+	/// `permission_mode` as Claude reports it: `default`, `acceptEdits`,
52	+	/// `plan`, `bypassPermissions`. Carried forward across events that don't
53	+	/// include it (`Notification` is the one that matters — the mode must not
54	+	/// blink out exactly when you're being asked to approve something).
55	+	#[serde(default, skip_serializing_if = "Option::is_none")]
56	+	pub mode: Option<String>,
57	+	/// Tool currently running, from `PreToolUse`.
58	+	#[serde(default, skip_serializing_if = "Option::is_none")]
59	+	pub tool: Option<String>,
60	+	/// Why it is waiting, from the `Notification` message.
61	+	#[serde(default, skip_serializing_if = "Option::is_none")]
62	+	pub message: Option<String>,
63	+	/// Session title, when Claude has one.
64	+	#[serde(default, skip_serializing_if = "Option::is_none")]
65	+	pub name: Option<String>,
66	+	/// Which asterisk frame this session's glyph is on. Advanced once per hook
67	+	/// event so the tmux status line has something to animate with — see
68	+	/// [`crate::window_status`]. The sidebar runs its own timer and ignores it.
69	+	#[serde(default)]
70	+	pub frame: u8,
71	+	/// Unix seconds of the last event. Lets a reader spot a session whose
72	+	/// process died without a `SessionEnd`.
73	+	pub updated: u64,
74	+	}
75	+
76	+	pub fn dir() -> PathBuf {
77	+	crate::paths::config_dir().join("agents")
78	+	}
79	+
80	+	/// Every record on disk, newest first. Unreadable or malformed files are
81	+	/// skipped: a status panel is not worth failing a connection over.
82	+	pub fn read_all() -> Vec<Record> {
83	+	let Ok(entries) = fs::read_dir(dir()) else {
84	+	return Vec::new();
85	+	};
86	+	let mut out: Vec<Record> = entries
87	+	.flatten()
88	+	.filter(\|e\| e.path().extension().is_some_and(\|x\| x == "json"))
89	+	.filter_map(\|e\| fs::read_to_string(e.path()).ok())
90	+	.filter_map(\|s\| serde_json::from_str(&s).ok())
91	+	.collect();
92	+	out.sort_by_key(\|r\| std::cmp::Reverse(r.updated));
93	+	out
94	+	}
95	+
96	+	/// Newest record per pane. Panes get reused across sessions, so "newest wins"
97	+	/// is what keeps a finished session from shadowing the live one.
98	+	pub fn by_pane() -> HashMap<String, Record> {
99	+	let mut map = HashMap::new();
100	+	for r in read_all() {
101	+	if let Some(pane) = r.pane.clone() {
102	+	map.entry(pane).or_insert(r);
103	+	}
104	+	}
105	+	map
106	+	}
107	+
108	+	fn now() -> u64 {
109	+	std::time::SystemTime::now()
110	+	.duration_since(std::time::UNIX_EPOCH)
111	+	.map(\|d\| d.as_secs())
112	+	.unwrap_or(0)
113	+	}
114	+
115	+	/// Apply one hook event. Returns the new record, or `None` when the event ends
116	+	/// the session and the record was removed.
117	+	///
118	+	/// Unknown events are ignored rather than rejected — Claude Code gains hook
119	+	/// events over time and an unrecognised one is not an error.
120	+	pub fn apply(event: &serde_json::Value) -> io::Result<Option<Record>> {
121	+	let Some(session_id) = event.get("session_id").and_then(\|v\| v.as_str()) else {
122	+	return Ok(None);
123	+	};
124	+	let path = dir().join(format!("{}.json", sanitize_id(session_id)));
125	+	let hook = event
126	+	.get("hook_event_name")
127	+	.and_then(\|v\| v.as_str())
128	+	.unwrap_or("");
129	+
130	+	if hook == "SessionEnd" {
131	+	let _ = fs::remove_file(&path);
132	+	return Ok(None);
133	+	}
134	+
135	+	let str_field = \|k: &str\| event.get(k).and_then(\|v\| v.as_str()).map(str::to_string);
136	+	let notification_type = str_field("notification_type");
137	+
138	+	let state = match hook {
139	+	"UserPromptSubmit" \| "PreToolUse" \| "PostToolUse" \| "PostToolUseFailure" => State::Working,
140	+	"Stop" \| "SessionStart" \| "SubagentStop" => State::Idle,
141	+	// Claude fires this both to ask for something and to say it has been
142	+	// idle a while; only the first means it is blocked on you.
143	+	"Notification" => match notification_type.as_deref() {
144	+	Some("idle_prompt") => State::Idle,
145	+	_ => State::Waiting,
146	+	},
147	+	"PermissionRequest" => State::Waiting,
148	+	_ => return Ok(None),
149	+	};
150	+
151	+	let previous: Option<Record> = fs::read_to_string(&path)
152	+	.ok()
153	+	.and_then(\|s\| serde_json::from_str(&s).ok());
154	+	let carry = \|field: fn(&Record) -> Option<String>\| previous.as_ref().and_then(field);
155	+
156	+	let record = Record {
157	+	session_id: session_id.to_string(),
158	+	// TMUX_PANE comes from the environment Claude was launched in, which
159	+	// the hook process inherits.
160	+	pane: std::env::var("TMUX_PANE")
161	+	.ok()
162	+	.or_else(\|\| carry(\|r\| r.pane.clone())),
163	+	cwd: str_field("cwd")
164	+	.or_else(\|\| previous.as_ref().map(\|r\| r.cwd.clone()))
165	+	.unwrap_or_default(),
166	+	state,
167	+	mode: str_field("permission_mode").or_else(\|\| carry(\|r\| r.mode.clone())),
168	+	tool: match hook {
169	+	"PreToolUse" => str_field("tool_name"),
170	+	_ => None,
171	+	},
172	+	message: match state {
173	+	State::Waiting => str_field("message"),
174	+	_ => None,
175	+	},
176	+	name: str_field("session_name").or_else(\|\| carry(\|r\| r.name.clone())),
177	+	// Wrapping, and the glyph indexes into a six-frame cycle: the absolute
178	+	// count is never read, only its position in the loop.
179	+	frame: previous.as_ref().map_or(0, \|p\| p.frame.wrapping_add(1)),
180	+	updated: now(),
181	+	};
182	+
183	+	write(&path, &record)?;
184	+	Ok(Some(record))
185	+	}
186	+
187	+	fn write(path: &std::path::Path, record: &Record) -> io::Result<()> {
188	+	let dir = path.parent().expect("record path has a parent");
189	+	fs::create_dir_all(dir)?;
190	+	let json = serde_json::to_string(record).map_err(io::Error::other)?;
191	+	// Write-then-rename: the daemon polls this directory and must never read a
192	+	// half-written file.
193	+	let tmp = path.with_extension("tmp");
194	+	fs::write(&tmp, json)?;
195	+	fs::rename(&tmp, path)
196	+	}
197	+
198	+	/// Session ids come from Claude, but they end up in a filename, so treat them
199	+	/// as untrusted: no separators, no `..`, no surprises.
200	+	fn sanitize_id(id: &str) -> String {
201	+	id.chars()
202	+	.filter(\|c\| c.is_ascii_alphanumeric() \|\| c == '-' \|\| c == '_')
203	+	.take(128)
204	+	.collect()
205	+	}
206	+
207	+	/// The settings block a user pastes into `~/.claude/settings.json`.
208	+	pub fn hook_settings(exe: &str) -> String {
209	+	let events = [
210	+	("SessionStart", ""),
211	+	("UserPromptSubmit", ""),
212	+	("PreToolUse", "*"),
213	+	("PostToolUse", "*"),
214	+	("Notification", ""),
215	+	("Stop", ""),
216	+	("SessionEnd", ""),
217	+	];
218	+	let blocks: Vec<String> = events
219	+	.iter()
220	+	.map(\|(event, matcher)\| {
221	+	let matcher = if matcher.is_empty() {
222	+	String::new()
223	+	} else {
224	+	format!("\"matcher\": \"{matcher}\", ")
225	+	};
226	+	format!(
227	+	" \"{event}\": [\n {{ {matcher}\"hooks\": [{{ \"type\": \"command\", \"command\": \"{exe} hook\" }}] }}\n ]"
228	+	)
229	+	})
230	+	.collect();
231	+	format!("{{\n \"hooks\": {{\n{}\n }}\n}}", blocks.join(",\n"))
232	+	}
233	+
234	+	#[cfg(test)]
235	+	mod tests {
236	+	use super::*;
237	+
238	+	/// Each test gets its own config dir; `apply` writes to a real path. The
239	+	/// lock is load-bearing: the dir is selected by an env var, which is
240	+	/// process-wide, and cargo runs these tests on threads.
241	+	static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
242	+
243	+	fn with_temp_dir(f: impl FnOnce()) {
244	+	let _guard = ENV_LOCK.lock().unwrap_or_else(\|e\| e.into_inner());
245	+	let tmp = tempfile::tempdir().unwrap();
246	+	// SAFETY: single-threaded test, and the var is read through
247	+	// paths::config_dir() only.
248	+	unsafe { std::env::set_var("TERMBRIDGE_CONFIG_DIR", tmp.path()) };
249	+	f();
250	+	unsafe { std::env::remove_var("TERMBRIDGE_CONFIG_DIR") };
251	+	}
252	+
253	+	fn event(json: serde_json::Value) -> Option<Record> {
254	+	apply(&json).unwrap()
255	+	}
256	+
257	+	#[test]
258	+	fn tracks_the_documented_lifecycle() {
259	+	with_temp_dir(\|\| {
260	+	let r = event(serde_json::json!({
261	+	"session_id": "abc", "hook_event_name": "UserPromptSubmit",
262	+	"cwd": "/tmp/p", "permission_mode": "acceptEdits",
263	+	}))
264	+	.unwrap();
265	+	assert_eq!(r.state, State::Working);
266	+	assert_eq!(r.mode.as_deref(), Some("acceptEdits"));
267	+
268	+	let r = event(serde_json::json!({
269	+	"session_id": "abc", "hook_event_name": "PreToolUse",
270	+	"cwd": "/tmp/p", "permission_mode": "acceptEdits", "tool_name": "Bash",
271	+	}))
272	+	.unwrap();
273	+	assert_eq!(r.tool.as_deref(), Some("Bash"));
274	+
275	+	let r = event(serde_json::json!({
276	+	"session_id": "abc", "hook_event_name": "Stop", "cwd": "/tmp/p",
277	+	}))
278	+	.unwrap();
279	+	assert_eq!(r.state, State::Idle);
280	+	assert_eq!(r.tool, None);
281	+	});
282	+	}
283	+
284	+	#[test]
285	+	fn notification_distinguishes_asking_from_idling() {
286	+	with_temp_dir(\|\| {
287	+	let asking = event(serde_json::json!({
288	+	"session_id": "a", "hook_event_name": "Notification",
289	+	"notification_type": "permission_prompt", "message": "Bash needs approval",
290	+	}))
291	+	.unwrap();
292	+	assert_eq!(asking.state, State::Waiting);
293	+	assert_eq!(asking.message.as_deref(), Some("Bash needs approval"));
294	+
295	+	let idling = event(serde_json::json!({
296	+	"session_id": "b", "hook_event_name": "Notification",
297	+	"notification_type": "idle_prompt",
298	+	}))
299	+	.unwrap();
300	+	assert_eq!(idling.state, State::Idle);
301	+	});
302	+	}
303	+
304	+	/// Notification carries no `permission_mode`, and that is exactly when the
305	+	/// user wants to see it.
306	+	#[test]
307	+	fn mode_survives_events_that_omit_it() {
308	+	with_temp_dir(\|\| {
309	+	event(serde_json::json!({
310	+	"session_id": "a", "hook_event_name": "UserPromptSubmit",
311	+	"permission_mode": "plan", "cwd": "/tmp/p",
312	+	}));
313	+	let r = event(serde_json::json!({
314	+	"session_id": "a", "hook_event_name": "Notification",
315	+	"notification_type": "permission_prompt",
316	+	}))
317	+	.unwrap();
318	+	assert_eq!(r.mode.as_deref(), Some("plan"));
319	+	assert_eq!(r.cwd, "/tmp/p");
320	+	});
321	+	}
322	+
323	+	#[test]
324	+	fn session_end_removes_the_record() {
325	+	with_temp_dir(\|\| {
326	+	event(serde_json::json!({
327	+	"session_id": "a", "hook_event_name": "SessionStart", "cwd": "/tmp/p",
328	+	}));
329	+	assert_eq!(read_all().len(), 1);
330	+	assert!(event(serde_json::json!({
331	+	"session_id": "a", "hook_event_name": "SessionEnd", "reason": "clear",
332	+	}))
333	+	.is_none());
334	+	assert!(read_all().is_empty());
335	+	});
336	+	}
337	+
338	+	#[test]
339	+	fn unknown_events_and_ids_are_ignored() {
340	+	with_temp_dir(\|\| {
341	+	assert!(event(serde_json::json!({"hook_event_name": "Stop"})).is_none());
342	+	assert!(event(serde_json::json!({"session_id": "a", "hook_event_name": "Wat"})).is_none());
343	+	assert!(read_all().is_empty());
344	+	});
345	+	}
346	+
347	+	#[test]
348	+	fn session_ids_cannot_escape_the_directory() {
349	+	assert_eq!(sanitize_id("../../etc/passwd"), "etcpasswd");
350	+	assert_eq!(sanitize_id("abc-123_XY"), "abc-123_XY");
351	+	}
352	+	}

1	+	//! A second tmux client, in control mode, used as a query and event channel.
2	+	//!
3	+	//! The interactive client in the pty cannot answer questions — it is busy being
4	+	//! a terminal. Control mode gives us a client that speaks a line protocol
5	+	//! instead of drawing: we write commands, tmux answers in `%begin`/`%end`
6	+	//! blocks, and pushes `%`-prefixed notifications whenever the server changes.
7	+	//! That replaces both halves of the obvious alternative: no `tmux` process
8	+	//! spawned per poll, and no polling at all for things tmux will tell us about.
9	+	//!
10	+	//! The client attaches with `-f read-only,ignore-size,no-output`:
11	+	//!
12	+	//! - `read-only` — it can never send keystrokes to a pane.
13	+	//! - `ignore-size` — an 80x24 control client would otherwise shrink the
14	+	//! session's windows to fit itself, which the user would see immediately.
15	+	//! - `no-output` — without it tmux streams every byte every pane produces, to a
16	+	//! client that has no use for any of it.
17	+	//!
18	+	//! `read-only` governs keys, not commands, so commands issued here still take
19	+	//! effect. Nothing in this module decides to run one: the caller passes a fully
20	+	//! built line, and the only lines built from client input are the allowlisted
21	+	//! ones in `server.rs`.
22	+
23	+	use std::collections::VecDeque;
24	+	use std::process::Stdio;
25	+	use std::sync::Arc;
26	+
27	+	use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
28	+	use tokio::sync::{mpsc, oneshot, Mutex};
29	+
30	+	/// A `%`-prefixed line tmux sent us unprompted, verbatim.
31	+	pub type Notification = String;
32	+
33	+	type Reply = oneshot::Sender<Result<Vec<String>, String>>;
34	+
35	+	pub struct Control {
36	+	jobs: mpsc::Sender<(String, Reply)>,
37	+	/// Held, not used: the client is spawned with `kill_on_drop`, so the handle
38	+	/// living exactly as long as this struct is what ties the extra tmux client
39	+	/// to the connection that wanted it.
40	+	_child: tokio::process::Child,
41	+	}
42	+
43	+	impl Control {
44	+	/// Attach to `session`. The session must already exist — the caller spawns
45	+	/// the interactive client first, which creates it.
46	+	///
47	+	/// `global_args` must be the profile's server-selection flags, or this
48	+	/// attaches to a different tmux server than the terminal is showing.
49	+	pub async fn attach(
50	+	session: &str,
51	+	global_args: &[String],
52	+	) -> std::io::Result<(Control, mpsc::Receiver<Notification>)> {
53	+	let mut child = tokio::process::Command::new("tmux")
54	+	.args(global_args)
55	+	.args([
56	+	"-C",
57	+	"attach",
58	+	"-t",
59	+	session,
60	+	"-f",
61	+	"read-only,ignore-size,no-output",
62	+	])
63	+	.stdin(Stdio::piped())
64	+	.stdout(Stdio::piped())
65	+	.stderr(Stdio::null())
66	+	.kill_on_drop(true)
67	+	.spawn()?;
68	+
69	+	let mut stdin = child.stdin.take().expect("stdin piped");
70	+	let stdout = child.stdout.take().expect("stdout piped");
71	+
72	+	let pending: Arc<Mutex<VecDeque<Reply>>> = Arc::new(Mutex::new(VecDeque::new()));
73	+	let (notify_tx, notify_rx) = mpsc::channel::<Notification>(64);
74	+	let (jobs_tx, mut jobs_rx) = mpsc::channel::<(String, Reply)>(16);
75	+
76	+	// Writer. Queues the reply slot before writing, so a fast answer can
77	+	// never arrive with the queue still empty.
78	+	let queue = Arc::clone(&pending);
79	+	tokio::spawn(async move {
80	+	while let Some((line, reply)) = jobs_rx.recv().await {
81	+	queue.lock().await.push_back(reply);
82	+	if stdin.write_all(format!("{line}\n").as_bytes()).await.is_err()
83	+	\|\| stdin.flush().await.is_err()
84	+	{
85	+	break;
86	+	}
87	+	}
88	+	// Dropping stdin makes tmux print %exit and the child exit, which
89	+	// is how the control client goes away when the sidebar does.
90	+	});
91	+
92	+	let mut lines = BufReader::new(stdout).lines();
93	+
94	+	// tmux answers the attach itself with an empty block before we have
95	+	// asked anything. Swallowing it here, while nothing is in flight, is
96	+	// what keeps replies lined up with requests: leave it for the reader
97	+	// loop and it consumes the first real request's slot, silently shifting
98	+	// every answer by one. The timeout is for a future tmux that stops
99	+	// sending it, so we hang for half a second rather than forever.
100	+	let _ = tokio::time::timeout(std::time::Duration::from_millis(500), async {
101	+	while let Ok(Some(line)) = lines.next_line().await {
102	+	if line.starts_with("%end") \|\| line.starts_with("%error") {
103	+	break;
104	+	}
105	+	}
106	+	})
107	+	.await;
108	+
109	+	// Reader.
110	+	let queue = Arc::clone(&pending);
111	+	tokio::spawn(async move {
112	+	let mut block: Option<Vec<String>> = None;
113	+	while let Ok(Some(line)) = lines.next_line().await {
114	+	if line.starts_with("%begin") {
115	+	block = Some(Vec::new());
116	+	} else if line.starts_with("%end") \|\| line.starts_with("%error") {
117	+	let body = block.take().unwrap_or_default();
118	+	let result = if line.starts_with("%error") {
119	+	Err(body.join("\n"))
120	+	} else {
121	+	Ok(body)
122	+	};
123	+	// tmux answers the attach itself with an empty block before
124	+	// we have asked anything; an unmatched reply is normal and
125	+	// is dropped rather than desynchronising the queue.
126	+	if let Some(reply) = queue.lock().await.pop_front() {
127	+	let _ = reply.send(result);
128	+	}
129	+	} else if let Some(body) = block.as_mut() {
130	+	body.push(line);
131	+	} else if line.starts_with('%') && notify_tx.send(line).await.is_err() {
132	+	break;
133	+	}
134	+	}
135	+	// tmux is gone: fail every waiter rather than leaving them hanging.
136	+	for reply in queue.lock().await.drain(..) {
137	+	let _ = reply.send(Err("control client exited".into()));
138	+	}
139	+	});
140	+
141	+	let control = Control {
142	+	jobs: jobs_tx,
143	+	_child: child,
144	+	};
145	+	Ok((control, notify_rx))
146	+	}
147	+
148	+	/// Run one tmux command line and return its output lines.
149	+	///
150	+	/// `line` must be a complete, already-quoted tmux command. Anything derived
151	+	/// from client input has to be validated by the caller first — this is a
152	+	/// command channel to a live tmux server, not a sandbox.
153	+	pub async fn run(&self, line: impl Into<String>) -> Result<Vec<String>, String> {
154	+	let (tx, rx) = oneshot::channel();
155	+	self.jobs
156	+	.send((line.into(), tx))
157	+	.await
158	+	.map_err(\|_\| "control client is gone".to_string())?;
159	+	rx.await.unwrap_or_else(\|_\| Err("no reply".into()))
160	+	}
161	+	}
162	+
163	+	/// Notifications that mean our view of the server is stale. Everything else
164	+	/// (`%output`, `%layout-change`, pane modes) changes nothing we display.
165	+	pub fn is_interesting(notification: &str) -> bool {
166	+	const PREFIXES: [&str; 8] = [
167	+	"%sessions-changed",
168	+	"%session-changed",
169	+	"%session-renamed",
170	+	"%session-window-changed",
171	+	"%client-session-changed",
172	+	"%window-add",
173	+	"%window-close",
174	+	"%window-renamed",
175	+	];
176	+	PREFIXES.iter().any(\|p\| notification.starts_with(p))
177	+	}
178	+
179	+	#[cfg(test)]
180	+	mod tests {
181	+	use super::*;
182	+
183	+	#[test]
184	+	fn only_server_shape_changes_are_interesting() {
185	+	assert!(is_interesting("%client-session-changed /dev/pts/3 $1 work"));
186	+	assert!(is_interesting("%window-renamed @4 editor"));
187	+	assert!(!is_interesting("%output %2 hello"));
188	+	assert!(!is_interesting("%layout-change @1 abcd,80x24,0,0,1"));
189	+	}
190	+
191	+	/// Needs a tmux on PATH; skipped rather than failed where there isn't one,
192	+	/// so the suite still runs in a bare container.
193	+	#[tokio::test]
194	+	async fn round_trips_a_command_against_real_tmux() {
195	+	if !crate::pty::Profile::tmux_available() {
196	+	return;
197	+	}
198	+	let session = "termbridge-control-test";
199	+	let _ = std::process::Command::new("tmux")
200	+	.args(["new-session", "-d", "-s", session])
201	+	.status();
202	+
203	+	let Ok((control, _notifications)) = Control::attach(session, &[]).await else {
204	+	return;
205	+	};
206	+	let out = control
207	+	.run("list-sessions -F '#{session_name}'")
208	+	.await
209	+	.expect("list-sessions succeeds");
210	+	assert!(out.iter().any(\|l\| l == session));
211	+
212	+	let err = control.run("definitely-not-a-command").await;
213	+	assert!(err.is_err(), "tmux errors come back as Err, not output");
214	+
215	+	let _ = std::process::Command::new("tmux")
216	+	.args(["kill-session", "-t", session])
217	+	.status();
218	+	}
219	+	}

1	+	use std::time::Duration;
2	+
3	+	use termbridge::paths;
4	+	use termbridge::pty::Profile;
5	+	use termbridge::{Config, Event, Server};
6	+
7	+	const DEFAULT_PORT: u16 = 7681;
8	+
9	+	fn usage() -> ! {
10	+	eprintln!(
11	+	"termbridge — loopback WebSocket bridge (security spike)
12	+
13	+	USAGE:
14	+	termbridge serve [--port N] [--session NAME]
15	+	start the daemon
16	+	termbridge token print the auth token (paste into extension)
17	+	termbridge token --rotate generate a new token
18	+	termbridge pair <origin> approve an extension origin
19	+	termbridge unpair <origin> revoke an origin
20	+	termbridge list show paired origins
21	+	termbridge cert show the TLS certificate path + fingerprint
22	+	termbridge cert --regenerate make a new certificate
23	+	termbridge hooks print the Claude Code hook settings to install
24	+	termbridge hook record one hook event (reads JSON on stdin)
25	+	termbridge tmux print the tmux.conf line for the status glyph
26	+
27	+	Origins look like:
28	+	chrome-extension://abcdefghijklmnopabcdefghijklmnop
29	+	moz-extension://11111111-2222-3333-4444-555555555555
30	+	"
31	+	);
32	+	std::process::exit(2)
33	+	}
34	+
35	+	#[tokio::main]
36	+	async fn main() -> Result<(), Box<dyn std::error::Error>> {
37	+	let args: Vec<String> = std::env::args().skip(1).collect();
38	+	let dir = paths::config_dir();
39	+
40	+	match args.first().map(String::as_str) {
41	+	Some("serve") => {
42	+	let port = match args.iter().position(\|a\| a == "--port") {
43	+	Some(i) => args
44	+	.get(i + 1)
45	+	.and_then(\|p\| p.parse().ok())
46	+	.unwrap_or(DEFAULT_PORT),
47	+	None => DEFAULT_PORT,
48	+	};
49	+	let session = args
50	+	.iter()
51	+	.position(\|a\| a == "--session")
52	+	.and_then(\|i\| args.get(i + 1))
53	+	.cloned();
54	+	serve(port, session).await
55	+	}
56	+	Some("token") => {
57	+	let token = if args.iter().any(\|a\| a == "--rotate") {
58	+	paths::generate_token(&dir)?
59	+	} else {
60	+	paths::load_or_create_token(&dir)?
61	+	};
62	+	println!("{token}");
63	+	println!("\n(from {})", paths::token_path().display());
64	+	Ok(())
65	+	}
66	+	Some("pair") => {
67	+	let origin = args.get(1).unwrap_or_else(\|\| usage());
68	+	if paths::pair_origin(&dir, origin)? {
69	+	println!("paired: {origin}");
70	+	} else {
71	+	println!("already paired: {origin}");
72	+	}
73	+	Ok(())
74	+	}
75	+	Some("unpair") => {
76	+	let origin = args.get(1).unwrap_or_else(\|\| usage());
77	+	if paths::unpair_origin(&dir, origin)? {
78	+	println!("unpaired: {origin}");
79	+	} else {
80	+	println!("not paired: {origin}");
81	+	}
82	+	Ok(())
83	+	}
84	+	Some("cert") => {
85	+	let id = if args.iter().any(\|a\| a == "--regenerate") {
86	+	termbridge::tls::generate(&dir)?
87	+	} else {
88	+	termbridge::tls::load_or_create(&dir)?
89	+	};
90	+	println!("certificate: {}", dir.join(termbridge::tls::CERT_FILE).display());
91	+	println!("private key: {}", dir.join(termbridge::tls::KEY_FILE).display());
92	+	println!("SHA-256: {}", id.fingerprint);
93	+	Ok(())
94	+	}
95	+	// Runs on every hook event, so it must be quiet and must never fail in
96	+	// a way Claude would surface. Any error here is a status panel that is
97	+	// briefly stale, which is not worth interrupting the user's session.
98	+	Some("hook") => {
99	+	let mut input = String::new();
100	+	use std::io::Read;
101	+	let _ = std::io::stdin().read_to_string(&mut input);
102	+	if let Ok(event) = serde_json::from_str::<serde_json::Value>(&input) {
103	+	let _ = termbridge::agents::apply(&event);
104	+	// After the record is on disk, so the status line is computed
105	+	// from the same state the sidebar will read. Runs even when
106	+	// the event removed the record: that is what clears the glyph
107	+	// from a window whose Claude has gone.
108	+	termbridge::window_status::publish();
109	+	}
110	+	Ok(())
111	+	}
112	+	Some("hooks") => {
113	+	let exe = std::env::current_exe()
114	+	.map(\|p\| p.display().to_string())
115	+	.unwrap_or_else(\|_\| "termbridge".into());
116	+	println!(
117	+	"Add this to ~/.claude/settings.json (merge with any hooks you already have):\n"
118	+	);
119	+	println!("{}", termbridge::agents::hook_settings(&exe));
120	+	println!(
121	+	"\nRecords are written to {}\n\
122	+	Claude sessions then show up in the sidebar with their state and permission mode.",
123	+	termbridge::agents::dir().display()
124	+	);
125	+	Ok(())
126	+	}
127	+	Some("tmux") => {
128	+	println!(
129	+	"Add this to ~/.tmux.conf, then `tmux source-file ~/.tmux.conf`:\n"
130	+	);
131	+	print!("{}", termbridge::window_status::tmux_conf());
132	+	println!(
133	+	"\nThe hooks are what set it, so install those first if you haven't:\n\
134	+	\x20 termbridge hooks"
135	+	);
136	+	Ok(())
137	+	}
138	+	Some("list") => {
139	+	let origins = paths::load_paired_origins(&dir);
140	+	if origins.is_empty() {
141	+	println!(
142	+	"no paired origins ({})",
143	+	paths::paired_origins_path().display()
144	+	);
145	+	} else {
146	+	for o in origins {
147	+	println!("{o}");
148	+	}
149	+	}
150	+	Ok(())
151	+	}
152	+	_ => usage(),
153	+	}
154	+	}
155	+
156	+	async fn serve(port: u16, session: Option<String>) -> Result<(), Box<dyn std::error::Error>> {
157	+	let dir = paths::config_dir();
158	+	let token = paths::load_or_create_token(&dir)?;
159	+	let paired = paths::load_paired_origins(&dir);
160	+
161	+	let identity = termbridge::tls::load_or_create(&dir)?;
162	+	let mut config = Config::new(token, paired.clone());
163	+	config.auth_timeout = Duration::from_secs(3);
164	+	config.tls = Some(termbridge::tls::acceptor(&identity)?);
165	+	let pinned = session
166	+	.as_deref()
167	+	.and_then(termbridge::pty::valid_session_name);
168	+	let default_session = pinned
169	+	.clone()
170	+	.unwrap_or_else(\|\| termbridge::pty::DEFAULT_SESSION.to_string());
171	+	config.default_session = default_session.clone();
172	+	// A pinned --session is a choice; without one, a lone existing session is
173	+	// a better guess than a fresh "browser" beside it.
174	+	config.adopt_sole_session = pinned.is_none();
175	+	config.profile = if Profile::tmux_available() {
176	+	Profile::tmux(&default_session)
177	+	} else {
178	+	eprintln!("warning: tmux not found on PATH — falling back to a plain shell.");
179	+	eprintln!(" Sessions will NOT survive closing the sidebar.");
180	+	Profile::shell_fallback()
181	+	};
182	+	let profile = config.profile.clone();
183	+	let config_adopts_sole = config.adopt_sole_session && profile.program == "tmux";
184	+
185	+	let mut server = Server::start(config, port).await?;
186	+	println!("termbridge listening on wss://{a} (ws:// also accepted on the same port)", a = server.addr());
187	+	println!("running: {} {}", profile.program, profile.args.join(" "));
188	+	let existing = termbridge::pty::list_sessions(&profile.tmux_global_args());
189	+	if !existing.is_empty() {
190	+	println!("tmux sessions available: {}", existing.join(", "));
191	+	}
192	+	if config_adopts_sole {
193	+	match existing.as_slice() {
194	+	[only] => println!("joining the only existing session: {only}"),
195	+	_ => println!("new clients start in session: {default_session}"),
196	+	}
197	+	}
198	+	println!("token: {}", paths::token_path().display());
199	+	println!("cert: SHA-256 {}", identity.fingerprint);
200	+	println!(
201	+	"\nFirst time only — the certificate is self-signed, so trust it once:\n\
202	+	\n open https://{a}/ and accept the warning\n",
203	+	a = server.addr()
204	+	);
205	+	if paired.is_empty() {
206	+	println!(
207	+	"\nNo origins paired yet — every connection will be refused.\n\
208	+	Load the extension, copy its origin from the sidebar, then run:\n\
209	+	\n termbridge pair <origin>\n"
210	+	);
211	+	} else {
212	+	println!("paired origins: {}", paired.join(", "));
213	+	}
214	+
215	+	while let Some(event) = server.next_event().await {
216	+	match event {
217	+	Event::Accepted { origin } => println!("[accept] {origin}"),
218	+	Event::Rejected { origin, why, detail } => {
219	+	let o = origin.unwrap_or_else(\|\| "<none>".into());
220	+	println!("[reject] {o}: {}", why.reason());
221	+	if let Some(d) = detail {
222	+	println!(" cause: {d}");
223	+	}
224	+	match why {
225	+	termbridge::auth::Denied::UnpairedOrigin => {
226	+	println!(" to approve: termbridge pair {o}");
227	+	}
228	+	// By far the most common first-run mistake: the extension
229	+	// was loaded but nobody ever pasted a token into it. The
230	+	// wire-level reason ("invalid token") does not say where
231	+	// the right token comes from, so spell it out.
232	+	termbridge::auth::Denied::BadToken
233	+	\| termbridge::auth::Denied::MalformedAuth
234	+	\| termbridge::auth::Denied::AuthTimeout => {
235	+	println!(
236	+	" the extension did not present the token in {}",
237	+	paths::token_path().display()
238	+	);
239	+	println!(
240	+	" to fix: run termbridge token and paste the 64 hex chars\n\
241	+	\x20 into the sidebar's settings → Token field"
242	+	);
243	+	}
244	+	_ => {}
245	+	}
246	+	}
247	+	}
248	+	}
249	+	Ok(())
250	+	}

1	+	//! On-disk state: the auth token and the explicitly-paired origin list.
2	+	//!
3	+	//! Both live in a 0700 config dir. The token file is 0600 and we *refuse to use
4	+	//! it* if the mode ever loosens — on a multi-user box, 127.0.0.1 is reachable by
5	+	//! every local uid, so the file mode is the only thing keeping other users out.
6	+
7	+	use std::fs;
8	+	use std::io::{self, Write};
9	+	use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
10	+	use std::path::{Path, PathBuf};
11	+
12	+	pub const TOKEN_BYTES: usize = 32;
13	+
14	+	#[derive(Debug)]
15	+	pub enum TokenError {
16	+	Io(io::Error),
17	+	/// The token file is readable by group or other. Refuse rather than
18	+	/// silently authenticate against a world-readable secret.
19	+	TooPermissive { path: PathBuf, mode: u32 },
20	+	Malformed,
21	+	}
22	+
23	+	impl std::fmt::Display for TokenError {
24	+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25	+	match self {
26	+	TokenError::Io(e) => write!(f, "{e}"),
27	+	TokenError::TooPermissive { path, mode } => write!(
28	+	f,
29	+	"token file {} has mode {:04o}; expected 0600. \
30	+	Fix with: chmod 600 {}",
31	+	path.display(),
32	+	mode,
33	+	path.display()
34	+	),
35	+	TokenError::Malformed => write!(f, "token file is empty or malformed"),
36	+	}
37	+	}
38	+	}
39	+
40	+	impl std::error::Error for TokenError {}
41	+
42	+	impl From<io::Error> for TokenError {
43	+	fn from(e: io::Error) -> Self {
44	+	TokenError::Io(e)
45	+	}
46	+	}
47	+
48	+	pub fn config_dir() -> PathBuf {
49	+	if let Some(x) = std::env::var_os("TERMBRIDGE_CONFIG_DIR") {
50	+	return PathBuf::from(x);
51	+	}
52	+	let base = std::env::var_os("XDG_CONFIG_HOME")
53	+	.map(PathBuf::from)
54	+	.unwrap_or_else(\|\| {
55	+	let home = std::env::var_os("HOME").map(PathBuf::from).unwrap_or_default();
56	+	home.join(".config")
57	+	});
58	+	base.join("termbridge")
59	+	}
60	+
61	+	pub fn token_path() -> PathBuf {
62	+	config_dir().join("token")
63	+	}
64	+
65	+	pub fn paired_origins_path() -> PathBuf {
66	+	config_dir().join("paired-origins")
67	+	}
68	+
69	+	fn ensure_config_dir(dir: &Path) -> io::Result<()> {
70	+	fs::create_dir_all(dir)?;
71	+	// 0700: the dir itself should not be traversable by other users.
72	+	fs::set_permissions(dir, fs::Permissions::from_mode(0o700))
73	+	}
74	+
75	+	/// Generate a fresh CSPRNG token and write it 0600, replacing any existing one.
76	+	pub fn generate_token(dir: &Path) -> Result<String, TokenError> {
77	+	ensure_config_dir(dir)?;
78	+	let token = random_hex(TOKEN_BYTES);
79	+	let path = dir.join("token");
80	+
81	+	// Create with 0600 at open time — never create-then-chmod, which leaves a
82	+	// window where the secret is world-readable.
83	+	let mut f = fs::OpenOptions::new()
84	+	.write(true)
85	+	.create(true)
86	+	.truncate(true)
87	+	.mode(0o600)
88	+	.open(&path)?;
89	+	f.write_all(token.as_bytes())?;
90	+	f.write_all(b"\n")?;
91	+	f.sync_all()?;
92	+
93	+	// An existing file keeps its old mode through O_CREAT, so enforce it too.
94	+	fs::set_permissions(&path, fs::Permissions::from_mode(0o600))?;
95	+	Ok(token)
96	+	}
97	+
98	+	/// Load the token, refusing if the file is group/other accessible.
99	+	pub fn load_token(dir: &Path) -> Result<String, TokenError> {
100	+	let path = dir.join("token");
101	+	let meta = fs::metadata(&path)?;
102	+	let mode = meta.permissions().mode() & 0o777;
103	+	if mode & 0o077 != 0 {
104	+	return Err(TokenError::TooPermissive { path, mode });
105	+	}
106	+	let token = fs::read_to_string(&path)?.trim().to_string();
107	+	if token.is_empty() {
108	+	return Err(TokenError::Malformed);
109	+	}
110	+	Ok(token)
111	+	}
112	+
113	+	pub fn load_or_create_token(dir: &Path) -> Result<String, TokenError> {
114	+	match load_token(dir) {
115	+	Ok(t) => Ok(t),
116	+	Err(TokenError::Io(e)) if e.kind() == io::ErrorKind::NotFound => generate_token(dir),
117	+	Err(e) => Err(e),
118	+	}
119	+	}
120	+
121	+	/// Origins the user has explicitly approved. Absence of this file means no
122	+	/// client can connect — pairing is never implicit.
123	+	pub fn load_paired_origins(dir: &Path) -> Vec<String> {
124	+	let path = dir.join("paired-origins");
125	+	let Ok(contents) = fs::read_to_string(path) else {
126	+	return Vec::new();
127	+	};
128	+	contents
129	+	.lines()
130	+	.map(str::trim)
131	+	.filter(\|l\| !l.is_empty() && !l.starts_with('#'))
132	+	.map(\|l\| l.to_ascii_lowercase())
133	+	.collect()
134	+	}
135	+
136	+	pub fn pair_origin(dir: &Path, origin: &str) -> io::Result<bool> {
137	+	ensure_config_dir(dir)?;
138	+	let origin = origin.trim().to_ascii_lowercase();
139	+	let mut existing = load_paired_origins(dir);
140	+	if existing.iter().any(\|o\| o == &origin) {
141	+	return Ok(false);
142	+	}
143	+	existing.push(origin);
144	+	let path = dir.join("paired-origins");
145	+	let mut f = fs::OpenOptions::new()
146	+	.write(true)
147	+	.create(true)
148	+	.truncate(true)
149	+	.mode(0o600)
150	+	.open(&path)?;
151	+	writeln!(f, "# Origins approved to connect to termbridge. One per line.")?;
152	+	for o in &existing {
153	+	writeln!(f, "{o}")?;
154	+	}
155	+	Ok(true)
156	+	}
157	+
158	+	pub fn unpair_origin(dir: &Path, origin: &str) -> io::Result<bool> {
159	+	let origin = origin.trim().to_ascii_lowercase();
160	+	let existing = load_paired_origins(dir);
161	+	if !existing.iter().any(\|o\| o == &origin) {
162	+	return Ok(false);
163	+	}
164	+	let path = dir.join("paired-origins");
165	+	let mut f = fs::OpenOptions::new()
166	+	.write(true)
167	+	.create(true)
168	+	.truncate(true)
169	+	.mode(0o600)
170	+	.open(&path)?;
171	+	writeln!(f, "# Origins approved to connect to termbridge. One per line.")?;
172	+	for o in existing.iter().filter(\|o\| *o != &origin) {
173	+	writeln!(f, "{o}")?;
174	+	}
175	+	Ok(true)
176	+	}
177	+
178	+	fn random_hex(n: usize) -> String {
179	+	let mut buf = vec![0u8; n];
180	+	// Straight from the OS CSPRNG. Deliberately not a userspace PRNG — this is
181	+	// the only thing standing between another local uid and a shell.
182	+	getrandom::fill(&mut buf).expect("OS CSPRNG unavailable");
183	+	let mut s = String::with_capacity(n * 2);
184	+	for b in buf {
185	+	use std::fmt::Write as _;
186	+	let _ = write!(s, "{b:02x}");
187	+	}
188	+	s
189	+	}

1	+	//! PTY session backend.
2	+	//!
3	+	//! One PTY per authenticated connection, running tmux. tmux does the
4	+	//! multiplexing, so the daemon deliberately has no concept of tabs, panes or
5	+	//! sessions — that would be reimplementing tmux badly.
6	+	//!
7	+	//! `portable-pty` is blocking, so reads and writes each get a dedicated thread
8	+	//! and talk to the async side over channels.
9	+
10	+	use std::io::{Read, Write};
11	+	use std::sync::{Arc, Mutex};
12	+
13	+	use portable_pty::{Child, CommandBuilder, MasterPty, PtySize};
14	+	use tokio::sync::mpsc;
15	+
16	+	/// What the daemon is allowed to run.
17	+	///
18	+	/// Deliberately not client-supplied. An authenticated client can type
19	+	/// anything into the resulting shell anyway, so this isn't a privilege
20	+	/// boundary — but it means the WebSocket API is not literally "exec arbitrary
21	+	/// argv", which keeps the blast radius of any future auth bug much smaller.
22	+	#[derive(Debug, Clone)]
23	+	pub struct Profile {
24	+	pub program: String,
25	+	pub args: Vec<String>,
26	+	}
27	+
28	+	impl Default for Profile {
29	+	fn default() -> Self {
30	+	Profile::tmux(DEFAULT_SESSION)
31	+	}
32	+	}
33	+
34	+	pub const DEFAULT_SESSION: &str = "browser";
35	+
36	+	/// Session names reach `execvp` as a separate argv element, never a shell, so
37	+	/// metacharacters cannot inject a command. The one real hazard is a leading
38	+	/// dash, which tmux would parse as a flag. The charset restriction on top of
39	+	/// that is belt-and-braces, and keeps names to something tmux is happy with.
40	+	pub fn valid_session_name(raw: &str) -> Option<String> {
41	+	let s = raw.trim();
42	+	if s.is_empty() \|\| s.len() > 64 \|\| s.starts_with('-') {
43	+	return None;
44	+	}
45	+	// tmux itself rejects '.' and ':' in session names.
46	+	if s.contains('.') \|\| s.contains(':') {
47	+	return None;
48	+	}
49	+	if !s
50	+	.chars()
51	+	.all(\|c\| c.is_ascii_alphanumeric() \|\| c == '-' \|\| c == '_')
52	+	{
53	+	return None;
54	+	}
55	+	Some(s.to_string())
56	+	}
57	+
58	+	/// Existing tmux sessions, so the sidebar can offer them instead of guessing.
59	+	///
60	+	/// `global_args` carries the server-selection flags from the profile; without
61	+	/// them this asks the default tmux server, which is a different set of
62	+	/// sessions than the one the sidebar is attached to.
63	+	pub fn list_sessions(global_args: &[String]) -> Vec<String> {
64	+	let Ok(out) = std::process::Command::new("tmux")
65	+	.args(global_args)
66	+	.args(["list-sessions", "-F", "#{session_name}"])
67	+	.output()
68	+	else {
69	+	return Vec::new();
70	+	};
71	+	if !out.status.success() {
72	+	return Vec::new(); // no server running yet
73	+	}
74	+	String::from_utf8_lossy(&out.stdout)
75	+	.lines()
76	+	.map(str::trim)
77	+	.filter(\|l\| !l.is_empty())
78	+	.map(str::to_string)
79	+	.collect()
80	+	}
81	+
82	+	/// The one existing tmux session, when there is exactly one.
83	+	///
84	+	/// With a single session running there is no ambiguity about which one the
85	+	/// user meant, so joining it beats standing up a second session beside it.
86	+	/// Zero sessions, or more than one, and the caller falls back to its default.
87	+	pub fn sole_session(global_args: &[String]) -> Option<String> {
88	+	let mut sessions = list_sessions(global_args);
89	+	(sessions.len() == 1).then(\|\| sessions.remove(0))
90	+	}
91	+
92	+	/// tmux pane ids are `%` followed by digits. Client-supplied ones end up in a
93	+	/// command line sent to a live tmux server, so nothing else is allowed through.
94	+	pub fn valid_pane_id(raw: &str) -> Option<String> {
95	+	let s = raw.trim();
96	+	let Some(digits) = s.strip_prefix('%') else {
97	+	return None;
98	+	};
99	+	if digits.is_empty() \|\| digits.len() > 12 \|\| !digits.chars().all(\|c\| c.is_ascii_digit()) {
100	+	return None;
101	+	}
102	+	Some(s.to_string())
103	+	}
104	+
105	+	/// A tmux window id (`@3`), same treatment as a pane id.
106	+	///
107	+	/// The sidebar names windows by id rather than index precisely because it goes
108	+	/// into a command line: an id is `@` plus digits and nothing else, while an
109	+	/// index is part of a `session:index.pane` target syntax with its own escapes.
110	+	pub fn valid_window_id(raw: &str) -> Option<String> {
111	+	let s = raw.trim();
112	+	let Some(digits) = s.strip_prefix('@') else {
113	+	return None;
114	+	};
115	+	if digits.is_empty() \|\| digits.len() > 12 \|\| !digits.chars().all(\|c\| c.is_ascii_digit()) {
116	+	return None;
117	+	}
118	+	Some(s.to_string())
119	+	}
120	+
121	+	/// Our own pty's slave path, on its way into `switch-client -c`. It comes from
122	+	/// the kernel rather than a client, but it is still quoted into a command line,
123	+	/// so it gets the same treatment.
124	+	pub fn valid_tty(raw: &str) -> Option<&str> {
125	+	let s = raw.trim();
126	+	(s.starts_with("/dev/")
127	+	&& s.len() < 64
128	+	&& s.chars()
129	+	.all(\|c\| c.is_ascii_alphanumeric() \|\| "/-_.".contains(c)))
130	+	.then_some(s)
131	+	}
132	+
133	+	impl Profile {
134	+	/// Fall back to a bare shell when tmux isn't installed, so the daemon is
135	+	/// still useful rather than failing to start.
136	+	pub fn shell_fallback() -> Self {
137	+	Self {
138	+	program: std::env::var("SHELL").unwrap_or_else(\|_\| "/bin/sh".into()),
139	+	args: vec!["-l".into()],
140	+	}
141	+	}
142	+
143	+	/// Build a tmux profile for a specific session.
144	+	///
145	+	/// `-A` attaches to `session` if it exists and creates it otherwise, which
146	+	/// is what lets the sidebar rejoin your existing work rather than starting
147	+	/// something new every time.
148	+	pub fn tmux(session: &str) -> Self {
149	+	Self {
150	+	program: "tmux".into(),
151	+	args: vec![
152	+	"new-session".into(),
153	+	"-A".into(),
154	+	"-s".into(),
155	+	session.to_string(),
156	+	],
157	+	}
158	+	}
159	+
160	+	/// The same profile pointed at a different session.
161	+	///
162	+	/// Only the `-s` value changes, so the server-selection flags and any
163	+	/// trailing command survive — rebuilding with [`Profile::tmux`] would drop
164	+	/// both and silently address the default tmux server.
165	+	pub fn with_session(&self, session: &str) -> Self {
166	+	let mut args = self.args.clone();
167	+	match args.iter().position(\|a\| a == "-s") {
168	+	Some(i) if i + 1 < args.len() => {
169	+	args[i + 1] = session.to_string();
170	+	Self {
171	+	program: self.program.clone(),
172	+	args,
173	+	}
174	+	}
175	+	_ => Profile::tmux(session),
176	+	}
177	+	}
178	+
179	+	/// Flags that select which tmux server to talk to (`-L`, `-S`, `-f`),
180	+	/// taken from the front of the profile's argv. Every other tmux invocation
181	+	/// — the control client, session listings — has to repeat them or it
182	+	/// silently addresses a different server.
183	+	pub fn tmux_global_args(&self) -> Vec<String> {
184	+	let mut out = Vec::new();
185	+	let mut args = self.args.iter();
186	+	while let Some(a) = args.next() {
187	+	if !a.starts_with('-') {
188	+	break; // First command word; globals are all before it.
189	+	}
190	+	out.push(a.clone());
191	+	if matches!(a.as_str(), "-L" \| "-S" \| "-f") {
192	+	if let Some(value) = args.next() {
193	+	out.push(value.clone());
194	+	}
195	+	}
196	+	}
197	+	out
198	+	}
199	+
200	+	pub fn tmux_available() -> bool {
201	+	std::process::Command::new("tmux")
202	+	.arg("-V")
203	+	.stdout(std::process::Stdio::null())
204	+	.stderr(std::process::Stdio::null())
205	+	.status()
206	+	.map(\|s\| s.success())
207	+	.unwrap_or(false)
208	+	}
209	+	}
210	+
211	+	pub struct PtySession {
212	+	master: Box<dyn MasterPty + Send>,
213	+	writer_tx: mpsc::UnboundedSender<Vec<u8>>,
214	+	child: Arc<Mutex<Box<dyn Child + Send + Sync>>>,
215	+	}
216	+
217	+	pub struct Spawned {
218	+	pub session: PtySession,
219	+	/// Raw bytes from the pty. Chunked as they arrive; no framing, no encoding.
220	+	pub output: mpsc::Receiver<Vec<u8>>,
221	+	/// Fires once with the child's exit status.
222	+	pub exit: tokio::sync::oneshot::Receiver<i32>,
223	+	}
224	+
225	+	impl PtySession {
226	+	pub fn spawn(profile: &Profile, cols: u16, rows: u16) -> std::io::Result<Spawned> {
227	+	let pty = portable_pty::native_pty_system();
228	+	let pair = pty
229	+	.openpty(PtySize {
230	+	rows: rows.max(1),
231	+	cols: cols.max(1),
232	+	pixel_width: 0,
233	+	pixel_height: 0,
234	+	})
235	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
236	+
237	+	let mut cmd = CommandBuilder::new(&profile.program);
238	+	for a in &profile.args {
239	+	cmd.arg(a);
240	+	}
241	+	// xterm-256color is what xterm.js actually implements. Advertising
242	+	// anything richer makes programs emit sequences the renderer drops.
243	+	cmd.env("TERM", "xterm-256color");
244	+	cmd.env("COLORTERM", "truecolor");
245	+	if let Some(home) = std::env::var_os("HOME") {
246	+	cmd.cwd(home);
247	+	}
248	+
249	+	let child = pair
250	+	.slave
251	+	.spawn_command(cmd)
252	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
253	+	// Drop the slave in the parent, or the pty never reports EOF.
254	+	drop(pair.slave);
255	+
256	+	let mut reader = pair
257	+	.master
258	+	.try_clone_reader()
259	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
260	+	let mut writer = pair
261	+	.master
262	+	.take_writer()
263	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
264	+
265	+	// Bounded: if the browser can't keep up with a `yes` flood, block the
266	+	// reader thread rather than growing a queue until the daemon OOMs.
267	+	let (out_tx, output) = mpsc::channel::<Vec<u8>>(256);
268	+	std::thread::spawn(move \|\| {
269	+	let mut buf = [0u8; 8192];
270	+	loop {
271	+	match reader.read(&mut buf) {
272	+	Ok(0) \| Err(_) => break,
273	+	Ok(n) => {
274	+	if out_tx.blocking_send(buf[..n].to_vec()).is_err() {
275	+	break;
276	+	}
277	+	}
278	+	}
279	+	}
280	+	});
281	+
282	+	let (writer_tx, mut writer_rx) = mpsc::unbounded_channel::<Vec<u8>>();
283	+	std::thread::spawn(move \|\| {
284	+	while let Some(chunk) = writer_rx.blocking_recv() {
285	+	if writer.write_all(&chunk).is_err() \|\| writer.flush().is_err() {
286	+	break;
287	+	}
288	+	}
289	+	});
290	+
291	+	let child = Arc::new(Mutex::new(child));
292	+	let (exit_tx, exit) = tokio::sync::oneshot::channel();
293	+	let waiter = Arc::clone(&child);
294	+	std::thread::spawn(move \|\| {
295	+	let code = loop {
296	+	let status = { waiter.lock().unwrap().try_wait() };
297	+	match status {
298	+	Ok(Some(s)) => break s.exit_code() as i32,
299	+	Ok(None) => std::thread::sleep(std::time::Duration::from_millis(100)),
300	+	Err(_) => break -1,
301	+	}
302	+	};
303	+	let _ = exit_tx.send(code);
304	+	});
305	+
306	+	Ok(Spawned {
307	+	session: PtySession {
308	+	master: pair.master,
309	+	writer_tx,
310	+	child,
311	+	},
312	+	output,
313	+	exit,
314	+	})
315	+	}
316	+
317	+	/// Path of the slave side, e.g. `/dev/pts/7`. This is how tmux names our
318	+	/// client, so it is the key for looking the client's session back up.
319	+	#[cfg(unix)]
320	+	pub fn tty_name(&self) -> Option<String> {
321	+	self.master
322	+	.tty_name()
323	+	.map(\|p\| p.to_string_lossy().into_owned())
324	+	}
325	+
326	+	#[cfg(not(unix))]
327	+	pub fn tty_name(&self) -> Option<String> {
328	+	None
329	+	}
330	+
331	+	/// Keystrokes from the browser, straight through. No interpretation.
332	+	pub fn write(&self, bytes: Vec<u8>) -> bool {
333	+	self.writer_tx.send(bytes).is_ok()
334	+	}
335	+
336	+	/// TIOCSWINSZ on the master; the child gets SIGWINCH and tmux reflows.
337	+	pub fn resize(&self, cols: u16, rows: u16) -> std::io::Result<()> {
338	+	self.master
339	+	.resize(PtySize {
340	+	rows: rows.max(1),
341	+	cols: cols.max(1),
342	+	pixel_width: 0,
343	+	pixel_height: 0,
344	+	})
345	+	.map_err(\|e\| std::io::Error::other(e.to_string()))
346	+	}
347	+
348	+	pub fn kill(&self) {
349	+	let _ = self.child.lock().unwrap().kill();
350	+	}
351	+	}
352	+
353	+	impl Drop for PtySession {
354	+	fn drop(&mut self) {
355	+	// Killing the tmux client on disconnect is correct and is the whole
356	+	// point: the tmux server keeps the session alive for the next attach.
357	+	self.kill();
358	+	}
359	+	}

1	+	//! A stream wrapper that replays bytes we already consumed.
2	+	//!
3	+	//! We need to look at the HTTP request head before handing the stream to the
4	+	//! WebSocket handshake, so we can serve a human-readable page to someone who
5	+	//! navigated to https://127.0.0.1:7681 to accept the certificate. TLS streams
6	+	//! can't be peeked like a TcpStream, so we read, decide, and rewind.
7	+
8	+	use std::pin::Pin;
9	+	use std::task::{Context, Poll};
10	+
11	+	use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
12	+
13	+	pub struct Rewind<S> {
14	+	prefix: Vec<u8>,
15	+	pos: usize,
16	+	inner: S,
17	+	}
18	+
19	+	impl<S> Rewind<S> {
20	+	pub fn new(prefix: Vec<u8>, inner: S) -> Self {
21	+	Self {
22	+	prefix,
23	+	pos: 0,
24	+	inner,
25	+	}
26	+	}
27	+	}
28	+
29	+	impl<S: AsyncRead + Unpin> AsyncRead for Rewind<S> {
30	+	fn poll_read(
31	+	mut self: Pin<&mut Self>,
32	+	cx: &mut Context<'_>,
33	+	buf: &mut ReadBuf<'_>,
34	+	) -> Poll<std::io::Result<()>> {
35	+	if self.pos < self.prefix.len() {
36	+	let remaining = &self.prefix[self.pos..];
37	+	let n = remaining.len().min(buf.remaining());
38	+	buf.put_slice(&remaining[..n]);
39	+	self.pos += n;
40	+	return Poll::Ready(Ok(()));
41	+	}
42	+	Pin::new(&mut self.inner).poll_read(cx, buf)
43	+	}
44	+	}
45	+
46	+	impl<S: AsyncWrite + Unpin> AsyncWrite for Rewind<S> {
47	+	fn poll_write(
48	+	mut self: Pin<&mut Self>,
49	+	cx: &mut Context<'_>,
50	+	buf: &[u8],
51	+	) -> Poll<std::io::Result<usize>> {
52	+	Pin::new(&mut self.inner).poll_write(cx, buf)
53	+	}
54	+	fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
55	+	Pin::new(&mut self.inner).poll_flush(cx)
56	+	}
57	+	fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
58	+	Pin::new(&mut self.inner).poll_shutdown(cx)
59	+	}
60	+	}
61	+
62	+	/// Read the request head (up to the blank line) without consuming the body.
63	+	/// Returns the bytes read so they can be replayed.
64	+	pub async fn read_head<S: AsyncRead + Unpin>(
65	+	stream: &mut S,
66	+	limit: usize,
67	+	) -> std::io::Result<Vec<u8>> {
68	+	use tokio::io::AsyncReadExt;
69	+	let mut buf = Vec::with_capacity(1024);
70	+	let mut byte = [0u8; 1];
71	+	while buf.len() < limit {
72	+	let n = stream.read(&mut byte).await?;
73	+	if n == 0 {
74	+	break;
75	+	}
76	+	buf.push(byte[0]);
77	+	if buf.ends_with(b"\r\n\r\n") {
78	+	break;
79	+	}
80	+	}
81	+	Ok(buf)
82	+	}
83	+
84	+	pub fn is_websocket_upgrade(head: &[u8]) -> bool {
85	+	let text = String::from_utf8_lossy(head).to_ascii_lowercase();
86	+	text.contains("upgrade: websocket") \|\| text.contains("upgrade:websocket")
87	+	}

1	+	//! What the sidebar shows above the terminal: which tmux session we're on, what
2	+	//! else is available, and what each Claude Code in the session is doing.
3	+	//!
4	+	//! Two sources, both authoritative, neither guessed:
5	+	//!
6	+	//! - tmux, asked over the [control channel](crate::control), for the session
7	+	//! our client is attached to and the panes in it.
8	+	//! - Claude Code's hook interface, via the records in [`crate::agents`].
9	+	//!
10	+	//! The join between them is the tmux pane id.
11	+
12	+	use serde::Serialize;
13	+
14	+	use crate::control::Control;
15	+
16	+	/// Tab character, as tmux sees it. Single quotes make tmux take the byte
17	+	/// literally, so the separator survives into the output and window names
18	+	/// containing spaces or `\|` stay intact.
19	+	const T: char = '\t';
20	+
21	+	/// One pane running Claude Code.
22	+	#[derive(Serialize, Debug, Clone, PartialEq, Eq)]
23	+	pub struct Agent {
24	+	/// tmux pane id (`%12`), stable for the pane's lifetime.
25	+	pub pane: String,
26	+	/// tmux window id (`@3`) — the join to [`WindowInfo`], so the sidebar can
27	+	/// mark the tab an agent is in without matching on a shifting index.
28	+	pub window_id: String,
29	+	pub window: String,
30	+	/// Window name — what the user sees in the tmux status line.
31	+	pub name: String,
32	+	/// `working` \| `waiting` \| `idle`, or `unknown` when the pane is running
33	+	/// Claude but no hook has ever reported for it.
34	+	pub state: &'static str,
35	+	/// Claude's `permission_mode`: `default`, `acceptEdits`, `plan`,
36	+	/// `bypassPermissions`.
37	+	pub mode: Option<String>,
38	+	/// Tool in flight, while working.
39	+	pub tool: Option<String>,
40	+	/// Why it is waiting on you.
41	+	pub message: Option<String>,
42	+	/// Claude's session title, when it has one.
43	+	pub title: Option<String>,
44	+	}
45	+
46	+	#[derive(Serialize, Debug, Clone, PartialEq, Eq)]
47	+	pub struct SessionInfo {
48	+	pub name: String,
49	+	pub windows: u32,
50	+	pub attached: bool,
51	+	}
52	+
53	+	/// One window in the attached session — one tab in the sidebar.
54	+	#[derive(Serialize, Debug, Clone, PartialEq, Eq)]
55	+	pub struct WindowInfo {
56	+	/// tmux window id (`@3`). Stable for the window's lifetime, unlike the
57	+	/// index, which shifts when a window before it closes — so this, not the
58	+	/// index, is what the sidebar sends back to select one.
59	+	pub id: String,
60	+	/// What the user sees in the status line and types as `prefix 2`.
61	+	pub index: u32,
62	+	pub name: String,
63	+	pub active: bool,
64	+	pub panes: u32,
65	+	/// Output arrived here since it was last looked at.
66	+	pub activity: bool,
67	+	}
68	+
69	+	#[derive(Serialize, Debug, Clone, PartialEq, Eq)]
70	+	pub struct Snapshot {
71	+	/// Session our client is attached to right now, not the one we asked for.
72	+	pub session: Option<String>,
73	+	/// Every session on the server, for the sidebar's switcher.
74	+	pub sessions: Vec<SessionInfo>,
75	+	/// Windows of the attached session, in index order — the sidebar's tabs.
76	+	pub windows: Vec<WindowInfo>,
77	+	pub agents: Vec<Agent>,
78	+	}
79	+
80	+	/// Ask tmux, then fold in the hook records.
81	+	pub async fn snapshot(control: &Control, tty: Option<&str>) -> Snapshot {
82	+	let session = current_session(control, tty).await;
83	+	let sessions = list_sessions(control).await;
84	+	let (windows, agents) = match &session {
85	+	Some(s) => (list_windows(control, s).await, agents_in(control, s).await),
86	+	None => (Vec::new(), Vec::new()),
87	+	};
88	+	Snapshot {
89	+	session,
90	+	sessions,
91	+	windows,
92	+	agents,
93	+	}
94	+	}
95	+
96	+	/// Which session the interactive client on `tty` is on.
97	+	///
98	+	/// tmux is the authority: the client can leave the session it was spawned with
99	+	/// (`switch-client`, `choose-tree`, prefix-`(`/`)`), and the name we passed to
100	+	/// `new-session` goes stale the moment it does.
101	+	pub async fn current_session(control: &Control, tty: Option<&str>) -> Option<String> {
102	+	let tty = tty?;
103	+	let out = control
104	+	.run(format!("list-clients -F '#{{client_tty}}{T}#{{session_name}}'"))
105	+	.await
106	+	.ok()?;
107	+	out.iter()
108	+	.filter_map(\|l\| l.split_once(T))
109	+	.find(\|(client_tty, _)\| *client_tty == tty)
110	+	.map(\|(_, name)\| name.trim().to_string())
111	+	.filter(\|name\| !name.is_empty())
112	+	}
113	+
114	+	async fn list_sessions(control: &Control) -> Vec<SessionInfo> {
115	+	let fmt = format!("#{{session_name}}{T}#{{session_windows}}{T}#{{session_attached}}");
116	+	let Ok(out) = control.run(format!("list-sessions -F '{fmt}'")).await else {
117	+	return Vec::new();
118	+	};
119	+	out.iter()
120	+	.filter_map(\|line\| {
121	+	let mut f = line.split(T);
122	+	Some(SessionInfo {
123	+	name: f.next()?.to_string(),
124	+	windows: f.next()?.parse().unwrap_or(0),
125	+	attached: f.next().unwrap_or("0") != "0",
126	+	})
127	+	})
128	+	.collect()
129	+	}
130	+
131	+	/// Windows of `session`, in the order tmux lists them (by index).
132	+	///
133	+	/// `session` reaches here from tmux itself or from a name validated in
134	+	/// [`crate::pty::valid_session_name`], and is single-quoted besides.
135	+	async fn list_windows(control: &Control, session: &str) -> Vec<WindowInfo> {
136	+	let fmt = format!(
137	+	"#{{window_id}}{T}#{{window_index}}{T}#{{window_name}}{T}\
138	+	#{{window_active}}{T}#{{window_panes}}{T}#{{window_activity_flag}}"
139	+	);
140	+	let Ok(out) = control
141	+	.run(format!("list-windows -t '{session}' -F '{fmt}'"))
142	+	.await
143	+	else {
144	+	return Vec::new();
145	+	};
146	+	out.iter()
147	+	.filter_map(\|line\| {
148	+	let mut f = line.split(T);
149	+	Some(WindowInfo {
150	+	id: f.next()?.to_string(),
151	+	index: f.next()?.parse().ok()?,
152	+	name: f.next()?.to_string(),
153	+	active: f.next().unwrap_or("0") != "0",
154	+	panes: f.next().and_then(\|p\| p.parse().ok()).unwrap_or(1),
155	+	activity: f.next().unwrap_or("0") != "0",
156	+	})
157	+	})
158	+	.collect()
159	+	}
160	+
161	+	async fn agents_in(control: &Control, session: &str) -> Vec<Agent> {
162	+	let fmt = format!(
163	+	"#{{pane_id}}{T}#{{window_id}}{T}#{{window_index}}{T}\
164	+	#{{window_name}}{T}#{{pane_current_command}}"
165	+	);
166	+	// `session` reaches here from tmux itself or from a validated name, and is
167	+	// single-quoted besides.
168	+	let Ok(out) = control
169	+	.run(format!("list-panes -s -t '{session}' -F '{fmt}'"))
170	+	.await
171	+	else {
172	+	return Vec::new();
173	+	};
174	+	let records = crate::agents::by_pane();
175	+
176	+	out.iter()
177	+	.filter_map(\|line\| {
178	+	let mut f = line.split(T);
179	+	let pane = f.next()?.to_string();
180	+	let window_id = f.next()?.to_string();
181	+	let window = f.next()?.to_string();
182	+	let name = f.next()?.to_string();
183	+	let cmd = f.next().unwrap_or("");
184	+	let record = records.get(&pane);
185	+	// A pane qualifies if Claude is the foreground process, or if a
186	+	// hook has reported for it — Claude that shelled out to a
187	+	// long-running command shows that command as pane_current_command
188	+	// and would otherwise vanish from the sidebar mid-run.
189	+	if cmd != "claude" && record.is_none() {
190	+	return None;
191	+	}
192	+	Some(Agent {
193	+	pane,
194	+	window_id,
195	+	window,
196	+	name,
197	+	state: record.map(\|r\| r.state.as_str()).unwrap_or("unknown"),
198	+	mode: record.and_then(\|r\| r.mode.clone()),
199	+	tool: record.and_then(\|r\| r.tool.clone()),
200	+	message: record.and_then(\|r\| r.message.clone()),
201	+	title: record.and_then(\|r\| r.name.clone()),
202	+	})
203	+	})
204	+	.collect()
205	+	}

1	+	//! Self-signed TLS for loopback.
2	+	//!
3	+	//! Firefox's HTTPS-Only Mode rewrites `ws://` to `wss://`, including for
4	+	//! loopback. Rather than asking people to weaken a browser security setting so
5	+	//! our daemon can run, we just speak TLS.
6	+	//!
7	+	//! The certificate is generated once, stored in the config dir with the key at
8	+	//! 0600, and covers `127.0.0.1`, `::1` and `localhost`. It is self-signed, so
9	+	//! the browser needs a one-time exception — see `serve` output.
10	+
11	+	use std::fs;
12	+	use std::io::Write;
13	+	use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
14	+	use std::path::Path;
15	+	use std::sync::Arc;
16	+
17	+	use tokio_rustls::rustls::pki_types::{CertificateDer, PrivateKeyDer};
18	+	use tokio_rustls::rustls::ServerConfig;
19	+	use tokio_rustls::TlsAcceptor;
20	+
21	+	pub const CERT_FILE: &str = "cert.pem";
22	+	pub const KEY_FILE: &str = "key.pem";
23	+
24	+	/// Regenerate when the cert is within this of expiry, so a long-lived install
25	+	/// doesn't silently start failing.
26	+	const VALIDITY_DAYS: i64 = 3650;
27	+
28	+	pub struct Identity {
29	+	pub cert_pem: String,
30	+	pub key_pem: String,
31	+	/// SHA-256 of the DER certificate, colon-separated — the same fingerprint
32	+	/// the browser shows, so a user can verify they're trusting our cert.
33	+	pub fingerprint: String,
34	+	}
35	+
36	+	fn fingerprint(der: &[u8]) -> String {
37	+	// Avoid pulling in a hash crate for one call; rcgen already depends on ring.
38	+	let digest = ring_sha256(der);
39	+	digest
40	+	.iter()
41	+	.map(\|b\| format!("{b:02X}"))
42	+	.collect::<Vec<_>>()
43	+	.join(":")
44	+	}
45	+
46	+	fn ring_sha256(data: &[u8]) -> Vec<u8> {
47	+	use sha2::{Digest, Sha256};
48	+	Sha256::digest(data).to_vec()
49	+	}
50	+
51	+	/// Load the existing identity, or generate one on first run.
52	+	pub fn load_or_create(dir: &Path) -> std::io::Result<Identity> {
53	+	let cert_path = dir.join(CERT_FILE);
54	+	let key_path = dir.join(KEY_FILE);
55	+
56	+	if cert_path.exists() && key_path.exists() {
57	+	let mode = fs::metadata(&key_path)?.permissions().mode() & 0o777;
58	+	if mode & 0o077 != 0 {
59	+	return Err(std::io::Error::other(format!(
60	+	"{} has mode {mode:04o}; expected 0600. Fix with: chmod 600 {}",
61	+	key_path.display(),
62	+	key_path.display()
63	+	)));
64	+	}
65	+	let cert_pem = fs::read_to_string(&cert_path)?;
66	+	let key_pem = fs::read_to_string(&key_path)?;
67	+	let der = first_cert_der(&cert_pem)?;
68	+	return Ok(Identity {
69	+	fingerprint: fingerprint(&der),
70	+	cert_pem,
71	+	key_pem,
72	+	});
73	+	}
74	+
75	+	generate(dir)
76	+	}
77	+
78	+	pub fn generate(dir: &Path) -> std::io::Result<Identity> {
79	+	fs::create_dir_all(dir)?;
80	+	fs::set_permissions(dir, fs::Permissions::from_mode(0o700))?;
81	+
82	+	let mut params = rcgen::CertificateParams::new(vec![
83	+	"localhost".to_string(),
84	+	"127.0.0.1".to_string(),
85	+	"::1".to_string(),
86	+	])
87	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
88	+
89	+	params.distinguished_name = {
90	+	let mut dn = rcgen::DistinguishedName::new();
91	+	dn.push(rcgen::DnType::CommonName, "termbridge (local)");
92	+	dn.push(rcgen::DnType::OrganizationName, "termbridge");
93	+	dn
94	+	};
95	+	params.not_before = rcgen::date_time_ymd(2020, 1, 1);
96	+	params.not_after = rcgen::date_time_ymd(2025 + (VALIDITY_DAYS / 365) as i32, 1, 1);
97	+	// A leaf, not a CA: this cert can only ever vouch for this host, so
98	+	// trusting it cannot be leveraged to impersonate anything else.
99	+	params.is_ca = rcgen::IsCa::ExplicitNoCa;
100	+
101	+	let key = rcgen::KeyPair::generate().map_err(\|e\| std::io::Error::other(e.to_string()))?;
102	+	let cert = params
103	+	.self_signed(&key)
104	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
105	+
106	+	let cert_pem = cert.pem();
107	+	let key_pem = key.serialize_pem();
108	+
109	+	fs::write(dir.join(CERT_FILE), &cert_pem)?;
110	+	fs::set_permissions(dir.join(CERT_FILE), fs::Permissions::from_mode(0o644))?;
111	+
112	+	// The private key gets the same treatment as the auth token.
113	+	let key_path = dir.join(KEY_FILE);
114	+	let mut f = fs::OpenOptions::new()
115	+	.write(true)
116	+	.create(true)
117	+	.truncate(true)
118	+	.mode(0o600)
119	+	.open(&key_path)?;
120	+	f.write_all(key_pem.as_bytes())?;
121	+	f.sync_all()?;
122	+	fs::set_permissions(&key_path, fs::Permissions::from_mode(0o600))?;
123	+
124	+	let der = cert.der().to_vec();
125	+	Ok(Identity {
126	+	fingerprint: fingerprint(&der),
127	+	cert_pem,
128	+	key_pem,
129	+	})
130	+	}
131	+
132	+	fn first_cert_der(pem: &str) -> std::io::Result<Vec<u8>> {
133	+	let mut cursor = std::io::Cursor::new(pem.as_bytes());
134	+	let certs: Vec<CertificateDer> = rustls_pemfile_certs(&mut cursor)?;
135	+	certs
136	+	.first()
137	+	.map(\|c\| c.as_ref().to_vec())
138	+	.ok_or_else(\|\| std::io::Error::other("no certificate in cert.pem"))
139	+	}
140	+
141	+	/// Minimal PEM decoder so we don't add rustls-pemfile for two call sites.
142	+	fn rustls_pemfile_certs(
143	+	r: &mut std::io::Cursor<&[u8]>,
144	+	) -> std::io::Result<Vec<CertificateDer<'static>>> {
145	+	let text = String::from_utf8_lossy(*r.get_ref()).to_string();
146	+	let mut out = Vec::new();
147	+	for block in text.split("-----BEGIN CERTIFICATE-----").skip(1) {
148	+	let Some(body) = block.split("-----END CERTIFICATE-----").next() else {
149	+	continue;
150	+	};
151	+	let b64: String = body.chars().filter(\|c\| !c.is_whitespace()).collect();
152	+	out.push(CertificateDer::from(base64_decode(&b64)?));
153	+	}
154	+	Ok(out)
155	+	}
156	+
157	+	fn base64_decode(s: &str) -> std::io::Result<Vec<u8>> {
158	+	const TABLE: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
159	+	let mut rev = [255u8; 256];
160	+	for (i, c) in TABLE.iter().enumerate() {
161	+	rev[*c as usize] = i as u8;
162	+	}
163	+	let mut out = Vec::new();
164	+	let mut acc: u32 = 0;
165	+	let mut bits = 0;
166	+	for c in s.bytes() {
167	+	if c == b'=' {
168	+	break;
169	+	}
170	+	let v = rev[c as usize];
171	+	if v == 255 {
172	+	return Err(std::io::Error::other("invalid base64 in PEM"));
173	+	}
174	+	acc = (acc << 6) \| v as u32;
175	+	bits += 6;
176	+	if bits >= 8 {
177	+	bits -= 8;
178	+	out.push((acc >> bits) as u8);
179	+	}
180	+	}
181	+	Ok(out)
182	+	}
183	+
184	+	pub fn acceptor(identity: &Identity) -> std::io::Result<TlsAcceptor> {
185	+	let mut cert_cursor = std::io::Cursor::new(identity.cert_pem.as_bytes());
186	+	let certs = rustls_pemfile_certs(&mut cert_cursor)?;
187	+
188	+	let key = parse_private_key(&identity.key_pem)?;
189	+
190	+	let config = ServerConfig::builder()
191	+	.with_no_client_auth()
192	+	.with_single_cert(certs, key)
193	+	.map_err(\|e\| std::io::Error::other(e.to_string()))?;
194	+
195	+	Ok(TlsAcceptor::from(Arc::new(config)))
196	+	}
197	+
198	+	fn parse_private_key(pem: &str) -> std::io::Result<PrivateKeyDer<'static>> {
199	+	for (begin, end) in [
200	+	("-----BEGIN PRIVATE KEY-----", "-----END PRIVATE KEY-----"),
201	+	("-----BEGIN EC PRIVATE KEY-----", "-----END EC PRIVATE KEY-----"),
202	+	("-----BEGIN RSA PRIVATE KEY-----", "-----END RSA PRIVATE KEY-----"),
203	+	] {
204	+	if let Some(rest) = pem.split(begin).nth(1) {
205	+	if let Some(body) = rest.split(end).next() {
206	+	let b64: String = body.chars().filter(\|c\| !c.is_whitespace()).collect();
207	+	let der = base64_decode(&b64)?;
208	+	return Ok(match begin {
209	+	"-----BEGIN EC PRIVATE KEY-----" => {
210	+	PrivateKeyDer::Sec1(der.into())
211	+	}
212	+	"-----BEGIN RSA PRIVATE KEY-----" => PrivateKeyDer::Pkcs1(der.into()),
213	+	_ => PrivateKeyDer::Pkcs8(der.into()),
214	+	});
215	+	}
216	+	}
217	+	}
218	+	Err(std::io::Error::other("no private key found in key.pem"))
219	+	}

1	+	//! The same Claude glyph the sidebar's tabs wear, published into tmux's own
2	+	//! status line.
3	+	//!
4	+	//! The sidebar gets its state over the daemon's control channel, which only
5	+	//! exists while a browser is attached — exactly the case where you are not
6	+	//! looking at the terminal. So this takes the other route: `termbridge hook`
7	+	//! already runs on every Claude Code event, inside the pane it is reporting on,
8	+	//! with `$TMUX` pointing at the right server. It sets a window user option, and
9	+	//! tmux redraws on the option change.
10	+	//!
11	+	//! The user opts in with one line in `~/.tmux.conf` (`termbridge tmux` prints
12	+	//! it). Nothing here touches a window that has never had a Claude in it, and
13	+	//! nothing here can change a window's name, layout or contents: the only
14	+	//! command it issues is `set-option -w @tb_claude`.
15	+
16	+	use std::process::{Command, Stdio};
17	+
18	+	use crate::agents::{self, Record, State};
19	+
20	+	/// The option the format reads. `@`-prefixed, so tmux treats it as a user
21	+	/// option and no future tmux release can collide with it.
22	+	const OPTION: &str = "@tb_claude";
23	+
24	+	/// Claude Code's asterisk cycle. A working window steps one frame per hook
25	+	/// event rather than on a timer: tmux only redraws its status when an option
26	+	/// changes or `status-interval` elapses, so a real animation would mean
27	+	/// forcing a full status repaint on every attached client several times a
28	+	/// second. Stepping on events costs nothing and still reads as alive — the
29	+	/// glyph moves exactly when Claude crosses a tool boundary.
30	+	const FRAMES: [&str; 6] = ["·", "✢", "✳", "∗", "✻", "✽"];
31	+
32	+	/// Recompute the glyph for the window the hook fired in, from every Claude
33	+	/// record in that window.
34	+	///
35	+	/// Errors are swallowed all the way down. This runs inside a Claude Code hook,
36	+	/// where the cost of failing loudly is an interrupted session and the cost of
37	+	/// failing quietly is a stale symbol until the next event.
38	+	pub fn publish() {
39	+	// Not in tmux, or not under a tmux that would show it: nothing to say.
40	+	if std::env::var_os("TMUX").is_none() {
41	+	return;
42	+	}
43	+	let Ok(pane) = std::env::var("TMUX_PANE") else {
44	+	return;
45	+	};
46	+	let panes = window_panes(&pane);
47	+	let by_pane = agents::by_pane();
48	+	// A window is one tab in the sidebar and one entry in the status line, so
49	+	// it reports the loudest thing in it — the same rule, and the same reason:
50	+	// a window with something waiting on you outranks one that is merely busy.
51	+	let winner = panes
52	+	.iter()
53	+	.filter_map(\|p\| by_pane.get(p))
54	+	.min_by_key(\|r\| rank(r.state));
55	+
56	+	match winner.map(glyph) {
57	+	Some(value) => set_option(&pane, &value),
58	+	None => unset_option(&pane),
59	+	}
60	+	}
61	+
62	+	fn rank(state: State) -> u8 {
63	+	match state {
64	+	State::Waiting => 0,
65	+	State::Working => 1,
66	+	State::Idle => 2,
67	+	}
68	+	}
69	+
70	+	/// Styled inline, because the option's value is expanded into the status format
71	+	/// and tmux reads `#[...]` in the result. `#[default]` hands the style back to
72	+	/// whatever the user's own format was using, so this cannot leak colour into
73	+	/// the window name that follows it.
74	+	fn glyph(r: &Record) -> String {
75	+	let (colour, sym) = match r.state {
76	+	State::Working => ("yellow", FRAMES[r.frame as usize % FRAMES.len()]),
77	+	State::Waiting => ("magenta", "✳"),
78	+	State::Idle => ("brightblack", "✻"),
79	+	};
80	+	format!("#[fg={colour}]{sym}#[default] ")
81	+	}
82	+
83	+	/// The panes of the window `pane` is in — one tmux call, and the only thing we
84	+	/// need tmux itself to tell us. The hook records key on pane id, so this is the
85	+	/// whole join.
86	+	fn window_panes(pane: &str) -> Vec<String> {
87	+	let out = tmux(&["list-panes", "-t", pane, "-F", "#{pane_id}"]);
88	+	out.lines().map(str::to_string).collect()
89	+	}
90	+
91	+	/// `-w` with a pane target sets the option on that pane's window, so the pane
92	+	/// id is the only handle needed.
93	+	fn set_option(pane: &str, value: &str) {
94	+	let _ = tmux(&["set-option", "-w", "-t", pane, OPTION, value]);
95	+	}
96	+
97	+	fn unset_option(pane: &str) {
98	+	let _ = tmux(&["set-option", "-wu", "-t", pane, OPTION]);
99	+	}
100	+
101	+	/// No `-L`/`-S`: the hook runs inside the pane, so `$TMUX` already names the
102	+	/// server the user is looking at, and inheriting it is what makes this correct
103	+	/// under multiple tmux servers.
104	+	fn tmux(args: &[&str]) -> String {
105	+	Command::new("tmux")
106	+	.args(args)
107	+	.stdin(Stdio::null())
108	+	.stderr(Stdio::null())
109	+	.output()
110	+	.ok()
111	+	.and_then(\|o\| String::from_utf8(o.stdout).ok())
112	+	.unwrap_or_default()
113	+	}
114	+
115	+	/// What `termbridge tmux` prints. Two formats, because tmux styles the current
116	+	/// window with a separate one and a glyph that vanished on the window you were
117	+	/// on would be the wrong half to lose.
118	+	pub fn tmux_conf() -> String {
119	+	format!(
120	+	"# Claude Code status in the tmux status line, from termbridge's hooks.\n\
121	+	# The option is empty for a window with no Claude in it, so windows\n\
122	+	# that never see one look exactly as they do now.\n\
123	+	set -g window-status-format \"#{{{OPTION}}}#I:#W#F\"\n\
124	+	set -g window-status-current-format \"#{{{OPTION}}}#I:#W#F\"\n"
125	+	)
126	+	}
127	+
128	+	#[cfg(test)]
129	+	mod tests {
130	+	use super::*;
131	+
132	+	fn record(state: State, frame: u8) -> Record {
133	+	Record {
134	+	session_id: "s".into(),
135	+	pane: Some("%1".into()),
136	+	cwd: "/tmp".into(),
137	+	state,
138	+	mode: None,
139	+	tool: None,
140	+	message: None,
141	+	name: None,
142	+	frame,
143	+	updated: 0,
144	+	}
145	+	}
146	+
147	+	#[test]
148	+	fn working_steps_through_the_cycle() {
149	+	let frames: Vec<String> = (0..7).map(\|f\| glyph(&record(State::Working, f))).collect();
150	+	assert!(frames[0].contains('·'));
151	+	assert!(frames[4].contains('✻'));
152	+	// Wraps rather than running off the end of the array.
153	+	assert_eq!(frames[0], frames[6]);
154	+	assert!(frames.iter().all(\|f\| f.ends_with("#[default] ")));
155	+	}
156	+
157	+	#[test]
158	+	fn waiting_outranks_working_outranks_idle() {
159	+	assert!(rank(State::Waiting) < rank(State::Working));
160	+	assert!(rank(State::Working) < rank(State::Idle));
161	+	}
162	+
163	+	#[test]
164	+	fn the_conf_names_the_option_the_hook_sets() {
165	+	assert!(tmux_conf().contains(&format!("#{{{OPTION}}}")));
166	+	}
167	+	}

1	+	//! End-to-end: browser-shaped client -> WebSocket -> pty -> shell -> back.
2	+	//!
3	+	//! Uses `sh` rather than tmux so the test doesn't depend on a tmux server or
4	+	//! leave sessions behind. The pty path is identical either way.
5	+
6	+	use std::time::Duration;
7	+
8	+	use futures_util::{SinkExt, StreamExt};
9	+	use tokio_tungstenite::tungstenite::client::IntoClientRequest;
10	+	use tokio_tungstenite::tungstenite::Message;
11	+
12	+	use termbridge::pty::Profile;
13	+	use termbridge::{Config, Server};
14	+
15	+	const TOKEN: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
16	+	const ORIGIN: &str = "chrome-extension://abcdefghijklmnopabcdefghijklmnop";
17	+
18	+	fn sh_profile() -> Profile {
19	+	Profile {
20	+	program: "/bin/sh".into(),
21	+	args: vec![],
22	+	}
23	+	}
24	+
25	+	async fn connect_authed(
26	+	server: &Server,
27	+	) -> tokio_tungstenite::WebSocketStream<
28	+	tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
29	+	> {
30	+	let mut req = server.url().into_client_request().unwrap();
31	+	req.headers_mut().insert("origin", ORIGIN.parse().unwrap());
32	+	let (mut ws, _) = tokio_tungstenite::connect_async(req).await.unwrap();
33	+
34	+	ws.send(Message::Text(
35	+	serde_json::json!({"type": "auth", "token": TOKEN})
36	+	.to_string()
37	+	.into(),
38	+	))
39	+	.await
40	+	.unwrap();
41	+	let ok = ws.next().await.unwrap().unwrap();
42	+	assert!(ok.to_text().unwrap().contains("\"ok\""), "{ok:?}");
43	+	ws
44	+	}
45	+
46	+	/// Read binary frames until `needle` shows up in the accumulated output.
47	+	async fn wait_for(
48	+	ws: &mut tokio_tungstenite::WebSocketStream<
49	+	tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
50	+	>,
51	+	needle: &str,
52	+	) -> String {
53	+	let mut acc = Vec::new();
54	+	let found = tokio::time::timeout(Duration::from_secs(10), async {
55	+	while let Some(Ok(msg)) = ws.next().await {
56	+	if let Message::Binary(b) = msg {
57	+	acc.extend_from_slice(&b);
58	+	if String::from_utf8_lossy(&acc).contains(needle) {
59	+	return true;
60	+	}
61	+	}
62	+	}
63	+	false
64	+	})
65	+	.await
66	+	.unwrap_or(false);
67	+
68	+	let text = String::from_utf8_lossy(&acc).to_string();
69	+	assert!(found, "never saw {needle:?}; got:\n{}", printable(&text));
70	+	text
71	+	}
72	+
73	+	/// Escape control bytes so a failing assertion can't repaint the terminal that
74	+	/// is printing it.
75	+	fn printable(s: &str) -> String {
76	+	s.chars()
77	+	.map(\|c\| match c {
78	+	'\n' \| '\t' => c.to_string(),
79	+	c if (c as u32) < 0x20 \|\| c as u32 == 0x7f => format!("\\x{:02x}", c as u32),
80	+	c => c.to_string(),
81	+	})
82	+	.collect()
83	+	}
84	+
85	+	/// Wait until the shell inside tmux is actually consuming input.
86	+	///
87	+	/// tmux drops keystrokes that arrive before its client has finished attaching,
88	+	/// so anything typed immediately after `open` can vanish. Probe until the echo
89	+	/// comes back rather than assuming a fixed delay is enough.
90	+	async fn wait_until_ready(
91	+	ws: &mut tokio_tungstenite::WebSocketStream<
92	+	tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
93	+	>,
94	+	probe: &str,
95	+	) {
96	+	let deadline = tokio::time::Instant::now() + Duration::from_secs(20);
97	+	let mut acc = Vec::new();
98	+	loop {
99	+	assert!(
100	+	tokio::time::Instant::now() < deadline,
101	+	"shell never became ready; saw:\n{}",
102	+	printable(&String::from_utf8_lossy(&acc))
103	+	);
104	+	ws.send(Message::Binary(format!("echo {probe}\n").into_bytes().into()))
105	+	.await
106	+	.unwrap();
107	+
108	+	let until = tokio::time::Instant::now() + Duration::from_millis(700);
109	+	loop {
110	+	match tokio::time::timeout_at(until, ws.next()).await {
111	+	Ok(Some(Ok(Message::Binary(b)))) => {
112	+	acc.extend_from_slice(&b);
113	+	// Twice: once as terminal echo of what we typed, once as
114	+	// the command's own output. One occurrence only proves the
115	+	// characters were displayed, not that a shell ran them.
116	+	if String::from_utf8_lossy(&acc).matches(probe).count() >= 2 {
117	+	return;
118	+	}
119	+	}
120	+	Ok(Some(Ok(_))) => {}
121	+	Ok(Some(Err(e))) => panic!("connection error while waiting: {e}"),
122	+	Ok(None) => panic!("connection closed while waiting for the shell"),
123	+	Err(_) => break, // no progress this round; probe again
124	+	}
125	+	}
126	+	}
127	+	}
128	+
129	+	async fn start(profile: Profile) -> Server {
130	+	let mut cfg = Config::new(TOKEN, vec![ORIGIN.to_string()]);
131	+	cfg.profile = profile;
132	+	Server::start(cfg, 0).await.unwrap()
133	+	}
134	+
135	+	#[tokio::test]
136	+	async fn shell_runs_and_output_comes_back_as_binary() {
137	+	let server = start(sh_profile()).await;
138	+	let mut ws = connect_authed(&server).await;
139	+
140	+	ws.send(Message::Text(
141	+	serde_json::json!({"type": "open", "cols": 80, "rows": 24})
142	+	.to_string()
143	+	.into(),
144	+	))
145	+	.await
146	+	.unwrap();
147	+
148	+	// Keystrokes go as binary, exactly as the sidebar will send them.
149	+	ws.send(Message::Binary(b"echo hello-from-pty\n".to_vec().into()))
150	+	.await
151	+	.unwrap();
152	+
153	+	wait_for(&mut ws, "hello-from-pty").await;
154	+	}
155	+
156	+	/// The pty must report the size we asked for — this is what makes tmux and vim
157	+	/// lay out correctly in a narrow sidebar.
158	+	#[tokio::test]
159	+	async fn winsize_is_applied_and_resizable() {
160	+	let server = start(sh_profile()).await;
161	+	let mut ws = connect_authed(&server).await;
162	+
163	+	ws.send(Message::Text(
164	+	serde_json::json!({"type": "open", "cols": 40, "rows": 20})
165	+	.to_string()
166	+	.into(),
167	+	))
168	+	.await
169	+	.unwrap();
170	+	ws.send(Message::Binary(b"stty size\n".to_vec().into()))
171	+	.await
172	+	.unwrap();
173	+	wait_for(&mut ws, "20 40").await;
174	+
175	+	// Now resize, as the sidebar does when the user drags its edge.
176	+	ws.send(Message::Text(
177	+	serde_json::json!({"type": "resize", "cols": 100, "rows": 30})
178	+	.to_string()
179	+	.into(),
180	+	))
181	+	.await
182	+	.unwrap();
183	+	tokio::time::sleep(Duration::from_millis(200)).await;
184	+	ws.send(Message::Binary(b"stty size\n".to_vec().into()))
185	+	.await
186	+	.unwrap();
187	+	wait_for(&mut ws, "30 100").await;
188	+	}
189	+
190	+	/// The pty is a byte pipe. Anything that isn't valid UTF-8 must survive, which
191	+	/// is the property a JSON transport could not have given us.
192	+	#[tokio::test]
193	+	async fn non_utf8_output_survives_intact() {
194	+	let server = start(sh_profile()).await;
195	+	let mut ws = connect_authed(&server).await;
196	+	ws.send(Message::Text(
197	+	serde_json::json!({"type": "open", "cols": 80, "rows": 24})
198	+	.to_string()
199	+	.into(),
200	+	))
201	+	.await
202	+	.unwrap();
203	+
204	+	// 0xff is not valid UTF-8 anywhere. Bracket it so we can find it.
205	+	ws.send(Message::Binary(
206	+	b"printf 'S\\377\\376E\\n'\n".to_vec().into(),
207	+	))
208	+	.await
209	+	.unwrap();
210	+
211	+	let mut acc = Vec::new();
212	+	let found = tokio::time::timeout(Duration::from_secs(10), async {
213	+	while let Some(Ok(Message::Binary(b))) = ws.next().await {
214	+	acc.extend_from_slice(&b);
215	+	if acc.windows(4).any(\|w\| w == [b'S', 0xff, 0xfe, b'E']) {
216	+	return true;
217	+	}
218	+	}
219	+	false
220	+	})
221	+	.await
222	+	.unwrap_or(false);
223	+
224	+	assert!(
225	+	found,
226	+	"raw bytes were mangled in transit; got {:x?}",
227	+	&acc[..acc.len().min(400)]
228	+	);
229	+	}
230	+
231	+	/// Exiting the shell must be reported, not silently hang the sidebar.
232	+	#[tokio::test]
233	+	async fn shell_exit_is_reported() {
234	+	let server = start(sh_profile()).await;
235	+	let mut ws = connect_authed(&server).await;
236	+	ws.send(Message::Text(
237	+	serde_json::json!({"type": "open", "cols": 80, "rows": 24})
238	+	.to_string()
239	+	.into(),
240	+	))
241	+	.await
242	+	.unwrap();
243	+	ws.send(Message::Binary(b"exit 7\n".to_vec().into()))
244	+	.await
245	+	.unwrap();
246	+
247	+	let got = tokio::time::timeout(Duration::from_secs(10), async {
248	+	while let Some(Ok(msg)) = ws.next().await {
249	+	if let Message::Text(t) = msg {
250	+	if t.contains("\"exit\"") {
251	+	return Some(t.to_string());
252	+	}
253	+	}
254	+	}
255	+	None
256	+	})
257	+	.await
258	+	.unwrap_or(None);
259	+
260	+	assert!(got.is_some(), "expected an exit message");
261	+	}
262	+
263	+	/// The client cannot choose what runs. Even authenticated, the protocol has no
264	+	/// field for argv — an auth bypass gets you the configured profile, not `exec`.
265	+	#[tokio::test]
266	+	async fn client_cannot_choose_the_program() {
267	+	let server = start(sh_profile()).await;
268	+	let mut ws = connect_authed(&server).await;
269	+
270	+	// Every field an attacker might hope is honoured.
271	+	ws.send(Message::Text(
272	+	serde_json::json!({
273	+	"type": "open", "cols": 80, "rows": 24,
274	+	"cmd": ["/bin/sh", "-c", "echo PWNED"],
275	+	"command": "echo PWNED",
276	+	"program": "/usr/bin/id",
277	+	"args": ["-a"],
278	+	"env": {"LD_PRELOAD": "/tmp/evil.so"}
279	+	})
280	+	.to_string()
281	+	.into(),
282	+	))
283	+	.await
284	+	.unwrap();
285	+
286	+	// Prove the session is the configured shell and that nothing else ran.
287	+	ws.send(Message::Binary(b"echo marker-$((6*7))\n".to_vec().into()))
288	+	.await
289	+	.unwrap();
290	+	let out = wait_for(&mut ws, "marker-42").await;
291	+	assert!(
292	+	!out.contains("PWNED"),
293	+	"client-supplied command was executed:\n{out}"
294	+	);
295	+	}
296	+
297	+	/// The whole reason tmux is the persistence layer: state must survive the
298	+	/// sidebar closing. Disconnect, reconnect, and the shell is still there.
299	+	#[tokio::test]
300	+	async fn tmux_session_survives_disconnect() {
301	+	if !Profile::tmux_available() {
302	+	eprintln!("skipping: tmux not installed");
303	+	return;
304	+	}
305	+	// Private socket + session so we never touch the user's real tmux.
306	+	let sock = "termbridge-test";
307	+	let sess = "termbridge-e2e";
308	+	let tmux = \|args: &[&str]\| {
309	+	std::process::Command::new("tmux")
310	+	.args(["-L", sock])
311	+	.args(args)
312	+	.output()
313	+	};
314	+	let _ = tmux(&["kill-server"]);
315	+
316	+	let profile = Profile {
317	+	program: "tmux".into(),
318	+	// Force /bin/sh: tmux's default-shell may be fish, whose assignment
319	+	// syntax differs. The test is about persistence, not shell dialects.
320	+	args: ["-L", sock, "new-session", "-A", "-s", sess, "/bin/sh"]
321	+	.iter()
322	+	.map(\|s\| s.to_string())
323	+	.collect(),
324	+	};
325	+
326	+	let server = start(profile).await;
327	+
328	+	// First attach: leave a marker in the shell's state.
329	+	{
330	+	let mut ws = connect_authed(&server).await;
331	+	ws.send(Message::Text(
332	+	serde_json::json!({"type": "open", "cols": 80, "rows": 24})
333	+	.to_string()
334	+	.into(),
335	+	))
336	+	.await
337	+	.unwrap();
338	+	wait_until_ready(&mut ws, "boot-one").await;
339	+	ws.send(Message::Binary(
340	+	b"MARKER=survived-the-disconnect\n".to_vec().into(),
341	+	))
342	+	.await
343	+	.unwrap();
344	+	ws.send(Message::Binary(b"echo first-attach-ok\n".to_vec().into()))
345	+	.await
346	+	.unwrap();
347	+	wait_for(&mut ws, "first-attach-ok").await;
348	+	ws.close(None).await.unwrap();
349	+	} // socket dropped == sidebar closed
350	+
351	+	tokio::time::sleep(Duration::from_millis(500)).await;
352	+
353	+	// Second attach: same session, shell variable still set.
354	+	{
355	+	let mut ws = connect_authed(&server).await;
356	+	ws.send(Message::Text(
357	+	serde_json::json!({"type": "open", "cols": 80, "rows": 24})
358	+	.to_string()
359	+	.into(),
360	+	))
361	+	.await
362	+	.unwrap();
363	+	wait_until_ready(&mut ws, "boot-two").await;
364	+	ws.send(Message::Binary(b"echo \"[$MARKER]\"\n".to_vec().into()))
365	+	.await
366	+	.unwrap();
367	+	wait_for(&mut ws, "[survived-the-disconnect]").await;
368	+	ws.close(None).await.unwrap();
369	+	}
370	+
371	+	let _ = tmux(&["kill-server"]);
372	+	}
373	+
374	+	// --- tmux session selection -------------------------------------------------
375	+
376	+	/// Session names reach `execvp` as a separate argv element, so shell
377	+	/// metacharacters cannot inject a command. A leading dash is the real hazard —
378	+	/// tmux would read it as a flag — and the charset check backs that up.
379	+	#[test]
380	+	fn session_name_validation() {
381	+	use termbridge::pty::valid_session_name as v;
382	+
383	+	for good in ["browser", "work", "my-session", "proj_2", "A1"] {
384	+	assert_eq!(v(good).as_deref(), Some(good), "{good} should be accepted");
385	+	}
386	+
387	+	for bad in [
388	+	"",
389	+	" ",
390	+	"-C", // tmux would read this as a flag
391	+	"--help",
392	+	"a b", // tmux disallows
393	+	"a.b", // tmux disallows '.'
394	+	"a:b", // tmux disallows ':'
395	+	"a/b",
396	+	"a;id",
397	+	"a$(id)",
398	+	"a`id`",
399	+	"a\|b",
400	+	"a&b",
401	+	"a\nb",
402	+	"a\0b",
403	+	"a'b",
404	+	"a\"b",
405	+	"../../etc/passwd",
406	+	"sess$IFS",
407	+	] {
408	+	assert_eq!(v(bad), None, "{bad:?} must be rejected");
409	+	}
410	+
411	+	assert_eq!(v(&"x".repeat(65)), None, "absurd length must be rejected");
412	+	assert_eq!(v(" padded ").as_deref(), Some("padded"), "trims");
413	+	}
414	+
415	+	/// A rejected session name must fall back to the default, never reach tmux, and
416	+	/// never change what program runs.
417	+	#[tokio::test]
418	+	async fn hostile_session_name_falls_back_and_cannot_inject() {
419	+	if !Profile::tmux_available() {
420	+	eprintln!("skipping: tmux not installed");
421	+	return;
422	+	}
423	+	let sock = "termbridge-inject";
424	+	let _ = std::process::Command::new("tmux")
425	+	.args(["-L", sock, "kill-server"])
426	+	.output();
427	+
428	+	// A tmux profile pinned to a private socket so the test is self-contained.
429	+	let profile = Profile {
430	+	program: "tmux".into(),
431	+	args: ["-L", sock, "new-session", "-A", "-s", "safe", "/bin/sh"]
432	+	.iter()
433	+	.map(\|s\| s.to_string())
434	+	.collect(),
435	+	};
436	+	let server = start(profile).await;
437	+	let mut ws = connect_authed(&server).await;
438	+
439	+	ws.send(Message::Text(
440	+	serde_json::json!({
441	+	"type": "open", "cols": 80, "rows": 24,
442	+	"session": "evil; touch /tmp/termbridge-pwned; #"
443	+	})
444	+	.to_string()
445	+	.into(),
446	+	))
447	+	.await
448	+	.unwrap();
449	+
450	+	wait_until_ready(&mut ws, "boot-inject").await;
451	+	ws.send(Message::Binary(b"echo marker-$((6*7))\n".to_vec().into()))
452	+	.await
453	+	.unwrap();
454	+	wait_for(&mut ws, "marker-42").await;
455	+
456	+	assert!(
457	+	!std::path::Path::new("/tmp/termbridge-pwned").exists(),
458	+	"session name was interpreted by a shell"
459	+	);
460	+
461	+	let _ = std::process::Command::new("tmux")
462	+	.args(["-L", sock, "kill-server"])
463	+	.output();
464	+	}
465	+
466	+	/// The status channel, end to end: the daemon's control-mode client reports
467	+	/// which session we're on, lists the others, and moves the live client when the
468	+	/// sidebar asks — all on a private tmux server so the user's own is untouched.
469	+	#[tokio::test]
470	+	async fn status_frames_track_the_session_and_switching_moves_the_client() {
471	+	if !Profile::tmux_available() {
472	+	eprintln!("skipping: tmux not installed");
473	+	return;
474	+	}
475	+	let sock = "termbridge-status-test";
476	+	let (first, second) = ("tb-status-one", "tb-status-two");
477	+	let tmux = \|args: &[&str]\| {
478	+	std::process::Command::new("tmux")
479	+	.args(["-L", sock])
480	+	.args(args)
481	+	.output()
482	+	};
483	+	let _ = tmux(&["kill-server"]);
484	+	let _ = tmux(&["new-session", "-d", "-s", second, "/bin/sh"]);
485	+
486	+	let profile = Profile {
487	+	program: "tmux".into(),
488	+	args: ["-L", sock, "new-session", "-A", "-s", first, "/bin/sh"]
489	+	.iter()
490	+	.map(\|s\| s.to_string())
491	+	.collect(),
492	+	};
493	+	let server = start(profile).await;
494	+	let mut ws = connect_authed(&server).await;
495	+	ws.send(Message::Text(
496	+	serde_json::json!({"type": "open", "cols": 80, "rows": 24})
497	+	.to_string()
498	+	.into(),
499	+	))
500	+	.await
501	+	.unwrap();
502	+
503	+	let on_first = next_status(&mut ws, first).await;
504	+	let names: Vec<&str> = on_first["sessions"]
505	+	.as_array()
506	+	.unwrap()
507	+	.iter()
508	+	.map(\|s\| s["name"].as_str().unwrap())
509	+	.collect();
510	+	assert!(
511	+	names.contains(&first) && names.contains(&second),
512	+	"switcher should see both sessions, got {names:?}"
513	+	);
514	+
515	+	// The whole point of doing this over control mode: no reconnect, no second
516	+	// pty, the same WebSocket keeps streaming.
517	+	ws.send(Message::Text(
518	+	serde_json::json!({"type": "tmux", "cmd": "switch", "session": second})
519	+	.to_string()
520	+	.into(),
521	+	))
522	+	.await
523	+	.unwrap();
524	+	next_status(&mut ws, second).await;
525	+
526	+	let _ = tmux(&["kill-server"]);
527	+	}
528	+
529	+	/// Read frames until a `status` frame reports `session`, ignoring terminal
530	+	/// output and the intermediate states tmux passes through.
531	+	async fn next_status(
532	+	ws: &mut tokio_tungstenite::WebSocketStream<
533	+	tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
534	+	>,
535	+	session: &str,
536	+	) -> serde_json::Value {
537	+	let mut seen = Vec::new();
538	+	let found = tokio::time::timeout(Duration::from_secs(20), async {
539	+	while let Some(Ok(msg)) = ws.next().await {
540	+	let Message::Text(t) = msg else { continue };
541	+	let Ok(v) = serde_json::from_str::<serde_json::Value>(&t) else {
542	+	continue;
543	+	};
544	+	if v["type"] != "status" {
545	+	continue;
546	+	}
547	+	seen.push(v["session"].as_str().unwrap_or("").to_string());
548	+	if v["session"] == session {
549	+	return Some(v);
550	+	}
551	+	}
552	+	None
553	+	})
554	+	.await
555	+	.ok()
556	+	.flatten();
557	+
558	+	found.unwrap_or_else(\|\| panic!("never saw a status frame for {session:?}; saw {seen:?}"))
559	+	}

	1	+	node_modules/
	2	+	dist/

1	+	# This file is automatically @generated by Cargo.
2	+	# It is not intended for manual editing.
3	+	version = 4
4	+
5	+	[[package]]
6	+	name = "anyhow"
7	+	version = "1.0.104"
8	+	source = "registry+https://github.com/rust-lang/crates.io-index"
9	+	checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
10	+
11	+	[[package]]
12	+	name = "asn1-rs"
13	+	version = "0.7.2"
14	+	source = "registry+https://github.com/rust-lang/crates.io-index"
15	+	checksum = "b7f43a50ac4fdca5df8e885c21b835997f0a1cdee65494a6847694a98652d9d8"
16	+	dependencies = [
17	+	"asn1-rs-derive",
18	+	"asn1-rs-impl",
19	+	"displaydoc",
20	+	"nom",
21	+	"num-traits",
22	+	"rusticata-macros",
23	+	"thiserror 2.0.19",
24	+	"time",
25	+	]
26	+
27	+	[[package]]
28	+	name = "asn1-rs-derive"
29	+	version = "0.6.0"
30	+	source = "registry+https://github.com/rust-lang/crates.io-index"
31	+	checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
32	+	dependencies = [
33	+	"proc-macro2",
34	+	"quote",
35	+	"syn 2.0.119",
36	+	"synstructure",
37	+	]
38	+
39	+	[[package]]
40	+	name = "asn1-rs-impl"

1	+	{
2	+	// Type checking without a build step. Nothing here compiles anything: the
3	+	// browser loads these .js files exactly as they are on disk, and
4	+	// `npm run check` only reads them.
5	+	//
6	+	// Shared by the two realms the manifest actually creates — see
7	+	// jsconfig.json (sidebar document) and jsconfig.sw.json (service worker).
8	+	// They are separate projects because they are separate global scopes: both
9	+	// declare `const api` at the top level, and only one of them has a `window`.
10	+	"compilerOptions": {
11	+	"checkJs": true,
12	+	"noEmit": true,
13	+	"target": "ES2022",
14	+	"strict": true,
15	+	"noFallthroughCasesInSwitch": true,
16	+
17	+	// These files are classic scripts, not modules — one shared global scope,
18	+	// which is how sidebar.js reaches Themes, Sanitize and tbPickElement
19	+	// without importing anything. Nothing here may introduce import/export
20	+	// syntax, or that stops being true.
21	+	"types": []
22	+	}
23	+	}

1	+	{
2	+	// The sidebar document: everything sidebar.html loads. This is the config
3	+	// editors pick up by default.
4	+	"extends": "./jsconfig.base.json",
5	+	"compilerOptions": {
6	+	"lib": ["ES2022", "DOM", "DOM.Iterable"]
7	+	},
8	+	"include": ["sidebar.js", "picker.js", "lib/*.js", "types/globals.d.ts"],
9	+	"exclude": ["lib/*.test.js"]
10	+	}

1	+	//! Regression tests for the four properties we committed to:
2	+	//!
3	+	//! 1. bind to loopback only
4	+	//! 2. Origin allowlist (blocks hostile web pages)
5	+	//! 3. 0600 token file (blocks other local uids)
6	+	//! 4. explicit pairing (never trust-on-first-use silently)
7	+	//!
8	+	//! Each is something that is easy to get right once and then quietly regress,
9	+	//! which is exactly what tests are for. The reference implementation we looked
10	+	//! at got #1 and #3 right and #2 and #4 wrong, and the result was that any
11	+	//! website could open a shell.
12	+
13	+	use std::net::{IpAddr, SocketAddr};
14	+	use std::time::Duration;
15	+
16	+	use futures_util::{SinkExt, StreamExt};
17	+	use tokio_tungstenite::tungstenite::client::IntoClientRequest;
18	+	use tokio_tungstenite::tungstenite::http::StatusCode;
19	+	use tokio_tungstenite::tungstenite::{Error as WsError, Message};
20	+	use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
21	+
22	+	use termbridge::auth::{self, Denied};
23	+	use termbridge::{paths, Config, Server};
24	+
25	+	const GOOD_TOKEN: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
26	+	const PAIRED: &str = "chrome-extension://abcdefghijklmnopabcdefghijklmnop";
27	+	const UNPAIRED: &str = "https://evil.example";
28	+
29	+	type Client = WebSocketStream<MaybeTlsStream<tokio::net::TcpStream>>;
30	+
31	+	fn test_config() -> Config {
32	+	let mut c = Config::new(GOOD_TOKEN, vec![PAIRED.to_string()]);
33	+	c.auth_timeout = Duration::from_millis(300);
34	+	// Exercise auth without spawning real shells.
35	+	c.echo_only = true;
36	+	c
37	+	}
38	+
39	+	async fn start(config: Config) -> Server {
40	+	Server::start(config, 0).await.expect("bind ephemeral port")
41	+	}
42	+
43	+	/// Connect with full control over Origin and Host, the two headers an attacker
44	+	/// would want to lie about.
45	+	async fn connect(
46	+	server: &Server,
47	+	origin: Option<&str>,
48	+	host_override: Option<&str>,
49	+	query: &str,
50	+	) -> Result<Client, WsError> {
51	+	let url = format!("{}{}", server.url(), query);
52	+	let mut req = url.into_client_request().unwrap();
53	+	if let Some(o) = origin {
54	+	req.headers_mut().insert("origin", o.parse().unwrap());
55	+	}
56	+	if let Some(h) = host_override {
57	+	req.headers_mut().insert("host", h.parse().unwrap());
58	+	}
59	+	connect_async(req).await.map(\|(ws, _)\| ws)
60	+	}
61	+
62	+	fn rejected_with(err: &WsError, expect: StatusCode) -> bool {
63	+	matches!(err, WsError::Http(resp) if resp.status() == expect)
64	+	}
65	+
66	+	/// A client that got through the handshake and sent a valid auth frame.
67	+	async fn authed(server: &Server) -> Client {
68	+	let mut ws = connect(server, Some(PAIRED), None, "").await.expect("handshake");
69	+	ws.send(Message::Text(
70	+	serde_json::json!({"type": "auth", "token": GOOD_TOKEN})
71	+	.to_string()
72	+	.into(),
73	+	))
74	+	.await
75	+	.unwrap();
76	+	let reply = ws.next().await.unwrap().unwrap();
77	+	assert!(
78	+	reply.to_text().unwrap().contains("\"ok\""),
79	+	"expected ok, got {reply:?}"
80	+	);
81	+	ws
82	+	}
83	+
84	+	// ---------------------------------------------------------------------------
85	+	// 1. Bind to loopback only
86	+	// ---------------------------------------------------------------------------
87	+
88	+	#[tokio::test]
89	+	async fn listener_address_is_loopback() {
90	+	let server = start(test_config()).await;
91	+	assert!(
92	+	server.addr().ip().is_loopback(),
93	+	"listening on {} — must be loopback",
94	+	server.addr()
95	+	);
96	+	}
97	+
98	+	/// The listener must not be reachable on this machine's LAN address. Without
99	+	/// this, a laptop on café wifi is serving shells to the network.
100	+	#[tokio::test]
101	+	async fn not_reachable_on_lan_interface() {
102	+	let server = start(test_config()).await;
103	+	let port = server.addr().port();
104	+
105	+	let Some(lan_ip) = outbound_interface_ip() else {
106	+	eprintln!("skipping: no non-loopback interface available");
107	+	return;
108	+	};
109	+
110	+	let target = SocketAddr::new(lan_ip, port);
111	+	let res = tokio::time::timeout(
112	+	Duration::from_millis(500),
113	+	tokio::net::TcpStream::connect(target),
114	+	)
115	+	.await;
116	+
117	+	match res {
118	+	Ok(Ok(_)) => panic!("connected to {target} — daemon is exposed on the network"),
119	+	_ => { /* refused or timed out, as required */ }
120	+	}
121	+	}
122	+
123	+	/// Guards against someone adding a `--bind` flag or flipping the constant.
124	+	/// A config option to listen on 0.0.0.0 has no legitimate use here and only
125	+	/// creates a remotely exploitable setup.
126	+	#[test]
127	+	fn source_never_binds_wildcard() {
128	+	let src = std::fs::read_to_string("src/server.rs").unwrap();
129	+	for needle in ["0.0.0.0", "UNSPECIFIED", "[::]"] {
130	+	assert!(
131	+	!src.contains(needle),
132	+	"src/server.rs mentions `{needle}` — the bind address must stay loopback-only"
133	+	);
134	+	}
135	+	}
136	+
137	+	// ---------------------------------------------------------------------------
138	+	// 2. Origin check — the defense against hostile web pages
139	+	// ---------------------------------------------------------------------------
140	+
141	+	/// WebSocket has no CORS preflight, so any page you visit can open a socket to
142	+	/// 127.0.0.1. `Origin` is browser-set and unforgeable from page JS, so this is
143	+	/// the check that actually stops that.
144	+	#[tokio::test]
145	+	async fn rejects_unpaired_origin() {
146	+	let server = start(test_config()).await;
147	+	let err = connect(&server, Some(UNPAIRED), None, "")
148	+	.await
149	+	.expect_err("hostile origin must be refused at handshake");
150	+	assert!(rejected_with(&err, StatusCode::FORBIDDEN), "got {err:?}");
151	+	}
152	+
153	+	/// Even with a stolen token. Origin and token are independent gates.
154	+	#[tokio::test]
155	+	async fn unpaired_origin_rejected_even_with_valid_token() {
156	+	let server = start(test_config()).await;
157	+	let err = connect(&server, Some(UNPAIRED), None, "")
158	+	.await
159	+	.expect_err("must fail before the token is ever considered");
160	+	assert!(rejected_with(&err, StatusCode::FORBIDDEN), "got {err:?}");
161	+	}
162	+
163	+	#[tokio::test]
164	+	async fn rejects_missing_origin() {
165	+	let server = start(test_config()).await;
166	+	let err = connect(&server, None, None, "")
167	+	.await
168	+	.expect_err("no Origin must be refused");
169	+	assert!(rejected_with(&err, StatusCode::FORBIDDEN), "got {err:?}");
170	+	}
171	+
172	+	#[tokio::test]
173	+	async fn rejects_null_origin() {
174	+	let server = start(test_config()).await;
175	+	let err = connect(&server, Some("null"), None, "")
176	+	.await
177	+	.expect_err("sandboxed-iframe `null` origin must be refused");
178	+	assert!(rejected_with(&err, StatusCode::FORBIDDEN), "got {err:?}");
179	+	}
180	+
181	+	/// DNS rebinding: attacker.com resolves to 127.0.0.1, so the page reaches us
182	+	/// while carrying its own origin. The Host header is what gives it away.
183	+	#[tokio::test]
184	+	async fn rejects_rebound_host_header() {
185	+	let server = start(test_config()).await;
186	+	let err = connect(&server, Some(PAIRED), Some("attacker.example"), "")
187	+	.await
188	+	.expect_err("non-loopback Host must be refused");
189	+	assert!(rejected_with(&err, StatusCode::FORBIDDEN), "got {err:?}");
190	+	}
191	+
192	+	#[test]
193	+	fn host_header_parsing() {
194	+	for good in ["127.0.0.1", "127.0.0.1:7681", "localhost", "localhost:7681", "[::1]:7681"] {
195	+	assert!(auth::host_is_loopback(good), "{good} should be loopback");
196	+	}
197	+	for bad in [
198	+	"attacker.example",
199	+	"attacker.example:7681",
200	+	"127.0.0.1.attacker.example",
201	+	"localhost.attacker.example",
202	+	"192.168.1.5:7681",
203	+	"",
204	+	] {
205	+	assert!(!auth::host_is_loopback(bad), "{bad} must not pass");
206	+	}
207	+	}
208	+
209	+	// ---------------------------------------------------------------------------
210	+	// 3. Token
211	+	// ---------------------------------------------------------------------------
212	+
213	+	#[tokio::test]
214	+	async fn rejects_wrong_token() {
215	+	let server = start(test_config()).await;
216	+	let mut ws = connect(&server, Some(PAIRED), None, "").await.unwrap();
217	+	ws.send(Message::Text(
218	+	serde_json::json!({"type": "auth", "token": "wrong"})
219	+	.to_string()
220	+	.into(),
221	+	))
222	+	.await
223	+	.unwrap();
224	+	let reply = ws.next().await.unwrap().unwrap();
225	+	assert!(reply.to_text().unwrap().contains("invalid token"), "{reply:?}");
226	+	}
227	+
228	+	#[tokio::test]
229	+	async fn rejects_missing_auth_frame() {
230	+	let server = start(test_config()).await;
231	+	let mut ws = connect(&server, Some(PAIRED), None, "").await.unwrap();
232	+	// Say nothing. The deadline must close us.
233	+	let outcome = tokio::time::timeout(Duration::from_secs(2), async {
234	+	while let Some(Ok(m)) = ws.next().await {
235	+	if let Message::Text(t) = &m {
236	+	if t.contains("auth timeout") {
237	+	return true;
238	+	}
239	+	}
240	+	}
241	+	false
242	+	})
243	+	.await
244	+	.expect("server must not leave an unauthenticated socket open");
245	+	assert!(outcome, "expected an auth timeout rejection");
246	+	}
247	+
248	+	/// Sending data before authenticating must not reach the terminal.
249	+	#[tokio::test]
250	+	async fn rejects_data_frame_before_auth() {
251	+	let server = start(test_config()).await;
252	+	let mut ws = connect(&server, Some(PAIRED), None, "").await.unwrap();
253	+	ws.send(Message::Binary(b"rm -rf ~\n".to_vec().into()))
254	+	.await
255	+	.unwrap();
256	+	let reply = ws.next().await.unwrap().unwrap();
257	+	assert!(
258	+	reply.to_text().unwrap().contains("malformed auth"),
259	+	"pre-auth data must be refused, got {reply:?}"
260	+	);
261	+	}
262	+
263	+	/// The token must not be accepted from the query string. Query strings leak
264	+	/// into logs, crash dumps and devtools history, and the browser WebSocket API
265	+	/// makes putting it there the path of least resistance.
266	+	#[tokio::test]
267	+	async fn query_string_token_does_not_authenticate() {
268	+	let server = start(test_config()).await;
269	+	let mut ws = connect(&server, Some(PAIRED), None, &format!("/?token={GOOD_TOKEN}"))
270	+	.await
271	+	.unwrap();
272	+	let outcome = tokio::time::timeout(Duration::from_secs(2), async {
273	+	while let Some(Ok(m)) = ws.next().await {
274	+	if let Message::Text(t) = &m {
275	+	if t.contains("\"ok\"") {
276	+	return false; // authenticated via URL — bad
277	+	}
278	+	if t.contains("auth timeout") {
279	+	return true;
280	+	}
281	+	}
282	+	}
283	+	false
284	+	})
285	+	.await
286	+	.expect("must not hang");
287	+	assert!(outcome, "query-string token must not authenticate");
288	+	}
289	+
290	+	#[test]
291	+	fn token_compare_rejects_wrong_length_and_content() {
292	+	assert!(auth::token_matches(GOOD_TOKEN, GOOD_TOKEN));
293	+	assert!(!auth::token_matches("", GOOD_TOKEN));
294	+	assert!(!auth::token_matches(&GOOD_TOKEN[..63], GOOD_TOKEN));
295	+	assert!(!auth::token_matches(&format!("{GOOD_TOKEN}x"), GOOD_TOKEN));
296	+	// Differs only in the final byte — a short-circuiting compare would leak
297	+	// this via timing.
298	+	let mut near = GOOD_TOKEN.to_string();
299	+	near.pop();
300	+	near.push('0');
301	+	assert!(!auth::token_matches(&near, GOOD_TOKEN));
302	+	}
303	+
304	+	#[test]
305	+	fn generated_token_file_is_0600() {
306	+	use std::os::unix::fs::PermissionsExt;
307	+	let dir = tempfile::tempdir().unwrap();
308	+	let token = paths::generate_token(dir.path()).unwrap();
309	+
310	+	assert_eq!(token.len(), paths::TOKEN_BYTES * 2, "expected 32 random bytes as hex");
311	+
312	+	let mode = std::fs::metadata(dir.path().join("token"))
313	+	.unwrap()
314	+	.permissions()
315	+	.mode()
316	+	& 0o777;
317	+	assert_eq!(mode, 0o600, "token file mode is {mode:04o}, must be 0600");
318	+
319	+	let dir_mode = std::fs::metadata(dir.path()).unwrap().permissions().mode() & 0o777;
320	+	assert_eq!(dir_mode, 0o700, "config dir mode is {dir_mode:04o}, must be 0700");
321	+	}
322	+
323	+	/// If the mode ever loosens, refuse rather than authenticate against a secret
324	+	/// every user on the box can read.
325	+	#[test]
326	+	fn load_token_refuses_group_or_world_readable_file() {
327	+	use std::os::unix::fs::PermissionsExt;
328	+	for bad_mode in [0o644, 0o640, 0o604, 0o666] {
329	+	let dir = tempfile::tempdir().unwrap();
330	+	paths::generate_token(dir.path()).unwrap();
331	+	std::fs::set_permissions(
332	+	dir.path().join("token"),
333	+	std::fs::Permissions::from_mode(bad_mode),
334	+	)
335	+	.unwrap();
336	+	assert!(
337	+	paths::load_token(dir.path()).is_err(),
338	+	"mode {bad_mode:04o} must be refused"
339	+	);
340	+	}
341	+	}
342	+
343	+	#[test]
344	+	fn tokens_are_unique_across_generations() {
345	+	let a = paths::generate_token(tempfile::tempdir().unwrap().path()).unwrap();
346	+	let b = paths::generate_token(tempfile::tempdir().unwrap().path()).unwrap();
347	+	assert_ne!(a, b);
348	+	}
349	+
350	+	// ---------------------------------------------------------------------------
351	+	// 4. Explicit pairing
352	+	// ---------------------------------------------------------------------------
353	+
354	+	/// A fresh install must grant nothing. No implicit trust-on-first-use.
355	+	#[tokio::test]
356	+	async fn fresh_install_pairs_nothing() {
357	+	let mut cfg = Config::new(GOOD_TOKEN, vec![]);
358	+	cfg.echo_only = true;
359	+	let server = start(cfg).await;
360	+	let err = connect(&server, Some(PAIRED), None, "")
361	+	.await
362	+	.expect_err("with no paired origins, everything is refused");
363	+	assert!(rejected_with(&err, StatusCode::FORBIDDEN), "got {err:?}");
364	+	}
365	+
366	+	#[test]
367	+	fn connecting_does_not_pair_itself() {
368	+	let dir = tempfile::tempdir().unwrap();
369	+	assert!(paths::load_paired_origins(dir.path()).is_empty());
370	+	// Pairing only ever happens through the explicit CLI path.
371	+	assert!(!auth::origin_is_paired(PAIRED, &paths::load_paired_origins(dir.path())));
372	+	}
373	+
374	+	#[test]
375	+	fn pair_and_unpair_round_trip() {
376	+	let dir = tempfile::tempdir().unwrap();
377	+	assert!(paths::pair_origin(dir.path(), PAIRED).unwrap());
378	+	assert!(!paths::pair_origin(dir.path(), PAIRED).unwrap(), "idempotent");
379	+	assert_eq!(paths::load_paired_origins(dir.path()), vec![PAIRED.to_string()]);
380	+
381	+	assert!(paths::unpair_origin(dir.path(), PAIRED).unwrap());
382	+	assert!(paths::load_paired_origins(dir.path()).is_empty());
383	+	}
384	+
385	+	/// Firefox's moz-extension origin is a random per-install UUID, so pairing must
386	+	/// work with an origin that cannot be known ahead of time.
387	+	#[test]
388	+	fn pairs_firefox_random_uuid_origin() {
389	+	let dir = tempfile::tempdir().unwrap();
390	+	let ff = "moz-extension://11111111-2222-3333-4444-555555555555";
391	+	paths::pair_origin(dir.path(), ff).unwrap();
392	+	let paired = paths::load_paired_origins(dir.path());
393	+	assert!(auth::origin_is_paired(ff, &paired));
394	+	assert!(auth::origin_is_paired(&ff.to_uppercase(), &paired), "case-insensitive");
395	+	assert!(!auth::origin_is_paired(
396	+	"moz-extension://99999999-2222-3333-4444-555555555555",
397	+	&paired
398	+	));
399	+	}
400	+
401	+	/// Pairing one origin must not imply its neighbours — no prefix or substring
402	+	/// matching. `chrome-extension://` as a blanket allow would let any other
403	+	/// installed extension through.
404	+	#[test]
405	+	fn pairing_is_exact_match_not_prefix() {
406	+	let paired = vec![PAIRED.to_string()];
407	+	for near_miss in [
408	+	"chrome-extension://",
409	+	"chrome-extension://abcdefghijklmnopabcdefghijklmnoq",
410	+	"chrome-extension://abcdefghijklmnopabcdefghijklmnop.evil.example",
411	+	"https://abcdefghijklmnopabcdefghijklmnop",
412	+	] {
413	+	assert!(
414	+	!auth::origin_is_paired(near_miss, &paired),
415	+	"{near_miss} must not match"
416	+	);
417	+	}
418	+	}
419	+
420	+	// ---------------------------------------------------------------------------
421	+	// Happy path + rate limiting
422	+	// ---------------------------------------------------------------------------
423	+
424	+	#[tokio::test]
425	+	async fn paired_origin_with_valid_token_is_accepted() {
426	+	let server = start(test_config()).await;
427	+	let _ws = authed(&server).await;
428	+	}
429	+
430	+	/// Binary frames survive round-trip untouched — this is what makes the
431	+	/// WebSocket transport worth it over native messaging's JSON-only channel.
432	+	/// Includes a lone continuation byte, which is invalid UTF-8 and would have to
433	+	/// be base64'd or mangled on a JSON transport.
434	+	#[tokio::test]
435	+	async fn binary_frames_round_trip_invalid_utf8() {
436	+	let server = start(test_config()).await;
437	+	let mut ws = authed(&server).await;
438	+
439	+	let raw: Vec<u8> = vec![0x1b, b'[', b'3', b'1', b'm', 0xff, 0xfe, 0x80, b'o', b'k'];
440	+	ws.send(Message::Binary(raw.clone().into())).await.unwrap();
441	+	let echoed = ws.next().await.unwrap().unwrap();
442	+	match echoed {
443	+	Message::Binary(b) => assert_eq!(b.as_ref(), raw.as_slice()),
444	+	other => panic!("expected binary echo, got {other:?}"),
445	+	}
446	+	}
447	+
448	+	#[tokio::test]
449	+	async fn repeated_failures_trigger_lockout() {
450	+	let mut config = test_config();
451	+	config.max_failures = 3;
452	+	config.lockout = Duration::from_secs(60);
453	+	let server = start(config).await;
454	+
455	+	for _ in 0..3 {
456	+	let _ = connect(&server, Some(UNPAIRED), None, "").await;
457	+	}
458	+
459	+	// Even a legitimate client is now refused, with 429 rather than 403.
460	+	let err = connect(&server, Some(PAIRED), None, "")
461	+	.await
462	+	.expect_err("must be locked out");
463	+	assert!(
464	+	rejected_with(&err, StatusCode::TOO_MANY_REQUESTS),
465	+	"expected 429, got {err:?}"
466	+	);
467	+	}
468	+
469	+	/// A plain HTTP request is not an auth failure, and must not be reported as
470	+	/// one — that sends you debugging tokens when the problem is the connection.
471	+	#[tokio::test]
472	+	async fn plain_http_request_is_reported_as_not_a_websocket() {
473	+	use tokio::io::AsyncWriteExt;
474	+	let mut server = start(test_config()).await;
475	+
476	+	let mut sock = tokio::net::TcpStream::connect(server.addr()).await.unwrap();
477	+	sock.write_all(
478	+	format!(
479	+	"GET / HTTP/1.1\r\nHost: 127.0.0.1:{}\r\nOrigin: {PAIRED}\r\n\r\n",
480	+	server.addr().port()
481	+	)
482	+	.as_bytes(),
483	+	)
484	+	.await
485	+	.unwrap();
486	+
487	+	let ev = tokio::time::timeout(Duration::from_secs(3), server.next_event())
488	+	.await
489	+	.expect("expected a rejection event")
490	+	.unwrap();
491	+
492	+	match ev {
493	+	termbridge::Event::Rejected { why, detail, .. } => {
494	+	assert_eq!(
495	+	why,
496	+	Denied::NotAWebSocketUpgrade,
497	+	"a non-upgrade request must not be blamed on auth"
498	+	);
499	+	assert!(detail.is_some(), "the real cause must be reported");
500	+	}
501	+	other => panic!("expected Rejected, got {other:?}"),
502	+	}
503	+	}
504	+
505	+	/// A wss:// attempt against a daemon started without a TLS identity must be
506	+	/// named, not reported as a parse failure. (With TLS configured it is served
507	+	/// normally — see tests/tls.rs.)
508	+	#[tokio::test]
509	+	async fn tls_client_hello_is_named() {
510	+	use tokio::io::AsyncWriteExt;
511	+	let mut server = start(test_config()).await;
512	+
513	+	let mut sock = tokio::net::TcpStream::connect(server.addr()).await.unwrap();
514	+	// Opening bytes of a TLS 1.x ClientHello record.
515	+	sock.write_all(&[0x16, 0x03, 0x01, 0x00, 0x2f, 0x01]).await.unwrap();
516	+
517	+	let ev = tokio::time::timeout(Duration::from_secs(3), server.next_event())
518	+	.await
519	+	.expect("expected a rejection event")
520	+	.unwrap();
521	+
522	+	match ev {
523	+	termbridge::Event::Rejected { why, detail, .. } => {
524	+	assert_eq!(why, Denied::TlsAttempted);
525	+	assert!(
526	+	detail.unwrap().contains("without a TLS identity"),
527	+	"the message should say what to do about it"
528	+	);
529	+	}
530	+	other => panic!("expected Rejected, got {other:?}"),
531	+	}
532	+	}
533	+
534	+	#[test]
535	+	fn denied_reasons_are_stable() {
536	+	assert_eq!(Denied::UnpairedOrigin.status(), 403);
537	+	assert_eq!(Denied::RateLimited.status(), 429);
538	+	}
539	+
540	+	// ---------------------------------------------------------------------------
541	+
542	+	/// Discover this host's outbound interface address without sending packets.
543	+	fn outbound_interface_ip() -> Option<IpAddr> {
544	+	let sock = std::net::UdpSocket::bind("0.0.0.0:0").ok()?;
545	+	sock.connect("192.0.2.1:9").ok()?; // TEST-NET-1, never routed
546	+	let ip = sock.local_addr().ok()?.ip();
547	+	(!ip.is_loopback() && !ip.is_unspecified()).then_some(ip)
548	+	}

1	+	//! TLS is a new attack surface, so it gets the same scrutiny as the rest.
2	+	//!
3	+	//! The rule under test: enabling wss:// must not weaken anything. Every check
4	+	//! that applies over ws:// applies identically over wss://, and the private key
5	+	//! is guarded like the token.
6	+
7	+	use std::sync::Arc;
8	+	use std::time::Duration;
9	+
10	+	use futures_util::{SinkExt, StreamExt};
11	+	use tokio_rustls::rustls::pki_types::ServerName;
12	+	use tokio_tungstenite::tungstenite::client::IntoClientRequest;
13	+	use tokio_tungstenite::tungstenite::Message;
14	+
15	+	use termbridge::{tls, Config, Server};
16	+
17	+	const TOKEN: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
18	+	const PAIRED: &str = "chrome-extension://abcdefghijklmnopabcdefghijklmnop";
19	+	const UNPAIRED: &str = "https://evil.example";
20	+
21	+	fn identity(dir: &std::path::Path) -> tls::Identity {
22	+	tls::load_or_create(dir).unwrap()
23	+	}
24	+
25	+	async fn start_tls(dir: &std::path::Path, paired: Vec<String>) -> Server {
26	+	let mut cfg = Config::new(TOKEN, paired);
27	+	cfg.echo_only = true;
28	+	cfg.auth_timeout = Duration::from_millis(500);
29	+	cfg.tls = Some(tls::acceptor(&identity(dir)).unwrap());
30	+	Server::start(cfg, 0).await.unwrap()
31	+	}
32	+
33	+	/// A client that trusts only our generated certificate — the browser's position
34	+	/// after the user accepts the exception.
35	+	fn client_config(id: &tls::Identity) -> Arc<tokio_rustls::rustls::ClientConfig> {
36	+	let mut roots = tokio_rustls::rustls::RootCertStore::empty();
37	+	for block in id.cert_pem.split("-----BEGIN CERTIFICATE-----").skip(1) {
38	+	let body = block.split("-----END CERTIFICATE-----").next().unwrap();
39	+	let der = pem_body_to_der(body);
40	+	roots.add(der.into()).unwrap();
41	+	}
42	+	Arc::new(
43	+	tokio_rustls::rustls::ClientConfig::builder()
44	+	.with_root_certificates(roots)
45	+	.with_no_client_auth(),
46	+	)
47	+	}
48	+
49	+	fn pem_body_to_der(body: &str) -> Vec<u8> {
50	+	const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
51	+	let mut rev = [255u8; 256];
52	+	for (i, c) in T.iter().enumerate() {
53	+	rev[*c as usize] = i as u8;
54	+	}
55	+	let (mut out, mut acc, mut bits) = (Vec::new(), 0u32, 0u32);
56	+	for c in body.bytes().filter(\|c\| !c.is_ascii_whitespace()) {
57	+	if c == b'=' {
58	+	break;
59	+	}
60	+	acc = (acc << 6) \| rev[c as usize] as u32;
61	+	bits += 6;
62	+	if bits >= 8 {
63	+	bits -= 8;
64	+	out.push((acc >> bits) as u8);
65	+	}
66	+	}
67	+	out
68	+	}
69	+
70	+	async fn tls_connect(
71	+	server: &Server,
72	+	id: &tls::Identity,
73	+	origin: Option<&str>,
74	+	) -> Result<
75	+	tokio_tungstenite::WebSocketStream<
76	+	tokio_rustls::client::TlsStream<tokio::net::TcpStream>,
77	+	>,
78	+	tokio_tungstenite::tungstenite::Error,
79	+	> {
80	+	let connector = tokio_rustls::TlsConnector::from(client_config(id));
81	+	let tcp = tokio::net::TcpStream::connect(server.addr()).await.unwrap();
82	+	let dnsname = ServerName::try_from("127.0.0.1").unwrap();
83	+	let stream = connector
84	+	.connect(dnsname, tcp)
85	+	.await
86	+	.map_err(tokio_tungstenite::tungstenite::Error::Io)?;
87	+
88	+	let mut req = format!("wss://{}/", server.addr())
89	+	.into_client_request()
90	+	.unwrap();
91	+	if let Some(o) = origin {
92	+	req.headers_mut().insert("origin", o.parse().unwrap());
93	+	}
94	+	tokio_tungstenite::client_async(req, stream)
95	+	.await
96	+	.map(\|(ws, _)\| ws)
97	+	}
98	+
99	+	// ---------------------------------------------------------------------------
100	+
101	+	#[tokio::test]
102	+	async fn wss_happy_path() {
103	+	let dir = tempfile::tempdir().unwrap();
104	+	let id = identity(dir.path());
105	+	let server = start_tls(dir.path(), vec![PAIRED.to_string()]).await;
106	+
107	+	let mut ws = tls_connect(&server, &id, Some(PAIRED)).await.unwrap();
108	+	ws.send(Message::Text(
109	+	serde_json::json!({"type": "auth", "token": TOKEN})
110	+	.to_string()
111	+	.into(),
112	+	))
113	+	.await
114	+	.unwrap();
115	+	let reply = ws.next().await.unwrap().unwrap();
116	+	assert!(reply.to_text().unwrap().contains("\"ok\""), "{reply:?}");
117	+	}
118	+
119	+	/// The whole point of the change: one port serves both, so Firefox's HTTPS-Only
120	+	/// rewrite and Chrome's plain ws:// both work without configuration.
121	+	#[tokio::test]
122	+	async fn same_port_serves_plaintext_too() {
123	+	let dir = tempfile::tempdir().unwrap();
124	+	let server = start_tls(dir.path(), vec![PAIRED.to_string()]).await;
125	+
126	+	let mut req = server.url().into_client_request().unwrap();
127	+	req.headers_mut().insert("origin", PAIRED.parse().unwrap());
128	+	let (mut ws, _) = tokio_tungstenite::connect_async(req).await.unwrap();
129	+	ws.send(Message::Text(
130	+	serde_json::json!({"type": "auth", "token": TOKEN})
131	+	.to_string()
132	+	.into(),
133	+	))
134	+	.await
135	+	.unwrap();
136	+	let reply = ws.next().await.unwrap().unwrap();
137	+	assert!(reply.to_text().unwrap().contains("\"ok\""), "{reply:?}");
138	+	}
139	+
140	+	/// TLS must not become a way around the origin allowlist.
141	+	#[tokio::test]
142	+	async fn origin_check_still_applies_over_tls() {
143	+	let dir = tempfile::tempdir().unwrap();
144	+	let id = identity(dir.path());
145	+	let server = start_tls(dir.path(), vec![PAIRED.to_string()]).await;
146	+
147	+	let err = tls_connect(&server, &id, Some(UNPAIRED))
148	+	.await
149	+	.expect_err("unpaired origin must be refused over wss too");
150	+	assert!(
151	+	matches!(&err, tokio_tungstenite::tungstenite::Error::Http(r) if r.status() == 403),
152	+	"got {err:?}"
153	+	);
154	+	}
155	+
156	+	#[tokio::test]
157	+	async fn token_check_still_applies_over_tls() {
158	+	let dir = tempfile::tempdir().unwrap();
159	+	let id = identity(dir.path());
160	+	let server = start_tls(dir.path(), vec![PAIRED.to_string()]).await;
161	+
162	+	let mut ws = tls_connect(&server, &id, Some(PAIRED)).await.unwrap();
163	+	ws.send(Message::Text(
164	+	serde_json::json!({"type": "auth", "token": "wrong"})
165	+	.to_string()
166	+	.into(),
167	+	))
168	+	.await
169	+	.unwrap();
170	+	let reply = ws.next().await.unwrap().unwrap();
171	+	assert!(reply.to_text().unwrap().contains("invalid token"), "{reply:?}");
172	+	}
173	+
174	+	#[tokio::test]
175	+	async fn missing_origin_still_refused_over_tls() {
176	+	let dir = tempfile::tempdir().unwrap();
177	+	let id = identity(dir.path());
178	+	let server = start_tls(dir.path(), vec![PAIRED.to_string()]).await;
179	+
180	+	let err = tls_connect(&server, &id, None)
181	+	.await
182	+	.expect_err("no Origin must be refused over wss too");
183	+	assert!(
184	+	matches!(&err, tokio_tungstenite::tungstenite::Error::Http(r) if r.status() == 403),
185	+	"got {err:?}"
186	+	);
187	+	}
188	+
189	+	// --- key material -----------------------------------------------------------
190	+
191	+	#[test]
192	+	fn private_key_is_0600_and_cert_is_not_secret() {
193	+	use std::os::unix::fs::PermissionsExt;
194	+	let dir = tempfile::tempdir().unwrap();
195	+	tls::generate(dir.path()).unwrap();
196	+
197	+	let key_mode = std::fs::metadata(dir.path().join(tls::KEY_FILE))
198	+	.unwrap()
199	+	.permissions()
200	+	.mode()
201	+	& 0o777;
202	+	assert_eq!(key_mode, 0o600, "private key mode is {key_mode:04o}");
203	+
204	+	let dir_mode = std::fs::metadata(dir.path()).unwrap().permissions().mode() & 0o777;
205	+	assert_eq!(dir_mode, 0o700);
206	+	}
207	+
208	+	#[test]
209	+	fn refuses_a_world_readable_private_key() {
210	+	use std::os::unix::fs::PermissionsExt;
211	+	let dir = tempfile::tempdir().unwrap();
212	+	tls::generate(dir.path()).unwrap();
213	+	std::fs::set_permissions(
214	+	dir.path().join(tls::KEY_FILE),
215	+	std::fs::Permissions::from_mode(0o644),
216	+	)
217	+	.unwrap();
218	+	assert!(
219	+	tls::load_or_create(dir.path()).is_err(),
220	+	"a group/world readable key must be refused, not used"
221	+	);
222	+	}
223	+
224	+	#[test]
225	+	fn certificate_is_not_a_ca() {
226	+	// Trusting our cert must not let it vouch for any other host. A CA cert in
227	+	// the browser's trust store would be a far bigger grant than intended.
228	+	let dir = tempfile::tempdir().unwrap();
229	+	let id = tls::generate(dir.path()).unwrap();
230	+	let der = pem_body_to_der(
231	+	id.cert_pem
232	+	.split("-----BEGIN CERTIFICATE-----")
233	+	.nth(1)
234	+	.unwrap()
235	+	.split("-----END CERTIFICATE-----")
236	+	.next()
237	+	.unwrap(),
238	+	);
239	+	// basicConstraints CA:TRUE encodes as 30 03 01 01 FF inside the extension.
240	+	let ca_true: &[u8] = &[0x30, 0x03, 0x01, 0x01, 0xff];
241	+	assert!(
242	+	!der.windows(ca_true.len()).any(\|w\| w == ca_true),
243	+	"certificate asserts CA:TRUE"
244	+	);
245	+	}
246	+
247	+	#[test]
248	+	fn identity_is_stable_across_loads() {
249	+	let dir = tempfile::tempdir().unwrap();
250	+	let a = tls::load_or_create(dir.path()).unwrap();
251	+	let b = tls::load_or_create(dir.path()).unwrap();
252	+	assert_eq!(a.fingerprint, b.fingerprint, "cert must not churn per start");
253	+	assert_eq!(a.fingerprint.len(), 32 * 3 - 1, "SHA-256 hex with colons");
254	+
255	+	let c = tls::generate(dir.path()).unwrap();
256	+	assert_ne!(a.fingerprint, c.fingerprint, "--regenerate must make a new one");
257	+	}
258	+
259	+	/// The landing page exists so the certificate-trust visit is comprehensible.
260	+	/// It must never leak the token — that is the exact mistake that made the
261	+	/// reference implementation remotely exploitable.
262	+	#[tokio::test]
263	+	async fn landing_page_does_not_leak_the_token() {
264	+	use tokio::io::{AsyncReadExt, AsyncWriteExt};
265	+	let dir = tempfile::tempdir().unwrap();
266	+	let server = start_tls(dir.path(), vec![PAIRED.to_string()]).await;
267	+
268	+	let mut sock = tokio::net::TcpStream::connect(server.addr()).await.unwrap();
269	+	sock.write_all(
270	+	format!("GET / HTTP/1.1\r\nHost: 127.0.0.1:{}\r\n\r\n", server.addr().port()).as_bytes(),
271	+	)
272	+	.await
273	+	.unwrap();
274	+
275	+	let mut body = Vec::new();
276	+	let _ = tokio::time::timeout(Duration::from_secs(2), sock.read_to_end(&mut body)).await;
277	+	let text = String::from_utf8_lossy(&body);
278	+
279	+	assert!(text.contains("200 OK"), "expected the landing page, got:\n{text}");
280	+	assert!(!text.contains(TOKEN), "landing page leaked the auth token");
281	+	assert!(
282	+	!text.to_lowercase().contains("\"token\""),
283	+	"landing page exposes a token field"
284	+	);
285	+	}

1	+	{
2	+	// The service worker: sw.js plus the one file it importScripts. It keeps the
3	+	// DOM lib even though a worker has no DOM — picker.js only defines
4	+	// tbPickElement here; the body runs in the page, injected by
5	+	// scripting.executeScript, and has to be checked against the page's globals.
6	+	// (lib.webworker and lib.dom cannot both be loaded — they redeclare each
7	+	// other. `importScripts` is declared in types/worker.d.ts instead.)
8	+	"extends": "./jsconfig.base.json",
9	+	"compilerOptions": {
10	+	"lib": ["ES2022", "DOM", "DOM.Iterable"]
11	+	},
12	+	"include": ["sw.js", "picker.js", "lib/shot.js", "types/globals.d.ts", "types/worker.d.ts"]
13	+	}

1	+	// Turning page-controlled text into something safe to type at a live shell.
2	+	//
3	+	// Everything here treats its input as hostile. A selector is built from
4	+	// attributes the page chose — an id, an aria-label, a class name — so a page
5	+	// can put anything it likes in there, including a newline. A newline typed into
6	+	// a terminal is a pressed Enter key, which is arbitrary code execution.
7	+	//
8	+	// Two independent defenses, both required:
9	+	// 1. strip control characters, so nothing can submit a line or drive the
10	+	// terminal's own escape-sequence parser;
11	+	// 2. single-quote the result, so shell metacharacters are inert.
12	+	//
13	+	// Pure functions, no DOM — so they can be tested under `node --test`.
14	+
15	+	/** Hard cap. Nothing legitimate is this long; a 10MB "selector" is an attack. */
16	+	const MAX_LEN = 4096;
17	+
18	+	/**
19	+	* Remove every C0 control character, DEL, and the Unicode line separators.
20	+	*
21	+	* \r and \n are the dangerous ones (they execute). ESC matters too: xterm.js
22	+	* feeds what we send straight to the pty, and an escape sequence could drive
23	+	* an application's own input handling. \t is dropped as well — it triggers
24	+	* shell completion, which can execute in some configurations.
25	+	*
26	+	* @param {unknown} input anything at all — callers pass page-controlled values
27	+	*/
28	+	function stripControl(input) {
29	+	const text = String(input ?? "");
30	+	// C0 controls (covers NUL, TAB, LF, CR, ESC), DEL, and the Unicode line
31	+	// separators, which some terminals also treat as line breaks.
32	+	return text.replace(/[\u0000-\u001F\u007F\u2028\u2029]/g, "");
33	+	}
34	+
35	+	/**
36	+	* POSIX single-quoting. Inside single quotes the shell interprets nothing, so
37	+	* $, `, ;, &, \|, newline and friends are all literal. The only character that
38	+	* needs handling is the single quote itself, which we close/escape/reopen.
39	+	*
40	+	* @param {unknown} input
41	+	*/
42	+	function shellQuote(input) {
43	+	const text = String(input ?? "");
44	+	return "'" + text.replace(/'/g, "'\\''") + "'";
45	+	}
46	+
47	+	/**
48	+	* The full pipeline for text that is about to be written to the pty.
49	+	*
50	+	* Returns the safe string plus what had to be removed, so the UI can tell the
51	+	* user rather than silently altering what they picked.
52	+	*
53	+	* @param {unknown} input
54	+	*/
55	+	function forTerminal(input) {
56	+	const raw = String(input ?? "");
57	+	const truncated = raw.length > MAX_LEN;
58	+	const capped = truncated ? raw.slice(0, MAX_LEN) : raw;
59	+	const stripped = stripControl(capped);
60	+	return {
61	+	text: shellQuote(stripped),
62	+	removedControl: stripped.length !== capped.length,
63	+	truncated,
64	+	};
65	+	}
66	+
67	+	/**
68	+	* For the system clipboard. Control characters still come out — a newline in
69	+	* the clipboard is not execution — but a paste into a terminal would be, and
70	+	* some terminals paste without bracketed-paste protection. Same treatment,
71	+	* minus the shell quoting, which would be noise in an editor.
72	+	*
73	+	* @param {unknown} input
74	+	*/
75	+	function forClipboard(input) {
76	+	const raw = String(input ?? "");
77	+	const capped = raw.length > MAX_LEN ? raw.slice(0, MAX_LEN) : raw;
78	+	return stripControl(capped);
79	+	}
80	+
81	+	const Sanitize = { stripControl, shellQuote, forTerminal, forClipboard, MAX_LEN };
82	+
83	+	if (typeof module !== "undefined" && module.exports) {
84	+	module.exports = Sanitize;
85	+	}

1	+	// Run with: node --test "extension/lib/*.test.js"
2	+	//
3	+	// This is the boundary between page-controlled text and a live shell. Every
4	+	// case below is something a hostile (or merely careless) page can put in an
5	+	// id, a class, or an aria-label.
6	+
7	+	const test = require("node:test");
8	+	const assert = require("node:assert");
9	+	const { execFileSync } = require("node:child_process");
10	+	const S = require("./sanitize.js");
11	+
12	+	test("newlines are removed — a newline in a terminal is a pressed Enter", () => {
13	+	for (const nl of ["\n", "\r", "\r\n", "\u2028", "\u2029"]) {
14	+	const { text } = S.forTerminal(`a${nl}whoami`);
15	+	assert.strictEqual(text, "'awhoami'", `newline survived: ${JSON.stringify(text)}`);
16	+	}
17	+	});
18	+
19	+	test("the classic injection payload cannot execute", () => {
20	+	const { text } = S.forTerminal("x'; rm -rf ~; echo '");
21	+	// Single-quoted, with the embedded quotes neutralised. Handing this to sh
22	+	// yields one literal argument.
23	+	assert.strictEqual(text, "'x'\\''; rm -rf ~; echo '\\'''");
24	+	});
25	+
26	+	test("shell metacharacters are inert inside single quotes", () => {
27	+	for (const payload of [
28	+	"$(whoami)",
29	+	"`id`",
30	+	"${HOME}",
31	+	"a && b",
32	+	"a \|\| b",
33	+	"a; b",
34	+	"a \| b",
35	+	"a > /etc/passwd",
36	+	"~/secrets",
37	+	"*",
38	+	"$IFS",
39	+	]) {
40	+	const { text } = S.forTerminal(payload);
41	+	assert.strictEqual(text, `'${payload}'`, `mangled: ${payload}`);
42	+	}
43	+	});
44	+
45	+	test("escape sequences are stripped, not passed to the terminal", () => {
46	+	const { text, removedControl } = S.forTerminal("\u001b]0;pwned\u0007ok");
47	+	assert.ok(!text.includes("\u001b"), "ESC survived");
48	+	assert.ok(!text.includes("\u0007"), "BEL survived");
49	+	assert.strictEqual(text, "']0;pwnedok'");
50	+	assert.ok(removedControl, "should report that something was removed");
51	+	});
52	+
53	+	test("tab is stripped — it triggers shell completion", () => {
54	+	assert.strictEqual(S.forTerminal("a\tb").text, "'ab'");
55	+	});
56	+
57	+	test("NUL and other C0 controls are stripped", () => {
58	+	assert.strictEqual(S.forTerminal("a\u0000b\u0001c").text, "'abc'");
59	+	});
60	+
61	+	test("removedControl is false for ordinary input", () => {
62	+	const { text, removedControl, truncated } = S.forTerminal("#main > div.card");
63	+	assert.strictEqual(text, "'#main > div.card'");
64	+	assert.strictEqual(removedControl, false);
65	+	assert.strictEqual(truncated, false);
66	+	});
67	+
68	+	test("absurdly long input is capped and reported", () => {
69	+	const { text, truncated } = S.forTerminal("a".repeat(S.MAX_LEN * 3));
70	+	assert.ok(truncated);
71	+	assert.ok(text.length <= S.MAX_LEN + 2);
72	+	});
73	+
74	+	// The real proof: hand the quoted string to an actual shell and check it comes
75	+	// back byte-for-byte as a single argument.
76	+	test("quoting survives a round trip through sh", () => {
77	+	for (const payload of [
78	+	"x'; rm -rf ~; echo '",
79	+	"$(id)",
80	+	"it's a `test`",
81	+	'double "quotes" too',
82	+	"back\\slash",
83	+	"#main > div.card:nth-of-type(2)",
84	+	"//*[@id='thing']",
85	+	]) {
86	+	const { text } = S.forTerminal(payload);
87	+	const out = execFileSync("/bin/sh", ["-c", `printf %s ${text}`], {
88	+	encoding: "utf8",
89	+	});
90	+	assert.strictEqual(out, payload, `sh did not treat it as one literal: ${payload}`);
91	+	}
92	+	});
93	+
94	+	// A newline must not become a second command even when sh evaluates the line.
95	+	test("an injected newline cannot start a second command in sh", () => {
96	+	const { text } = S.forTerminal("harmless\nid");
97	+	const out = execFileSync("/bin/sh", ["-c", `printf %s ${text}`], {
98	+	encoding: "utf8",
99	+	});
100	+	assert.strictEqual(out, "harmlessid");
101	+	assert.ok(!/uid=/.test(out), "a second command ran");
102	+	});
103	+
104	+	test("clipboard output strips controls but does not shell-quote", () => {
105	+	assert.strictEqual(S.forClipboard("#main > .card"), "#main > .card");
106	+	assert.strictEqual(S.forClipboard("a\nwhoami"), "awhoami");
107	+	assert.strictEqual(S.forClipboard("it's"), "it's");
108	+	});
109	+
110	+	test("null and undefined do not throw", () => {
111	+	assert.strictEqual(S.forTerminal(null).text, "''");
112	+	assert.strictEqual(S.forTerminal(undefined).text, "''");
113	+	assert.strictEqual(S.forClipboard(null), "");
114	+	});

1	+	// Cropping a picked element out of a tab screenshot and putting it on the
2	+	// system clipboard.
3	+	//
4	+	// Why the clipboard rather than a file: the daemon runs on the same machine as
5	+	// the browser, so the PNG the browser copies is the PNG an agent running in the
6	+	// pty reads back when it sees a ^V. That gives us an image handoff without the
7	+	// extension ever writing to disk or the daemon growing a file-upload path.
8	+	//
9	+	// Loaded by both the sidebar (a document) and the background worker (no DOM),
10	+	// so nothing here may touch `document` outside a function that only the sidebar
11	+	// calls. `createImageBitmap`, `OffscreenCanvas` and `btoa` exist in both.
12	+
13	+	/** Padding around the element's box, in CSS pixels. Enough to see its edge. */
14	+	const SHOT_PAD = 4;
15	+
16	+	/** @param {string} b64 */
17	+	function base64ToBytes(b64) {
18	+	const bin = atob(b64);
19	+	const out = new Uint8Array(bin.length);
20	+	for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
21	+	return out;
22	+	}
23	+
24	+	/** @param {Uint8Array} bytes */
25	+	function bytesToBase64(bytes) {
26	+	// Chunked: String.fromCharCode blows the argument limit on a whole PNG.
27	+	let s = "";
28	+	const CHUNK = 0x8000;
29	+	for (let i = 0; i < bytes.length; i += CHUNK) {
30	+	s += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
31	+	}
32	+	return btoa(s);
33	+	}
34	+
35	+	/**
36	+	* A `data:` URL is decoded by hand rather than with `fetch`, because a page's
37	+	* CSP can forbid fetching one and this code also runs injected into pages.
38	+	*
39	+	* @param {string} dataUrl
40	+	*/
41	+	function dataUrlBytes(dataUrl) {
42	+	const comma = dataUrl.indexOf(",");
43	+	if (comma < 0) throw new Error("not a data URL");
44	+	return base64ToBytes(dataUrl.slice(comma + 1));
45	+	}
46	+
47	+	/**
48	+	* Cut the element's box out of a full-viewport screenshot.
49	+	*
50	+	* The scale factor comes from the captured image's own width rather than
51	+	* devicePixelRatio: browser zoom, HiDPI and Chrome's own capture downscaling
52	+	* all move the two apart, and the ratio the image reports is the true one.
53	+	*
54	+	* @param {string} dataUrl PNG data URL of the visible tab
55	+	* @param {TbPickedRect} rect element box in CSS pixels, viewport-relative
56	+	* @param {{ w: number; h: number }} viewport CSS pixel size of the viewport
57	+	* @returns {Promise<Uint8Array>} PNG bytes
58	+	*/
59	+	async function cropShot(dataUrl, rect, viewport) {
60	+	const bmp = await createImageBitmap(new Blob([dataUrlBytes(dataUrl)], { type: "image/png" }));
61	+	const scale = viewport.w > 0 ? bmp.width / viewport.w : 1;
62	+
63	+	// Clamp to the viewport: an element can hang off the edge, and drawImage
64	+	// silently produces transparent pixels for the part that isn't there.
65	+	const left = Math.max(0, rect.x - SHOT_PAD);
66	+	const top = Math.max(0, rect.y - SHOT_PAD);
67	+	const right = Math.min(viewport.w, rect.x + rect.width + SHOT_PAD);
68	+	const bottom = Math.min(viewport.h, rect.y + rect.height + SHOT_PAD);
69	+
70	+	const sx = Math.round(left * scale);
71	+	const sy = Math.round(top * scale);
72	+	const sw = Math.round((right - left) * scale);
73	+	const sh = Math.round((bottom - top) * scale);
74	+	if (sw < 1 \|\| sh < 1) throw new Error("element is not visible in the viewport");
75	+
76	+	const canvas = new OffscreenCanvas(sw, sh);
77	+	const ctx = canvas.getContext("2d");
78	+	if (!ctx) throw new Error("no 2d context");
79	+	ctx.drawImage(bmp, sx, sy, sw, sh, 0, 0, sw, sh);
80	+	bmp.close();
81	+
82	+	const blob = await canvas.convertToBlob({ type: "image/png" });
83	+	return new Uint8Array(await blob.arrayBuffer());
84	+	}
85	+
86	+	/**
87	+	* Put a PNG on the clipboard from inside the page.
88	+	*
89	+	* Serialised into the tab by executeScript, so it must be self-contained. It
90	+	* runs in the isolated world — page script can neither see it nor tamper with
91	+	* the `navigator.clipboard` it calls.
92	+	*
93	+	* The page is where this has to happen: the async clipboard API refuses to
94	+	* write from a document that isn't focused, and after you click an element the
95	+	* focused document is the page, not the side panel.
96	+	*
97	+	* @param {string} b64 base64 PNG
98	+	* @returns {Promise<true \| string>} true, or the failure to report
99	+	*/
100	+	async function tbCopyPngInPage(b64) {
101	+	try {
102	+	const bin = atob(b64);
103	+	const bytes = new Uint8Array(bin.length);
104	+	for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
105	+	const blob = new Blob([bytes], { type: "image/png" });
106	+	await navigator.clipboard.write([new ClipboardItem({ "image/png": blob })]);
107	+	return true;
108	+	} catch (e) {
109	+	return e instanceof Error ? e.message : String(e);
110	+	}
111	+	}
112	+
113	+	/**
114	+	* Screenshot the picked element and leave it on the system clipboard.
115	+	*
116	+	* Three routes, in order of how little they can go wrong:
117	+	* 1. Firefox's `clipboard.setImageData`, which is an extension API and so
118	+	* needs neither a focused document nor a content script;
119	+	* 2. the calling document, when it happens to hold focus;
120	+	* 3. the page, via injection — the usual case right after a pick.
121	+	*
122	+	* @param {TbExtensionApi} api
123	+	* @param {number \| undefined} tabId
124	+	* @param {TbPicked} picked
125	+	* @returns {Promise<true \| string>} true, or why not
126	+	*/
127	+	async function copyPickedShot(api, tabId, picked) {
128	+	if (!picked.rect \|\| !picked.viewport) return "no element geometry";
129	+	let png;
130	+	try {
131	+	const dataUrl = await api.tabs.captureVisibleTab({ format: "png" });
132	+	png = await cropShot(dataUrl, picked.rect, picked.viewport);
133	+	} catch (e) {
134	+	return e instanceof Error ? e.message : String(e);
135	+	}
136	+
137	+	if (api.clipboard?.setImageData) {
138	+	try {
139	+	// Firefox wants a plain ArrayBuffer, and a subarray's buffer may be larger.
140	+	const buf = /** @type {ArrayBuffer} */ (
141	+	png.buffer.slice(png.byteOffset, png.byteOffset + png.byteLength)
142	+	);
143	+	await api.clipboard.setImageData(buf, "png");
144	+	return true;
145	+	} catch (e) {
146	+	// Fall through — the injected route may still work.
147	+	}
148	+	}
149	+
150	+	const b64 = bytesToBase64(png);
151	+
152	+	if (typeof document !== "undefined" && document.hasFocus()) {
153	+	const direct = await tbCopyPngInPage(b64);
154	+	if (direct === true) return true;
155	+	}
156	+
157	+	if (tabId == null) return "no tab to copy from";
158	+	try {
159	+	const results = await api.scripting.executeScript({
160	+	target: { tabId },
161	+	func: tbCopyPngInPage,
162	+	args: [b64],
163	+	});
164	+	const r = results?.[0]?.result;
165	+	return r === true ? true : String(r ?? "clipboard write did not run");
166	+	} catch (e) {
167	+	return e instanceof Error ? e.message : String(e);
168	+	}
169	+	}
170	+
171	+	const Shot = { cropShot, copyPickedShot, SHOT_PAD };
172	+
173	+	if (typeof module !== "undefined" && module.exports) {
174	+	module.exports = Shot;
175	+	}

1	+	// Terminal + sidebar palettes.
2	+	//
3	+	// One source of truth. `ui` becomes CSS custom properties on :root, `xterm`
4	+	// goes to term.options.theme — so the chrome and the terminal can never drift
5	+	// apart, which is the usual failure mode when a theme is half in CSS and half
6	+	// in JS.
7	+	//
8	+	// Pure data plus one function, so `node --test` can check the palettes are
9	+	// complete and actually readable.
10	+
11	+	const THEMES = {
12	+	dark: {
13	+	name: "dark",
14	+	colorScheme: "dark",
15	+	ui: {
16	+	"--bg": "#14161a",
17	+	"--bg-panel": "#1c1f25",
18	+	"--bg-input": "#14161a",
19	+	"--border": "#2d3138",
20	+	"--fg": "#d7dae0",
21	+	"--fg-muted": "#8b93a1",
22	+	"--accent": "#3b6ea5",
23	+	"--accent-hover": "#4a82bd",
24	+	"--accent-fg": "#ffffff",
25	+	"--ok": "#6ec177",
26	+	"--err": "#e06c75",
27	+	"--warn": "#d5a458",
28	+	"--warn-bg": "#241f16",
29	+	"--warn-border": "#4a3a22",
30	+	"--shadow": "rgba(0,0,0,.4)",
31	+	},
32	+	xterm: {
33	+	background: "#14161a",
34	+	foreground: "#d7dae0",
35	+	cursor: "#d7dae0",
36	+	cursorAccent: "#14161a",
37	+	selectionBackground: "#3b6ea5",
38	+	selectionForeground: "#ffffff",
39	+	black: "#2d3138",
40	+	red: "#e06c75",
41	+	green: "#6ec177",
42	+	yellow: "#d5a458",
43	+	blue: "#61afef",
44	+	magenta: "#c678dd",
45	+	cyan: "#56b6c2",
46	+	white: "#d7dae0",
47	+	brightBlack: "#6b7280",
48	+	brightRed: "#ff7b86",
49	+	brightGreen: "#86d98f",
50	+	brightYellow: "#e8c07d",
51	+	brightBlue: "#7fb3e8",
52	+	brightMagenta: "#d7a3e8",
53	+	brightCyan: "#6fd0dd",
54	+	brightWhite: "#ffffff",
55	+	},
56	+	},
57	+
58	+	light: {
59	+	name: "light",
60	+	colorScheme: "light",
61	+	ui: {
62	+	"--bg": "#ffffff",
63	+	"--bg-panel": "#f6f8fa",
64	+	"--bg-input": "#ffffff",
65	+	"--border": "#d0d7de",
66	+	"--fg": "#1f2328",
67	+	"--fg-muted": "#656d76",
68	+	"--accent": "#0969da",
69	+	"--accent-hover": "#0550ae",
70	+	"--accent-fg": "#ffffff",
71	+	"--ok": "#1a7f37",
72	+	"--err": "#cf222e",
73	+	"--warn": "#9a6700",
74	+	"--warn-bg": "#fff8c5",
75	+	"--warn-border": "#d4a72c",
76	+	"--shadow": "rgba(31,35,40,.15)",
77	+	},
78	+	xterm: {
79	+	background: "#ffffff",
80	+	foreground: "#1f2328",
81	+	cursor: "#1f2328",
82	+	cursorAccent: "#ffffff",
83	+	selectionBackground: "#b6d7ff",
84	+	selectionForeground: "#1f2328",
85	+	// Deliberately the darker end of each hue: these sit on white, and the
86	+	// usual bright terminal colours are unreadable there.
87	+	black: "#1f2328",
88	+	red: "#cf222e",
89	+	green: "#116329",
90	+	yellow: "#7d4e00",
91	+	blue: "#0550ae",
92	+	magenta: "#8250df",
93	+	cyan: "#1b7c83",
94	+	white: "#6e7781",
95	+	brightBlack: "#57606a",
96	+	brightRed: "#a40e26",
97	+	brightGreen: "#1a7f37",
98	+	brightYellow: "#9a6700",
99	+	brightBlue: "#0969da",
100	+	brightMagenta: "#6639ba",
101	+	brightCyan: "#3192aa",
102	+	brightWhite: "#7f8894",
103	+	},
104	+	},
105	+	};
106	+
107	+	/** Preference values the UI offers, in cycle order. */
108	+	const PREFERENCES = ["auto", "light", "dark"];
109	+
110	+	/**
111	+	* Resolve a stored preference to a concrete theme.
112	+	* `auto` follows the browser, which follows the OS.
113	+	*
114	+	* @param {string} preference one of PREFERENCES; anything else means `auto`
115	+	* @param {boolean} prefersDark what the browser says the OS wants
116	+	*/
117	+	function resolveTheme(preference, prefersDark) {
118	+	if (preference === "light") return THEMES.light;
119	+	if (preference === "dark") return THEMES.dark;
120	+	return prefersDark ? THEMES.dark : THEMES.light;
121	+	}
122	+
123	+	const Themes = { THEMES, PREFERENCES, resolveTheme };
124	+
125	+	if (typeof module !== "undefined" && module.exports) {
126	+	module.exports = Themes;
127	+	}

1	+	// Run with: node --test "extension/lib/*.test.js"
2	+	//
3	+	// A light terminal theme is easy to get wrong: the standard ANSI palette is
4	+	// tuned for dark backgrounds, and dropping it onto white produces yellow you
5	+	// cannot read. These tests check every colour against its own background.
6	+
7	+	const test = require("node:test");
8	+	const assert = require("node:assert");
9	+	const { THEMES, PREFERENCES, resolveTheme } = require("./theme.js");
10	+
11	+	// --- WCAG relative luminance / contrast ------------------------------------
12	+
13	+	function srgbToLinear(c) {
14	+	const v = c / 255;
15	+	return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
16	+	}
17	+
18	+	function luminance(hex) {
19	+	const m = /^#([0-9a-f]{6})$/i.exec(hex);
20	+	assert.ok(m, `not a 6-digit hex colour: ${hex}`);
21	+	const n = parseInt(m[1], 16);
22	+	const [r, g, b] = [(n >> 16) & 255, (n >> 8) & 255, n & 255];
23	+	return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);
24	+	}
25	+
26	+	function contrast(a, b) {
27	+	const [x, y] = [luminance(a), luminance(b)].sort((p, q) => q - p);
28	+	return (x + 0.05) / (y + 0.05);
29	+	}
30	+
31	+	test("contrast helper matches known values", () => {
32	+	assert.ok(Math.abs(contrast("#000000", "#ffffff") - 21) < 0.01);
33	+	assert.strictEqual(contrast("#123456", "#123456"), 1);
34	+	});
35	+
36	+	// --- structure --------------------------------------------------------------
37	+
38	+	test("both themes define exactly the same keys", () => {
39	+	const { light, dark } = THEMES;
40	+	assert.deepStrictEqual(Object.keys(light.ui).sort(), Object.keys(dark.ui).sort());
41	+	assert.deepStrictEqual(Object.keys(light.xterm).sort(), Object.keys(dark.xterm).sort());
42	+	});
43	+
44	+	test("the full 16-colour ANSI palette is present", () => {
45	+	const ansi = [
46	+	"black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
47	+	"brightBlack", "brightRed", "brightGreen", "brightYellow",
48	+	"brightBlue", "brightMagenta", "brightCyan", "brightWhite",
49	+	];
50	+	for (const theme of Object.values(THEMES)) {
51	+	for (const name of ansi) {
52	+	assert.ok(theme.xterm[name], `${theme.name} is missing ${name}`);
53	+	}
54	+	}
55	+	});
56	+
57	+	// --- readability ------------------------------------------------------------
58	+
59	+	test("body text meets WCAG AA (4.5:1)", () => {
60	+	for (const theme of Object.values(THEMES)) {
61	+	const c = contrast(theme.xterm.foreground, theme.xterm.background);
62	+	assert.ok(c >= 4.5, `${theme.name}: foreground on background is ${c.toFixed(2)}:1`);
63	+	const ui = contrast(theme.ui["--fg"], theme.ui["--bg"]);
64	+	assert.ok(ui >= 4.5, `${theme.name}: --fg on --bg is ${ui.toFixed(2)}:1`);
65	+	}
66	+	});
67	+
68	+	test("muted text still meets AA for large text (3:1)", () => {
69	+	for (const theme of Object.values(THEMES)) {
70	+	const c = contrast(theme.ui["--fg-muted"], theme.ui["--bg-panel"]);
71	+	assert.ok(c >= 3, `${theme.name}: --fg-muted on --bg-panel is ${c.toFixed(2)}:1`);
72	+	}
73	+	});
74	+
75	+	test("every ANSI colour is legible on its own background", () => {
76	+	// 3:1 is the WCAG threshold for non-text/large text. Terminal output is
77	+	// mostly small, but demanding 4.5 across all 16 slots would force a palette
78	+	// with no hue separation left.
79	+	const MIN = 3;
80	+	for (const theme of Object.values(THEMES)) {
81	+	const bg = theme.xterm.background;
82	+	for (const [name, colour] of Object.entries(theme.xterm)) {
83	+	if (["background", "cursorAccent", "selectionBackground"].includes(name)) continue;
84	+	// Black is the background-ish slot by definition; it is used as a
85	+	// foreground only in inverse video.
86	+	if (name === "black" && theme.name === "dark") continue;
87	+	const c = contrast(colour, bg);
88	+	assert.ok(c >= MIN, `${theme.name}: ${name} (${colour}) on ${bg} is ${c.toFixed(2)}:1`);
89	+	}
90	+	}
91	+	});
92	+
93	+	test("accent buttons are readable", () => {
94	+	for (const theme of Object.values(THEMES)) {
95	+	const c = contrast(theme.ui["--accent-fg"], theme.ui["--accent"]);
96	+	assert.ok(c >= 4.5, `${theme.name}: accent text is ${c.toFixed(2)}:1`);
97	+	}
98	+	});
99	+
100	+	test("selected text is readable against the selection highlight", () => {
101	+	for (const theme of Object.values(THEMES)) {
102	+	const c = contrast(theme.xterm.selectionForeground, theme.xterm.selectionBackground);
103	+	assert.ok(c >= 4.5, `${theme.name}: selection is ${c.toFixed(2)}:1`);
104	+	}
105	+	});
106	+
107	+	test("the two themes are actually different", () => {
108	+	assert.notStrictEqual(THEMES.light.xterm.background, THEMES.dark.xterm.background);
109	+	assert.ok(
110	+	luminance(THEMES.light.xterm.background) > luminance(THEMES.dark.xterm.background),
111	+	"light should be lighter than dark",
112	+	);
113	+	});
114	+
115	+	// --- preference resolution --------------------------------------------------
116	+
117	+	test("auto follows the system", () => {
118	+	assert.strictEqual(resolveTheme("auto", true).name, "dark");
119	+	assert.strictEqual(resolveTheme("auto", false).name, "light");
120	+	});
121	+
122	+	test("explicit choices override the system", () => {
123	+	assert.strictEqual(resolveTheme("light", true).name, "light");
124	+	assert.strictEqual(resolveTheme("dark", false).name, "dark");
125	+	});
126	+
127	+	test("an unknown or missing preference degrades to auto", () => {
128	+	assert.strictEqual(resolveTheme(undefined, true).name, "dark");
129	+	assert.strictEqual(resolveTheme("chartreuse", false).name, "light");
130	+	});
131	+
132	+	test("every offered preference resolves", () => {
133	+	for (const p of PREFERENCES) {
134	+	assert.ok(resolveTheme(p, false).name, `${p} did not resolve`);
135	+	assert.ok(resolveTheme(p, true).name, `${p} did not resolve`);
136	+	}
137	+	});

1	+	{
2	+	"manifest_version": 3,
3	+	"name": "terminal",
4	+	"version": "0.0.1",
5	+	"description": "A tmux terminal in your browser sidebar.",
6	+	"permissions": [
7	+	"storage",
8	+	"sidePanel",
9	+	"tabs",
10	+	"activeTab",
11	+	"scripting",
12	+	"clipboardWrite"
13	+	],
14	+	"background": {
15	+	"service_worker": "sw.js"
16	+	},
17	+	"action": {
18	+	"default_title": "terminal",
19	+	"default_icon": {
20	+	"16": "icons/icon16.png",
21	+	"32": "icons/icon32.png",
22	+	"48": "icons/icon48.png",
23	+	"128": "icons/icon128.png"
24	+	}
25	+	},
26	+	"side_panel": {
27	+	"default_path": "sidebar.html"
28	+	},
29	+	"icons": {
30	+	"16": "icons/icon16.png",
31	+	"32": "icons/icon32.png",
32	+	"48": "icons/icon48.png",
33	+	"128": "icons/icon128.png"
34	+	},
35	+	"commands": {
36	+	"pick-element": {
37	+	"suggested_key": {
38	+	"default": "Alt+Shift+P"
39	+	},
40	+	"description": "Pick an element on the page"
41	+	}
42	+	},
43	+	"host_permissions": [
44	+	"http://localhost/*",
45	+	"https://localhost/*",
46	+	"http://.localhost/",
47	+	"https://.localhost/",
48	+	"http://127.0.0.1/*",
49	+	"https://127.0.0.1/*"
50	+	],
51	+	"optional_host_permissions": [
52	+	":///*",
53	+	"<all_urls>"
54	+	]
55	+	}

1	+	// The element picker that gets injected into the page.
2	+	//
3	+	// This function is serialised and executed in the page's world via
4	+	// scripting.executeScript, so it must be entirely self-contained — no imports,
5	+	// no closures over extension state. It has no extension privileges.
6	+	//
7	+	// It returns a Promise, and executeScript resolves to that promise's value.
8	+	// That means the result comes back as a return value rather than through
9	+	// runtime.sendMessage, so the sidebar needs no inbound message listener that a
10	+	// content script could reach.
11	+
12	+	function tbPickElement() {
13	+	return new Promise((resolve) => {
14	+	const PREV = "__tbPickerActive";
15	+	if (window[PREV]) {
16	+	window[PREV]();
17	+	}
18	+
19	+	const box = document.createElement("div");
20	+	Object.assign(box.style, {
21	+	position: "fixed",
22	+	zIndex: "2147483647",
23	+	pointerEvents: "none",
24	+	border: "2px solid #3b6ea5",
25	+	background: "rgba(59,110,165,0.15)",
26	+	borderRadius: "2px",
27	+	transition: "all 40ms linear",
28	+	});
29	+
30	+	const label = document.createElement("div");
31	+	Object.assign(label.style, {
32	+	position: "fixed",
33	+	zIndex: "2147483647",
34	+	pointerEvents: "none",
35	+	font: "12px ui-monospace, monospace",
36	+	background: "#14161a",
37	+	color: "#d7dae0",
38	+	padding: "3px 6px",
39	+	borderRadius: "3px",
40	+	maxWidth: "60vw",
41	+	overflow: "hidden",
42	+	textOverflow: "ellipsis",
43	+	whiteSpace: "nowrap",
44	+	boxShadow: "0 2px 8px rgba(0,0,0,.4)",
45	+	});
46	+
47	+	document.documentElement.append(box, label);
48	+
49	+	/** Element under the cursor, so a click resolves what the box is drawn on. */
50	+	let current = /** @type {Element \| null} */ (null);
51	+
52	+	const cleanup = () => {
53	+	window[PREV] = null;
54	+	box.remove();
55	+	label.remove();
56	+	document.removeEventListener("mousemove", onMove, true);
57	+	document.removeEventListener("click", onClick, true);
58	+	document.removeEventListener("keydown", onKey, true);
59	+	window.removeEventListener("scroll", onScroll, true);
60	+	};
61	+	window[PREV] = () => {
62	+	cleanup();
63	+	resolve(null);
64	+	};
65	+
66	+	/** @param {Element} el */
67	+	function paint(el) {
68	+	const r = el.getBoundingClientRect();
69	+	Object.assign(box.style, {
70	+	left: `${r.left}px`,
71	+	top: `${r.top}px`,
72	+	width: `${r.width}px`,
73	+	height: `${r.height}px`,
74	+	});
75	+	label.textContent = shortLabel(el);
76	+	const below = r.bottom + 22 < window.innerHeight;
77	+	label.style.left = `${Math.max(2, r.left)}px`;
78	+	label.style.top = below ? `${r.bottom + 3}px` : `${Math.max(2, r.top - 21)}px`;
79	+	}
80	+
81	+	/** @param {MouseEvent} e */
82	+	function onMove(e) {
83	+	const hit = /** @type {Element \| null} */ (e.target);
84	+	const el =
85	+	hit && hit !== box && hit !== label
86	+	? hit
87	+	: document.elementFromPoint(e.clientX ?? 0, e.clientY ?? 0);
88	+	if (!el \|\| el.nodeType !== 1 \|\| el === box \|\| el === label) return;
89	+	current = el;
90	+	paint(el);
91	+	}
92	+
93	+	// Scrolling moves the page under a box drawn in fixed coordinates. The
94	+	// element does not change, only where it is, so this repaints rather than
95	+	// re-hit-testing — a scroll event's target is the scroller, not what the
96	+	// cursor is over.
97	+	function onScroll() {
98	+	if (current) paint(current);
99	+	}
100	+
101	+	/** @param {KeyboardEvent} e */
102	+	function onKey(e) {
103	+	if (e.key === "Escape") {
104	+	e.preventDefault();
105	+	e.stopPropagation();
106	+	cleanup();
107	+	resolve(null);
108	+	}
109	+	}
110	+
111	+	// Capture phase + preventDefault, so picking a link doesn't navigate.
112	+	/** @param {MouseEvent} e */
113	+	function onClick(e) {
114	+	e.preventDefault();
115	+	e.stopPropagation();
116	+	const el = current \|\| /** @type {Element \| null} */ (e.target);
117	+	cleanup();
118	+	resolve(el && el.nodeType === 1 ? describe(el) : null);
119	+	}
120	+
121	+	document.addEventListener("mousemove", onMove, true);
122	+	document.addEventListener("click", onClick, true);
123	+	document.addEventListener("keydown", onKey, true);
124	+	window.addEventListener("scroll", onScroll, true);
125	+
126	+	// --- identifier construction ---------------------------------------------
127	+
128	+	/** @param {string} v */
129	+	function cssEscape(v) {
130	+	return window.CSS && CSS.escape ? CSS.escape(v) : String(v).replace(/[^\w-]/g, "\\$&");
131	+	}
132	+
133	+	/** @param {string} sel */
134	+	function isUnique(sel) {
135	+	try {
136	+	return document.querySelectorAll(sel).length === 1;
137	+	} catch {
138	+	return false;
139	+	}
140	+	}
141	+
142	+	// Attributes worth preferring: chosen by the app author, so they survive a
143	+	// redesign in a way that :nth-of-type chains do not.
144	+	const STABLE = [
145	+	"data-testid",
146	+	"data-test-id",
147	+	"data-test",
148	+	"data-cy",
149	+	"data-qa",
150	+	"name",
151	+	"aria-label",
152	+	"role",
153	+	];
154	+
155	+	/** @param {Element} el */
156	+	function stableAttrSelector(el) {
157	+	for (const a of STABLE) {
158	+	const v = el.getAttribute && el.getAttribute(a);
159	+	if (v && v.length < 100) {
160	+	const sel = `${el.tagName.toLowerCase()}[${a}="${v.replace(/"/g, '\\"')}"]`;
161	+	if (isUnique(sel)) return sel;
162	+	}
163	+	}
164	+	return null;
165	+	}
166	+
167	+	/** @param {Element} el */
168	+	function cssSelector(el) {
169	+	if (el.id && isUnique(`#${cssEscape(el.id)}`)) return `#${cssEscape(el.id)}`;
170	+	const stable = stableAttrSelector(el);
171	+	if (stable) return stable;
172	+
173	+	/** @type {string[]} */
174	+	const parts = [];
175	+	let cur = /** @type {Element \| null} */ (el);
176	+	while (cur && cur.nodeType === 1 && parts.length < 8) {
177	+	const tag = cur.tagName;
178	+	let part = tag.toLowerCase();
179	+	if (cur.id && isUnique(`#${cssEscape(cur.id)}`)) {
180	+	parts.unshift(`#${cssEscape(cur.id)}`);
181	+	break;
182	+	}
183	+	let idx = 1;
184	+	for (let s = cur.previousElementSibling; s; s = s.previousElementSibling) {
185	+	if (s.tagName === tag) idx++;
186	+	}
187	+	const needsIndex =
188	+	cur.parentElement &&
189	+	[...cur.parentElement.children].filter((c) => c.tagName === tag).length > 1;
190	+	if (needsIndex) part += `:nth-of-type(${idx})`;
191	+	parts.unshift(part);
192	+	if (isUnique(parts.join(" > "))) break;
193	+	cur = cur.parentElement;
194	+	}
195	+	return parts.join(" > ");
196	+	}
197	+
198	+	/** @param {string} v */
199	+	function xpathLiteral(v) {
200	+	if (!v.includes("'")) return `'${v}'`;
201	+	if (!v.includes('"')) return `"${v}"`;
202	+	return `concat('${v.split("'").join(`', "'", '`)}')`;
203	+	}
204	+
205	+	/** @param {Element} el */
206	+	function xpath(el) {
207	+	if (el.id) return `//*[@id=${xpathLiteral(el.id)}]`;
208	+	/** @type {string[]} */
209	+	const parts = [];
210	+	for (
211	+	let cur = /** @type {Element \| null} */ (el);
212	+	cur && cur.nodeType === 1;
213	+	cur = cur.parentElement
214	+	) {
215	+	let i = 1;
216	+	for (let s = cur.previousElementSibling; s; s = s.previousElementSibling) {
217	+	if (s.tagName === cur.tagName) i++;
218	+	}
219	+	parts.unshift(`${cur.tagName.toLowerCase()}[${i}]`);
220	+	}
221	+	return `/${parts.join("/")}`;
222	+	}
223	+
224	+	/** @param {Element} el */
225	+	function shortLabel(el) {
226	+	let s = el.tagName.toLowerCase();
227	+	if (el.id) s += `#${el.id}`;
228	+	else if (el.classList && el.classList.length) s += `.${[...el.classList].slice(0, 2).join(".")}`;
229	+	const r = el.getBoundingClientRect();
230	+	return `${s} ${Math.round(r.width)}×${Math.round(r.height)}`;
231	+	}
232	+
233	+	/** @param {Element} el */
234	+	function describe(el) {
235	+	const text = (el.textContent \|\| "").trim().replace(/\s+/g, " ").slice(0, 120);
236	+	// Geometry for the screenshot crop. Read here, at pick time, while the
237	+	// overlay is already gone and the page has not had a chance to move.
238	+	const r = el.getBoundingClientRect();
239	+	return {
240	+	rect: { x: r.left, y: r.top, width: r.width, height: r.height },
241	+	viewport: { w: window.innerWidth, h: window.innerHeight },
242	+	css: cssSelector(el),
243	+	xpath: xpath(el),
244	+	id: el.id \|\| null,
245	+	testid:
246	+	(el.getAttribute && (el.getAttribute("data-testid") \|\| el.getAttribute("data-test"))) \|\|
247	+	null,
248	+	tag: el.tagName.toLowerCase(),
249	+	text: text \|\| null,
250	+	href: el.getAttribute && el.getAttribute("href"),
251	+	pageUrl: location.href,
252	+	};
253	+	}
254	+	});
255	+	}

1	+	/* Every colour comes from lib/theme.js, applied to :root as custom properties
2	+	at startup. The fallbacks here are the dark theme, so the panel is never
3	+	unstyled during the first paint. */
4	+	:root {
5	+	color-scheme: dark;
6	+	--bg: #14161a;
7	+	--bg-panel: #1c1f25;
8	+	--bg-input: #14161a;
9	+	--border: #2d3138;
10	+	--fg: #d7dae0;
11	+	--fg-muted: #8b93a1;
12	+	--accent: #3b6ea5;
13	+	--accent-hover: #4a82bd;
14	+	--accent-fg: #ffffff;
15	+	--ok: #6ec177;
16	+	--err: #e06c75;
17	+	--warn: #d5a458;
18	+	--warn-bg: #241f16;
19	+	--warn-border: #4a3a22;
20	+	--shadow: rgba(0, 0, 0, 0.4);
21	+	}
22	+	* { box-sizing: border-box; }
23	+	/* Author `display` beats the UA rule for [hidden] no matter the specificity, so
24	+	every flex/inline-flex element in here would otherwise ignore .hidden = true.
25	+	Everything that toggles itself does it through the attribute; this is what
26	+	makes that work. */
27	+	[hidden] { display: none !important; }
28	+	html, body { height: 100%; margin: 0; }
29	+	body {
30	+	font: 13px/1.5 system-ui, sans-serif;
31	+	background: var(--bg); color: var(--fg);
32	+	display: flex; flex-direction: column; overflow: hidden;
33	+	}
34	+	/* Vertical space is scarce in a sidebar, but not so scarce that controls
35	+	should become unclickable. 26px is about the smallest comfortable pointer
36	+	target; the header stays short by having only two of them. */
37	+	/* Stretch, not centre: the active tab has to reach the bottom edge to sit on
38	+	the seam. Everything else in the row re-centres itself. */
39	+	header {
40	+	display: flex; align-items: stretch; gap: 4px;
41	+	padding: 4px 6px 0; background: var(--bg-panel);
42	+	border-bottom: 1px solid var(--border); flex: none;
43	+	}
44	+	#status-text {
45	+	flex: 1; font-size: 11px; color: var(--fg-muted); min-width: 0;
46	+	white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
47	+	}
48	+	.dot { width: 7px; height: 7px; border-radius: 50%; flex: none; }
49	+
50	+	/* The tabs are the only thing in this row that reaches the seam; everything
51	+	else is centred on the same 22px band, so the dot, the session name and the
52	+	icons sit on one line rather than each on its own accidental one. The 4px
53	+	bottom margin is the tabs' own gap above the seam, matched here. */
54	+	header > #session-chip,
55	+	header > #status-text,
56	+	header > button.icon {
57	+	align-self: center;
58	+	margin-bottom: 4px;
59	+	}
60	+	header > #status-text,
61	+	header > #session-chip { height: 22px; }
62	+	header > #status-text { line-height: 20px; }
63	+
64	+	/* The session chip. Without a session there is nothing to switch to, so it is
65	+	just the status dot sitting where it always did; with one it closes up into a
66	+	recessed pill. The grey is mixed from the row rather than taken from
67	+	--bg-input, which in the light theme is the same white as the terminal — the
68	+	chip would then read as a lifted tab, which is the whole thing being avoided.
69	+	The extra right margin is the gap that says the tabs are a different group. */
70	+	#session-chip {
71	+	display: inline-flex; align-items: center; gap: 5px;
72	+	flex: 0 1 auto; min-width: 0;
73	+	margin-left: 2px;
74	+	border: 1px solid transparent; border-radius: 999px;
75	+	}
76	+	body.has-session #session-chip {
77	+	padding: 0 5px 0 7px; margin-right: 9px;
78	+	background: rgba(128, 128, 128, 0.13);
79	+	border-color: var(--border);
80	+	}
81	+	body.has-session #session-chip:hover { background: rgba(128, 128, 128, 0.2); }
82	+	#session-chip:focus-within { border-color: var(--accent); }
83	+
84	+	/* Shrinkable: in a narrow panel the tabs are what the row is for, and the
85	+	session name is already in the select's own tooltip. The select draws no box
86	+	of its own — the chip around it is the box. */
87	+	#session-switch {
88	+	flex: 0 1 auto; min-width: 3rem; max-width: 9rem;
89	+	font: inherit; font-size: 11px; font-weight: 500; line-height: 20px;
90	+	padding: 0; border: 0; border-radius: 0;
91	+	background: transparent; color: var(--fg);
92	+	text-overflow: ellipsis;
93	+	}
94	+	#session-switch:focus-visible { outline: none; }
95	+
96	+	/* --- window tabs -----------------------------------------------------------
97	+	A tab is a window of the attached session — what `prefix 2` selects. Clicking
98	+	one is a select-window: nothing in this strip spawns or destroys a shell
99	+	except "+", which opens a window. */
100	+	/* Sized to its tabs, not to the row: "+" sits against the last tab the way a
101	+	browser's does, and the strip gives up width to scrolling before the row
102	+	gives up its buttons. */
103	+	/* The strip has to reach over the header's bottom border, because the active
104	+	tab's whole trick is covering the 1px of it that it sits on. `overflow-x:
105	+	auto` computes overflow-y to `auto` as well, so a scroll container clips its
106	+	children at the padding box no matter which axis you asked for: without the
107	+	margin/padding pair below, the tab's overhang is cut off at the seam and the
108	+	line runs straight through the one tab that is meant to break it.
109	+	The margin grows the box downwards onto the border, the padding puts the
110	+	tabs' own bottom edge back where it was, and the 1px between the two is room
111	+	the overhang is allowed to paint in. */
112	+	#tabs {
113	+	display: flex; align-items: stretch; gap: 2px;
114	+	flex: 0 1 auto; min-width: 0;
115	+	margin-bottom: -1px; padding-bottom: 1px;
116	+	overflow-x: auto; scrollbar-width: none;
117	+	}
118	+	#tabs::-webkit-scrollbar { display: none; }
119	+	/* Nothing follows the tabs, so this is just what stops "+" from being stretched
120	+	away from the last one. */
121	+	#tab-new { margin-right: auto; }
122	+
123	+	/* The panel's controls are one group and the session is another; the row's 4px
124	+	gap is not enough to say so. */
125	+	header > #settings-toggle { margin-right: 5px; }
126	+
127	+	/* The tab and its close ✕ are siblings — a button cannot contain a button —
128	+	so the slot is what the strip lays out, and the ✕ is positioned over the
129	+	tab's right edge.
130	+
131	+	Past the min width a name is unreadable, so the strip scrolls instead of
132	+	shrinking further: the same trade browsers make when the bar fills up. */
133	+	.tab-slot {
134	+	position: relative; display: flex; align-items: stretch;
135	+	flex: 0 1 auto; min-width: 5.5rem; max-width: 11rem;
136	+	}
137	+	/* The window you are on gives up its characters last. */
138	+	.tab-slot.active { min-width: 7rem; }
139	+
140	+	button.tab {
141	+	flex: 1 1 auto; min-width: 0;
142	+	display: inline-flex; align-items: center; gap: 5px;
143	+	padding: 4px 8px 5px; margin-bottom: 4px;
144	+	border: 0; border-radius: 6px 6px 0 0;
145	+	background: transparent; color: var(--fg-muted);
146	+	font: inherit; font-size: 11px; line-height: 1.4;
147	+	white-space: nowrap; cursor: pointer; text-align: left;
148	+	}
149	+	button.tab:hover { background: rgba(128, 128, 128, 0.16); color: var(--fg); }
150	+	button.tab:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
151	+	button.tab .name { overflow: hidden; text-overflow: ellipsis; min-width: 0; }
152	+	button.tab .index {
153	+	font-size: 9.5px; opacity: .6; font-variant-numeric: tabular-nums; flex: none;
154	+	}
155	+	/* tmux's own "something happened here while you were away". */
156	+	button.tab.activity { color: var(--fg); }
157	+	button.tab.activity .name { font-weight: 600; }
158	+
159	+	/* The favicon slot: what Claude Code is doing in that window, and nothing at
160	+	all for a window that is just a shell — an always-lit glyph would be a status
161	+	light reporting on nothing.
162	+
163	+	The glyph is Claude Code's own asterisk spinner, so a working window in the
164	+	strip and the transcript in the pane are saying the same thing the same way.
165	+	The box is sized and centred once, for the widest frame, so the name beside
166	+	it does not step sideways as the animation cycles. */
167	+	button.tab .glyph {
168	+	flex: none;
169	+	width: 10px; height: 11px;
170	+	display: inline-flex; align-items: center; justify-content: center;
171	+	font-size: 10px; line-height: 1;
172	+	color: var(--fg-muted); opacity: .5;
173	+	}
174	+	button.tab .glyph.none { display: none; }
175	+	button.tab .glyph.working { color: var(--warn); opacity: 1; }
176	+	button.tab .glyph.waiting { color: var(--accent-hover); opacity: 1; animation: pulse 1.4s ease-in-out infinite; }
177	+
178	+	/* The lift: the terminal's background, shoulders drawn with an inset border,
179	+	and a negative bottom margin that punches through the header's seam so the
180	+	tab and the terminal read as one surface. */
181	+	button.tab[aria-selected="true"] {
182	+	background: var(--bg); color: var(--fg);
183	+	margin-bottom: -1px; padding-bottom: 10px;
184	+	box-shadow: inset 1px 1px 0 0 var(--border), inset -1px 0 0 0 var(--border);
185	+	}
186	+	button.tab[aria-selected="true"]:hover { background: var(--bg); }
187	+
188	+	/* Room for the ✕ is reserved rather than made on hover, so a name does not
189	+	re-ellipsis under the pointer. */
190	+	.tab-slot.closable button.tab { padding-right: 20px; }
191	+
192	+	/* Pinned: down to the dot and the index, sized to its content and sitting at
193	+	the head of the strip. The index is what stays visible rather than the name,
194	+	because the index is the thing you can type — `prefix 3` still selects it,
195	+	pinned or not. */
196	+	.tab-slot.pinned { flex: 0 0 auto; min-width: 0; max-width: none; }
197	+	.tab-slot.pinned button.tab { padding-left: 7px; padding-right: 7px; gap: 4px; }
198	+	.tab-slot.pinned button.tab .index { opacity: 1; font-size: 11px; }
199	+	/* A hairline against the unpinned run, the way a browser separates them. */
200	+	.tab-slot.pinned + .tab-slot:not(.pinned) { margin-left: 5px; }
201	+	.tab-slot.pinned + .tab-slot:not(.pinned)::before {
202	+	content: ""; position: absolute; left: -3px; top: 6px; bottom: 6px;
203	+	border-left: 1px solid var(--border);
204	+	}
205	+
206	+	/* Right-click menu. A plain positioned element: an extension page would
207	+	otherwise get the browser's own menu, which has nothing to say about tmux. */
208	+	.tab-menu {
209	+	position: fixed; z-index: 20; min-width: 8rem;
210	+	display: flex; flex-direction: column; padding: 3px;
211	+	background: var(--bg-panel); color: var(--fg);
212	+	border: 1px solid var(--border); border-radius: 6px;
213	+	box-shadow: 0 6px 20px var(--shadow);
214	+	}
215	+	.tab-menu button {
216	+	background: transparent; color: var(--fg);
217	+	border: 0; border-radius: 4px; padding: 5px 8px;
218	+	font: inherit; font-size: 11px; text-align: left; cursor: pointer;
219	+	}
220	+	.tab-menu button:hover { background: var(--border); }
221	+	.tab-menu button.danger { color: var(--err); }
222	+	.tab-menu button.danger:hover { background: var(--err); color: var(--accent-fg); }
223	+	.tab-menu button:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
224	+
225	+	button.tab-close {
226	+	position: absolute; right: 4px; top: 5px;
227	+	width: 15px; height: 15px; padding: 0;
228	+	display: inline-flex; align-items: center; justify-content: center;
229	+	border: 0; border-radius: 4px;
230	+	background: transparent; color: var(--fg-muted); cursor: pointer;
231	+	opacity: 0; pointer-events: none; transition: opacity 90ms linear;
232	+	}
233	+	button.tab-close svg { width: 9px; height: 9px; display: block; }
234	+	/* On the tab you are on and the one you are pointing at — a full strip of ✕ is
235	+	noise, and every one of them is destructive. */
236	+	.tab-slot.active button.tab-close,
237	+	.tab-slot:hover button.tab-close,
238	+	.tab-slot:focus-within button.tab-close { opacity: 1; pointer-events: auto; }
239	+	/* Red on hover rather than the usual grey: this is the one control in the
240	+	panel that destroys something, and it takes effect on the first click. */
241	+	button.tab-close:hover { background: var(--err); color: var(--accent-fg); }
242	+	button.tab-close:focus-visible { outline: 2px solid var(--accent); outline-offset: 0; }
243	+
244	+
245	+	button.icon {
246	+	flex: none;
247	+	width: 26px; height: 26px; padding: 0;
248	+	display: inline-flex; align-items: center; justify-content: center;
249	+	background: transparent; border: 0; border-radius: 5px;
250	+	color: var(--fg-muted); cursor: pointer;
251	+	}
252	+	button.icon svg { width: 15px; height: 15px; display: block; }
253	+	button.icon:hover { background: var(--border); color: var(--fg); }
254	+	button.icon:active { transform: translateY(0.5px); }
255	+	button.icon:focus-visible { outline: 2px solid var(--accent); outline-offset: -1px; }
256	+	#pick.active { background: var(--accent); color: var(--accent-fg); }
257	+
258	+	/* The session name lives in the switcher once there is one, so the status text
259	+	stands down rather than saying it twice. The dot stays: it is the only thing
260	+	reporting on the connection itself. */
261	+	body.has-session > header > #status-text { display: none; }
262	+
263	+	/* Compact: lose the status text, keep the targets clickable. */
264	+	body.compact header { padding: 2px 4px 0; }
265	+	body.compact #status-text { display: none; }
266	+	body.compact button.icon { width: 24px; height: 24px; }
267	+	body.compact > header > #session-chip { height: 20px; }
268	+	body.compact #session-switch { line-height: 18px; }
269	+	body.compact .tab-slot { max-width: 8rem; }
270	+	body.compact button.tab { padding: 3px 6px 4px; }
271	+	body.compact .tab-slot.closable button.tab { padding-right: 19px; }
272	+	body.compact button.tab[aria-selected="true"] { padding-bottom: 9px; }
273	+	body.compact button.tab .index { display: none; }
274	+	body.compact button.tab-close { top: 4px; }
275	+	body.compact #term { padding: 2px; }
276	+
277	+	/* Hidden: no header at all. A 4px strip along the top brings it back on
278	+	hover, so the settings panel is never unreachable. */
279	+	body.chromeless header {
280	+	position: absolute; top: 0; left: 0; right: 0; z-index: 5;
281	+	opacity: 0; pointer-events: none; transition: opacity 90ms linear;
282	+	}
283	+	body.chromeless #reveal-strip {
284	+	display: block; position: absolute; top: 0; left: 0; right: 0;
285	+	height: 4px; z-index: 6;
286	+	}
287	+	body.chromeless #reveal-strip:hover ~ header,
288	+	body.chromeless header:hover { opacity: 1; pointer-events: auto; }
289	+	body.chromeless #term { padding: 2px; }
290	+	#reveal-strip { display: none; }
291	+
292	+	.dot.on { background: var(--ok); }
293	+	.dot.off { background: var(--err); }
294	+	.dot.pending { background: var(--warn); }
295	+
296	+	@keyframes pulse { 50% { opacity: .25; } }
297	+	/* The spinner is driven from script, which parks it on a single frame when
298	+	motion is reduced; this is only the waiting glyph's own breathing. */
299	+	@media (prefers-reduced-motion: reduce) {
300	+	button.tab .glyph.waiting { animation: none; }
301	+	}
302	+	#term { flex: 1; min-height: 0; padding: 4px; overflow: hidden; }
303	+	#term .xterm { height: 100%; }
304	+	aside {
305	+	flex: none; max-height: 55%; overflow-y: auto;
306	+	padding: 10px; background: var(--bg-panel); border-top: 1px solid var(--border);
307	+	}
308	+	h2 { font-size: 11px; text-transform: uppercase; letter-spacing: .06em;
309	+	color: var(--fg-muted); margin: 12px 0 4px; font-weight: 600; }
310	+	h2:first-child { margin-top: 0; }
311	+	.hint { color: var(--fg-muted); margin: 0 0 6px; font-size: 11px; }
312	+	.row { display: flex; gap: 6px; align-items: center; }
313	+	input[type=text], input[type=password], input:not([type]), #url {
314	+	width: 100%; background: var(--bg-input); color: var(--fg);
315	+	border: 1px solid var(--border); border-radius: 4px; padding: 5px 7px;
316	+	font-family: ui-monospace, monospace; font-size: 11px;
317	+	}
318	+	button {
319	+	background: var(--accent); color: var(--accent-fg); border: 0; border-radius: 4px;
320	+	padding: 5px 10px; font-size: 11px; cursor: pointer;
321	+	}
322	+	button:hover { background: var(--accent-hover); }
323	+	button.ghost { background: transparent; border: 1px solid var(--border);
324	+	color: var(--fg-muted); padding: 3px 7px; }
325	+	button.ghost:hover { background: var(--border); }
326	+	pre {
327	+	background: var(--bg-input); border: 1px solid var(--border); border-radius: 4px;
328	+	padding: 6px; margin: 0 0 6px; overflow-x: auto;
329	+	font-family: ui-monospace, monospace; font-size: 10px;
330	+	white-space: pre-wrap; word-break: break-all;
331	+	}
332	+	#log { max-height: 120px; overflow-y: auto; color: var(--fg-muted); }
333	+	code { font-family: ui-monospace, monospace; background: var(--bg-input);
334	+	padding: 1px 3px; border-radius: 3px; font-size: 10px; }
335	+	label.row { color: var(--fg-muted); font-size: 11px; margin-top: 5px; }
336	+	label.row input { width: auto; }
337	+
338	+	#trust-hint { margin-top: 8px; padding: 8px; border: 1px solid var(--warn-border);
339	+	background: var(--warn-bg); border-radius: 4px; }
340	+	.hint.warn { color: var(--warn); }
341	+
342	+	/* Picked-element panel. A results card, not a toolbar: one primary action,
343	+	the rest reduced to icons so the value itself is what draws the eye. */
344	+	#picked {
345	+	flex: none;
346	+	background: var(--bg-panel);
347	+	border-bottom: 1px solid var(--border);
348	+	border-top: 2px solid var(--accent);
349	+	padding: 7px 8px 9px;
350	+	}
351	+
352	+	.picked-top { display: flex; align-items: center; gap: 6px; margin-bottom: 6px; }
353	+	.chip {
354	+	font-family: ui-monospace, monospace; font-size: 11px;
355	+	color: var(--accent); background: var(--bg-input);
356	+	border: 1px solid var(--border); border-radius: 4px;
357	+	padding: 1px 6px; flex: none;
358	+	}
359	+	#picked-meta {
360	+	flex: 1; min-width: 0; font-size: 11px; color: var(--fg-muted);
361	+	white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
362	+	}
363	+	.picked-top button.icon { width: 22px; height: 22px; }
364	+	.picked-top button.icon svg { width: 13px; height: 13px; }
365	+
366	+	/* Segmented control instead of a native <select>: the options are few, short,
367	+	and worth seeing all at once. */
368	+	.segmented {
369	+	display: flex; gap: 2px; margin-bottom: 6px;
370	+	background: var(--bg-input);
371	+	border: 1px solid var(--border); border-radius: 6px; padding: 2px;
372	+	}
373	+	.segmented button {
374	+	flex: 1 1 0; min-width: 0;
375	+	background: transparent; color: var(--fg-muted);
376	+	border: 0; border-radius: 4px; padding: 3px 4px;
377	+	font-size: 10px; font-weight: 500; letter-spacing: .02em;
378	+	cursor: pointer; white-space: nowrap;
379	+	overflow: hidden; text-overflow: ellipsis;
380	+	}
381	+	.segmented button:hover { color: var(--fg); background: var(--border); }
382	+	.segmented button[aria-selected="true"] {
383	+	background: var(--accent); color: var(--accent-fg);
384	+	}
385	+	.segmented button[aria-selected="true"]:hover { background: var(--accent-hover); }
386	+
387	+	#picked-value {
388	+	background: var(--bg-input);
389	+	border: 1px solid var(--border); border-radius: 6px;
390	+	padding: 7px 8px;
391	+	font-family: ui-monospace, monospace; font-size: 11px; line-height: 1.45;
392	+	color: var(--fg);
393	+	word-break: break-all; white-space: pre-wrap;
394	+	max-height: 84px; overflow-y: auto;
395	+	user-select: all;
396	+	}
397	+	#picked-value.empty { color: var(--fg-muted); font-style: italic; user-select: none; }
398	+
399	+	#picked-insert { width: 100%; margin-top: 7px; padding: 6px 10px; font-size: 11px; }
400	+	#picked-warn { margin: 6px 0 0; font-size: 11px; }
401	+	#picked-grant { width: 100%; margin-top: 6px; }
402	+
403	+	select { font-family: inherit; }
404	+
405	+	#density-hint { margin-top: 6px; }
406	+
407	+	#font-row { margin-top: 7px; }
408	+	#font-row .hint { margin: 0; margin-right: auto; }
409	+	#font-row button.icon { width: 24px; height: 24px; border: 1px solid var(--border); }
410	+	#font-size { font-variant-numeric: tabular-nums; font-size: 11px; min-width: 2ch;
411	+	text-align: center; color: var(--fg); }
412	+	#font-reset { padding: 4px 8px; font-size: 11px; }
413	+	#theme-select, #density-select { width: auto; background: var(--bg-input); color: var(--fg);
414	+	border: 1px solid var(--border); border-radius: 4px; padding: 5px 7px; font-size: 11px; }

1	+	<!doctype html>
2	+	<html>
3	+	<head>
4	+	<meta charset="utf-8" />
5	+	<title>terminal</title>
6	+	<link rel="stylesheet" href="vendor/xterm.css" />
7	+	<link rel="stylesheet" href="sidebar.css" />
8	+	</head>
9	+	<body>
10	+	<div id="reveal-strip"></div>
11	+
12	+	<header>
13	+	<!-- The panel's own controls, held together at the left edge so the tab
14	+	strip owns the rest of the row and grows rightwards into it.
15	+	Reconnect appears only when it is actually actionable; theme and
16	+	density live in settings. Inline SVG rather than unicode glyphs,
17	+	which render at wildly different weights depending on which font the
18	+	platform falls back to. -->
19	+	<button id="reconnect" class="icon" title="Reconnect" hidden>
20	+	<svg viewBox="0 0 16 16" aria-hidden="true">
21	+	<path d="M13.5 8a5.5 5.5 0 1 1-1.7-4" fill="none" stroke="currentColor"
22	+	stroke-width="1.6" stroke-linecap="round"/>
23	+	<path d="M13.5 1.5v3.2h-3.2" fill="none" stroke="currentColor"
24	+	stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/>
25	+	</svg>
26	+	</button>
27	+
28	+	<button id="pick" class="icon" title="Pick an element on the page (Esc cancels)">
29	+	<svg viewBox="0 0 16 16" aria-hidden="true">
30	+	<circle cx="8" cy="8" r="3.1" fill="none" stroke="currentColor" stroke-width="1.6"/>
31	+	<path d="M8 .8v2.6M8 12.6v2.6M.8 8h2.6M12.6 8h2.6" stroke="currentColor"
32	+	stroke-width="1.6" stroke-linecap="round"/>
33	+	</svg>
34	+	</button>
35	+
36	+	<button id="settings-toggle" class="icon" title="Settings">
37	+	<svg viewBox="0 0 16 16" aria-hidden="true">
38	+	<path d="M2 4.5h12M2 8h12M2 11.5h12" stroke="currentColor"
39	+	stroke-width="1.6" stroke-linecap="round"/>
40	+	<circle cx="5.5" cy="4.5" r="1.9" fill="currentColor"/>
41	+	<circle cx="10.5" cy="11.5" r="1.9" fill="currentColor"/>
42	+	</svg>
43	+	</button>
44	+
45	+	<!-- The session the tabs belong to. Switching here moves the live tmux
46	+	client (switch-client), so the terminal below stays connected and
47	+	nothing is re-spawned. It also carries the session name that the
48	+	status text used to, since the tabs push that out of the row.
49	+
50	+	Dot and select are one chip so the session reads as a control and not
51	+	as another tab: the chip is a recessed pill with a full border, where
52	+	a tab is borderless and the selected one is lifted onto the
53	+	terminal's background. Same row, opposite direction. -->
54	+	<div id="session-chip">
55	+	<span id="status" class="dot off" title="disconnected"></span>
56	+	<select id="session-switch" title="tmux session" hidden></select>
57	+	</div>
58	+
59	+	<!-- Only while there is no session name to stand in for it. -->
60	+	<span id="status-text">disconnected</span>
61	+
62	+	<!-- One tab per window in the attached session, browser-style: the active
63	+	tab is lifted to the terminal's own background so the two read as one
64	+	surface, and the dot in its favicon slot is what Claude Code is doing
65	+	in that window. Clicking a tab runs select-window — the same thing
66	+	`prefix 2` does in the terminal, and it moves every client watching
67	+	the session, because a window belongs to the session and not to us.
68	+	Populated from the daemon's status frames. -->
69	+	<div id="tabs" role="tablist" aria-label="tmux windows" hidden></div>
70	+
71	+	<button id="tab-new" class="icon" title="New window" hidden>
72	+	<svg viewBox="0 0 16 16" aria-hidden="true">
73	+	<path d="M3.5 8h9M8 3.5v9" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/>
74	+	</svg>
75	+	</button>
76	+
77	+	</header>
78	+
79	+	<div id="picked" hidden>
80	+	<div class="picked-top">
81	+	<span id="picked-tag" class="chip"></span>
82	+	<span id="picked-meta"></span>
83	+	<button id="picked-copy" class="icon" title="Copy to clipboard">
84	+	<svg viewBox="0 0 16 16" aria-hidden="true">
85	+	<rect x="5.2" y="5.2" width="8.6" height="8.6" rx="1.8"
86	+	fill="none" stroke="currentColor" stroke-width="1.5"/>
87	+	<path d="M10.8 5.2V4a1.8 1.8 0 0 0-1.8-1.8H4A1.8 1.8 0 0 0 2.2 4v5a1.8 1.8 0 0 0 1.8 1.8h1.2"
88	+	fill="none" stroke="currentColor" stroke-width="1.5"/>
89	+	</svg>
90	+	</button>
91	+	<button id="picked-close" class="icon" title="Dismiss">
92	+	<svg viewBox="0 0 16 16" aria-hidden="true">
93	+	<path d="M4 4l8 8M12 4l-8 8" stroke="currentColor"
94	+	stroke-width="1.6" stroke-linecap="round"/>
95	+	</svg>
96	+	</button>
97	+	</div>
98	+
99	+	<div id="picked-formats" class="segmented" role="tablist"></div>
100	+	<div id="picked-value"></div>
101	+
102	+	<p id="picked-warn" class="hint warn" hidden></p>
103	+	<button id="picked-grant" hidden></button>
104	+	<button id="picked-insert">Insert into terminal</button>
105	+	</div>
106	+
107	+	<div id="term"></div>
108	+
109	+	<aside id="settings" hidden>
110	+	<h2>Pair this extension</h2>
111	+	<p class="hint">Run this once, then restart the daemon:</p>
112	+	<pre id="pair-cmd">loading…</pre>
113	+	<button id="copy-origin" class="ghost">copy</button>
114	+
115	+	<h2>Token</h2>
116	+	<p class="hint"><code>termbridge token</code> prints it.</p>
117	+	<input id="token" type="password" placeholder="64 hex chars" autocomplete="off" spellcheck="false" />
118	+	<label class="row"><input id="reveal" type="checkbox" /> reveal</label>
119	+	<p id="token-hint" class="hint warn" hidden></p>
120	+
121	+	<h2>Appearance</h2>
122	+	<div class="row">
123	+	<select id="theme-select">
124	+	<option value="auto">Follow system</option>
125	+	<option value="light">Light</option>
126	+	<option value="dark">Dark</option>
127	+	</select>
128	+	<select id="density-select" title="How much room the header takes">
129	+	<option value="normal">Normal header</option>
130	+	<option value="compact">Compact header</option>
131	+	<option value="hidden">Hide header</option>
132	+	</select>
133	+	</div>
134	+	<p class="hint" id="density-hint"></p>
135	+
136	+	<div class="row" id="font-row">
137	+	<span class="hint">Font size</span>
138	+	<button id="font-smaller" class="icon" title="Smaller (Ctrl+Alt+- or Ctrl+wheel)">
139	+	<svg viewBox="0 0 16 16" aria-hidden="true">
140	+	<path d="M3.5 8h9" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/>
141	+	</svg>
142	+	</button>
143	+	<span id="font-size">12</span>
144	+	<button id="font-bigger" class="icon" title="Bigger (Ctrl+Alt+= or Ctrl+wheel)">
145	+	<svg viewBox="0 0 16 16" aria-hidden="true">
146	+	<path d="M3.5 8h9M8 3.5v9" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/>
147	+	</svg>
148	+	</button>
149	+	<button id="font-reset" class="ghost" title="Reset (Ctrl+Alt+0)">reset</button>
150	+	</div>
151	+
152	+	<h2>tmux session</h2>
153	+	<p class="hint">Attaches if it exists, creates it otherwise.</p>
154	+	<div class="row">
155	+	<input id="session" list="session-list" placeholder="browser" spellcheck="false" />
156	+	<datalist id="session-list"></datalist>
157	+	<button id="session-apply" class="ghost">attach</button>
158	+	</div>
159	+
160	+	<h2>Daemon</h2>
161	+	<input id="url" value="ws://127.0.0.1:7681" spellcheck="false" />
162	+	<button id="connect">connect</button>
163	+
164	+	<div id="trust-hint" hidden>
165	+	<p class="hint warn">
166	+	Firefox upgrades <code>ws://</code> to <code>wss://</code>. The
167	+	daemon's certificate is self-signed, so it needs a one-time exception.
168	+	</p>
169	+	<button id="trust-cert" class="ghost">open https:// to trust the cert</button>
170	+	</div>
171	+
172	+	<h2>Log</h2>
173	+	<pre id="log"></pre>
174	+	</aside>
175	+
176	+	<script src="lib/theme.js"></script>
177	+	<script src="lib/sanitize.js"></script>
178	+	<script src="lib/shot.js"></script>
179	+	<script src="picker.js"></script>
180	+	<script src="vendor/xterm.js"></script>
181	+	<script src="vendor/addon-fit.js"></script>
182	+	<script src="sidebar.js"></script>
183	+	</body>
184	+	</html>

1	+	// Background worker.
2	+	//
3	+	// Its one real job is the element picker's keyboard shortcut. `activeTab` — the
4	+	// permission that lets us touch a page without asking for <all_urls> — is only
5	+	// granted on specific user gestures: a toolbar-action click, a context menu
6	+	// item, or a keyboard command. A click inside the side panel is not one of
7	+	// them, so the in-panel button can fail while the shortcut always works. Both
8	+	// paths exist; this is the reliable one.
9	+
10	+	// One of the two always exists — this file only ever runs as an extension
11	+	// background script — but neither is declared unconditionally, so say which.
12	+	const api = /** @type {TbExtensionApi} */ (globalThis.browser ?? globalThis.chrome);
13	+
14	+	// Chrome's service worker starts empty; Firefox loads picker.js alongside this
15	+	// file via background.scripts, so there it is already defined.
16	+	if (typeof tbPickElement === "undefined" && typeof importScripts === "function") {
17	+	importScripts("picker.js", "lib/shot.js");
18	+	}
19	+
20	+	// Chrome only: make the toolbar button open the side panel.
21	+	if (api.sidePanel?.setPanelBehavior) {
22	+	api.sidePanel
23	+	.setPanelBehavior({ openPanelOnActionClick: true })
24	+	.catch((e) => console.error(e));
25	+	}
26	+
27	+	const SKIP = /^(chrome\|about\|edge\|moz-extension\|chrome-extension\|view-source\|devtools):/;
28	+
29	+	async function runPicker() {
30	+	const [tab] = await api.tabs.query({ active: true, currentWindow: true });
31	+	if (!tab \|\| SKIP.test(tab.url ?? "")) {
32	+	console.warn("termbridge: cannot pick on this page", tab?.url);
33	+	return;
34	+	}
35	+
36	+	let value = null;
37	+	try {
38	+	const results = await api.scripting.executeScript({
39	+	target: { tabId: tab.id },
40	+	func: tbPickElement,
41	+	});
42	+	value = results?.[0]?.result ?? null;
43	+	} catch (e) {
44	+	console.error("termbridge: pick failed", e);
45	+	return;
46	+	}
47	+	if (!value) return;
48	+
49	+	// Screenshot here rather than in the sidebar: this path's page access comes
50	+	// from the activeTab grant the keyboard command just minted, and that grant
51	+	// belongs to the worker.
52	+	const shot = await Shot.copyPickedShot(api, tab.id, value);
53	+	if (shot !== true) console.warn("termbridge: no screenshot", shot);
54	+
55	+	// The sidebar may not be open. Try to hand it over directly, and fall back to
56	+	// storage so the pick isn't lost — the sidebar drains it when it next opens.
57	+	try {
58	+	await api.runtime.sendMessage({ type: "picked", value, shot: shot === true });
59	+	} catch {
60	+	await api.storage.local.set({ pendingPick: value });
61	+	}
62	+	}
63	+
64	+	api.commands?.onCommand.addListener((command) => {
65	+	if (command === "pick-element") runPicker();
66	+	});

1	+	// Ambient declarations for the globals these scripts run against.
2	+	//
3	+	// Hand-written rather than pulled from @types/chrome on purpose: this file is
4	+	// the inventory of extension API surface termbridge touches. Adding a call
5	+	// means adding it here first, which is a small, useful speed bump — the
6	+	// manifest's permission list has to grow with it. It is also why `npm run
7	+	// check` needs exactly one dependency.
8	+	//
9	+	// Chrome and Firefox differ: `browser.*` is promise-based everywhere, and
10	+	// Chrome's `chrome.*` has been promise-based for MV3. Everything below is typed
11	+	// as promises because that is the only way it is called here.
12	+
13	+	interface TbTab {
14	+	id?: number;
15	+	url?: string;
16	+	title?: string;
17	+	}
18	+
19	+	interface TbInjectionResult<T = unknown> {
20	+	result?: T;
21	+	frameId?: number;
22	+	}
23	+
24	+	interface TbMessageSender {
25	+	id?: string;
26	+	/** Set for content scripts and only for content scripts — the check that
27	+	keeps a hostile page from reaching the sidebar's message handler. */
28	+	tab?: TbTab;
29	+	}
30	+
31	+	interface TbStorageArea {
32	+	get(keys?: string \| string[] \| null): Promise<Record<string, any>>;
33	+	set(items: Record<string, any>): Promise<void>;
34	+	remove(keys: string \| string[]): Promise<void>;
35	+	}
36	+
37	+	interface TbExtensionApi {
38	+	runtime: {
39	+	id: string;
40	+	sendMessage(message: any): Promise<any>;
41	+	onMessage: {
42	+	addListener(
43	+	cb: (message: any, sender: TbMessageSender) => void \| boolean \| Promise<any>,
44	+	): void;
45	+	};
46	+	};
47	+	storage: { local: TbStorageArea };
48	+	tabs: {
49	+	query(info: { active?: boolean; currentWindow?: boolean }): Promise<TbTab[]>;
50	+	create(props: { url: string }): Promise<TbTab>;
51	+	/** The visible area of the active tab, as a PNG data URL. Needs a host
52	+	permission for the page, exactly as the picker's injection does. */
53	+	captureVisibleTab(options: { format: "png" }): Promise<string>;
54	+	};
55	+	permissions: {
56	+	request(perms: { origins?: string[]; permissions?: string[] }): Promise<boolean>;
57	+	};
58	+	scripting: {
59	+	/**
60	+	* `Awaited<T>`: a func that returns a promise is awaited by the browser,
61	+	* and `result` is what it resolved to — which is the whole reason the
62	+	* picker can hand its value back as a return value.
63	+	*/
64	+	executeScript<T, A extends any[] = []>(injection: {
65	+	target: { tabId: number \| undefined };
66	+	func: (...args: A) => T;
67	+	/** Structured-cloned into the page. Keep it small — a screenshot goes
68	+	through here as base64. */
69	+	args?: A;
70	+	}): Promise<TbInjectionResult<Awaited<T>>[]>;
71	+	};
72	+	/** Firefox only: writes an image to the clipboard without a focused
73	+	document, which the async clipboard API refuses to do. */
74	+	clipboard?: {
75	+	setImageData(image: ArrayBuffer, type: "png" \| "jpeg"): Promise<void>;
76	+	};
77	+	/** Absent in Firefox, and absent in Chrome until the browser is new enough. */
78	+	sidePanel?: {
79	+	setPanelBehavior?(behavior: {
80	+	openPanelOnActionClick: boolean;
81	+	}): Promise<void>;
82	+	};
83	+	/** Absent when no keyboard shortcuts are declared in the manifest. */
84	+	commands?: {
85	+	onCommand: { addListener(cb: (command: string) => void): void };
86	+	};
87	+	}
88	+
89	+	declare var browser: TbExtensionApi \| undefined;
90	+	declare var chrome: TbExtensionApi \| undefined;
91	+
92	+	// --- the daemon's wire protocol ---------------------------------------------
93	+	//
94	+	// The other half of these shapes is Rust: `Snapshot`, `SessionInfo` and `Agent`
95	+	// in daemon/src/status.rs, and the `ok` frame built in daemon/src/server.rs.
96	+	// Change one side and this side has to move with it — which is most of why
97	+	// they are written down at all.
98	+	//
99	+	// Everything here arrives over a socket. It is claimed structure, not
100	+	// guaranteed structure, and it is only ever assigned through textContent.
101	+
102	+	interface TbSessionInfo {
103	+	name: string;
104	+	/** Window count. 0 when it isn't known yet — the `ok` frame sends names only. */
105	+	windows: number;
106	+	/** Some tmux client, anywhere, is on this session. */
107	+	attached: boolean;
108	+	}
109	+
110	+	/** One window of the attached session — one tab. */
111	+	interface TbWindowInfo {
112	+	/** tmux window id (`@3`). Stable; the index is not. */
113	+	id: string;
114	+	index: number;
115	+	name: string;
116	+	active: boolean;
117	+	panes: number;
118	+	activity: boolean;
119	+	}
120	+
121	+	interface TbAgent {
122	+	/** tmux pane id (`%12`), stable for the pane's lifetime. */
123	+	pane: string;
124	+	/** tmux window id (`@3`) — the join to TbWindowInfo. */
125	+	window_id: string;
126	+	window: string;
127	+	name: string;
128	+	state: "working" \| "waiting" \| "idle" \| "unknown";
129	+	mode?: string \| null;
130	+	tool?: string \| null;
131	+	message?: string \| null;
132	+	title?: string \| null;
133	+	}
134	+
135	+	/**
136	+	* First frame after a successful auth. It carries session names only — the
137	+	* window list needs the control channel, which is up a moment later.
138	+	*/
139	+	interface TbOkFrame {
140	+	type: "ok";
141	+	profile: string;
142	+	tmux: boolean;
143	+	defaultSession?: string;
144	+	/** Names only — window counts arrive with the first status frame. */
145	+	sessions?: string[];
146	+	}
147	+
148	+	/** Pushed whenever tmux says something changed. */
149	+	interface TbStatusFrame {
150	+	type: "status";
151	+	session?: string;
152	+	sessions?: TbSessionInfo[];
153	+	/** Windows of `session`, in index order. */
154	+	windows?: TbWindowInfo[];
155	+	agents?: TbAgent[];
156	+	}
157	+
158	+	type TbFrame =
159	+	\| TbOkFrame
160	+	\| TbStatusFrame
161	+	\| { type: "exit"; code: number }
162	+	\| { type: "error"; reason: string }
163	+	\| { type: "tmux-error"; reason: string };
164	+
165	+	/** The element's box in CSS pixels, relative to the viewport. */
166	+	interface TbPickedRect {
167	+	x: number;
168	+	y: number;
169	+	width: number;
170	+	height: number;
171	+	}
172	+
173	+	/** The identifier flavours the panel can show — the string-valued keys of
174	+	TbPicked, and the only ones that may reach the terminal. */
175	+	type TbPickedFormat = "css" \| "xpath" \| "id" \| "testid" \| "text" \| "href";
176	+
177	+	/** What picker.js's describe() returns — page-controlled, all of it. */
178	+	interface TbPicked {
179	+	/** Where to crop the tab screenshot. Absent on picks made before 0.0.2. */
180	+	rect?: TbPickedRect;
181	+	/** Viewport size at pick time, which fixes the screenshot's scale factor. */
182	+	viewport?: { w: number; h: number };
183	+	css: string;
184	+	xpath: string;
185	+	id: string \| null;
186	+	testid: string \| null;
187	+	tag: string;
188	+	text: string \| null;
189	+	href: string \| null;
190	+	pageUrl: string;
191	+	}
192	+
193	+	// --- vendored xterm.js ------------------------------------------------------
194	+	//
195	+	// The vendored build ships no types. Only the handful of members used here are
196	+	// declared; anything else is a deliberate error rather than a silent `any`.
197	+
198	+	interface TbTerminalTheme {
199	+	[color: string]: string;
200	+	}
201	+
202	+	interface TbTerminalOptions {
203	+	fontFamily?: string;
204	+	fontSize?: number;
205	+	lineHeight?: number;
206	+	cursorBlink?: boolean;
207	+	scrollback?: number;
208	+	allowProposedApi?: boolean;
209	+	convertEol?: boolean;
210	+	macOptionIsMeta?: boolean;
211	+	theme?: TbTerminalTheme;
212	+	}
213	+
214	+	declare class Terminal {
215	+	constructor(options?: TbTerminalOptions);
216	+	readonly cols: number;
217	+	readonly rows: number;
218	+	readonly element?: HTMLElement;
219	+	options: TbTerminalOptions;
220	+	open(parent: HTMLElement): void;
221	+	write(data: string \| Uint8Array): void;
222	+	focus(): void;
223	+	clear(): void;
224	+	loadAddon(addon: unknown): void;
225	+	attachCustomKeyEventHandler(handler: (e: KeyboardEvent) => boolean): void;
226	+	onData(cb: (data: string) => void): { dispose(): void };
227	+	/** Bytes xterm could not represent as UTF-16 — each char is one byte. */
228	+	onBinary(cb: (data: string) => void): { dispose(): void };
229	+	onResize(cb: (size: { cols: number; rows: number }) => void): { dispose(): void };
230	+	}
231	+
232	+	declare namespace FitAddon {
233	+	class FitAddon {
234	+	fit(): void;
235	+	proposeDimensions(): { cols: number; rows: number } \| undefined;
236	+	}
237	+	}
238	+
239	+	// --- our own files, as the browser sees them --------------------------------
240	+	//
241	+	// lib/theme.js and lib/sanitize.js are loaded as classic scripts here and
242	+	// require()d by their node --test files, so each one ends with a CommonJS tail
243	+	// guarded on `typeof module`. That tail is enough to make TypeScript treat them
244	+	// as modules, so their globals have to be re-stated — from the files
245	+	// themselves, so the shapes cannot drift.
246	+	declare var module: { exports: any } \| undefined;
247	+
248	+	declare const Themes: typeof import("../lib/theme.js");
249	+	declare const Sanitize: typeof import("../lib/sanitize.js");
250	+	declare const Shot: typeof import("../lib/shot.js");
251	+
252	+	/** Set by picker.js inside the page, not here — see cancelPick(). */
253	+	interface Window {
254	+	__tbPickerActive?: (() => void) \| null;
255	+	}

1	+	// Service-worker-only globals.
2	+	//
3	+	// The worker project loads lib.dom rather than lib.webworker (they redeclare
4	+	// each other, and picker.js's injected body is checked against page globals),
5	+	// so the one worker API sw.js uses is declared by hand.
6	+
7	+	declare function importScripts(...urls: string[]): void;

	1	+	!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.FitAddon=t():e.FitAddon=t()}(globalThis,(()=>(()=>{"use strict";var e={};return(()=>{var t=e;Object.defineProperty(t,"__esModule",{value:!0}),t.FitAddon=void 0,t.FitAddon=class{activate(e){this._terminal=e}dispose(){}fit(){const e=this.proposeDimensions();if(!e\|\|!this._terminal\|\|isNaN(e.cols)\|\|isNaN(e.rows))return;const t=this._terminal._core;this._terminal.rows===e.rows&&this._terminal.cols===e.cols\|\|(t._renderService.clear(),this._terminal.resize(e.cols,e.rows))}proposeDimensions(){if(!this._terminal)return;if(!this._terminal.element\|\|!this._terminal.element.parentElement)return;const e=this._terminal._core._renderService.dimensions;if(0===e.css.cell.width\|\|0===e.css.cell.height)return;const t=0===this._terminal.options.scrollback?0:this._terminal.options.overviewRuler?.width\|\|14,r=window.getComputedStyle(this._terminal.element.parentElement),i=parseInt(r.getPropertyValue("height")),o=Math.max(0,parseInt(r.getPropertyValue("width"))),s=window.getComputedStyle(this._terminal.element),n=i-(parseInt(s.getPropertyValue("padding-top"))+parseInt(s.getPropertyValue("padding-bottom"))),l=o-(parseInt(s.getPropertyValue("padding-right"))+parseInt(s.getPropertyValue("padding-left")))-t;return{cols:Math.max(2,Math.floor(l/e.css.cell.width)),rows:Math.max(1,Math.floor(n/e.css.cell.height))}}}})(),e})()));
	2	+	//# sourceMappingURL=addon-fit.js.map

1	+	/**
2	+	* Copyright (c) 2014 The xterm.js authors. All rights reserved.
3	+	* Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
4	+	* https://github.com/chjj/term.js
5	+	* @license MIT
6	+	*
7	+	* Permission is hereby granted, free of charge, to any person obtaining a copy
8	+	* of this software and associated documentation files (the "Software"), to deal
9	+	* in the Software without restriction, including without limitation the rights
10	+	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11	+	* copies of the Software, and to permit persons to whom the Software is
12	+	* furnished to do so, subject to the following conditions:
13	+	*
14	+	* The above copyright notice and this permission notice shall be included in
15	+	* all copies or substantial portions of the Software.
16	+	*
17	+	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18	+	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19	+	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20	+	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21	+	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22	+	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23	+	* THE SOFTWARE.
24	+	*
25	+	* Originally forked from (with the author's permission):
26	+	* Fabrice Bellard's javascript vt100 for jslinux:
27	+	* http://bellard.org/jslinux/
28	+	* Copyright (c) 2011 Fabrice Bellard
29	+	* The original design remains. The terminal itself
30	+	* has been extended to include xterm CSI codes, among
31	+	* other features.
32	+	*/
33	+
34	+	/**
35	+	* Default styles for xterm.js
36	+	*/
37	+
38	+	.xterm {
39	+	cursor: text;
40	+	position: relative;
41	+	user-select: none;
42	+	-ms-user-select: none;
43	+	-webkit-user-select: none;
44	+	}
45	+
46	+	.xterm.focus,
47	+	.xterm:focus {
48	+	outline: none;
49	+	}
50	+
51	+	.xterm .xterm-helpers {
52	+	position: absolute;
53	+	top: 0;
54	+	/**
55	+	* The z-index of the helpers must be higher than the canvases in order for
56	+	* IMEs to appear on top.
57	+	*/
58	+	z-index: 5;
59	+	}
60	+
61	+	.xterm .xterm-helper-textarea {
62	+	padding: 0;
63	+	border: 0;
64	+	margin: 0;
65	+	/* Move textarea out of the screen to the far left, so that the cursor is not visible */
66	+	position: absolute;
67	+	opacity: 0;
68	+	left: -9999em;
69	+	top: 0;
70	+	width: 0;
71	+	height: 0;
72	+	z-index: -5;
73	+	/** Prevent wrapping so the IME appears against the textarea at the correct position */
74	+	white-space: nowrap;
75	+	overflow: hidden;
76	+	resize: none;
77	+	}
78	+
79	+	.xterm .composition-view {
80	+	/* TODO: Composition position got messed up somewhere */
81	+	background: #000;
82	+	color: #FFF;
83	+	display: none;
84	+	position: absolute;
85	+	white-space: nowrap;
86	+	z-index: 1;
87	+	}
88	+
89	+	.xterm .composition-view.active {
90	+	display: block;
91	+	}
92	+
93	+	.xterm .xterm-viewport {
94	+	/* On OS X this is required in order for the scroll bar to appear fully opaque */
95	+	background-color: #000;
96	+	overflow-y: scroll;
97	+	cursor: default;
98	+	position: absolute;
99	+	right: 0;
100	+	left: 0;
101	+	top: 0;
102	+	bottom: 0;
103	+	}
104	+
105	+	.xterm .xterm-screen {
106	+	position: relative;
107	+	}
108	+
109	+	.xterm .xterm-screen canvas {
110	+	position: absolute;
111	+	left: 0;
112	+	top: 0;
113	+	}
114	+
115	+	.xterm-char-measure-element {
116	+	display: inline-block;
117	+	visibility: hidden;
118	+	position: absolute;
119	+	top: 0;
120	+	left: -9999em;
121	+	line-height: normal;
122	+	}
123	+
124	+	.xterm.enable-mouse-events {
125	+	/* When mouse events are enabled (eg. tmux), revert to the standard pointer cursor */
126	+	cursor: default;
127	+	}
128	+
129	+	.xterm.xterm-cursor-pointer,
130	+	.xterm .xterm-cursor-pointer {
131	+	cursor: pointer;
132	+	}
133	+
134	+	.xterm.column-select.focus {
135	+	/* Column selection mode */
136	+	cursor: crosshair;
137	+	}
138	+
139	+	.xterm .xterm-accessibility:not(.debug),
140	+	.xterm .xterm-message {
141	+	position: absolute;
142	+	left: 0;
143	+	top: 0;
144	+	bottom: 0;
145	+	right: 0;
146	+	z-index: 10;
147	+	color: transparent;
148	+	pointer-events: none;
149	+	}
150	+
151	+	.xterm .xterm-accessibility-tree:not(.debug) *::selection {
152	+	color: transparent;
153	+	}
154	+
155	+	.xterm .xterm-accessibility-tree {
156	+	font-family: monospace;
157	+	user-select: text;
158	+	white-space: pre;
159	+	}
160	+
161	+	.xterm .xterm-accessibility-tree > div {
162	+	transform-origin: left;
163	+	width: fit-content;
164	+	}
165	+
166	+	.xterm .live-region {
167	+	position: absolute;
168	+	left: -9999px;
169	+	width: 1px;
170	+	height: 1px;
171	+	overflow: hidden;
172	+	}
173	+
174	+	.xterm-dim {
175	+	/* Dim should not apply to background, so the opacity of the foreground color is applied
176	+	* explicitly in the generated class and reset to 1 here */
177	+	opacity: 1 !important;
178	+	}
179	+
180	+	.xterm-underline-1 { text-decoration: underline; }
181	+	.xterm-underline-2 { text-decoration: double underline; }
182	+	.xterm-underline-3 { text-decoration: wavy underline; }
183	+	.xterm-underline-4 { text-decoration: dotted underline; }
184	+	.xterm-underline-5 { text-decoration: dashed underline; }
185	+
186	+	.xterm-overline {
187	+	text-decoration: overline;
188	+	}
189	+
190	+	.xterm-overline.xterm-underline-1 { text-decoration: overline underline; }
191	+	.xterm-overline.xterm-underline-2 { text-decoration: overline double underline; }
192	+	.xterm-overline.xterm-underline-3 { text-decoration: overline wavy underline; }
193	+	.xterm-overline.xterm-underline-4 { text-decoration: overline dotted underline; }
194	+	.xterm-overline.xterm-underline-5 { text-decoration: overline dashed underline; }
195	+
196	+	.xterm-strikethrough {
197	+	text-decoration: line-through;
198	+	}
199	+
200	+	.xterm-screen .xterm-decoration-container .xterm-decoration {
201	+	z-index: 6;
202	+	position: absolute;
203	+	}
204	+
205	+	.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer {
206	+	z-index: 7;
207	+	}
208	+
209	+	.xterm-decoration-overview-ruler {
210	+	z-index: 8;
211	+	position: absolute;
212	+	top: 0;
213	+	right: 0;
214	+	pointer-events: none;
215	+	}
216	+
217	+	.xterm-decoration-top {
218	+	z-index: 2;
219	+	position: relative;
220	+	}
221	+
222	+
223	+
224	+	/* Derived from vs/base/browser/ui/scrollbar/media/scrollbar.css */
225	+
226	+	/* xterm.js customization: Override xterm's cursor style */
227	+	.xterm .xterm-scrollable-element > .scrollbar {
228	+	cursor: default;
229	+	}
230	+
231	+	/* Arrows */
232	+	.xterm .xterm-scrollable-element > .scrollbar > .scra {
233	+	cursor: pointer;
234	+	font-size: 11px !important;
235	+	}
236	+
237	+	.xterm .xterm-scrollable-element > .visible {
238	+	opacity: 1;
239	+
240	+	/* Background rule added for IE9 - to allow clicks on dom node */
241	+	background:rgba(0,0,0,0);
242	+
243	+	transition: opacity 100ms linear;
244	+	/* In front of peek view */
245	+	z-index: 11;
246	+	}
247	+	.xterm .xterm-scrollable-element > .invisible {
248	+	opacity: 0;
249	+	pointer-events: none;
250	+	}
251	+	.xterm .xterm-scrollable-element > .invisible.fade {
252	+	transition: opacity 800ms linear;
253	+	}
254	+
255	+	/* Scrollable Content Inset Shadow */
256	+	.xterm .xterm-scrollable-element > .shadow {
257	+	position: absolute;
258	+	display: none;
259	+	}
260	+	.xterm .xterm-scrollable-element > .shadow.top {
261	+	display: block;
262	+	top: 0;
263	+	left: 3px;
264	+	height: 3px;
265	+	width: 100%;
266	+	box-shadow: var(--vscode-scrollbar-shadow, #000) 0 6px 6px -6px inset;
267	+	}
268	+	.xterm .xterm-scrollable-element > .shadow.left {
269	+	display: block;
270	+	top: 3px;
271	+	left: 0;
272	+	height: 100%;
273	+	width: 3px;
274	+	box-shadow: var(--vscode-scrollbar-shadow, #000) 6px 0 6px -6px inset;
275	+	}
276	+	.xterm .xterm-scrollable-element > .shadow.top-left-corner {
277	+	display: block;
278	+	top: 0;
279	+	left: 0;
280	+	height: 3px;
281	+	width: 3px;
282	+	}
283	+	.xterm .xterm-scrollable-element > .shadow.top.left {
284	+	box-shadow: var(--vscode-scrollbar-shadow, #000) 6px 0 6px -6px inset;
285	+	}

1	+	{
2	+	"name": "browser-terminal-extension",
3	+	"version": "1.0.0",
4	+	"lockfileVersion": 3,
5	+	"requires": true,
6	+	"packages": {
7	+	"": {
8	+	"name": "browser-terminal-extension",
9	+	"version": "1.0.0",
10	+	"license": "ISC",
11	+	"devDependencies": {
12	+	"typescript": "^7.0.2"
13	+	}
14	+	},
15	+	"node_modules/@typescript/typescript-aix-ppc64": {
16	+	"version": "7.0.2",
17	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-aix-ppc64/-/typescript-aix-ppc64-7.0.2.tgz",
18	+	"integrity": "sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ==",
19	+	"cpu": [
20	+	"ppc64"
21	+	],
22	+	"dev": true,
23	+	"license": "Apache-2.0",
24	+	"optional": true,
25	+	"os": [
26	+	"aix"
27	+	],
28	+	"engines": {
29	+	"node": ">=16.20.0"
30	+	}
31	+	},
32	+	"node_modules/@typescript/typescript-darwin-arm64": {
33	+	"version": "7.0.2",
34	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-arm64/-/typescript-darwin-arm64-7.0.2.tgz",
35	+	"integrity": "sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA==",
36	+	"cpu": [
37	+	"arm64"
38	+	],
39	+	"dev": true,
40	+	"license": "Apache-2.0",
41	+	"optional": true,
42	+	"os": [
43	+	"darwin"
44	+	],
45	+	"engines": {
46	+	"node": ">=16.20.0"
47	+	}
48	+	},
49	+	"node_modules/@typescript/typescript-darwin-x64": {
50	+	"version": "7.0.2",
51	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-x64/-/typescript-darwin-x64-7.0.2.tgz",
52	+	"integrity": "sha512-SZ9xZInqApNlNGc9s0W1VSsktYSOe9cFqNOIqmN1Gs8SmkjKZYFt017G4VwPxASInODuAdbTW7sXiFUf893RgA==",
53	+	"cpu": [
54	+	"x64"
55	+	],
56	+	"dev": true,
57	+	"license": "Apache-2.0",
58	+	"optional": true,
59	+	"os": [
60	+	"darwin"
61	+	],
62	+	"engines": {
63	+	"node": ">=16.20.0"
64	+	}
65	+	},
66	+	"node_modules/@typescript/typescript-freebsd-arm64": {
67	+	"version": "7.0.2",
68	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-arm64/-/typescript-freebsd-arm64-7.0.2.tgz",
69	+	"integrity": "sha512-W5NH4y/J0plIIS5b2xvTEkU7JFxyqdMAOgf+Ilhl0vHQXKO5dZoxd+C/jEtq56c4F3wk71RB4BMRQ2XdI+bwYQ==",
70	+	"cpu": [
71	+	"arm64"
72	+	],
73	+	"dev": true,
74	+	"license": "Apache-2.0",
75	+	"optional": true,
76	+	"os": [
77	+	"freebsd"
78	+	],
79	+	"engines": {
80	+	"node": ">=16.20.0"
81	+	}
82	+	},
83	+	"node_modules/@typescript/typescript-freebsd-x64": {
84	+	"version": "7.0.2",
85	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-x64/-/typescript-freebsd-x64-7.0.2.tgz",
86	+	"integrity": "sha512-UMGDx5sTpzNw3WiPebH7l90IWfJggEd+egHt/q6p7/Cm3zqoV7VxkGXt+3DxPIw8CcmvAB0j3sVVfbhX+M4Tpw==",
87	+	"cpu": [
88	+	"x64"
89	+	],
90	+	"dev": true,
91	+	"license": "Apache-2.0",
92	+	"optional": true,
93	+	"os": [
94	+	"freebsd"
95	+	],
96	+	"engines": {
97	+	"node": ">=16.20.0"
98	+	}
99	+	},
100	+	"node_modules/@typescript/typescript-linux-arm": {
101	+	"version": "7.0.2",
102	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm/-/typescript-linux-arm-7.0.2.tgz",
103	+	"integrity": "sha512-gffT3xPz9sR7j/YJExkyPntrI0P2EP9XbOyWzth2/Gs0RstK+90RBcO0ncXoXy/beYll1SXw846Nf2zdnEz0QQ==",
104	+	"cpu": [
105	+	"arm"
106	+	],
107	+	"dev": true,
108	+	"license": "Apache-2.0",
109	+	"optional": true,
110	+	"os": [
111	+	"linux"
112	+	],
113	+	"engines": {
114	+	"node": ">=16.20.0"
115	+	}
116	+	},
117	+	"node_modules/@typescript/typescript-linux-arm64": {
118	+	"version": "7.0.2",
119	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm64/-/typescript-linux-arm64-7.0.2.tgz",
120	+	"integrity": "sha512-Qh4eU4/y3yDjnfjjyPYihMj5/ODIlmt+Bzu17OI+fiSRDW57QmU5SiN63exPRNJPKUzcc1INa1NXdrJ+MqHjUQ==",
121	+	"cpu": [
122	+	"arm64"
123	+	],
124	+	"dev": true,
125	+	"license": "Apache-2.0",
126	+	"optional": true,
127	+	"os": [
128	+	"linux"
129	+	],
130	+	"engines": {
131	+	"node": ">=16.20.0"
132	+	}
133	+	},
134	+	"node_modules/@typescript/typescript-linux-loong64": {
135	+	"version": "7.0.2",
136	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-loong64/-/typescript-linux-loong64-7.0.2.tgz",
137	+	"integrity": "sha512-uEHck9i8hoAzXPiYRib1O7miOnz23SxIeVl6F4LXox+qov1K35jHcEW6VHKvZI+pyvl7fZEP4MCU5LYvIq1GuQ==",
138	+	"cpu": [
139	+	"loong64"
140	+	],
141	+	"dev": true,
142	+	"license": "Apache-2.0",
143	+	"optional": true,
144	+	"os": [
145	+	"linux"
146	+	],
147	+	"engines": {
148	+	"node": ">=16.20.0"
149	+	}
150	+	},
151	+	"node_modules/@typescript/typescript-linux-mips64el": {
152	+	"version": "7.0.2",
153	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-mips64el/-/typescript-linux-mips64el-7.0.2.tgz",
154	+	"integrity": "sha512-R4KvAMnE43W5Qeqb0Ly56O3mWMWIAgsMyz36DCaycd5nbg/9kzm0liw3JocfRqyJY0KPmzFjbswozXyW0DnIYA==",
155	+	"cpu": [
156	+	"mips64el"
157	+	],
158	+	"dev": true,
159	+	"license": "Apache-2.0",
160	+	"optional": true,
161	+	"os": [
162	+	"linux"
163	+	],
164	+	"engines": {
165	+	"node": ">=16.20.0"
166	+	}
167	+	},
168	+	"node_modules/@typescript/typescript-linux-ppc64": {
169	+	"version": "7.0.2",
170	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-ppc64/-/typescript-linux-ppc64-7.0.2.tgz",
171	+	"integrity": "sha512-DORx5b3sd/4S7eayxm4FQv+A7CrkUIGRaHiwI8oiHTAI1fAPWhF4J0vAlkC8biAlHSVVwxMQ3tjZ2/DVbnQiiA==",
172	+	"cpu": [
173	+	"ppc64"
174	+	],
175	+	"dev": true,
176	+	"license": "Apache-2.0",
177	+	"optional": true,
178	+	"os": [
179	+	"linux"
180	+	],
181	+	"engines": {
182	+	"node": ">=16.20.0"
183	+	}
184	+	},
185	+	"node_modules/@typescript/typescript-linux-riscv64": {
186	+	"version": "7.0.2",
187	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-riscv64/-/typescript-linux-riscv64-7.0.2.tgz",
188	+	"integrity": "sha512-wf0jqEDOjrPRnKwYRyyJDRo11KMbvMFrU+q4zqKyChODBzvlkbhNQfKvLxQCcwTpdDaXSHZTVuh0JoCrKCUMHQ==",
189	+	"cpu": [
190	+	"riscv64"
191	+	],
192	+	"dev": true,
193	+	"license": "Apache-2.0",
194	+	"optional": true,
195	+	"os": [
196	+	"linux"
197	+	],
198	+	"engines": {
199	+	"node": ">=16.20.0"
200	+	}
201	+	},
202	+	"node_modules/@typescript/typescript-linux-s390x": {
203	+	"version": "7.0.2",
204	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-s390x/-/typescript-linux-s390x-7.0.2.tgz",
205	+	"integrity": "sha512-IkwJc3L7yhytWd/ewjyxNDfOmswCm9GWMJT/ue/dU4aZNbwZeYAetq42VyLmsmSjvoX7z74X6ZaYCtzAr0EuGw==",
206	+	"cpu": [
207	+	"s390x"
208	+	],
209	+	"dev": true,
210	+	"license": "Apache-2.0",
211	+	"optional": true,
212	+	"os": [
213	+	"linux"
214	+	],
215	+	"engines": {
216	+	"node": ">=16.20.0"
217	+	}
218	+	},
219	+	"node_modules/@typescript/typescript-linux-x64": {
220	+	"version": "7.0.2",
221	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-linux-x64/-/typescript-linux-x64-7.0.2.tgz",
222	+	"integrity": "sha512-EYdf2cNg7rgCWJnxCdJ+F3V39O8ihb37eHAu1LK8oAFizgTQbPOK7zHHXbPt8rX24COqODXeI3sIf0fCXG7H/A==",
223	+	"cpu": [
224	+	"x64"
225	+	],
226	+	"dev": true,
227	+	"license": "Apache-2.0",
228	+	"optional": true,
229	+	"os": [
230	+	"linux"
231	+	],
232	+	"engines": {
233	+	"node": ">=16.20.0"
234	+	}
235	+	},
236	+	"node_modules/@typescript/typescript-netbsd-arm64": {
237	+	"version": "7.0.2",
238	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-arm64/-/typescript-netbsd-arm64-7.0.2.tgz",
239	+	"integrity": "sha512-+polYF4MF04aPpO5FTkHran9yUQDSXqy5GiSDKpsll5jy3l3+g9QLhpf39T+ePtefhXLOGrLl0QIjkQP6VnelA==",
240	+	"cpu": [
241	+	"arm64"
242	+	],
243	+	"dev": true,
244	+	"license": "Apache-2.0",
245	+	"optional": true,
246	+	"os": [
247	+	"netbsd"
248	+	],
249	+	"engines": {
250	+	"node": ">=16.20.0"
251	+	}
252	+	},
253	+	"node_modules/@typescript/typescript-netbsd-x64": {
254	+	"version": "7.0.2",
255	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-x64/-/typescript-netbsd-x64-7.0.2.tgz",
256	+	"integrity": "sha512-8YIT0EHM/3dq10ZOVF/A7pc/YSMtbcecct4rWtexrnSCHOPcpC2KTLXfTCR6vDpnSiY12heNb1GiN/wu+T/FyA==",
257	+	"cpu": [
258	+	"x64"
259	+	],
260	+	"dev": true,
261	+	"license": "Apache-2.0",
262	+	"optional": true,
263	+	"os": [
264	+	"netbsd"
265	+	],
266	+	"engines": {
267	+	"node": ">=16.20.0"
268	+	}
269	+	},
270	+	"node_modules/@typescript/typescript-openbsd-arm64": {
271	+	"version": "7.0.2",
272	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-arm64/-/typescript-openbsd-arm64-7.0.2.tgz",
273	+	"integrity": "sha512-APT8+ClYnuYm1u9+kgGXoMj2VzWzcymwh2gNSQVySHfkRDGOTVkoWLjCmOQSaO+PoqQ57B0flRp9SA+7GnnkzQ==",
274	+	"cpu": [
275	+	"arm64"
276	+	],
277	+	"dev": true,
278	+	"license": "Apache-2.0",
279	+	"optional": true,
280	+	"os": [
281	+	"openbsd"
282	+	],
283	+	"engines": {
284	+	"node": ">=16.20.0"
285	+	}
286	+	},
287	+	"node_modules/@typescript/typescript-openbsd-x64": {
288	+	"version": "7.0.2",
289	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-x64/-/typescript-openbsd-x64-7.0.2.tgz",
290	+	"integrity": "sha512-yX7s+Q0Dln0Dt9tEzZsAjXXR/+ytBM7AlglaqyeMPxQszJ1JhlJdZ6jLA+IzldHtflX81em7lDao1xXu+aRRkg==",
291	+	"cpu": [
292	+	"x64"
293	+	],
294	+	"dev": true,
295	+	"license": "Apache-2.0",
296	+	"optional": true,
297	+	"os": [
298	+	"openbsd"
299	+	],
300	+	"engines": {
301	+	"node": ">=16.20.0"
302	+	}
303	+	},
304	+	"node_modules/@typescript/typescript-sunos-x64": {
305	+	"version": "7.0.2",
306	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-sunos-x64/-/typescript-sunos-x64-7.0.2.tgz",
307	+	"integrity": "sha512-dLJDGaLZ1D4HPQn62u1n8mBDkJREwMsAkCdkwd4Ieqw+x3TUyTsqY0YiBCtE6H6OzzgGk3iuZ3vFWRS+E8/d1g==",
308	+	"cpu": [
309	+	"x64"
310	+	],
311	+	"dev": true,
312	+	"license": "Apache-2.0",
313	+	"optional": true,
314	+	"os": [
315	+	"sunos"
316	+	],
317	+	"engines": {
318	+	"node": ">=16.20.0"
319	+	}
320	+	},
321	+	"node_modules/@typescript/typescript-win32-arm64": {
322	+	"version": "7.0.2",
323	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-win32-arm64/-/typescript-win32-arm64-7.0.2.tgz",
324	+	"integrity": "sha512-Gyl1Vy6OsWesLzmq+EP0Fb7b4Nid5232AvcA2SFcdYreldpNtYFFofPjnt62y9hQy7VTaZp65ICJjuAQRaVcIQ==",
325	+	"cpu": [
326	+	"arm64"
327	+	],
328	+	"dev": true,
329	+	"license": "Apache-2.0",
330	+	"optional": true,
331	+	"os": [
332	+	"win32"
333	+	],
334	+	"engines": {
335	+	"node": ">=16.20.0"
336	+	}
337	+	},
338	+	"node_modules/@typescript/typescript-win32-x64": {
339	+	"version": "7.0.2",
340	+	"resolved": "https://registry.npmjs.org/@typescript/typescript-win32-x64/-/typescript-win32-x64-7.0.2.tgz",
341	+	"integrity": "sha512-0BQ3HkAHHlKLSp1qRvf3SUhGpGsDuhB/jgFw75guyqbxJqEaS0Cw/VFO8i2nHglJUzQCRtMMR/IBAKE3ETMC4g==",
342	+	"cpu": [
343	+	"x64"
344	+	],
345	+	"dev": true,
346	+	"license": "Apache-2.0",
347	+	"optional": true,
348	+	"os": [
349	+	"win32"
350	+	],
351	+	"engines": {
352	+	"node": ">=16.20.0"
353	+	}
354	+	},
355	+	"node_modules/typescript": {
356	+	"version": "7.0.2",
357	+	"resolved": "https://registry.npmjs.org/typescript/-/typescript-7.0.2.tgz",
358	+	"integrity": "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==",
359	+	"dev": true,
360	+	"license": "Apache-2.0",
361	+	"bin": {
362	+	"tsc": "bin/tsc"
363	+	},
364	+	"engines": {
365	+	"node": ">=16.20.0"
366	+	},
367	+	"optionalDependencies": {
368	+	"@typescript/typescript-aix-ppc64": "7.0.2",
369	+	"@typescript/typescript-darwin-arm64": "7.0.2",
370	+	"@typescript/typescript-darwin-x64": "7.0.2",
371	+	"@typescript/typescript-freebsd-arm64": "7.0.2",
372	+	"@typescript/typescript-freebsd-x64": "7.0.2",
373	+	"@typescript/typescript-linux-arm": "7.0.2",
374	+	"@typescript/typescript-linux-arm64": "7.0.2",
375	+	"@typescript/typescript-linux-loong64": "7.0.2",
376	+	"@typescript/typescript-linux-mips64el": "7.0.2",
377	+	"@typescript/typescript-linux-ppc64": "7.0.2",
378	+	"@typescript/typescript-linux-riscv64": "7.0.2",
379	+	"@typescript/typescript-linux-s390x": "7.0.2",
380	+	"@typescript/typescript-linux-x64": "7.0.2",
381	+	"@typescript/typescript-netbsd-arm64": "7.0.2",
382	+	"@typescript/typescript-netbsd-x64": "7.0.2",
383	+	"@typescript/typescript-openbsd-arm64": "7.0.2",
384	+	"@typescript/typescript-openbsd-x64": "7.0.2",
385	+	"@typescript/typescript-sunos-x64": "7.0.2",
386	+	"@typescript/typescript-win32-arm64": "7.0.2",
387	+	"@typescript/typescript-win32-x64": "7.0.2"
388	+	}
389	+	}
390	+	}
391	+	}

1	+	{
2	+	"name": "browser-terminal-extension",
3	+	"description": "A tmux sidebar for Chrome and Firefox.",
4	+	"private": true,
5	+	"//": "The extension ships as plain files that the browser loads directly — npm is here for the type checker and nothing else. Nothing in node_modules reaches dist/.",
6	+	"scripts": {
7	+	"test": "node --test extension/lib/*.test.js",
8	+	"check": "tsc -p extension/jsconfig.json && tsc -p extension/jsconfig.sw.json"
9	+	},
10	+	"devDependencies": {
11	+	"typescript": "^7.0.2"
12	+	}
13	+	}

1	+	#!/usr/bin/env bash
2	+	# Build and run the termbridge daemon.
3	+	# ./run.sh serve on the default port
4	+	# ./run.sh --port 8080 pass flags through to `termbridge serve`
5	+	# ./run.sh token run any other subcommand instead of serve
6	+	set -euo pipefail
7	+	cd "$(dirname "$0")/daemon"
8	+
9	+	cargo build --release
10	+
11	+	bin=target/release/termbridge
12	+
13	+	case "${1-}" in
14	+	serve\|token\|pair\|unpair\|list\|cert) exec "$bin" "$@" ;;
15	+	*) exec "$bin" serve "$@" ;;
16	+	esac