@jals1212/pi-spaces-cli 0.6.2 → 0.7.1

package/CHANGELOG.md

@@ -6,6 +6,44 @@ commands and options and a patch version fixes.
 
 ## Unreleased
 
+## 0.7.1
+
+### Fixed
+
+- A bare `pi-space` with `--setup`: a space of another profile now starts with
+  that `--setup` (as `PI_SPACES_SETUP`), as the spaces of the current profile
+  already did.
+- A failure starting a space of another profile (a command with an unclosed
+  quote, a program that cannot start) is reported with the profile's command
+  and exits 2 or 1, with a test for each.
+- The picker puts the terminal back (raw mode off, cursor shown, picker
+  erased) on SIGTERM, SIGHUP and SIGINT, then ends the process with that
+  signal, instead of leaving the terminal raw.
+- An escape sequence a terminal splits after its start (`ESC [`, `ESC O`, or
+  `ESC [` with parameters) is joined with its rest instead of being read as Esc
+  and text. If the rest never comes, a lone Esc still cancels and any other
+  half sequence is ignored.
+- Lines with wide characters (Chinese, Japanese, Korean, fullwidth, emoji)
+  are cut by the columns they take, so they no longer wrap and break the
+  redraw; combining marks take none.
+
+## 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

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";
@@ -429,8 +431,8 @@ function agentHome(env     , home        )         {
  
 
                         
-	                                                   
-	                                         
+	                               
+	                                 
 	                                         
 	         
 	                                                                                                                                                              
@@ -576,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);
@@ -607,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);
 	}
 }
 
@@ -1037,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 and --setup 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);
@@ -1049,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 } : {}), ...(call.setup !== undefined ? { setup: call.setup } : {}), 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,352 @@
+// 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;
+}
+
+/**
+ * A chunk split into what is complete and the incomplete escape sequence at its end (empty when none): a lone
+ * ESC, ESC O, or ESC [ with parameter and intermediate bytes but no final byte yet. A terminal may send the
+ * rest of such a sequence in the next chunk.
+ */
+export function splitIncomplete(chunk        )                                   {
+	const start = chunk.lastIndexOf("\x1b");
+	if (start === -1) return [chunk, ""];
+	const tail = chunk.slice(start);
+	const incomplete = tail === "\x1b" || tail === "\x1bO" || (tail.startsWith("\x1b[") && /^[\x20-\x3f]*$/.test(tail.slice(2)));
+	return incomplete ? [chunk.slice(0, start), tail] : [chunk, ""];
+}
+
+/** 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 terminal columns of one character: 0 for combining marks and joiners, 2 for East Asian wide ones and emoji, else 1. */
+function charWidth(char        )         {
+	const code = char.codePointAt(0)          ;
+	if ((code >= 0x200b && code <= 0x200f) || (code >= 0xfe00 && code <= 0xfe0f) || /^[\p{Mn}\p{Me}]$/u.test(char)) return 0;
+	const wide =
+		(code >= 0x1100 && code <= 0x115f) ||
+		(code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) ||
+		(code >= 0xac00 && code <= 0xd7a3) ||
+		(code >= 0xf900 && code <= 0xfaff) ||
+		(code >= 0xfe30 && code <= 0xfe4f) ||
+		(code >= 0xff00 && code <= 0xff60) ||
+		(code >= 0xffe0 && code <= 0xffe6) ||
+		(code >= 0x1f300 && code <= 0x1f64f) ||
+		(code >= 0x1f900 && code <= 0x1f9ff) ||
+		(code >= 0x20000 && code <= 0x3fffd);
+	return wide ? 2 : 1;
+}
+
+/** The columns a text takes on a terminal. */
+export function displayWidth(text        )         {
+	let width = 0;
+	for (const char of text) width += charWidth(char);
+	return width;
+}
+
+/** The line cut to `columns` terminal columns, ending with "…" when it was longer, so it never wraps. */
+function fit(line        , columns        )         {
+	if (displayWidth(line) <= columns) return line;
+	// Keep one column for the "…" (none when there is room for just one); a wide character is never cut in half.
+	const room = columns <= 1 ? Math.max(0, columns) : columns - 1;
+	let kept = "";
+	let width = 0;
+	for (const char of line) {
+		if (width + charWidth(char) > room) break;
+		kept += char;
+		width += charWidth(char);
+	}
+	return columns <= 1 ? kept : `${kept}…`;
+}
+
+/**
+ * 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];
+}
+
+                                 
+	                                                                                        
+	                                                                          
+ 
+
+/** What runPicker needs of the process: its listeners and the way to raise a signal; the real process by default. */
+                             
+	            
+	                                                 
+	                                                   
+	                                                  
+	                                           
+ 
+
+/** The signals that end the picker's process: it restores the terminal, then dies of the same signal. */
+const SIGNALS = ["SIGTERM", "SIGHUP", "SIGINT"]         ;
+
+/** 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; on SIGTERM,
+ * SIGHUP or SIGINT the terminal is restored and the signal raised again, so the process ends as it would have.
+ * A chunk ending in an incomplete escape sequence is held for `escapeWaitMs` to join the next chunk; if none
+ * comes, a held lone ESC is the Esc key and any other held sequence is dropped.
+ */
+export function runPicker(items              , terminal                , escapeWaitMs = ESCAPE_WAIT_MS, host             = process)                        {
+	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;
+		// An incomplete escape sequence waiting for the rest of it, and the timer that ends the wait.
+		let pending = "";
+		let held                                           ;
+		const finish = (outcome                                               ) => {
+			if (finished) return;
+			finished = true;
+			clearTimeout(held);
+			stopListening();
+			restore();
+			if ("error" in outcome) reject(outcome.error);
+			else resolve(outcome.result);
+		};
+		const stopListening = () => {
+			host.off("exit", onExit);
+			for (const signal of SIGNALS) host.off(signal, onSignal[signal]);
+			stdin.off("data", onData);
+			stdin.off("end", onEnd);
+		};
+		// Restoring must not stop halfway: a write that fails here must not keep the terminal raw.
+		const restore = () => {
+			try {
+				stdin.setRawMode?.(false);
+				stdin.pause();
+			} catch {}
+			try {
+				draw([]);
+			} catch {}
+			try {
+				stdout.write("\x1b[?25h");
+			} catch {}
+		};
+		// A signal: restore, stop listening so its default action applies, then raise it again. The promise never settles.
+		const onSignal = Object.fromEntries(
+			SIGNALS.map((signal) => [
+				signal,
+				() => {
+					if (finished) return;
+					finished = true;
+					clearTimeout(held);
+					stopListening();
+					restore();
+					host.kill(host.pid, signal);
+				},
+			]),
+		)                                                ;
+		// 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 = "";
+				const [complete, tail] = splitIncomplete(text);
+				if (tail === "") {
+					handle(text);
+					return;
+				}
+				// An incomplete sequence at the end may be one the terminal split: hold it for the next chunk.
+				if (complete !== "" && handle(complete)) return;
+				pending = tail;
+				held = setTimeout(() => guarded(() => {
+					pending = "";
+					// A lone ESC is the Esc key; any other half sequence is dropped.
+					if (tail === "\x1b") handle("\x1b");
+				}), escapeWaitMs);
+			});
+		const onEnd = () => finish({ result: { item: undefined, interrupted: false } });
+		host.on("exit", onExit);
+		for (const signal of SIGNALS) host.once(signal, onSignal[signal]);
+		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.2",
+  "version": "0.7.1",
   "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",