jaitus 0.3.4 → 0.3.5

package/src/mcp.js

@@ -1,51 +1,127 @@
 // ─── Model Context Protocol over stdio ─────────────────────────────────────────
 //
 // Jaitus supports the portable part of MCP that is most useful in a terminal: local
-// stdio servers exposing tools. Each tool invocation gets a short-lived server process,
-// which avoids leaking a child process across sessions and makes crashes recoverable.
+// stdio servers exposing tools.
+//
+// Servers come from two places, merged: your own (~/.jaitus/mcp.json, added with
+// `jaitus mcp add --global`) and the project's (.mcp.json). A project's file comes with
+// the repository — somebody else wrote it — so its servers run only after you have
+// approved that exact command (`jaitus mcp trust`, or the prompt in a session). The
+// previous version started every command in a cloned repo's .mcp.json on the first
+// prompt, without asking, even in plan mode.
+//
+// A server is started once and kept for the session, so a stateful one (a browser, a
+// database connection) keeps its state between calls. Discovery is cached per project
+// until a config file changes.
 
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { SESSIONS } from './config.js';
+import { spawn, spawnSync } from 'node:child_process';
+import { SESSIONS, loadSettings, saveSettings } from './config.js';
+
+const GLOBAL_FILE = path.join(path.dirname(SESSIONS), 'mcp.json');
+const projectFile = (cwd) => path.join(cwd, '.mcp.json');
+
+function readServers(file) {
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return data?.mcpServers && typeof data.mcpServers === 'object' ? data.mcpServers : {};
+  } catch { return {}; }
+}
 
-function configPaths(cwd) {
-  return [path.join(cwd, '.mcp.json'), path.join(path.dirname(SESSIONS), 'mcp.json')];
+/** Every configured server: { name, config, scope: 'global'|'project', file }. Project wins a name clash. */
+export function allServers(cwd) {
+  const out = new Map();
+  for (const [name, config] of Object.entries(readServers(GLOBAL_FILE))) out.set(name, { name, config, scope: 'global', file: GLOBAL_FILE });
+  for (const [name, config] of Object.entries(readServers(projectFile(cwd)))) out.set(name, { name, config, scope: 'project', file: projectFile(cwd) });
+  return [...out.values()];
 }
 
+/** Kept for callers that want the old shape. */
 export function readMcpConfig(cwd) {
-  for (const file of configPaths(cwd)) {
-    try {
-      const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-      if (data?.mcpServers && typeof data.mcpServers === 'object') return { file, servers: data.mcpServers };
-    } catch { /* try the next scope */ }
-  }
-  return { file: configPaths(cwd)[0], servers: {} };
+  const servers = {};
+  for (const s of allServers(cwd)) servers[s.name] = s.config;
+  return { file: projectFile(cwd), servers };
+}
+
+// ── Trust ──
+/** What is approved: the command line itself. Change the command and it asks again. */
+export function fingerprint(config) {
+  const body = JSON.stringify({ command: config?.command || '', args: config?.args || [], env: config?.env || {} });
+  return crypto.createHash('sha256').update(body).digest('hex').slice(0, 24);
+}
+const trustKey = (cwd) => path.resolve(cwd).toLowerCase();
+export function isTrusted(cwd, server) {
+  if (server.scope === 'global') return true;
+  const t = loadSettings().trustedMcp?.[trustKey(cwd)] || {};
+  return t[server.name] === fingerprint(server.config);
+}
+export function trustServer(cwd, server) {
+  const s = loadSettings();
+  const all = { ...(s.trustedMcp || {}) };
+  all[trustKey(cwd)] = { ...(all[trustKey(cwd)] || {}), [server.name]: fingerprint(server.config) };
+  saveSettings({ ...s, trustedMcp: all });
+  discovery.clear();
+}
+export function untrustedServers(cwd) {
+  return allServers(cwd).filter((s) => s.config?.command && !isTrusted(cwd, s));
 }
 
 export function listMcpServers(cwd) {
-  const { servers } = readMcpConfig(cwd);
-  return Object.entries(servers).map(([name, config]) => ({
-    name,
-    transport: config?.type || (config?.command ? 'stdio' : 'unknown'),
-    command: config?.command || config?.url || '',
+  return allServers(cwd).map((s) => ({
+    name: s.name,
+    scope: s.scope,
+    trusted: isTrusted(cwd, s),
+    transport: s.config?.type || (s.config?.command ? 'stdio' : 'unknown'),
+    command: [s.config?.command || s.config?.url || '', ...(s.config?.args || [])].join(' ').trim(),
   }));
 }
 
-export function addMcpServer(cwd, name, config) {
-  const projectFile = path.join(cwd, '.mcp.json');
-  let servers = {};
-  try { servers = JSON.parse(fs.readFileSync(projectFile, 'utf8')).mcpServers || {}; } catch { /* create project config */ }
-  const next = { mcpServers: { ...servers, [name]: config } };
-  fs.writeFileSync(projectFile, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+export function addMcpServer(cwd, name, config, { global = false } = {}) {
+  const file = global ? GLOBAL_FILE : projectFile(cwd);
+  const next = { mcpServers: { ...readServers(file), [name]: config } };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  // You added it yourself: approved.
+  if (!global) trustServer(cwd, { name, config, scope: 'project' });
+  discovery.clear();
 }
 
 export function removeMcpServer(cwd, name) {
-  const current = readMcpConfig(cwd);
-  if (!current.servers[name]) return false;
-  const { [name]: _, ...rest } = current.servers;
-  fs.writeFileSync(current.file, `${JSON.stringify({ mcpServers: rest }, null, 2)}\n`, { mode: 0o600 });
-  return true;
+  for (const file of [projectFile(cwd), GLOBAL_FILE]) {
+    const servers = readServers(file);
+    if (!servers[name]) continue;
+    const { [name]: _, ...rest } = servers;
+    fs.writeFileSync(file, `${JSON.stringify({ mcpServers: rest }, null, 2)}\n`, { mode: 0o600 });
+    discovery.clear();
+    closeAll();
+    return true;
+  }
+  return false;
+}
+
+// ── Starting a server ──
+
+/**
+ * On Windows, spawn without a shell only finds .exe and .com — `npx`, `npm`, `uvx` are
+ * .cmd shims and failed with ENOENT (silently: the server just had no tools). The
+ * command is looked up on PATH with PATHEXT; a .cmd/.bat is run through cmd.exe with
+ * every argument quoted.
+ */
+function resolveSpawn(command, args) {
+  if (process.platform !== 'win32') return { file: command, args, opts: {} };
+  let full = command;
+  if (!/[\\/]/.test(command) || !path.extname(command)) {
+    const r = spawnSync('where', [command], { encoding: 'utf8', windowsHide: true });
+    const hits = String(r.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+    full = hits.find((h) => /\.(exe|com)$/i.test(h)) || hits.find((h) => /\.(cmd|bat)$/i.test(h)) || command;
+  }
+  if (/\.(cmd|bat)$/i.test(full)) {
+    const q = (s) => `"${String(s).replace(/"/g, '""')}"`;
+    return { file: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', `"${[q(full), ...args.map(q)].join(' ')}"`], opts: { windowsVerbatimArguments: true } };
+  }
+  return { file: full, args, opts: {} };
 }
 
 class StdioClient {
@@ -55,25 +131,37 @@ class StdioClient {
     this.nextId = 1;
     this.pending = new Map();
     this.buffer = '';
+    this.stderr = '';
+    this.alive = false;
   }
 
   async start() {
     if (!this.config?.command) throw new Error('MCP server has no stdio command');
-    this.child = spawn(this.config.command, this.config.args || [], {
+    const { file, args, opts } = resolveSpawn(this.config.command, this.config.args || []);
+    this.child = spawn(file, args, {
       cwd: this.cwd,
       shell: false,
       env: { ...process.env, ...(this.config.env || {}) },
-      stdio: ['pipe', 'pipe', 'ignore'],
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+      ...opts,
     });
+    this.alive = true;
+    // A server kept for the session must not keep the PROCESS alive: a one-shot run
+    // finished its answer and then never exited. A request in flight holds its own
+    // timer, which is what keeps Node running while one is needed.
+    try { this.child.unref(); this.child.stdout.unref?.(); this.child.stderr.unref?.(); this.child.stdin.unref?.(); } catch { /* keep them */ }
     this.child.stdout.setEncoding('utf8');
     this.child.stdout.on('data', (chunk) => this.onData(chunk));
-    this.child.on('error', (error) => this.rejectAll(error));
-    this.child.on('close', (code) => this.rejectAll(new Error(`MCP server exited (${code ?? 'unknown'})`)));
+    // Kept (the tail) so a failure can say what the server said.
+    this.child.stderr.on('data', (d) => { this.stderr = (this.stderr + d).slice(-2000); });
+    this.child.on('error', (error) => { this.alive = false; this.rejectAll(error); });
+    this.child.on('close', (code) => { this.alive = false; this.rejectAll(new Error(`MCP server exited (${code ?? 'unknown'})${this.stderr.trim() ? `: ${this.stderr.trim().split('\n').pop()}` : ''}`)); });
     await this.request('initialize', {
       protocolVersion: '2024-11-05',
       capabilities: {},
-      clientInfo: { name: 'jaitus', version: '0.2.0' },
-    });
+      clientInfo: { name: 'jaitus', version: '0.3' },
+    }, 20_000);
     this.notify('notifications/initialized', {});
     return this;
   }
@@ -96,23 +184,24 @@ class StdioClient {
     }
   }
 
-  request(method, params) {
+  request(method, params, timeoutMs = 120_000) {
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
-        reject(new Error(`MCP request timed out: ${method}`));
-      }, 15_000);
+        reject(new Error(`MCP request timed out after ${Math.round(timeoutMs / 1000)}s: ${method}`));
+      }, timeoutMs);
       this.pending.set(id, {
         resolve: (value) => { clearTimeout(timer); resolve(value); },
         reject: (error) => { clearTimeout(timer); reject(error); },
       });
-      this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+      try { this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`); }
+      catch (e) { this.pending.delete(id); clearTimeout(timer); reject(e); }
     });
   }
 
   notify(method, params) {
-    this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
+    try { this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`); } catch { /* gone */ }
   }
 
   rejectAll(error) {
@@ -121,40 +210,88 @@ class StdioClient {
   }
 
   close() {
-    try { this.child?.kill(); } catch { /* already gone */ }
+    this.alive = false;
+    try {
+      if (process.platform === 'win32' && this.child?.pid) spawnSync('taskkill', ['/pid', String(this.child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+      else this.child?.kill();
+    } catch { /* already gone */ }
   }
 }
 
-/** Discover MCP tools and wrap them in the same permission-aware shape as local tools. */
-export async function discoverMcpTools(cwd) {
-  const { servers } = readMcpConfig(cwd);
-  const result = [];
-  for (const [serverName, config] of Object.entries(servers)) {
-    if (!config?.command) continue; // HTTP/SSE can be added without changing the tool shape.
-    const client = new StdioClient(config, cwd);
-    try {
-      await client.start();
-      const listed = await client.request('tools/list', {});
-      for (const remote of listed?.tools || []) {
-        const name = `mcp__${serverName}__${remote.name}`;
-        result.push({
-          name,
-          description: remote.description || `Tool ${remote.name} from MCP server ${serverName}.`,
-          input_schema: remote.inputSchema || { type: 'object', properties: {} },
-          needsPermission: true,
-          summarise: () => `${serverName}: ${remote.name}`,
-          async run(input) {
-            const live = new StdioClient(config, cwd);
-            try {
-              await live.start();
-              const response = await live.request('tools/call', { name: remote.name, arguments: input || {} });
-              return response?.content?.map((item) => item.text || JSON.stringify(item)).join('\n') || JSON.stringify(response || {});
-            } finally { live.close(); }
-          },
-        });
-      }
-    } catch { /* an unavailable integration must not disable the local agent */ }
-    finally { client.close(); }
+// One live client per server for the session.
+const clients = new Map();
+function closeAll() { for (const client of clients.values()) client.close(); clients.clear(); }
+process.once('exit', closeAll);
+
+async function clientFor(key, config, cwd) {
+  const have = clients.get(key);
+  if (have?.alive) return have;
+  const fresh = new StdioClient(config, cwd);
+  await fresh.start();
+  clients.set(key, fresh);
+  return fresh;
+}
+
+// A provider rejects every request whose tools list holds an invalid name.
+const safeName = (s) => String(s).replace(/[^a-zA-Z0-9_-]/g, '_');
+
+function toolText(response) {
+  return (response?.content || []).map((item) => {
+    if (item?.type === 'text') return item.text;
+    if (item?.type === 'image') return '[the tool returned an image]';
+    if (item?.type === 'resource') return item.resource?.text || `[resource ${item.resource?.uri || ''}]`;
+    return JSON.stringify(item);
+  }).join('\n') || JSON.stringify(response || {});
+}
+
+const discovery = new Map(); // cwd|mtimes -> Promise<tools>
+
+function stamp(cwd) {
+  return [GLOBAL_FILE, projectFile(cwd)].map((f) => { try { return fs.statSync(f).mtimeMs; } catch { return 0; } }).join('|');
+}
+
+/**
+ * The tools of every trusted server, in the same permission-aware shape as local tools.
+ * Servers are started in parallel, once per session (until a config file changes).
+ */
+export function discoverMcpTools(cwd) {
+  const key = `${path.resolve(cwd)}|${stamp(cwd)}|${JSON.stringify(loadSettings().trustedMcp?.[trustKey(cwd)] || {})}`;
+  if (!discovery.has(key)) {
+    discovery.set(key, (async () => {
+      const servers = allServers(cwd).filter((s) => s.config?.command && isTrusted(cwd, s));
+      const lists = await Promise.all(servers.map(async (server) => {
+        const ckey = `${path.resolve(cwd)}|${server.scope}|${server.name}|${fingerprint(server.config)}`;
+        try {
+          const client = await clientFor(ckey, server.config, cwd);
+          const listed = await client.request('tools/list', {}, 20_000);
+          return (listed?.tools || []).map((remote) => ({
+            name: `mcp__${safeName(server.name)}__${safeName(remote.name)}`.slice(0, 64),
+            description: remote.description || `Tool ${remote.name} from MCP server ${server.name}.`,
+            input_schema: remote.inputSchema || { type: 'object', properties: {} },
+            needsPermission: true,
+            summarise: () => `${server.name}: ${remote.name}`,
+            async run(input) {
+              const live = await clientFor(ckey, server.config, cwd);
+              const timeout = Number(server.config.timeoutMs) > 0 ? Number(server.config.timeoutMs) : 120_000;
+              const response = await live.request('tools/call', { name: remote.name, arguments: input || {} }, timeout);
+              const text = toolText(response);
+              // The server said it failed: a failure, not a result that happens to
+              // contain an error message.
+              if (response?.isError) throw new Error(text || `${remote.name} failed`);
+              return text;
+            },
+          }));
+        } catch (e) {
+          // Shown once per session instead of silently leaving the server toolless.
+          mcpProblems.set(server.name, e.message);
+          return [];
+        }
+      }));
+      return lists.flat();
+    })());
   }
-  return result;
+  return discovery.get(key);
 }
+
+/** Servers that failed to start this session, and why. */
+export const mcpProblems = new Map();

package/src/session.js

@@ -49,6 +49,20 @@ export function deviceId() {
   return id;
 }
 
+/**
+ * Tokens go only to the server that issued them. Pointing the CLI elsewhere
+ * (`jaitus config baseUrl …`, JAITUS_BASE_URL) used to send the saved access AND refresh
+ * tokens to that host — anyone who got a user to set it could take over the account.
+ * The login records its server; a different origin needs its own sign-in.
+ */
+export function assertSameServer(creds) {
+  if (!creds?.baseUrl) return; // older logins did not record it
+  const origin = (u) => { try { return new URL(u).origin.toLowerCase(); } catch { return String(u || '').toLowerCase(); } };
+  if (origin(creds.baseUrl) !== origin(endpoints().baseUrl)) {
+    throw new JaitusError({ code: 'auth_required', message: `You are signed in to ${origin(creds.baseUrl)}, but Jaitus is pointed at ${origin(endpoints().baseUrl)}. Sign in there with /login, or point it back.` });
+  }
+}
+
 export function deviceName() {
   return os.hostname().slice(0, 60);
 }
@@ -151,6 +165,7 @@ export async function accessToken({ rejected = null } = {}) {
   if (process.env.JAITUS_TOKEN) return process.env.JAITUS_TOKEN.trim();
   const creds = loadCredentials();
   if (!creds?.refreshToken) throw new JaitusError({ code: 'auth_required' });
+  assertSameServer(creds);
   if (!rejected && fresh(creds)) return creds.accessToken;
   // Another process may already have renewed: the file holds a different, fresh token.
   if (rejected && fresh(creds) && creds.accessToken !== rejected) return creds.accessToken;
@@ -190,7 +205,10 @@ export async function signOut() {
   if (!creds?.refreshToken && !creds?.accessToken) return { hadSession: false, server: false };
   const { baseUrl } = endpoints();
   let server = false;
+  let otherServer = false;
+  try { assertSameServer(creds); } catch { otherServer = true; }
   try {
+    if (otherServer) throw new Error('pointed at a different server — the tokens are not sent there');
     const res = await fetch(`${baseUrl}/api/auth/cli/logout`, {
       method: 'POST',
       headers: {

package/src/sessions.js

@@ -46,7 +46,19 @@ export function saveSession(session) {
 }
 
 export function loadSession(id) {
-  const file = fileFor(id);
+  const direct = readSessionFile(fileFor(id));
+  if (direct) return direct;
+  // The ids shown by `jaitus sessions` and /sessions are 8-character prefixes; resuming
+  // one of those used to say "No saved session found". A unique prefix is enough.
+  const want = String(id || '').trim().toLowerCase();
+  if (want.length < 4) return null;
+  try {
+    const hits = fs.readdirSync(SESSIONS).filter((name) => name.endsWith('.json') && name.toLowerCase().startsWith(want));
+    return hits.length === 1 ? readSessionFile(path.join(SESSIONS, hits[0])) : null;
+  } catch { return null; }
+}
+
+function readSessionFile(file) {
   if (!file) return null;
   try {
     const session = JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -57,13 +69,19 @@ export function loadSession(id) {
   }
 }
 
+/** The same folder, however it was typed: on Windows `c:\app` and `C:\App` are one place. */
+export const sameDir = (a, b) => {
+  const norm = (p) => { const r = path.resolve(String(p || '')); return process.platform === 'win32' ? r.toLowerCase() : r; };
+  return norm(a) === norm(b);
+};
+
 export function listSessions({ cwd = null } = {}) {
   try {
     return fs.readdirSync(SESSIONS)
       .filter((name) => name.endsWith('.json'))
       .map((name) => loadSession(name.slice(0, -5)))
       .filter(Boolean)
-      .filter((session) => !cwd || path.resolve(session.cwd) === path.resolve(cwd))
+      .filter((session) => !cwd || sameDir(session.cwd, cwd))
       .sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
   } catch {
     return [];

package/src/terminal.js

@@ -8,28 +8,57 @@
 // instead of painting codes that render as nothing. Sixel capability is
 // attribute 4 (";4" in the report).
 //
+// The same handshake asks for the BACKGROUND colour (OSC 11). "auto" used to read only
+// COLORFGBG, which macOS Terminal, VS Code and Windows Terminal never set, so a light
+// terminal got the dark theme: near-white input text on a white window. OSC 11 is sent
+// FIRST and DA second: terminals answer in order and every terminal answers DA, so a DA
+// reply with no colour before it means "does not support the query", and nothing waits
+// for a reply that will never come (the approach Neovim and terminal-colorsaurus use).
+//
 // Done inline as a subprocess-style handshake: raw mode for the duration so
 // the reply doesn't echo, restored on the way out. Cached per process;
 // `probeDevice` does the work once.
 
 import fs from 'node:fs';
 
-const state = { done: false, vt: false, sixel: false };
+const state = { done: false, vt: false, sixel: false, background: null };
 let pending = null;
 
 /** A device-attributes reply: CSI [? params c. */
 const DA_REPLY = /\x1b\[[?0-9;]*c/;
 /** The replies that mean "yes, images": xterm's CSI ? 6 2 ; ... c and kin. */
 const SIXEL_ATTR = /;4[;c]/;
+/** A background-colour reply: OSC 11 ; rgb:R/G/B (1-4 hex digits each), ended by BEL or ST. */
+const BG_REPLY = /\x1b\]11;rgb:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})(?:\x07|\x1b\\)/i;
+
+/**
+ * 'light' or 'dark' from an OSC 11 reply, or null. By WCAG relative luminance, with the
+ * cut at 0.179 — the point where black text and white text contrast equally with it.
+ */
+export function backgroundFromReply(text) {
+  const m = BG_REPLY.exec(String(text || ''));
+  if (!m) return null;
+  const [r, g, b] = m.slice(1, 4).map((h) => parseInt(h, 16) / (16 ** h.length - 1));
+  const lin = (c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+  const luminance = 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+  return luminance > 0.179 ? 'light' : 'dark';
+}
 
 // 300ms was too tight. A terminal over SSH, one under a multiplexer, or one whose reply
 // queues behind anything else on stdin misses it — and a missed reply used to be read as
 // "this console cannot do escape sequences", which turned the whole UI to ASCII twins.
 // Startup does not wait on this: the probe runs concurrently with the model lookup.
-export function probeDevice({ timeoutMs = 900 } = {}) {
+// `input`/`write` are the terminal's two directions; the defaults are the real ones, and
+// tests pass a stand-in to hold the exact conversation a terminal has with the app.
+export function probeDevice({
+  timeoutMs = 900,
+  input = process.stdin,
+  write = (text) => fs.writeSync(1, text),
+  tty = Boolean(process.stdout.isTTY && process.stdin.isTTY),
+} = {}) {
   if (state.done) return Promise.resolve({ vt: state.vt, sixel: state.sixel });
   if (pending) return pending;
-  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+  if (!tty) {
     state.done = true;
     return Promise.resolve({ vt: false, sixel: false });
   }
@@ -38,18 +67,19 @@ export function probeDevice({ timeoutMs = 900 } = {}) {
     let finished = false;
     let buffer = '';
     let wasRaw = false;
-    try { wasRaw = !!process.stdin.isRaw; } catch { /* not a TTY */ }
+    try { wasRaw = !!input.isRaw; } catch { /* not a TTY */ }
     const finish = () => {
       if (finished) return;
       finished = true;
       clearTimeout(timer);
-      try { process.stdin.setRawMode(wasRaw); } catch { /* already gone */ }
-      try { process.stdin.pause(); } catch { /* already gone */ }
-      process.stdin.removeListener('data', onData);
+      try { input.setRawMode(wasRaw); } catch { /* already gone */ }
+      try { input.pause(); } catch { /* already gone */ }
+      input.removeListener('data', onData);
       const vt = DA_REPLY.test(buffer);
       state.done = true;
       state.vt = vt;
       state.sixel = vt && SIXEL_ATTR.test(buffer);
+      state.background = backgroundFromReply(buffer);
       pending = null;
       resolve({ vt: state.vt, sixel: state.sixel });
     };
@@ -62,11 +92,11 @@ export function probeDevice({ timeoutMs = 900 } = {}) {
     const timer = setTimeout(finish, timeoutMs);
 
     try {
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.on('data', onData);
+      input.setRawMode(true);
+      input.resume();
+      input.on('data', onData);
       // Ask on stdout. The reply comes back through stdin as if typed.
-      fs.writeSync(1, '\x1b[c');
+      write('\x1b]11;?\x1b\\\x1b[c');
     } catch {
       finish();
     }
@@ -74,6 +104,11 @@ export function probeDevice({ timeoutMs = 900 } = {}) {
   return pending;
 }
 
+/** 'light' | 'dark' as the terminal itself reported it, or null when it did not say. */
+export function terminalBackground() {
+  return state.background;
+}
+
 /** Legacy wrapper: true when this terminal shows sixel images. */
 export async function probeAsync({ timeoutMs = 400 } = {}) {
   const { sixel } = await probeDevice({ timeoutMs });

package/src/tui/ansi.js

@@ -225,7 +225,9 @@ export function wrapRow(row, width, indent = '') {
       for (const ch of chunk) {
         const cw = cellWidth(ch.codePointAt(0));
         if (used + pieceWidth + cw > width) {
-          current.push({ ...span, t: piece });
+          // `cut` marks a word split mid-way, so a URL cut here can be rejoined when it is
+          // clicked (the renderer ignores the field).
+          current.push(piece ? { ...span, t: piece, cut: true } : { ...span, t: piece });
           flush();
           piece = '';
           pieceWidth = 0;