@jals1212/pi-spaces-cli 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -6,6 +6,34 @@ commands and options and a patch version fixes.
 
 ## Unreleased
 
+## 0.7.0
+
+### Changed
+
+- A bare `pi-space` opens a picker instead of a numbered list: ↑/↓ (or
+  Ctrl-P/Ctrl-N, Tab) move, Enter starts Pi, Esc or Ctrl-D cancel (exit 0),
+  Ctrl-C exits 130, and typing filters by space or profile name (Backspace,
+  Ctrl-U). `base` comes first; the cursor starts on the space this Pi runs in
+  (`PI_SPACE_HOME`), marked `(active)`. A long list scrolls to fit the
+  terminal. No new dependency. Without a terminal it prints the usage and exits
+  2, as before.
+- With a config file, and no `--profile`, `--dir` or `--command` in the call,
+  the picker lists the spaces of every profile under its name, the current one
+  first; a profile whose spaces folder is already listed is skipped. A space of
+  another profile starts with that profile's command and spaces folder (and
+  the `--config` of the call).
+
+## 0.6.2
+
+### Fixed
+
+- `pi-space --help <TAB>` (and `-h`) offers the commands with their summary,
+  `completion` included, so the help of a command is one Tab away.
+- `--every` is completed in its own `target` group instead of among the space
+  names, since it is not a space.
+- The completion text of the first `--help` says it also takes a command:
+  `print the help, or a command's: --help <command>`.
+
 ## 0.6.1
 
 ### Added

package/README.md

@@ -16,7 +16,7 @@ The command words are reserved: a space can never be named `list`, `new`, `remov
 
 | Command | What it does |
 | --- | --- |
-| `pi-space` | Shows a numbered list of spaces and starts Pi in the one you pick. |
+| `pi-space` | Opens a picker of the spaces and starts Pi in the one you choose: ↑/↓ (or Ctrl-P/Ctrl-N, Tab) move, Enter starts Pi, Esc cancels, typing filters by space or profile name. `base` comes first, and the cursor starts on the space this Pi runs in, marked `(active)`. With a config file and no `--profile`, `--dir` or `--command`, the spaces of every profile are listed under its name, the current one first; a space of another profile starts with that profile. |
 | `pi-space <name> [pi args...]` | Starts Pi in that space (`base` for the home Pi starts with). |
 | `pi-space list` | Lists the spaces. |
 | `pi-space list <name\|--every>` | Lists the packages of a space (Pi's `list`). |
@@ -206,7 +206,8 @@ Only those three variables change. A variable that points into the base home sta
 | Status | Meaning |
 | --- | --- |
 | 0 … | Pi's own exit status, for a space and for a package command in one space; the setup's exit status for `setup <name>` and for a `new` whose setup failed. |
-| 1 | An unknown or invalid space, a name `new` or `rename` cannot use (taken, reserved or invalid), a space `remove` or `rename` cannot touch, `remove` without `--yes` and no terminal, an out-of-range pick, the program could not start, or `--every` and at least one run failed (the failed spaces are on the last line of stderr), or `setup base`, since setup runs only in spaces. |
+| 1 | An unknown or invalid space, a name `new` or `rename` cannot use (taken, reserved or invalid), a space `remove` or `rename` cannot touch, `remove` without `--yes` and no terminal, the program could not start, or `--every` and at least one run failed (the failed spaces are on the last line of stderr), or `setup base`, since setup runs only in spaces. |
+| 130 | Ctrl-C in the picker. |
 | 2 | A config file that is wrong or an unknown `--profile` (the problem is printed), `completion` with another shell or none, no arguments and no terminal to pick in, a command with the wrong number of names (`new`, `remove`, `rename`), `install` or `uninstall` without a source, a package command without a space or `--every`, or `--command`, `--dir`, `--setup`, `--profile` or `--config` without a value (or a blank one) or given twice: the usage is printed. `setup` without a setup command: the problem is printed. The old `--new` and `--remove`: the replacing command is printed. A `--command`, `PI_SPACES_COMMAND`, `--setup`, `PI_SPACES_SETUP` or a profile's `command` or `setup` with an unclosed quote: the problem is printed, and nothing is created or started. |
 
 ## More

package/dist/cli.js

@@ -8,6 +8,7 @@ import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import crossSpawn from "cross-spawn";
+import {                                       runPicker } from "./picker.js";
 import {
 	BACKUPS,
 	BASE,
@@ -22,6 +23,7 @@ import {
 	removeSpace,
 	renameSpace,
 	SpaceError,
+	samePath,
 	spacesDir,
 	validateName,
 } from "@jals1212/pi-spaces/spaces";
@@ -239,8 +241,15 @@ const COMMANDS                              = {
 	},
 };
 
+/** --help after a command; GENERAL_OPTIONS has the --help that comes first. */
 const HELP_OPTION = { flag: "--help", alias: "-h", text: "the help of this command" };
 
+/** The options that stand alone in first place, as completion describes them. */
+const GENERAL_OPTIONS                                 = [
+	["--help", "print the help, or a command's: --help <command>"],
+	["--version", "print the version"],
+];
+
 /** The help of one command: usage, what it does, arguments, options, the call options that apply, and examples. */
 function commandHelp(name        )         {
 	const help = COMMANDS[name];
@@ -284,7 +293,7 @@ export function parseCli(args          )             {
 function parseCommand(args          )             {
 	const [first, ...rest] = args;
 	if (first === undefined) return { kind: "picker" };
-	if (isHelpFlag(first)) return rest.length === 0 ? { kind: "help" } : rest.length === 1 ? { kind: "command-help", command: rest[0] } : { kind: "usage" };
+	if (isHelpFlag(first)) return parseHelp(rest);
 	if (first === "--version" || first === "-v") return { kind: "version" };
 	if (Object.hasOwn(REPLACED, first)) return { kind: "replaced", option: first, instead: REPLACED[first                         ] };
 	if (first.startsWith("-")) return { kind: "unknown-option", option: first };
@@ -308,6 +317,13 @@ function parseCommand(args          )             {
 	return { kind: "launch", name: first, args: rest };
 }
 
+/** `--help` alone is the general help; `--help <command>` is that command's. */
+function parseHelp(rest          )             {
+	if (rest.length === 0) return { kind: "help" };
+	if (rest.length === 1) return { kind: "command-help", command: rest[0] };
+	return { kind: "usage" };
+}
+
 /** `setup <name>` or `setup --every`: exactly one argument. */
 function parseSetup(rest          )             {
 	if (rest.length !== 1) return { kind: "usage" };
@@ -415,8 +431,8 @@ function agentHome(env     , home        )         {
  
 
                         
-	                                                   
-	                                         
+	                               
+	                                 
 	                                         
 	         
 	                                                                                                                                                              
@@ -562,6 +578,7 @@ export async function main(argv          , io       )                {
 		case "complete":
 			return complete(command.words, io);
 	}
+	const callerIo = io;
 	let settings          ;
 	try {
 		settings = resolveSettings(command, io);
@@ -593,7 +610,7 @@ export async function main(argv          , io       )                {
 		case "launch":
 			return launch(command.name, command.args, dir, io, commandSource);
 		case "picker":
-			return pick(dir, io, commandSource);
+			return pick(command, settings, callerIo);
 	}
 }
 
@@ -627,7 +644,7 @@ const ZSH_COMPLETION = [
 	"#compdef pi-space",
 	"# zsh completion for pi-space. Load it from .zshrc with: source <(pi-space completion zsh)",
 	"_pi_space() {",
-	"  local -a lines cmds spaces profiles shells opts",
+	"  local -a lines cmds spaces targets profiles shells opts",
 	"  local line group value text ret=1",
 	'  lines=("${(@f)$(command "${words[1]}" __complete "${(@)words[2,CURRENT-1]}" 2>/dev/null)}")',
 	`  if [[ "\${lines[1]}" == ${FILES} ]]; then`,
@@ -645,6 +662,7 @@ const ZSH_COMPLETION = [
 	'    case "$group" in',
 	'      command) cmds+=("$value:$text") ;;',
 	'      space) spaces+=("$value:$text") ;;',
+	'      target) targets+=("$value:$text") ;;',
 	'      profile) profiles+=("$value:$text") ;;',
 	'      shell) shells+=("$value:$text") ;;',
 	'      option) [[ "$PREFIX" == -* ]] && opts+=("$value:$text") ;;',
@@ -652,6 +670,7 @@ const ZSH_COMPLETION = [
 	"  done",
 	"  (( $#cmds )) && _describe -t commands 'command' cmds && ret=0",
 	"  (( $#spaces )) && _describe -t spaces 'space' spaces && ret=0",
+	"  (( $#targets )) && _describe -t targets 'target' targets && ret=0",
 	"  (( $#profiles )) && _describe -t profiles 'profile' profiles && ret=0",
 	"  (( $#shells )) && _describe -t shells 'shell' shells && ret=0",
 	"  (( $#opts )) && _describe -t options 'option' opts && ret=0",
@@ -661,8 +680,8 @@ const ZSH_COMPLETION = [
 	"",
 ].join("\n");
 
-/** The groups of a `__complete` line. */
-                                                                  
+/** The groups of a `__complete` line; `target` is --every, which stands in for a space name. */
+                                                                             
 
 /** One `__complete` line; the description never holds a tab or a newline. */
 function candidate(group       , value        , text        )         {
@@ -684,10 +703,10 @@ function complete(words          , io       )       {
 	return io.exit(0);
 }
 
-/** The first-place commands: `completion` is left out (it still works typed in full). */
-function commandCandidates()           {
+/** The commands with their summary; in first place `completion` is left out (it still works typed in full), after --help it is not. */
+function commandCandidates(withCompletion         )           {
 	return Object.entries(COMMANDS)
-		.filter(([name]) => name !== "completion")
+		.filter(([name]) => withCompletion || name !== "completion")
 		.map(([name, help]) => candidate("command", name, help.summary));
 }
 
@@ -696,7 +715,7 @@ function firstOptions(call             , alone         )           {
 	const calls = Object.entries(CALL_OPTIONS)
 		.filter(([, key]) => call[key] === undefined)
 		.map(([flag, key]) => candidate("option", flag, CALL_HELP[key][1]));
-	const general = alone ? [candidate("option", "--help", "print the help"), candidate("option", "--version", "print the version")] : [];
+	const general = alone ? GENERAL_OPTIONS.map(([flag, text]) => candidate("option", flag, text)) : [];
 	return [...calls, ...general];
 }
 
@@ -707,7 +726,7 @@ function spaceCandidates(spaces          , withBase         )           {
 
 /** What follows a command word: its target, its own options and --help. */
 function commandArguments(command        , spaces          )           {
-	const every = (text        ) => candidate("space", "--every", text);
+	const every = (text        ) => candidate("target", "--every", text);
 	const options = [...COMMANDS[command].options, HELP_OPTION].map((option) => candidate("option", option.flag, option.text));
 	switch (command) {
 		case "remove":
@@ -740,8 +759,10 @@ function candidates(words          , io       )           {
 	const { dir } = resolveSettings(call, io);
 	const rest = words.slice(index);
 	const spaces = listSpaces(dir);
-	if (rest.length === 0) return [...commandCandidates(), ...spaceCandidates(spaces, true), ...firstOptions(call, index === 0)];
-	if (rest.length > 1 || !Object.hasOwn(COMMANDS, rest[0])) return [];
+	if (rest.length === 0) return [...commandCandidates(false), ...spaceCandidates(spaces, true), ...firstOptions(call, index === 0)];
+	if (rest.length > 1) return [];
+	if (isHelpFlag(rest[0])) return commandCandidates(true);
+	if (!Object.hasOwn(COMMANDS, rest[0])) return [];
 	return commandArguments(rest[0], spaces);
 }
 
@@ -1019,7 +1040,48 @@ async function runSetup(target               , dir        , io       , setupSour
 	io.exit(0);
 }
 
-async function pick(dir        , io       , commandSource        )                {
+/** A picker item and where it starts: a profile of the config file, or the settings of this call. */
+                                           
+	                 
+ 
+
+/**
+ * The choices of the picker: base and the spaces of this call, then, when the call names no profile, folder or
+ * command and there is a config file, those of every other profile, each under its name; a profile whose spaces
+ * folder is already listed is skipped. The space this Pi runs in (PI_SPACE_HOME) is the active one.
+ */
+function pickerChoices(call             , settings          , callerIo       )                 {
+	const { dir, config, profile, io } = settings;
+	const activeHome = io.env.PI_SPACE_HOME;
+	const group = (groupName                    , profileName                    , spaces        , baseHome        )                 =>
+		[BASE, ...listSpaces(spaces)].map((name) => {
+			const home = name === BASE ? baseHome : join(spaces, name);
+			return {
+				name,
+				...(groupName !== undefined ? { group: groupName } : {}),
+				...(profileName !== undefined ? { profile: profileName } : {}),
+				...(activeHome && samePath(home, activeHome) ? { active: true } : {}),
+			};
+		});
+	const baseHome = profile?.home ?? (io.env.PI_SPACES_BASE_HOME || agentHome(io.env, io.home));
+	const others = config !== undefined && call.profile === undefined && call.dir === undefined && call.command === undefined
+		? profileNames(config)
+				.map((name) => profileByName(config, name, callerIo.env, callerIo.home))
+				.filter((other, index, all) => !samePath(other.dir, dir) && all.findIndex((first) => samePath(first.dir, other.dir)) === index)
+		: [];
+	if (others.length === 0) return group(undefined, undefined, dir, baseHome);
+	// The current one keeps the settings of this call; its header is its profile's name.
+	const current = group(profile?.name ?? "current", undefined, dir, baseHome);
+	return [...current, ...others.flatMap((other) => group(other.name, other.name, other.dir, other.home))];
+}
+
+/**
+ * A bare `pi-space` on a terminal: the picker, then Pi in the chosen space. A space of another profile starts
+ * with that profile's settings (and the --config of this call). Esc or the end of input exit 0; Ctrl-C exits 130.
+ */
+async function pick(call             , settings          , callerIo       )                {
+	const { dir, commandSource } = settings;
+	const io = settings.io;
 	if (!io.stdin.isTTY) {
 		io.stderr.write(USAGE);
 		return io.exit(2);
@@ -1031,28 +1093,18 @@ async function pick(dir        , io       , commandSource        )
 		io.stderr.write(`pi-space: ${commandSource}: ${(error         ).message}.\n`);
 		return io.exit(2);
 	}
-	const names = [BASE, ...listSpaces(dir)];
-	io.stdout.write(`${[`Spaces in ${dir}:`, ...names.map((name, index) => `${index + 1}) ${name}`)].join("\n")}\nSpace number: `);
-	const line = await readLine(io.stdin);
-	const answer = line?.trim() ?? "";
-	if (answer === "") return io.exit(0);
-	const number = /^\d+$/.test(answer) ? Number(answer) : 0;
-	if (number < 1 || number > names.length) {
-		io.stderr.write(`pi-space: Choose a number from 1 to ${names.length}.\n`);
-		return io.exit(1);
+	const { item, interrupted } = await runPicker(pickerChoices(call, settings, callerIo), io);
+	if (item === undefined) return io.exit(interrupted ? 130 : 0);
+	const choice = item                ;
+	if (choice.profile === undefined) return launch(choice.name, [], dir, io, commandSource);
+	let chosen          ;
+	try {
+		chosen = resolveSettings({ ...(call.config !== undefined ? { config: call.config } : {}), profile: choice.profile }, callerIo);
+	} catch (error) {
+		if (!(error instanceof ConfigError)) throw error;
+		io.stderr.write(`pi-space: ${error.message}\n`);
+		return io.exit(2);
 	}
-	return launch(names[number - 1], [], dir, io, commandSource);
-}
-
-/** One line from the stream, or undefined at end of input. */
-function readLine(input                       )                              {
-	return new Promise((resolve) => {
-		const rl = createInterface({ input });
-		rl.once("line", (line) => {
-			// Resolve first: close() emits "close" synchronously.
-			resolve(line);
-			rl.close();
-		});
-		rl.once("close", () => resolve(undefined));
-	});
+	// Its command was not checked before the picker: launch reports an unclosed quote.
+	return launch(choice.name, [], chosen.dir, chosen.io, chosen.commandSource);
 }

package/dist/picker.js

@@ -0,0 +1,268 @@
+// The interactive picker of a bare `pi-space`: arrows move, Enter picks, Esc cancels, typing filters.
+// No dependency: the terminal goes into raw mode and the keys are read from the bytes it sends.
+
+/** One choice: a space name (or base) in an optional group, a profile's name. */
+                             
+	               
+	             
+	                                                          
+	                 
+ 
+
+                 
+	                                                                                    
+	                                 
+
+                              
+	                    
+	              
+	                                  
+	               
+ 
+
+/** What one key leads to: the next state, or the end with the chosen item (none when cancelled). */
+                                                                                                 
+
+const CONTROL_KEYS                      = {
+	"\r": { kind: "enter" },
+	"\n": { kind: "enter" },
+	"\x03": { kind: "interrupt" },
+	// Ctrl-D, like the end of input, cancels.
+	"\x04": { kind: "escape" },
+	"\x7f": { kind: "backspace" },
+	"\b": { kind: "backspace" },
+	"\x15": { kind: "clear" },
+	"\x10": { kind: "up" },
+	"\x0e": { kind: "down" },
+	"\t": { kind: "down" },
+};
+
+const ARROWS                      = { A: { kind: "up" }, B: { kind: "down" } };
+
+/**
+ * The keys in one chunk of terminal input. ESC [ or ESC O start a sequence: up and down are kept, any other
+ * (Home, Delete, F1) is skipped whole. An ESC followed by nothing or by another ESC is the Esc key.
+ */
+export function parseKeys(chunk        )        {
+	const keys        = [];
+	const chars = [...chunk];
+	let index = 0;
+	while (index < chars.length) {
+		const char = chars[index];
+		if (char === "\x1b") {
+			const next = chars[index + 1];
+			if (next !== "[" && next !== "O") {
+				keys.push({ kind: "escape" });
+				index += 1;
+				continue;
+			}
+			// Parameters, then one final byte from "@" to "~"; ESC O takes just the one byte after it.
+			let end = index + 2;
+			if (next === "[") while (end < chars.length && !/[@-~]/.test(chars[end])) end += 1;
+			const final = chars[end];
+			if (final !== undefined && end === index + 2 && Object.hasOwn(ARROWS, final)) keys.push(ARROWS[final]);
+			index = end + 1;
+			continue;
+		}
+		if (Object.hasOwn(CONTROL_KEYS, char)) keys.push(CONTROL_KEYS[char]);
+		else if (char >= " ") keys.push({ kind: "text", text: char });
+		index += 1;
+	}
+	return keys;
+}
+
+/** The items whose name or group holds the query, case-insensitive, in order. */
+export function visibleItems(state             )               {
+	const query = state.query.toLowerCase();
+	if (query === "") return state.items;
+	return state.items.filter((item) => item.name.toLowerCase().includes(query) || (item.group?.toLowerCase().includes(query) ?? false));
+}
+
+/** No filter, the cursor on the active item, else on the first. */
+export function initialState(items              )              {
+	return { items, query: "", cursor: Math.max(0, items.findIndex((item) => item.active)) };
+}
+
+/** A new query puts the cursor on the first match. */
+function withQuery(state             , query        )              {
+	return { ...state, query, cursor: 0 };
+}
+
+export function step(state             , key     )       {
+	const count = visibleItems(state).length;
+	switch (key.kind) {
+		case "escape":
+			return { done: undefined };
+		case "interrupt":
+			return { done: undefined, interrupted: true };
+		case "enter":
+			return count === 0 ? { state } : { done: visibleItems(state)[state.cursor] };
+		case "up":
+		case "down":
+			if (count === 0) return { state };
+			return { state: { ...state, cursor: (state.cursor + (key.kind === "up" ? count - 1 : 1)) % count } };
+		case "backspace":
+			return { state: withQuery(state, [...state.query].slice(0, -1).join("")) };
+		case "clear":
+			return { state: withQuery(state, "") };
+		case "text":
+			return { state: withQuery(state, state.query + key.text) };
+	}
+}
+
+const HINT = "Pick a space: ↑/↓ move, Enter starts Pi, Esc cancels, type to filter";
+
+/** The line cut to `columns` code points, ending with "…" when it was longer, so it never wraps. */
+function fit(line        , columns        )         {
+	const chars = [...line];
+	if (chars.length <= columns) return line;
+	return columns <= 1 ? chars.slice(0, Math.max(0, columns)).join("") : `${chars.slice(0, columns - 1).join("")}…`;
+}
+
+/**
+ * The lines of one frame: the hint, the filter, then the items under a header per group (when they have
+ * groups), with the cursor and the active mark. Only a window around the cursor is drawn when the list is
+ * longer than the terminal (`rows` lines), with a line that says how many more are above and below. Every
+ * line is cut to `columns` so that one line is one terminal row, which the redraw counts on.
+ */
+export function renderPicker(state             , rows        , columns = 80)           {
+	return frame(state, rows).map((line) => fit(line, columns));
+}
+
+function frame(state             , rows        )           {
+	const items = visibleItems(state);
+	const head = [HINT, `> ${state.query}`];
+	if (items.length === 0) return [...head, "  No space matches."];
+	// The body: each item's line, with its group's header before the first of the group; `at` maps the cursor.
+	const body           = [];
+	let at = 0;
+	items.forEach((item, index) => {
+		if (item.group !== undefined && item.group !== items[index - 1]?.group) body.push(item.group);
+		if (index === state.cursor) at = body.length;
+		body.push(`${index === state.cursor ? "  > " : "    "}${item.name}${item.active ? " (active)" : ""}`);
+	});
+	// Lines the body may use: what the terminal has left after the head, keeping one for the shell prompt (at least 3).
+	const room = Math.max(3, rows - head.length - 1);
+	if (body.length <= room) return [...head, ...body];
+	// Body lines in the window: the room minus the two lines that may say there is more above and below.
+	const size = room - 2;
+	const start = Math.min(Math.max(0, at - Math.floor(size / 2)), body.length - size);
+	const end = start + size;
+	const above = start > 0 ? [`  … ${start} more above`] : [];
+	const below = end < body.length ? [`  … ${body.length - end} more below`] : [];
+	return [...head, ...above, ...body.slice(start, end), ...below];
+}
+
+                                 
+	                                                                                        
+	                                                                          
+ 
+
+/** The chosen item, none when cancelled (Esc, Ctrl-D, the end of input), and whether it was Ctrl-C. */
+                               
+	                             
+	                     
+ 
+
+/** How long a lone ESC waits for the rest of an escape sequence a terminal may have split across chunks. */
+const ESCAPE_WAIT_MS = 50;
+
+/**
+ * Runs the picker on a terminal: raw mode while it runs, each frame drawn over the last, and everything put
+ * back before it returns (raw mode off, the picker erased, the cursor shown, stdin paused) so Pi can start clean.
+ * That also holds when drawing throws (the promise rejects) or the process exits while it runs.
+ * A chunk ending in a bare ESC is held for `escapeWaitMs` to join the next chunk; if none comes, it is the Esc key.
+ */
+export function runPicker(items              , terminal                , escapeWaitMs = ESCAPE_WAIT_MS)                        {
+	const { stdin, stdout } = terminal;
+	let state = initialState(items);
+	let drawn = 0;
+	const render = () => renderPicker(state, stdout.rows ?? 24, stdout.columns ?? 80);
+	const draw = (lines          ) => {
+		// Back to the first line of the last frame, then erase down from there.
+		const up = drawn > 1 ? `\x1b[${drawn - 1}A` : "";
+		stdout.write(`${up}\r\x1b[J${lines.join("\n")}`);
+		drawn = lines.length;
+	};
+	return new Promise              ((resolve, reject) => {
+		let finished = false;
+		// A bare ESC waiting for the rest of its sequence, and the timer that turns it into the Esc key.
+		let pending = "";
+		let held                                           ;
+		const finish = (outcome                                               ) => {
+			if (finished) return;
+			finished = true;
+			clearTimeout(held);
+			process.off("exit", onExit);
+			stdin.off("data", onData);
+			stdin.off("end", onEnd);
+			// Restoring comes first and must not stop halfway: a write that fails here must not keep the terminal raw.
+			try {
+				stdin.setRawMode?.(false);
+				stdin.pause();
+			} catch {}
+			try {
+				draw([]);
+			} catch {}
+			try {
+				stdout.write("\x1b[?25h");
+			} catch {}
+			if ("error" in outcome) reject(outcome.error);
+			else resolve(outcome.result);
+		};
+		// The process is going away without finish (exit, a throw elsewhere): leave the terminal usable.
+		const onExit = () => {
+			try {
+				stdin.setRawMode?.(false);
+				stdout.write("\x1b[?25h");
+			} catch {}
+		};
+		/** Applies the keys of some input; true when the picker ended. */
+		const handle = (text        )          => {
+			for (const key of parseKeys(text)) {
+				const next = step(state, key);
+				if ("done" in next) {
+					finish({ result: { item: next.done, interrupted: next.interrupted === true } });
+					return true;
+				}
+				state = next.state;
+			}
+			draw(render());
+			return false;
+		};
+		const guarded = (run            ) => {
+			try {
+				run();
+			} catch (error) {
+				finish({ error });
+			}
+		};
+		const onData = (data                 ) =>
+			guarded(() => {
+				clearTimeout(held);
+				const text = pending + data.toString();
+				pending = "";
+				if (!text.endsWith("\x1b")) {
+					handle(text);
+					return;
+				}
+				// A bare ESC at the end may be the start of a sequence the terminal split: hold it for the next chunk.
+				if (text.length > 1 && handle(text.slice(0, -1))) return;
+				pending = "\x1b";
+				held = setTimeout(() => guarded(() => {
+					pending = "";
+					handle("\x1b");
+				}), escapeWaitMs);
+			});
+		const onEnd = () => finish({ result: { item: undefined, interrupted: false } });
+		process.on("exit", onExit);
+		guarded(() => {
+			stdin.setRawMode?.(true);
+			stdout.write("\x1b[?25l");
+			draw(render());
+			stdin.on("data", onData);
+			stdin.once("end", onEnd);
+			stdin.resume();
+		});
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jals1212/pi-spaces-cli",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "The pi-space command: pick a space and start Pi in it. Companion to the Pi extension @jals1212/pi-spaces.",
   "license": "MIT",
   "author": "jals1212",