codsh-bundle 0.3.0 → 0.4.0

package/lib/index.js

@@ -88,6 +88,7 @@ const SGR$1 = {
 /** A theme that emits no sequences, used off a TTY and under `NO_COLOR`. */
 const PLAIN = {
 	colored: false,
+	setLight: () => {},
 	dim: (text) => text,
 	bold: (text) => text,
 	error: (text) => text,
@@ -122,9 +123,13 @@ function createTheme(isTty, env) {
 	if (!isTty || env.NO_COLOR !== void 0) return PLAIN;
 	const palette = env.TERM?.includes("256color") === true || env.COLORTERM !== void 0;
 	const wrap = (code) => (text) => `${code}${text}${SGR$1.reset}`;
+	let gray = "\x1B[38;5;245m";
 	return {
 		colored: true,
-		dim: wrap(palette ? "\x1B[38;5;245m" : SGR$1.dim),
+		setLight(light) {
+			gray = light ? "\x1B[38;5;242m" : "\x1B[38;5;245m";
+		},
+		dim: (text) => `${palette ? gray : SGR$1.dim}${text}${SGR$1.reset}`,
 		bold: wrap(SGR$1.bold),
 		error: wrap(SGR$1.red),
 		success: wrap(SGR$1.green),
@@ -141,6 +146,25 @@ function createTheme(isTty, env) {
 	};
 }
 /**
+* Whether an OSC 10/11 color answer names a light color.
+*
+* Channels arrive as `rgb:RR/GG/BB` with one to four hex digits each; each is
+* normalized by its own width before the relative-luminance weighting.
+* @param payload - the reply payload, e.g. `rgb:ffff/ffff/ffff`.
+* @returns true for light, false for dark, undefined when unparseable.
+*/
+function backgroundIsLight(payload) {
+	const match = /^rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i.exec(payload.trim());
+	if (match === null) return void 0;
+	const channel = (hex) => Number.parseInt(hex, 16) / (16 ** hex.length - 1);
+	const [red, green, blue] = [
+		channel(match[1] ?? "0"),
+		channel(match[2] ?? "0"),
+		channel(match[3] ?? "0")
+	];
+	return .2126 * red + .7152 * green + .0722 * blue > .5;
+}
+/**
 * Display columns a string occupies once printed, ignoring styling sequences.
 *
 * Measured by `string-width` — the width authority cli-table3, ink, and every
@@ -653,14 +677,48 @@ const PASTE_END = "\x1B[201~";
 const WHEEL_LINES = 1;
 /** An SGR mouse report: `ESC [ < button ; column ; row (M|m)`. */
 const MOUSE = /^\u001B\[<(\d+);(\d+);(\d+)([Mm])/;
+/**
+* A kitty-keyboard-protocol report: `ESC [ code (:alternates) ; mods (:event) u`.
+*
+* The viewport pushes the protocol's disambiguate flag on entry (the same
+* flag Claude Code pushes), so terminals that speak it report Esc and every
+* modified key unambiguously — which is what makes Shift+Enter a key at all.
+* Terminals that don't speak it ignore the push and keep sending the legacy
+* sequences below.
+*/
+const KITTY = /^\u001B\[(\d+)(?::\d+)*(?:;(\d+)(?::(\d+))?)?u/;
+/** Kitty modifier bits, after the encoded +1 offset is removed. */
+const KITTY_SHIFT = 1;
+/** The Alt bit. */
+const KITTY_ALT = 2;
+/** The Control bit. */
+const KITTY_CTRL = 4;
 /** Wheel-up button code in the SGR encoding; wheel-down is one higher. */
 const WHEEL_UP = 64;
 /** Modifier bits in an SGR button code: Shift, Meta, and Control. */
 const MOUSE_MODIFIERS = 28;
 /** The motion bit, set on reports sent while a button is held. */
 const MOUSE_MOTION = 32;
+/**
+* An OSC reply from the terminal: `ESC ] code ; payload (BEL | ESC \)`.
+*
+* The viewport asks for the background color (OSC 11) on entry; the reply
+* arrives on stdin and must be consumed here — leaked past the decoder it
+* would be typed into the input box as text.
+*/
+const OSC_REPLY = /^\u001B\](\d+);([^\u0007\u001B]*)(?:\u0007|\u001B\\)/;
+/** An OSC reply still arriving, its possible ST half included. */
+const OSC_PARTIAL = /^\u001B\](?:\d*(?:;[^\u0007\u001B]*)?)?\u001B?$/;
 /** Sequences that resolve to one key, longest first so a prefix never wins. */
 const SEQUENCES = [
+	["\x1B[I", {
+		kind: "focus",
+		focused: true
+	}],
+	["\x1B[O", {
+		kind: "focus",
+		focused: false
+	}],
 	["\x1B[5~", {
 		kind: "page",
 		direction: -1
@@ -816,7 +874,23 @@ var KeyDecoder = class {
 			}
 			return [];
 		}
-		if (/^\u001B(\[(<\d*(;\d*){0,2})?)?$/.test(this.held)) return void 0;
+		const kitty = KITTY.exec(this.held);
+		if (kitty !== null) {
+			this.held = this.held.slice(kitty[0].length);
+			return this.kittyKey(Number(kitty[1]), Number(kitty[2] ?? "1"), Number(kitty[3] ?? "1"));
+		}
+		const osc = OSC_REPLY.exec(this.held);
+		if (osc !== null) {
+			this.held = this.held.slice(osc[0].length);
+			const code = Number(osc[1]);
+			if (code === 10 || code === 11) return [{
+				kind: "osc-reply",
+				code,
+				payload: osc[2] ?? ""
+			}];
+			return [];
+		}
+		if (/^\u001B(\[[\d;:<]*)?$/.test(this.held) || OSC_PARTIAL.test(this.held)) return void 0;
 		for (const [sequence, key] of SEQUENCES) {
 			if (this.held.startsWith(sequence)) {
 				this.held = this.held.slice(sequence.length);
@@ -846,6 +920,38 @@ var KeyDecoder = class {
 		}];
 	}
 	/**
+	* Map one kitty-protocol report onto the same keys the legacy bytes make.
+	* @param code - the key's Unicode code point.
+	* @param mods - the encoded modifiers, offset by one.
+	* @param event - press (1), repeat (2), or release (3).
+	* @returns the keys produced; unknown chords are swallowed, never typed.
+	*/
+	kittyKey(code, mods, event) {
+		if (event === 3) return [];
+		const bits = Math.max(0, mods - 1);
+		const shift = (bits & KITTY_SHIFT) !== 0;
+		const alt = (bits & KITTY_ALT) !== 0;
+		const ctrl = (bits & KITTY_CTRL) !== 0;
+		if (code === 27) return [{ kind: "escape" }];
+		if (code === 13) return [shift || alt ? { kind: "newline" } : { kind: "enter" }];
+		if (code === 9) return [shift ? { kind: "shift-tab" } : { kind: "tab" }];
+		if (code === 127 || code === 8) return [alt || ctrl ? { kind: "kill-word" } : { kind: "backspace" }];
+		if (ctrl && code >= 97 && code <= 122) {
+			const control = CONTROLS[String.fromCharCode(code - 96)];
+			return control === void 0 ? [] : [control];
+		}
+		if (alt) {
+			if (code === 98) return [{ kind: "word-left" }];
+			if (code === 102) return [{ kind: "word-right" }];
+			return [];
+		}
+		if (!ctrl && code >= 32) return [{
+			kind: "text",
+			text: String.fromCodePoint(code)
+		}];
+		return [];
+	}
+	/**
 	* Collect bracketed-paste content up to its end marker.
 	* @returns the paste key once complete, otherwise undefined.
 	*/
@@ -958,6 +1064,24 @@ const LEAVE_ALT = "\x1B[?1049l";
 const ENABLE_MOUSE = "\x1B[?1002h\x1B[?1006h";
 /** Stop reporting them. */
 const DISABLE_MOUSE = "\x1B[?1006l\x1B[?1002l";
+/**
+* Push the kitty keyboard protocol's disambiguate flag — what Claude Code
+* pushes — so Shift+Enter, Esc, and control chords report unambiguously on
+* terminals that speak it. Others ignore the push and keep the legacy bytes.
+*/
+const ENABLE_KITTY_KEYS = "\x1B[>1u";
+/** Pop it, restoring whatever the shell had. */
+const DISABLE_KITTY_KEYS = "\x1B[<u";
+/** Report focus in/out (mode 1004), which the bell policy reads. */
+const ENABLE_FOCUS = "\x1B[?1004h";
+/** Stop reporting focus. */
+const DISABLE_FOCUS = "\x1B[?1004l";
+/**
+* Ask the terminal for its background color (OSC 11), the way opencode and
+* Codex do. The reply decides the light-background palette; a terminal that
+* never answers leaves the dark default standing.
+*/
+const QUERY_BACKGROUND = "\x1B]11;?\x07";
 /** Ask the terminal to paint a frame atomically, so no half-frame is shown. */
 const SYNC_BEGIN = "\x1B[?2026h";
 /** End the atomic frame. */
@@ -1037,7 +1161,7 @@ var Screen = class {
 	enter() {
 		if (this.active) return;
 		this.active = true;
-		this.host.write(`${ENTER_ALT}${ENABLE_MOUSE}${HIDE_CURSOR}`);
+		this.host.write(`${ENTER_ALT}${ENABLE_MOUSE}${ENABLE_KITTY_KEYS}${ENABLE_FOCUS}${QUERY_BACKGROUND}${HIDE_CURSOR}`);
 		this.painted = [];
 		this.render();
 	}
@@ -1050,7 +1174,7 @@ var Screen = class {
 	leave() {
 		if (!this.active) return;
 		this.active = false;
-		this.host.write(`${DISABLE_MOUSE}${SHOW_CURSOR}${LEAVE_ALT}`);
+		this.host.write(`${DISABLE_FOCUS}${DISABLE_KITTY_KEYS}${DISABLE_MOUSE}${SHOW_CURSOR}${LEAVE_ALT}`);
 		this.painted = [];
 	}
 	/**
@@ -1442,6 +1566,11 @@ var TerminalConsole = class {
 	keyHandler;
 	/** Keys decoded before any handler registered — type-ahead is never dropped. */
 	earlyKeys = [];
+	/** Whether the terminal window has focus; undefined until it reports. */
+	focused;
+	/** The terminal's OSC 11 background answer, kept for late listeners. */
+	background;
+	backgroundHandler;
 	escapeTimer;
 	ended = false;
 	/** The viewport this surface owns on a terminal; absent off one. */
@@ -1600,6 +1729,17 @@ var TerminalConsole = class {
 	}
 	/** Hand one key to the handler, or hold it until one registers. */
 	deliver(key) {
+		if (key.kind === "focus") {
+			this.focused = key.focused;
+			return;
+		}
+		if (key.kind === "osc-reply") {
+			if (key.code === 11) {
+				this.background = key.payload;
+				this.backgroundHandler?.(key.payload);
+			}
+			return;
+		}
 		if (this.keyHandler === void 0) {
 			this.earlyKeys.push(key);
 			return;
@@ -1771,9 +1911,21 @@ var TerminalConsole = class {
 	/** Ring the terminal bell; a pipe gets nothing to beep with. */
 	bell() {
 		if (!this.isTty) return;
+		if (this.focused === true) return;
 		this.output.write("\x07");
 	}
 	/**
+	* Register for the terminal's background-color answer (OSC 11).
+	*
+	* The answer often lands before anyone is ready to hear it — the query goes
+	* out with the first frame — so a buffered reply is delivered immediately.
+	* @param handler - receives the raw payload, e.g. `rgb:1e1e/1e1e/2e2e`.
+	*/
+	onBackground(handler) {
+		this.backgroundHandler = handler;
+		if (this.background !== void 0) handler(this.background);
+	}
+	/**
 	* Set the terminal window title.
 	* @param title - the title text; control bytes are the terminal's to reject.
 	*/
@@ -4131,6 +4283,10 @@ async function run(ctx, config, io) {
 	if (sessions === void 0) return;
 	const cwd = process.cwd();
 	const theme = createTheme(io.console.isTty, process.env);
+	io.console.onBackground((payload) => {
+		const light = backgroundIsLight(payload);
+		if (light !== void 0) theme.setLight(light);
+	});
 	const preset = await installPackagedPreset();
 	if (preset.installed) io.console.write(theme.dim(`installed preset into ${preset.path}`));
 	const composed = await compose(ctx, config, cwd);

package/lib/types/console.d.ts

@@ -42,6 +42,11 @@ export declare class TerminalConsole {
     private keyHandler;
     /** Keys decoded before any handler registered — type-ahead is never dropped. */
     private readonly earlyKeys;
+    /** Whether the terminal window has focus; undefined until it reports. */
+    private focused;
+    /** The terminal's OSC 11 background answer, kept for late listeners. */
+    private background;
+    private backgroundHandler;
     private escapeTimer;
     private ended;
     /** The viewport this surface owns on a terminal; absent off one. */
@@ -212,6 +217,14 @@ export declare class TerminalConsole {
     clearRegion(): void;
     /** Ring the terminal bell; a pipe gets nothing to beep with. */
     bell(): void;
+    /**
+     * Register for the terminal's background-color answer (OSC 11).
+     *
+     * The answer often lands before anyone is ready to hear it — the query goes
+     * out with the first frame — so a buffered reply is delivered immediately.
+     * @param handler - receives the raw payload, e.g. `rgb:1e1e/1e1e/2e2e`.
+     */
+    onBackground(handler: (payload: string) => void): void;
     /**
      * Set the terminal window title.
      * @param title - the title text; control bytes are the terminal's to reject.

package/lib/types/keys.d.ts

@@ -81,6 +81,13 @@ export type Key = {
     kind: 'mouse-up';
     row: number;
     column: number;
+} | {
+    kind: 'focus';
+    focused: boolean;
+} | {
+    kind: 'osc-reply';
+    code: number;
+    payload: string;
 };
 /** Decodes terminal bytes into keys, holding partial sequences between reads. */
 export declare class KeyDecoder {
@@ -111,6 +118,14 @@ export declare class KeyDecoder {
      * @returns the keys produced, or undefined when more bytes are needed.
      */
     private take;
+    /**
+     * Map one kitty-protocol report onto the same keys the legacy bytes make.
+     * @param code - the key's Unicode code point.
+     * @param mods - the encoded modifiers, offset by one.
+     * @param event - press (1), repeat (2), or release (3).
+     * @returns the keys produced; unknown chords are swallowed, never typed.
+     */
+    private kittyKey;
     /**
      * Collect bracketed-paste content up to its end marker.
      * @returns the paste key once complete, otherwise undefined.

package/lib/types/theme.d.ts

@@ -21,6 +21,14 @@ export interface Theme {
     path(text: string): string;
     /** The user's own echoed input. */
     user(text: string): string;
+    /**
+     * Adopt the light- or dark-background palette.
+     *
+     * Base ANSI colors are the terminal theme's to map, but the secondary-text
+     * gray is an absolute palette entry, and the shade that recedes on a dark
+     * background washes out on a light one.
+     */
+    setLight(light: boolean): void;
     /** Roles used inside a fenced code block. */
     readonly syntax: SyntaxTheme;
 }
@@ -47,6 +55,15 @@ export interface SyntaxTheme {
  * @returns the styling functions for this surface.
  */
 export declare function createTheme(isTty: boolean, env: Record<string, string | undefined>): Theme;
+/**
+ * Whether an OSC 10/11 color answer names a light color.
+ *
+ * Channels arrive as `rgb:RR/GG/BB` with one to four hex digits each; each is
+ * normalized by its own width before the relative-luminance weighting.
+ * @param payload - the reply payload, e.g. `rgb:ffff/ffff/ffff`.
+ * @returns true for light, false for dark, undefined when unparseable.
+ */
+export declare function backgroundIsLight(payload: string): boolean | undefined;
 /**
  * Display columns a string occupies once printed, ignoring styling sequences.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codsh-bundle",
   "description": "The codsh runtime: the interactive TTY surface and code-cli agent preset, installed into a dsh profile. Users install codsh-cli (the launcher) — this package is what it registers.",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "license": "MIT",
   "main": "lib/index.js",