@tiagojct/subsub 0.21.0 → 0.23.0

package/dist/web.js

@@ -13,18 +13,15 @@
  * - Without an open page for a while (and with nothing waiting), the server
  *   stops by itself, so a shortcut can start it without a terminal.
  */
-import { spawn } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createReadStream, existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync, appendFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { homedir } from "node:os";
 import { basename, dirname, extname, join, normalize, relative, sep } from "node:path";
-import { StringDecoder } from "node:string_decoder";
 import { agentDirFor, chooseCwd, PACKAGE_DIR, packageVersion } from "./cli.js";
 import { configPath, loadConfig, RECOMMENDED_MODELS, readConfigFile, saveConfig, uiLanguage, withStarbuck } from "./config.js";
 import { TESTED_MODELS } from "./init.js";
 import { KEY_PROVIDERS, saveApiKey } from "./keys.js";
-import { field, frontMatter } from "./notes.js";
 export function parseWebArgs(args) {
     const o = { port: 0, open: true, librarian: false, here: false, idleMinutes: 10, piArgs: [] };
     for (let i = 0; i < args.length; i++) {
@@ -52,127 +49,9 @@ export { KEY_PROVIDERS, saveApiKey } from "./keys.js";
 // ---------------------------------------------------------------- files (shared with the terminal screens)
 import { allowedFile, listNotes, openExternal, openFile, OPENABLE, wikilinkTarget } from "./files.js";
 export { allowedFile, listNotes, openExternal, OPENABLE, wikilinkTarget };
-/** pi as a child process in RPC mode. Strict JSONL: records end at LF only. */
-export class Agent {
-    proc;
-    decoder = new StringDecoder("utf8");
-    buf = "";
-    n = 0;
-    pending = new Map();
-    listeners = new Set();
-    stderr = "";
-    onExit;
-    command;
-    args;
-    cwd;
-    env;
-    constructor(command, args, cwd, env) {
-        this.command = command;
-        this.args = args;
-        this.cwd = cwd;
-        this.env = env;
-    }
-    start(extra = []) {
-        this.buf = "";
-        this.decoder = new StringDecoder("utf8");
-        const proc = spawn(this.command, [...this.args, ...extra], { cwd: this.cwd, env: this.env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-        this.proc = proc;
-        proc.stdout.on("data", (chunk) => this.feed(this.decoder.write(chunk)));
-        proc.stderr.on("data", (d) => {
-            this.stderr = (this.stderr + d.toString()).slice(-20_000);
-        });
-        proc.once("exit", (code) => {
-            if (this.proc !== proc)
-                return;
-            this.proc = undefined;
-            for (const p of this.pending.values()) {
-                clearTimeout(p.timer);
-                p.reject(new Error(`pi stopped (code ${code}). ${this.stderr.slice(-500)}`));
-            }
-            this.pending.clear();
-            this.onExit?.(code);
-        });
-    }
-    feed(text) {
-        this.buf += text;
-        let i;
-        while ((i = this.buf.indexOf("\n")) >= 0) {
-            const line = this.buf.slice(0, i).replace(/\r$/, "");
-            this.buf = this.buf.slice(i + 1);
-            if (!line.trim())
-                continue;
-            let rec;
-            try {
-                rec = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (rec.type === "response" && typeof rec.id === "string" && this.pending.has(rec.id)) {
-                const p = this.pending.get(rec.id);
-                this.pending.delete(rec.id);
-                clearTimeout(p.timer);
-                if (rec.success === false)
-                    p.reject(new Error(rec.error ?? `${rec.command} failed`));
-                else
-                    p.resolve(rec.data);
-                continue;
-            }
-            for (const l of this.listeners)
-                l(rec);
-        }
-    }
-    on(l) {
-        this.listeners.add(l);
-        return () => this.listeners.delete(l);
-    }
-    write(rec) {
-        const stdin = this.proc?.stdin;
-        if (!stdin || !stdin.writable)
-            throw new Error("pi is not running");
-        stdin.write(`${JSON.stringify(rec)}\n`);
-    }
-    request(cmd, timeoutMs = 30_000) {
-        const id = `w${++this.n}`;
-        return new Promise((resolvePromise, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`pi did not answer ${String(cmd.type)} in time`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve: resolvePromise, reject, timer });
-            try {
-                this.write({ ...cmd, id });
-            }
-            catch (err) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(err);
-            }
-        });
-    }
-    async stop() {
-        const proc = this.proc;
-        if (!proc)
-            return;
-        this.proc = undefined;
-        for (const p of this.pending.values()) {
-            clearTimeout(p.timer);
-            p.reject(new Error("pi was stopped"));
-        }
-        this.pending.clear();
-        await new Promise((done) => {
-            const t = setTimeout(() => {
-                proc.kill("SIGKILL");
-                done();
-            }, 3000);
-            proc.once("exit", () => {
-                clearTimeout(t);
-                done();
-            });
-            proc.kill();
-        });
-    }
-}
+// ---------------------------------------------------------------- pi in RPC mode (src/rpc.ts)
+import { Agent, findLibrary, isDialog, Side, withHints } from "./rpc.js";
+export { Agent };
 // ---------------------------------------------------------------- helpers
 const TYPES = {
     ".html": "text/html; charset=utf-8",
@@ -198,14 +77,6 @@ const CSP = [
     "form-action 'none'",
     "frame-ancestors 'none'",
 ].join("; ");
-function readText(path) {
-    try {
-        return readFileSync(path, "utf8");
-    }
-    catch {
-        return "";
-    }
-}
 function same(a, b) {
     const x = Buffer.from(a);
     const y = Buffer.from(b);
@@ -273,7 +144,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
     const clients = new Set();
     const dialogs = new Map();
     let subsubState = null;
-    let lastFind = null;
+    const side = new Side();
     let busy = false;
     let lastSeen = Date.now();
     let restarting = false;
@@ -297,27 +168,14 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
     }
     agent.on((ev) => {
         if (ev.type === "extension_ui_request") {
-            if (["select", "confirm", "input", "editor"].includes(ev.method)) {
+            if (isDialog(ev)) {
                 dialogs.set(ev.id, ev);
                 broadcast(ev);
             }
-            else if (ev.method === "setStatus" && ev.statusKey === "subsub.web") {
-                try {
-                    subsubState = ev.statusText ? JSON.parse(ev.statusText) : null;
-                }
-                catch {
-                    subsubState = null;
-                }
+            else if (side.take(ev) === "state") {
+                subsubState = side.state;
                 broadcast({ type: "subsub_state", state: subsubState });
             }
-            else if (ev.method === "setStatus" && ev.statusKey === "subsub.find") {
-                try {
-                    lastFind = ev.statusText ? JSON.parse(ev.statusText) : null;
-                }
-                catch {
-                    lastFind = null;
-                }
-            }
             else if (ev.method === "notify") {
                 broadcast(ev);
             }
@@ -361,13 +219,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
             out.session = await agent.request({ type: "get_state" });
             lastSession = out.session.sessionFile ?? lastSession;
             out.messages = (await agent.request({ type: "get_messages" })).messages;
-            const commands = (await agent.request({ type: "get_commands" })).commands;
-            // RPC has no argument hints: read them from the prompt files.
-            out.commands = commands.map((c) => {
-                const front = c.source === "prompt" && c.sourceInfo?.path ? frontMatter(readText(c.sourceInfo.path)) : undefined;
-                const hint = front && field(front, "argument-hint");
-                return hint ? { ...c, hint } : c;
-            });
+            out.commands = withHints((await agent.request({ type: "get_commands" })).commands);
         }
         catch (err) {
             out.error = err.message;
@@ -649,8 +501,7 @@ export async function startWeb(opts, env = process.env, log = () => { }) {
                     const q = (url.searchParams.get("q") ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
                     if (!q)
                         return send(res, 200, { q, items: [] });
-                    await agent.request({ type: "prompt", message: `/subsub-find ${q}` });
-                    return send(res, 200, lastFind?.q === q ? lastFind : { q, items: [] });
+                    return send(res, 200, await findLibrary(agent, side, q));
                 }
                 case "POST /api/session/name": {
                     const body = await readJson(req);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiagojct/subsub",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Sub-Sub: a research assistant that works from your own Zotero library, in the browser or the terminal, built on pi",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -14,6 +14,7 @@
  * - `subsub init` sets Sub-Sub up; `subsub doctor` checks the setup.
  * - `subsub web` (or `subsub serve`) opens Sub-Sub in the browser;
  *   `subsub shortcut` adds a Sub-Sub shortcut that does the same.
+ * - `subsub tui` is Sub-Sub on the whole terminal: a full-screen client of pi's RPC mode, like the web view.
  */
 
 import { spawnSync } from "node:child_process";
@@ -99,6 +100,8 @@ function isEmptyAuth(file: string): boolean {
 export function shareAuth(agentDir: string, piAgentDir: string): boolean {
 	const mine = join(agentDir, "auth.json");
 	const theirs = join(piAgentDir, "auth.json");
+	// The web view and `subsub tui` start pi with PI_CODING_AGENT_DIR set to Sub-Sub's folder: a link to itself would make auth.json unreadable.
+	if (real(mine) === real(theirs)) return false;
 	if (!existsSync(theirs)) return false;
 	try {
 		const st = lstatSync(mine);
@@ -140,6 +143,7 @@ Usage:
   subsub                 Start Sub-Sub in the terminal
   subsub --librarian     Start in the Librarian, which only manages the library
   subsub web             Open Sub-Sub in the browser
+  subsub tui             Sub-Sub on the whole terminal: transcript, side panel, footer (--light or --dark for the colours)
   subsub init            Set up or change the settings (folder, tag list, models)
   subsub doctor          Check the set-up; each line marked FIX says what to do
   subsub usage           The pilot's usage log (if turned on): a summary and where the file is
@@ -182,6 +186,11 @@ export async function run(argv: string[] = process.argv.slice(2)): Promise<void>
 		process.exitCode = await webMain([...args.slice(1), ...(here ? ["--here"] : [])], env);
 		return;
 	}
+	if (args[0] === "tui") {
+		const { runTui } = await import("./tui.ts");
+		// The terminal is given back before this returns; exit so that nothing else keeps the process alive.
+		process.exit(await runTui([...args.slice(1), ...(here ? ["--here"] : [])], env));
+	}
 	if (args[0] === "shortcut") {
 		const { shortcutMain } = await import("./shortcut.ts");
 		process.exitCode = shortcutMain(args.slice(1), env);

package/src/rpc.ts

@@ -0,0 +1,198 @@
+/**
+ * pi in RPC mode, for the clients that show Sub-Sub: the web view (src/web.ts) and the full-screen terminal client (src/tui.ts). One child
+ * process, strict JSONL (records end at LF only), requests answered by id, every other record handed to the listeners. Sub-Sub's extension
+ * tells its clients what pi's RPC protocol has no place for through two status texts: the state of the library ("subsub.web") and the
+ * answer to a library search ("subsub.find").
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { field, frontMatter } from "./notes.ts";
+
+
+type Listener = (ev: any) => void;
+
+/** pi as a child process in RPC mode. Strict JSONL: records end at LF only. */
+export class Agent {
+	proc?: ChildProcess;
+	private decoder = new StringDecoder("utf8");
+	private buf = "";
+	private n = 0;
+	private pending = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void; timer: NodeJS.Timeout }>();
+	private listeners = new Set<Listener>();
+	stderr = "";
+	onExit?: (code: number | null) => void;
+
+	private readonly command: string;
+	private readonly args: string[];
+	private readonly cwd: string;
+	private readonly env: NodeJS.ProcessEnv;
+
+	constructor(command: string, args: string[], cwd: string, env: NodeJS.ProcessEnv) {
+		this.command = command;
+		this.args = args;
+		this.cwd = cwd;
+		this.env = env;
+	}
+
+	start(extra: string[] = []): void {
+		this.buf = "";
+		this.decoder = new StringDecoder("utf8");
+		const proc = spawn(this.command, [...this.args, ...extra], { cwd: this.cwd, env: this.env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+		this.proc = proc;
+		proc.stdout!.on("data", (chunk: Buffer) => this.feed(this.decoder.write(chunk)));
+		proc.stderr!.on("data", (d: Buffer) => {
+			this.stderr = (this.stderr + d.toString()).slice(-20_000);
+		});
+		proc.once("exit", (code) => {
+			if (this.proc !== proc) return;
+			this.proc = undefined;
+			for (const p of this.pending.values()) {
+				clearTimeout(p.timer);
+				p.reject(new Error(`pi stopped (code ${code}). ${this.stderr.slice(-500)}`));
+			}
+			this.pending.clear();
+			this.onExit?.(code);
+		});
+	}
+
+	private feed(text: string): void {
+		this.buf += text;
+		let i: number;
+		while ((i = this.buf.indexOf("\n")) >= 0) {
+			const line = this.buf.slice(0, i).replace(/\r$/, "");
+			this.buf = this.buf.slice(i + 1);
+			if (!line.trim()) continue;
+			let rec: any;
+			try {
+				rec = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (rec.type === "response" && typeof rec.id === "string" && this.pending.has(rec.id)) {
+				const p = this.pending.get(rec.id)!;
+				this.pending.delete(rec.id);
+				clearTimeout(p.timer);
+				if (rec.success === false) p.reject(new Error(rec.error ?? `${rec.command} failed`));
+				else p.resolve(rec.data);
+				continue;
+			}
+			for (const l of this.listeners) l(rec);
+		}
+	}
+
+	on(l: Listener): () => void {
+		this.listeners.add(l);
+		return () => this.listeners.delete(l);
+	}
+
+	write(rec: unknown): void {
+		const stdin = this.proc?.stdin;
+		if (!stdin || !stdin.writable) throw new Error("pi is not running");
+		stdin.write(`${JSON.stringify(rec)}\n`);
+	}
+
+	request<T = any>(cmd: Record<string, unknown>, timeoutMs = 30_000): Promise<T> {
+		const id = `w${++this.n}`;
+		return new Promise<T>((resolvePromise, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(new Error(`pi did not answer ${String(cmd.type)} in time`));
+			}, timeoutMs);
+			this.pending.set(id, { resolve: resolvePromise, reject, timer });
+			try {
+				this.write({ ...cmd, id });
+			} catch (err) {
+				clearTimeout(timer);
+				this.pending.delete(id);
+				reject(err as Error);
+			}
+		});
+	}
+
+	async stop(): Promise<void> {
+		const proc = this.proc;
+		if (!proc) return;
+		this.proc = undefined;
+		for (const p of this.pending.values()) {
+			clearTimeout(p.timer);
+			p.reject(new Error("pi was stopped"));
+		}
+		this.pending.clear();
+		await new Promise<void>((done) => {
+			const t = setTimeout(() => {
+				proc.kill("SIGKILL");
+				done();
+			}, 3000);
+			proc.once("exit", () => {
+				clearTimeout(t);
+				done();
+			});
+			proc.kill();
+		});
+	}
+}
+
+
+/** The dialogs that wait for an answer (extension_ui_response): the rest of the extension UI requests are notices. */
+export function isDialog(ev: any): boolean {
+	return ev?.type === "extension_ui_request" && ["select", "confirm", "input", "editor"].includes(ev.method);
+}
+
+export interface LibrarySearch {
+	q?: string;
+	items?: unknown[];
+	error?: string;
+}
+
+/** What the extension sends as status texts: the state of the library and the answer to the last library search. */
+export class Side {
+	state: unknown = null;
+	find: LibrarySearch | null = null;
+
+	/** Decode an extension_ui_request; tells which of the two it was, or undefined. */
+	take(ev: any): "state" | "find" | undefined {
+		if (ev?.type !== "extension_ui_request" || ev.method !== "setStatus") return undefined;
+		const decode = (): any => {
+			try {
+				return ev.statusText ? JSON.parse(ev.statusText) : null;
+			} catch {
+				return null;
+			}
+		};
+		if (ev.statusKey === "subsub.web") {
+			this.state = decode();
+			return "state";
+		}
+		if (ev.statusKey === "subsub.find") {
+			this.find = decode();
+			return "find";
+		}
+		return undefined;
+	}
+}
+
+/** Search the library through the extension (the hidden /subsub-find command); the answer comes back as a status text. */
+export async function findLibrary(agent: { request: Agent["request"] }, side: Side, q: string): Promise<LibrarySearch> {
+	if (!q) return { q, items: [] };
+	await agent.request({ type: "prompt", message: `/subsub-find ${q}` });
+	return side.find?.q === q ? side.find : { q, items: [] };
+}
+
+function readText(path: string): string {
+	try {
+		return readFileSync(path, "utf8");
+	} catch {
+		return "";
+	}
+}
+
+/** RPC has no argument hints: read them from the front matter of the prompt files. */
+export function withHints(commands: Array<Record<string, any>>): Array<Record<string, any>> {
+	return commands.map((c) => {
+		const front = c.source === "prompt" && c.sourceInfo?.path ? frontMatter(readText(c.sourceInfo.path)) : undefined;
+		const hint = front && field(front, "argument-hint");
+		return hint ? { ...c, hint } : c;
+	});
+}

package/src/screens.ts

@@ -18,12 +18,14 @@ export const SCREEN_WORDS = {
 		hintNotes: "up and down: choose   type: filter   PgUp PgDn: scroll   ctrl+o: open   Esc: close", hintRead: "up and down: scroll   ctrl+o: open   Esc: back",
 		library: "Library", typeToSearch: "Type to search your library.", searching: "Searching...", noItems: "Nothing found.", failed: "The search failed",
 		hintLibrary: "up and down: choose   Enter: read   ctrl+n: note   Esc: close", hintLibrarian: "up and down: choose   Enter: copy the key   Esc: close",
+		hintChoice: "up and down: choose   Enter: select   type: filter   Esc: cancel", noChoice: "Nothing matches.", hintInput: "Enter: send   Esc: cancel",
 	},
 	pt: {
 		notes: "Notas", of: "de", filter: "filtro", none: "Ainda não há notas. O Sub-Sub escreve-as em Literature/, Research/ e Syntheses/.", noMatch: "Nenhuma nota corresponde.", empty: "(nota vazia)",
 		hintNotes: "cima e baixo: escolher   escrever: filtrar   PgUp PgDn: deslocar   ctrl+o: abrir   Esc: fechar", hintRead: "cima e baixo: deslocar   ctrl+o: abrir   Esc: voltar",
 		library: "Biblioteca", typeToSearch: "Escreva para pesquisar na biblioteca.", searching: "A pesquisar...", noItems: "Nada encontrado.", failed: "A pesquisa falhou",
 		hintLibrary: "cima e baixo: escolher   Enter: ler   ctrl+n: nota   Esc: fechar", hintLibrarian: "cima e baixo: escolher   Enter: copiar a chave   Esc: fechar",
+		hintChoice: "cima e baixo: escolher   Enter: selecionar   escrever: filtrar   Esc: cancelar", noChoice: "Nada corresponde.", hintInput: "Enter: enviar   Esc: cancelar",
 	},
 };
 
@@ -372,3 +374,157 @@ export class LibraryView {
 		this.o.redraw?.();
 	}
 }
+
+// ---------------------------------------------------------------- a list to choose from
+
+export interface Choice {
+	label: string;
+	/** Dim text after the label (a command, a date). */
+	hint?: string;
+	value: string;
+}
+
+export interface ChoiceLayout {
+	title: string;
+	choices: Choice[];
+	selected: number;
+	filter: string;
+	width: number;
+	rows: number;
+	lang: Lang;
+	paint: Paint;
+	glyphs?: Glyphs;
+}
+
+export function choiceLines(o: ChoiceLayout): string[] {
+	const g = o.glyphs ?? UNICODE;
+	const p = o.paint;
+	const w = Math.max(20, o.width);
+	const words = SCREEN_WORDS[o.lang];
+	const room = Math.max(1, o.rows - 4);
+	const out = [p.mark(cut(` ${o.title}`, w)) + (o.filter ? p.muted(cut(`   ${words.filter}: ${o.filter}`, Math.max(0, w - o.title.length - 1))) : ""), rule(w, "solid", p.muted, g)];
+	if (!o.choices.length) out.push(p.muted(cut(`  ${words.noChoice}`, w)));
+	const start = Math.max(0, Math.min(o.selected - Math.floor(room / 2), o.choices.length - room));
+	for (const [k, c] of o.choices.slice(start, start + room).entries()) {
+		const chosen = start + k === o.selected;
+		const hint = c.hint ? `  ${c.hint}` : "";
+		const label = cut(c.label, Math.max(8, w - 2 - hint.length));
+		out.push(`${chosen ? p.mark(g.pointer) : " "} ${chosen ? p.text(label) : p.muted(label)}${p.dim(cut(hint, Math.max(0, w - 2 - label.length)))}`);
+	}
+	out.push(rule(w, "solid", p.muted, g), ...wrapTextWithAnsi(` ${words.hintChoice}`, w).map((l) => p.muted(l)));
+	return out;
+}
+
+export interface ChoiceOptions {
+	title: string;
+	choices: Choice[];
+	choose: (value: string) => void;
+	cancel: () => void;
+	lang: Lang;
+	paint: Paint;
+	glyphs?: Glyphs;
+	rows?: () => number;
+	redraw?: () => void;
+}
+
+export class ChoiceView {
+	private readonly o: ChoiceOptions;
+	private filter = "";
+	private selected = 0;
+	private answered = false;
+	constructor(o: ChoiceOptions) {
+		this.o = o;
+	}
+
+	private shown(): Choice[] {
+		const f = this.filter.toLowerCase();
+		return f ? this.o.choices.filter((c) => `${c.label} ${c.hint ?? ""}`.toLowerCase().includes(f)) : this.o.choices;
+	}
+
+	render(width: number): string[] {
+		const rows = Math.max(8, Math.floor(((this.o.rows?.() ?? 24) * 8) / 10));
+		return fill(choiceLines({ title: this.o.title, choices: this.shown(), selected: this.selected, filter: this.filter, width, rows, lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs }), width);
+	}
+
+	invalidate(): void {}
+
+	handleInput(data: string): void {
+		if (this.answered) return;
+		const list = this.shown();
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.answered = true;
+			return this.o.cancel();
+		}
+		if (matchesKey(data, "enter")) {
+			const c = list[this.selected];
+			if (!c) return;
+			this.answered = true;
+			return this.o.choose(c.value);
+		}
+		if (matchesKey(data, "up")) this.selected = Math.max(0, this.selected - 1);
+		else if (matchesKey(data, "down")) this.selected = Math.min(Math.max(0, list.length - 1), this.selected + 1);
+		else if (matchesKey(data, "backspace")) {
+			this.filter = this.filter.slice(0, -1);
+			this.selected = 0;
+		} else if (printable(data)) {
+			this.filter += data;
+			this.selected = 0;
+		} else return;
+		this.o.redraw?.();
+	}
+}
+
+// ---------------------------------------------------------------- a question with a typed answer
+
+export interface InputOptions {
+	title: string;
+	placeholder?: string;
+	prefill?: string;
+	submit: (text: string) => void;
+	cancel: () => void;
+	lang: Lang;
+	paint: Paint;
+	glyphs?: Glyphs;
+	redraw?: () => void;
+}
+
+export function inputLines(o: { title: string; placeholder?: string; text: string; width: number; lang: Lang; paint: Paint; glyphs?: Glyphs }): string[] {
+	const g = o.glyphs ?? UNICODE;
+	const p = o.paint;
+	const w = Math.max(20, o.width);
+	const shown = o.text ? p.text(cut(o.text, w - 5)) + p.mark("_") : p.dim(cut(o.placeholder ?? "", w - 5)) + p.mark("_");
+	return [p.mark(cut(` ${o.title}`, w)), rule(w, "solid", p.muted, g), ` ${p.muted(">")} ${shown}`, rule(w, "solid", p.muted, g), p.muted(cut(` ${SCREEN_WORDS[o.lang].hintInput}`, w))];
+}
+
+export class InputView {
+	private readonly o: InputOptions;
+	private text: string;
+	private answered = false;
+	constructor(o: InputOptions) {
+		this.o = o;
+		this.text = o.prefill ?? "";
+	}
+
+	render(width: number): string[] {
+		return fill(inputLines({ title: this.o.title, placeholder: this.o.placeholder, text: this.text, width, lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs }), width);
+	}
+
+	invalidate(): void {}
+
+	handleInput(data: string): void {
+		if (this.answered) return;
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.answered = true;
+			return this.o.cancel();
+		}
+		if (matchesKey(data, "enter")) {
+			this.answered = true;
+			return this.o.submit(this.text);
+		}
+		if (matchesKey(data, "backspace")) this.text = this.text.slice(0, -1);
+		else if (matchesKey(data, "ctrl+u")) this.text = "";
+		else if (printable(data)) this.text += data;
+		else return;
+		this.o.redraw?.();
+	}
+}