devicerent 0.1.0 → 0.2.0

package/dist/devicerent.mjs

@@ -2,14 +2,15 @@
 import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { createDecipheriv, createHash, createPublicKey, diffieHellman, generateKeyPairSync, hkdfSync, randomBytes, randomUUID } from "node:crypto";
 import http from "node:http";
-import { spawn } from "node:child_process";
-import os from "node:os";
+import { execFile, spawn } from "node:child_process";
 import readline from "node:readline/promises";
 import sharp from "sharp";
 import net from "node:net";
+import readline$1 from "node:readline";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -76,6 +77,61 @@ function int$1(opts, key, fallback) {
 	return n;
 }
 //#endregion
+//#region src/interactive/gate.ts
+/** CI=true / CI=1 / CI=anything — but not CI=false or CI=0. */
+function isCi(env) {
+	const v = env.CI;
+	return v !== void 0 && v !== "" && v !== "false" && v !== "0";
+}
+function shouldStartInteractive(i) {
+	return i.argv.length === 0 && !i.globals.includes("--json") && i.stdinTTY && i.stdoutTTY && i.stderrTTY && i.env.TERM !== "dumb" && !isCi(i.env) && !i.env.DEVICERENT_NO_INTERACTIVE;
+}
+//#endregion
+//#region src/output.ts
+/** An error whose message is already written for the person at the keyboard. */
+var CliError = class extends Error {
+	exitCode;
+	constructor(message, exitCode = 1) {
+		super(message);
+		this.exitCode = exitCode;
+	}
+};
+const useColor = () => !process.env.NO_COLOR && process.stderr.isTTY && process.stdout.isTTY;
+const paint = (code) => (s) => useColor() ? `\u001b[${code}m${s}\u001b[0m` : s;
+const bold = paint(1);
+const dim = paint(2);
+const red = paint(31);
+const green = paint(32);
+const yellow = paint(33);
+function note(message) {
+	process.stderr.write(`${message}\n`);
+}
+function warn(message) {
+	process.stderr.write(`${yellow("!")} ${message}\n`);
+}
+function success(message) {
+	process.stderr.write(`${green("✓")} ${message}\n`);
+}
+function printJson(value) {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function printLine(line = "") {
+	process.stdout.write(`${line}\n`);
+}
+/** A plain left-aligned table; widths fit the widest cell per column. */
+function formatTable(headers, rows) {
+	const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+	const line = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(widths[i])).join("  ").trimEnd();
+	return [line(headers), ...rows.map(line)].join("\n");
+}
+function printTable(headers, rows) {
+	if (rows.length === 0) return;
+	printLine(formatTable(headers, rows));
+}
+function eur(n) {
+	return `€${n.toFixed(2)}`;
+}
+//#endregion
 //#region ../../../OneDrive/Masaüstü/DeviceRent Software part 5/node_modules/zod/v4/core/core.js
 var _a$1;
 function $constructor(name, initializer, params) {
@@ -26909,51 +26965,6 @@ function openSealed(privateKey, sealed, aad) {
 	return Buffer.concat([decipher.update(body), decipher.final()]).toString("utf8");
 }
 //#endregion
-//#region src/output.ts
-/** An error whose message is already written for the person at the keyboard. */
-var CliError = class extends Error {
-	exitCode;
-	constructor(message, exitCode = 1) {
-		super(message);
-		this.exitCode = exitCode;
-	}
-};
-const useColor = () => !process.env.NO_COLOR && process.stderr.isTTY && process.stdout.isTTY;
-const paint = (code) => (s) => useColor() ? `\u001b[${code}m${s}\u001b[0m` : s;
-const bold = paint(1);
-const dim = paint(2);
-const red = paint(31);
-const green = paint(32);
-const yellow = paint(33);
-function note(message) {
-	process.stderr.write(`${message}\n`);
-}
-function warn(message) {
-	process.stderr.write(`${yellow("!")} ${message}\n`);
-}
-function success(message) {
-	process.stderr.write(`${green("✓")} ${message}\n`);
-}
-function printJson(value) {
-	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
-}
-function printLine(line = "") {
-	process.stdout.write(`${line}\n`);
-}
-/** A plain left-aligned table; widths fit the widest cell per column. */
-function formatTable(headers, rows) {
-	const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
-	const line = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(widths[i])).join("  ").trimEnd();
-	return [line(headers), ...rows.map(line)].join("\n");
-}
-function printTable(headers, rows) {
-	if (rows.length === 0) return;
-	printLine(formatTable(headers, rows));
-}
-function eur(n) {
-	return `€${n.toFixed(2)}`;
-}
-//#endregion
 //#region src/version.ts
 /**
 * This CLI's version. Sent to the server in every request and in the login
@@ -26961,7 +26972,7 @@ function eur(n) {
 * version.test.ts pins it to package.json so the two cannot drift (the
 * connector's hard-coded `--version` once did).
 */
-const CLI_VERSION = "0.1.0";
+const CLI_VERSION = "0.2.0";
 //#endregion
 //#region src/auth/loopback.ts
 function page(message) {
@@ -27007,9 +27018,20 @@ function listenOnLoopback(state) {
 }
 //#endregion
 //#region src/auth/terminal.ts
-/** Open a URL in the default browser. False when there is no way to. */
+/**
+* A Windows system program by its full path under %SystemRoot%\System32.
+* Never a bare name: Windows looks in the CURRENT folder before PATH, so a
+* `rundll32.exe` or `powershell.exe` sitting in whatever folder the person
+* ran `npx devicerent` from (a downloaded project, Downloads itself) would
+* run instead of the real one.
+*/
+function systemExe(relative) {
+	const root = process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
+	return path.win32.join(root, "System32", relative);
+}
+/** Open a URL (or a file) in its default app. False when there is no way to. */
 function openBrowser(url) {
-	const [cmd, args] = process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+	const [cmd, args] = process.platform === "win32" ? [systemExe("rundll32.exe"), ["url.dll,FileProtocolHandler", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
 	try {
 		const child = spawn(cmd, args, {
 			stdio: "ignore",
@@ -27022,15 +27044,31 @@ function openBrowser(url) {
 		return false;
 	}
 }
-/** One line from the person at the terminal. Refuses when there is none. */
+/** Ctrl-C at a prompt: a deliberate stop, exit code 130 as for SIGINT. */
+const CANCELLED = () => new CliError("Cancelled.", 130);
+/**
+* One line from the person at the terminal. Refuses when there is none.
+*
+* readline puts the terminal in raw mode while it asks, so Ctrl-C arrives as a
+* key, never as SIGINT: a process-level SIGINT handler never sees it, and
+* Node 24 just rejects the question with a bare AbortError. Ctrl-C (and an
+* aborted `signal`) therefore end here, as a plain "Cancelled.".
+*/
 async function promptLine(question, signal) {
 	if (!process.stdin.isTTY) throw new CliError("This step needs an interactive terminal.");
 	const rl = readline.createInterface({
 		input: process.stdin,
 		output: process.stderr
 	});
+	const interrupted = new Promise((_, reject) => {
+		rl.once("SIGINT", () => reject(CANCELLED()));
+	});
 	try {
-		return (await rl.question(question, signal ? { signal } : {})).trim();
+		return (await Promise.race([rl.question(question, signal ? { signal } : {}), interrupted])).trim();
+	} catch (err) {
+		if (err instanceof CliError) throw err;
+		if (err.name === "AbortError" || signal?.aborted) throw CANCELLED();
+		throw err;
 	} finally {
 		rl.close();
 	}
@@ -27062,7 +27100,7 @@ async function login(ctx, opts) {
 		const url = `${ctx.config.app_url}/account/cli/${segment}`;
 		note("Approve this sign-in in your browser:");
 		note(`  ${url}`);
-		sealed = opts.noBrowser ? await promptLine("\nPaste the code the page shows after you approve: ") : await waitForBrowser(url, listener.payload);
+		sealed = opts.noBrowser ? await promptLine("\nPaste the code the page shows after you approve: ", opts.signal) : await waitForBrowser(url, listener.payload, opts.signal);
 	} finally {
 		listener.close();
 	}
@@ -27084,9 +27122,9 @@ async function login(ctx, opts) {
 	const abandon = () => {
 		staging.client.auth.signOut({ scope: "local" }).finally(() => process.exit(130));
 	};
-	process.once("SIGINT", abandon);
+	if (!opts.signal) process.once("SIGINT", abandon);
 	try {
-		await stepUpIfEnrolled(staging.client);
+		await stepUpIfEnrolled(staging.client, opts.signal);
 	} finally {
 		process.off("SIGINT", abandon);
 	}
@@ -27094,17 +27132,22 @@ async function login(ctx, opts) {
 	staging.commit(ctx.store);
 	return data.user;
 }
-async function waitForBrowser(url, payload) {
+async function waitForBrowser(url, payload, signal) {
 	if (!openBrowser(url)) warn("Could not open a browser; open the link above yourself.");
 	note("Waiting for approval… If the page asked you to sign in first and then showed your dashboard, open the link again. (Ctrl-C to cancel. Browser on another machine? Run: devicerent login --no-browser)");
 	let timer;
+	let onAbort;
 	const timeout = new Promise((_, reject) => {
 		timer = setTimeout(() => reject(new CliError("Timed out waiting for the browser.")), APPROVAL_TIMEOUT_MS);
+		onAbort = () => reject(CANCELLED());
+		if (signal?.aborted) onAbort();
+		else signal?.addEventListener("abort", onAbort, { once: true });
 	});
 	try {
 		return await Promise.race([payload, timeout]);
 	} finally {
 		clearTimeout(timer);
+		if (onAbort) signal?.removeEventListener("abort", onAbort);
 	}
 }
 /**
@@ -27114,7 +27157,7 @@ async function waitForBrowser(url, payload) {
 * (getUser), never from a cached copy. Every failure signs the staged
 * session out, so it ends server-side too.
 */
-async function stepUpIfEnrolled(client) {
+async function stepUpIfEnrolled(client, signal) {
 	const refuse = async (message) => {
 		await client.auth.signOut({ scope: "local" });
 		throw new CliError(message);
@@ -27128,7 +27171,7 @@ async function stepUpIfEnrolled(client) {
 	const mfa = client.auth.mfa;
 	try {
 		for (let attempt = 1; attempt <= MFA_ATTEMPTS; attempt++) {
-			const code = await promptLine("Authenticator code: ");
+			const code = await promptLine("Authenticator code: ", signal);
 			const { error } = await mfa.challengeAndVerify({
 				factorId: totp.id,
 				code
@@ -27354,8 +27397,11 @@ const loginCommand = {
 	summary: "Sign this terminal in through your browser",
 	usage: "devicerent login [--no-browser]",
 	options: { "no-browser": { type: "boolean" } },
-	async run({ ctx, opts, json }) {
-		const user = await login(ctx, { noBrowser: opts["no-browser"] === true });
+	async run({ ctx, opts, json, signal }) {
+		const user = await login(ctx, {
+			noBrowser: opts["no-browser"] === true,
+			signal
+		});
 		if (json) return printJson({
 			email: user.email,
 			id: user.id,
@@ -29130,7 +29176,7 @@ function write4HexDigits(buffer, index, value) {
 }
 //#endregion
 //#region ../../../OneDrive/Masaüstü/DeviceRent Software part 5/node_modules/@yume-chan/adb/esm/utils/no-op.js
-const NOOP = /* @__NO_SIDE_EFFECTS__ */ () => {};
+const NOOP$1 = /* @__NO_SIDE_EFFECTS__ */ () => {};
 /**
 * When used in `Promise#catch`, means the promise should never throw errors.
 * An explicit way to suppress ESLint floating promise warnings.
@@ -29968,7 +30014,7 @@ async function pipeFileData(locked, file, packetSize, mtime) {
 	} }), { signal: abortController.signal }).then(async () => {
 		await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
 		await locked.flush();
-	}, NOOP);
+	}, NOOP$1);
 	await adbSyncReadResponse(locked, AdbSyncResponseId.Ok, AdbSyncOkResponse).catch((e) => {
 		abortController.abort();
 		throw e;
@@ -32022,6 +32068,70 @@ function obj(props, required) {
 	};
 }
 const NO_ARGS = obj({}, []);
+/** Tools that only read. Available as soon as a session exists. */
+const READ_TOOLS = [
+	{
+		name: "observe_screen",
+		description: "Read what is currently on the phone screen as a numbered list of interactable elements with exact pixel bounds and a ready-made tap point. This is your primary way of seeing the device: it is far cheaper and far more precise than a screenshot. Use it to look at a screen you have not just changed — at the start of a task, or after a wait. You do NOT need it after an action: tap, swipe, type_text, press_key and launch_app already return the resulting screen with them.",
+		parameters: NO_ARGS
+	},
+	{
+		name: "screenshot",
+		description: "Capture the screen as an image. Costs roughly three times as much as observe_screen and gives you no coordinates, so use it only when observe_screen returns no elements (games, video, canvas, some Jetpack Compose surfaces) or when the question is genuinely visual — colours, layout, whether something rendered correctly.",
+		parameters: NO_ARGS
+	},
+	{
+		name: "list_packages",
+		description: "List the third-party app packages installed on the phone. Use this to find the package name of an app before launching it.",
+		parameters: NO_ARGS
+	},
+	{
+		name: "device_info",
+		description: "Report the device model, Android version, screen resolution and current screen orientation.",
+		parameters: NO_ARGS
+	},
+	{
+		name: "wait",
+		description: "Pause for an animation, a page load or a splash screen, then get the screen as it stands after the pause — the same listing observe_screen returns, so you do NOT need observe_screen after a wait. Prefer waiting once for long enough over polling observe_screen repeatedly, which costs tokens each time.",
+		parameters: obj({ ms: {
+			type: "integer",
+			description: "Milliseconds to wait. Clamped to 100-5000."
+		} }, ["ms"])
+	},
+	{
+		name: "list_instrumentations",
+		description: "List the instrumentation test runners installed on the phone, with the exact target string to pass to run_instrumentation. Use this instead of guessing the runner name — a wrong target is the most common reason a test run never starts.",
+		parameters: NO_ARGS
+	},
+	{
+		name: "logcat_tail",
+		description: "Read the tail of the device log. This is the triage tool: when a test fails or an app crashes, read the log before you change anything. Guessing at a cause you have not read is how a fix loop turns into ten wasted steps.",
+		parameters: obj({
+			lines: {
+				type: "integer",
+				description: "How many recent lines to return. Clamped to 1-1000."
+			},
+			filter: {
+				type: "string",
+				description: "Case-insensitive substring to keep only matching lines - a tag, a package, or an exception class. Empty string returns everything."
+			}
+		}, ["lines", "filter"])
+	},
+	{
+		name: "read_device_file",
+		description: "Read a text file off the phone - a JUnit XML report, a coverage file, or anything a test wrote out. Only /data/local/tmp and /sdcard are readable, and binary files are refused.",
+		parameters: obj({
+			path: {
+				type: "string",
+				description: "Absolute path, under /data/local/tmp or /sdcard."
+			},
+			max_bytes: {
+				type: "integer",
+				description: "Maximum bytes to return. Clamped to 1000-100000."
+			}
+		}, ["path", "max_bytes"])
+	}
+];
 /** Tools that touch the device. Gated on the session's allow_actions toggle. */
 const ACTION_TOOLS = [
 	{
@@ -32805,7 +32915,7 @@ const browserImageCodec = { async pngToScaledJpeg(png) {
 //#region ../../src/lib/ai/clientToolArgs.ts
 /** Cap on any single tool result. One runaway dump must not blow up a turn. */
 const MAX_RESULT_CHARS = 2e4;
-function truncate(s) {
+function truncate$1(s) {
 	if (s.length <= MAX_RESULT_CHARS) return s;
 	return s.slice(0, MAX_RESULT_CHARS) + `\n… truncated (${s.length - MAX_RESULT_CHARS} more characters)`;
 }
@@ -34100,7 +34210,7 @@ async function executeToolCall(ctx, call) {
 	});
 	const ok = (msg) => ({
 		toolCallId: call.id,
-		content: truncate(msg),
+		content: truncate$1(msg),
 		isError: false
 	});
 	const { adb, control, mirrorSize, status } = ctx.getHandles();
@@ -34807,6 +34917,12 @@ function parseWmSize(out) {
 }
 //#endregion
 //#region src/ai/loop.ts
+/**
+* DeviceyAI was given look-only access and the task needs to tap or type. Its
+* message is the one-shot instruction; the interactive session catches the
+* type and asks for the permission instead.
+*/
+var AiNeedsActionsError = class extends CliError {};
 /** What a refused turn means, as an instruction a person can act on. */
 function describeTurnFailure(status, failure) {
 	if (status === 409 && failure.needs_actions) return "This task needs to tap and type on the phone. Run it again with --allow-actions.";
@@ -34820,7 +34936,10 @@ async function readTurn(payload, signal, hooks) {
 	} catch {
 		return null;
 	}
-	if (reply.kind === "failed") throw new CliError(describeTurnFailure(reply.status, reply.failure));
+	if (reply.kind === "failed") {
+		const message = describeTurnFailure(reply.status, reply.failure);
+		throw reply.status === 409 && reply.failure.needs_actions ? new AiNeedsActionsError(message) : new CliError(message);
+	}
 	if (reply.kind === "json") return reply.turn;
 	let done = null;
 	for await (const ev of reply.events) if (ev.name === "text") hooks.onText(ev.delta);
@@ -35159,17 +35278,139 @@ const RENTAL_OPTION = { rental: {
 	type: "string",
 	short: "r"
 } };
-/** Resolve the rental, open the phone, run, and always close it again. */
+const STOPPED = () => new CliError("Stopped.", 130);
+/**
+* Resolve the rental, open the phone, run, and always close it again.
+*
+* In the interactive session Ctrl-C aborts `input.signal`. That closes the
+* connection to the phone at once — a `finally` alone would never run while a
+* `logcat -f` read loop is blocked — and the stream error it causes is
+* reported as the deliberate stop it was. A one-shot run has no signal.
+*/
 async function withDevice(input, fn) {
 	const user = await requireUser(input.ctx);
 	const rental = chooseRental(await loadActiveRentals(), str$1(input.opts, "rental") ?? process.env.DEVICERENT_RENTAL);
+	if (input.signal?.aborted) throw STOPPED();
 	const device = await openDevice(input.ctx, rental);
+	const onAbort = () => void device.close();
+	input.signal?.addEventListener("abort", onAbort, { once: true });
 	try {
 		return await fn(device, user);
+	} catch (err) {
+		if (input.signal?.aborted) throw STOPPED();
+		throw err;
 	} finally {
+		input.signal?.removeEventListener("abort", onAbort);
 		await device.close();
 	}
 }
+const CSI = `[`;
+function colorLevel(env, isTTY) {
+	if (env.NO_COLOR) return 0;
+	const force = env.FORCE_COLOR;
+	if (force === "0" || force === "false") return 0;
+	const truecolor = env.COLORTERM === "truecolor" || env.COLORTERM === "24bit" || Boolean(env.WT_SESSION) || env.TERM_PROGRAM === "vscode" || env.TERM_PROGRAM === "iTerm.app" || env.TERM_PROGRAM === "WezTerm";
+	if (force !== void 0 && force !== "") return force === "3" || truecolor ? 3 : 1;
+	if (!isTTY || env.TERM === "dumb") return 0;
+	return truecolor ? 3 : 1;
+}
+const ANSI_RE = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+function stripAnsi(s) {
+	return s.replace(ANSI_RE, "");
+}
+const CONTROL_RE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+/**
+* Text from outside — DeviceyAI's answer, a tool's error, a file name — made
+* safe to print. Escape sequences are removed whole, then every remaining
+* control character, so text read off a phone's screen cannot retitle the
+* window, rewrite the clipboard (OSC 52) or hide what is printed after it. A
+* sequence split across two chunks loses its ESC and prints as harmless text.
+*/
+function sanitize(text) {
+	return text.replace(ANSI_RE, "").replace(CONTROL_RE, "");
+}
+/** Zero-width: combining marks, joiners, variation selectors. */
+function isZeroWidth(cp) {
+	return cp >= 768 && cp <= 879 || cp >= 8203 && cp <= 8207 || cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999 || cp === 8419;
+}
+/** Drawn two cells wide: East Asian wide/fullwidth and emoji pictographs. */
+function isWide(cp) {
+	return cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 12350 || cp >= 12353 && cp <= 13311 || cp >= 13312 && cp <= 19903 || cp >= 19968 && cp <= 40959 || cp >= 40960 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 127744 && cp <= 128591 || cp >= 128640 && cp <= 128767 || cp >= 129280 && cp <= 129535 || cp >= 129648 && cp <= 129791 || cp >= 131072 && cp <= 262141;
+}
+function charWidth(ch) {
+	const cp = ch.codePointAt(0) ?? 0;
+	if (cp < 32 || cp >= 127 && cp < 160) return 0;
+	if (isZeroWidth(cp)) return 0;
+	return isWide(cp) ? 2 : 1;
+}
+/** How many terminal cells `s` occupies once its escape codes are drawn. */
+function visibleWidth(s) {
+	let w = 0;
+	for (const ch of stripAnsi(s)) w += charWidth(ch);
+	return w;
+}
+/**
+* Cut `s` to at most `max` visible cells, keeping escape codes intact and
+* ending with "…" when anything was cut. A reset is appended after a cut so a
+* colour cannot bleed into the next line.
+*/
+function truncate(s, max) {
+	if (max <= 0) return "";
+	if (visibleWidth(s) <= max) return s;
+	let out = "";
+	let w = 0;
+	let i = 0;
+	while (i < s.length) {
+		ANSI_RE.lastIndex = i;
+		const m = ANSI_RE.exec(s);
+		if (m && m.index === i) {
+			out += m[0];
+			i += m[0].length;
+			continue;
+		}
+		const ch = String.fromCodePoint(s.codePointAt(i) ?? 0);
+		const cw = charWidth(ch);
+		if (w + cw > max - 1) break;
+		out += ch;
+		w += cw;
+		i += ch.length;
+	}
+	ANSI_RE.lastIndex = 0;
+	return `${out}…${CSI}0m`;
+}
+/** Pad with spaces to exactly `width` visible cells (truncating if longer). */
+function padEnd(s, width) {
+	const t = truncate(s, width);
+	return t + " ".repeat(Math.max(0, width - visibleWidth(t)));
+}
+/** Word-wrap plain text to `width` cells. Words longer than a line are split. */
+function wrap(text, width) {
+	const out = [];
+	for (const paragraph of text.split("\n")) {
+		let line = "";
+		for (const word of paragraph.split(/ +/)) {
+			if (word === "") continue;
+			let w = word;
+			while (visibleWidth(w) > width) {
+				if (line) {
+					out.push(line);
+					line = "";
+				}
+				const head = [...w].slice(0, width).join("");
+				out.push(head);
+				w = w.slice(head.length);
+			}
+			if (!line) line = w;
+			else if (visibleWidth(line) + 1 + visibleWidth(w) <= width) line += ` ${w}`;
+			else {
+				out.push(line);
+				line = w;
+			}
+		}
+		out.push(line);
+	}
+	return out;
+}
 //#endregion
 //#region src/commands/ai.ts
 const ConfigSchema = object({
@@ -35181,6 +35422,20 @@ const ConfigSchema = object({
 	})),
 	credits: number$1()
 });
+/** The models and credit balance DeviceyAI offers on this rental. */
+async function loadAiConfig(rentalId) {
+	const res = await fetch(`/api/ai/config?rental_id=${encodeURIComponent(rentalId)}`);
+	const cfg = ConfigSchema.safeParse(await res.json().catch(() => ({})));
+	if (!res.ok || !cfg.success) throw new CliError(res.status === 404 ? "DeviceyAI is not available on this deployment." : `DeviceyAI config failed (${res.status}).`);
+	return cfg.data;
+}
+/** The model --model names, else the default, else the first offered. */
+function pickModel(models, wanted) {
+	const model = models.find((m) => m.id === (wanted ?? "claude-sonnet-5")) ?? (wanted ? void 0 : models[0]);
+	if (!model) throw new CliError(`Model ${wanted} is not offered here. See: devicerent ai --models`);
+	return model;
+}
+const OUT_OF_CREDITS = "You are out of DeviceyAI credits. Buy a pack: devicerent credits buy s";
 const aiCommands = [{
 	name: "ai",
 	summary: "Give DeviceyAI a task on your rented phone",
@@ -35196,25 +35451,21 @@ const aiCommands = [{
 		const task = input.args.join(" ").trim();
 		if (!task && input.opts.models !== true) throw new CliError("Say what to do: devicerent ai \"open Settings and tell me the Android version\"");
 		return withDevice(input, async (device) => {
-			const res = await fetch(`/api/ai/config?rental_id=${encodeURIComponent(device.rental.id)}`);
-			const cfg = ConfigSchema.safeParse(await res.json().catch(() => ({})));
-			if (!res.ok || !cfg.success) throw new CliError(res.status === 404 ? "DeviceyAI is not available on this deployment." : `DeviceyAI config failed (${res.status}).`);
-			const { models, credits } = cfg.data;
+			const { models, credits } = await loadAiConfig(device.rental.id);
 			if (input.opts.models === true) {
 				if (input.json) return void printJson(models);
 				for (const m of models) printLine(`${m.id}  ${dim(m.label)}${m.id === "claude-sonnet-5" ? "  (default)" : ""}`);
 				return 0;
 			}
-			const wanted = str$1(input.opts, "model") ?? "claude-sonnet-5";
-			const model = models.find((m) => m.id === wanted) ?? (str$1(input.opts, "model") ? void 0 : models[0]);
-			if (!model) throw new CliError(`Model ${wanted} is not offered here. See: devicerent ai --models`);
-			if (credits <= 0) throw new CliError("You are out of DeviceyAI credits. Buy a pack: devicerent credits buy s");
+			const model = pickModel(models, str$1(input.opts, "model"));
+			if (credits <= 0) throw new CliError(OUT_OF_CREDITS);
 			const allowActions = input.opts["allow-actions"] === true;
 			if (!allowActions) note("Read-only: DeviceyAI can look but not touch. Add --allow-actions to let it tap and type.");
 			note(`DeviceyAI (${model.label}) on ${device.rental.deviceName} — Ctrl-C stops it.`);
 			const controller = new AbortController();
 			const onSigint = () => controller.abort();
 			process.once("SIGINT", onSigint);
+			input.signal?.addEventListener("abort", onSigint, { once: true });
 			let streamed = false;
 			try {
 				const result = await runAiTask(device, {
@@ -35227,7 +35478,7 @@ const aiCommands = [{
 					onText: (delta) => {
 						if (input.json) return;
 						streamed = true;
-						process.stdout.write(delta);
+						process.stdout.write(sanitize(delta));
 					},
 					onTool: (name) => {
 						if (input.json) return;
@@ -35236,7 +35487,7 @@ const aiCommands = [{
 						process.stderr.write(dim(`→ ${name}\n`));
 					},
 					onToolDone: (name, isError, content) => {
-						if (!input.json && isError) warn(`${name}: ${content.split("\n")[0]}`);
+						if (!input.json && isError) warn(`${name}: ${sanitize(content.split("\n")[0])}`);
 					}
 				});
 				if (input.json) return void printJson(result);
@@ -35248,6 +35499,7 @@ const aiCommands = [{
 				return result.stopReason === "done" ? 0 : 1;
 			} finally {
 				process.off("SIGINT", onSigint);
+				input.signal?.removeEventListener("abort", onSigint);
 			}
 		});
 	}
@@ -36003,7 +36255,7 @@ function progressPrinter(label) {
 	let last = -1;
 	return (p) => {
 		if (p.stage === "installing") {
-			process.stderr.write(`${tty ? "\r" : ""}${label}: installing…${tty ? "        " : ""}\n`);
+			process.stderr.write(`${tty ? "\r\x1B[K" : ""}${label}: installing…\n`);
 			return;
 		}
 		const pct = p.totalBytes ? Math.floor(p.pushedBytes / p.totalBytes * 100) : 0;
@@ -36058,6 +36310,13 @@ const installCommand = {
 			}
 			return out;
 		});
+		input.onResult?.({
+			kind: "installed",
+			apps: results.map((r) => ({
+				filename: r.filename,
+				packageName: r.packageName
+			}))
+		});
 		if (input.json) printJson(results);
 	}
 };
@@ -36221,6 +36480,10 @@ const screenshotCommand = {
 		});
 		if (!bytes) throw new CliError("The phone did not return a PNG.");
 		fs.writeFileSync(file, bytes);
+		input.onResult?.({
+			kind: "screenshot",
+			file
+		});
 		if (input.json) return printJson({
 			file,
 			bytes: bytes.length
@@ -36358,7 +36621,7 @@ const rentalCommands = [
 		name: "rent",
 		summary: "Rent one to three phones (billing starts now)",
 		usage: "devicerent rent <device…>   e.g. devicerent rent \"Pixel 7a\" \"Galaxy A54\", or an Id from devicerent devices",
-		async run({ ctx, args, json }) {
+		async run({ ctx, args, json, onResult }) {
 			await requireUser(ctx);
 			if (args.length === 0) throw new CliError("Name a device (id, serial or model). See: devicerent devices");
 			if (args.length > MAX_PER_REQUEST) throw new CliError(`At most ${MAX_PER_REQUEST} devices at once.`);
@@ -36372,6 +36635,10 @@ const rentalCommands = [
 			const { data, error } = picks.length === 1 ? await ctx.supabase.rpc("rent_device", { p_device_id: picks[0].id }) : await ctx.supabase.rpc("rent_devices", { p_device_ids: picks.map((d) => d.id) });
 			if (error) throw new CliError(`Rental refused: ${error.message}`);
 			const rentals = Array.isArray(data) ? data : [data];
+			onResult?.({
+				kind: "rented",
+				rentalIds: rentals.map((r) => r.id)
+			});
 			if (json) return printJson(rentals);
 			for (const r of rentals) success(`Rented ${picks.find((p) => p.id === r.device_id)?.name ?? r.device_id} — rental ${r.id}`);
 			warn("Billing runs per minute until you `devicerent stop` (a rental with no activity for 30 minutes is stopped for you).");
@@ -36422,12 +36689,16 @@ const rentalCommands = [
 			all: { type: "boolean" },
 			rental: { type: "string" }
 		},
-		async run({ ctx, args, opts, json }) {
+		async run({ ctx, args, opts, json, onResult }) {
 			await requireUser(ctx);
 			if (opts.all === true) {
 				const { data, error } = await ctx.supabase.rpc("stop_all_rentals");
 				if (error) throw new CliError(`Could not stop: ${error.message}`);
 				const stopped = data ?? [];
+				onResult?.({
+					kind: "stopped",
+					rentalIds: stopped.map((r) => r.id)
+				});
 				if (json) return printJson(stopped);
 				if (stopped.length === 0) return note("Nothing was running.");
 				for (const r of stopped) success(`Stopped ${r.id} — ${eur(Number(r.total_cost ?? 0))}`);
@@ -36437,6 +36708,10 @@ const rentalCommands = [
 			const { data, error } = await ctx.supabase.rpc("stop_rental", { p_rental_id: rental.id });
 			if (error) throw new CliError(`Could not stop: ${error.message}`);
 			const row = data;
+			onResult?.({
+				kind: "stopped",
+				rentalIds: [rental.id]
+			});
 			if (json) return printJson(data);
 			success(`Stopped ${rental.deviceName} — ${eur(Number(row?.total_cost ?? 0))}`);
 		}
@@ -40720,7 +40995,7 @@ function createAdbServer({ getCreds, log = () => {} }) {
 	const server = net.createServer((sock) => {
 		sock.on("error", () => {});
 		readFirstRequest(sock, (payload, tail) => {
-			dispatch(sock, payload, tail, {
+			dispatch$1(sock, payload, tail, {
 				getCreds,
 				log,
 				forwards
@@ -40758,7 +41033,7 @@ function readFirstRequest(sock, cb) {
 	};
 	sock.on("data", onData);
 }
-async function dispatch(sock, payload, tail, ctx) {
+async function dispatch$1(sock, payload, tail, ctx) {
 	let creds = null;
 	try {
 		creds = ctx.getCreds();
@@ -41069,6 +41344,7 @@ const testingCommands = [
 				input.ctx.supabase.rpc("touch_rental_activity", { p_rental_id: rental.id });
 			}, 6e4);
 			let timer;
+			let disconnected = false;
 			const renew = async () => {
 				try {
 					ticket = await mintBridgeTicket(rental.id);
@@ -41077,8 +41353,10 @@ const testingCommands = [
 						token: ticket.token,
 						tokenTransport: "subprotocol"
 					})).getVersion();
+					if (disconnected) return;
 					timer = setTimeout(renew, renewDelayMs(ticket.expires_at, Date.now()));
 				} catch (err) {
+					if (disconnected) return;
 					warn(`Could not renew device access: ${err.message}`);
 					timer = setTimeout(renew, 3e4);
 				}
@@ -41095,29 +41373,46 @@ const testingCommands = [
 				},
 				log: (...parts) => note(parts.join(" "))
 			});
-			await new Promise((resolve, reject) => {
-				server.once("error", reject);
-				server.listen(port, "127.0.0.1", () => resolve());
-			});
-			success(`${rental.deviceName} (${ticket.serial}) is now a local adb device.`);
-			printLine("");
-			printLine(process.platform === "win32" ? `  $env:ANDROID_ADB_SERVER_PORT=${port}   # PowerShell` : `  export ANDROID_ADB_SERVER_PORT=${port}`);
-			printLine("");
-			note("Then use adb, gradle or Appium as usual in that shell. Ctrl-C disconnects (the rental keeps running).");
-			await new Promise((resolve) => {
-				const stop = () => resolve();
-				process.once("SIGINT", stop);
-				process.once("SIGTERM", stop);
+			const sockets = /* @__PURE__ */ new Set();
+			server.on("connection", (s) => {
+				sockets.add(s);
+				s.once("close", () => sockets.delete(s));
 			});
-			clearTimeout(timer);
-			clearInterval(touch);
-			server.close();
+			try {
+				await new Promise((resolve, reject) => {
+					server.once("error", reject);
+					server.listen(port, "127.0.0.1", () => resolve());
+				});
+				success(`${rental.deviceName} (${ticket.serial}) is now a local adb device.`);
+				printLine("");
+				printLine(process.platform === "win32" ? `  $env:ANDROID_ADB_SERVER_PORT=${port}   # PowerShell` : `  export ANDROID_ADB_SERVER_PORT=${port}`);
+				printLine("");
+				note("Then use adb, gradle or Appium as usual in that shell. Ctrl-C disconnects (the rental keeps running).");
+				await new Promise((resolve) => {
+					const stop = () => {
+						process.off("SIGINT", stop);
+						process.off("SIGTERM", stop);
+						input.signal?.removeEventListener("abort", stop);
+						resolve();
+					};
+					process.on("SIGINT", stop);
+					process.on("SIGTERM", stop);
+					if (input.signal?.aborted) stop();
+					else input.signal?.addEventListener("abort", stop);
+				});
+			} finally {
+				disconnected = true;
+				clearTimeout(timer);
+				clearInterval(touch);
+				server.close();
+				for (const s of sockets) s.destroy();
+			}
 			note("Disconnected. Stop the rental with: devicerent stop");
 		}
 	}
 ];
 //#endregion
-//#region src/main.ts
+//#region src/registry.ts
 const GROUPS = [
 	{
 		title: "Account",
@@ -41153,6 +41448,2763 @@ function findCommand(argv, commands = COMMANDS) {
 	}
 	return null;
 }
+/** --api-base, else DEVICERENT_API_BASE, else production. */
+function resolveApiBase(values) {
+	return normalizeApiBase((typeof values["api-base"] === "string" ? values["api-base"] : void 0) ?? process.env.DEVICERENT_API_BASE ?? "https://devicerent.net");
+}
+/**
+* Find, parse and run one command. Arguments are parsed BEFORE the context is
+* asked for, so a usage error never touches the network.
+*/
+async function runCommandLine(getCtx, argv, opts = {}) {
+	const found = findCommand(argv);
+	if (!found) return { kind: "unknown" };
+	const { command, rest } = found;
+	let values;
+	let positionals;
+	try {
+		({values, positionals} = parseArgs({
+			args: [...opts.globals ?? [], ...rest],
+			options: {
+				...GLOBAL_OPTIONS,
+				...command.options
+			},
+			allowPositionals: true,
+			strict: true
+		}));
+	} catch (err) {
+		process.stderr.write(`${red(err.message)}\nUsage: ${command.usage}\n`);
+		return {
+			kind: "usage",
+			code: 2
+		};
+	}
+	if (values.help === true) {
+		printLine(`${command.summary}\n\nUsage: ${command.usage}`);
+		return {
+			kind: "ran",
+			code: 0
+		};
+	}
+	if (opts.interactive && values["api-base"] !== void 0) throw new CliError("--api-base cannot change inside this session. Leave, then run: devicerent --api-base <url>", 2);
+	const ctx = await getCtx(resolveApiBase(values));
+	const code = await command.run({
+		ctx,
+		args: positionals,
+		opts: values,
+		json: values.json === true,
+		signal: opts.signal,
+		onResult: opts.onResult
+	});
+	return {
+		kind: "ran",
+		code: typeof code === "number" ? code : 0
+	};
+}
+//#endregion
+//#region src/tui/box.ts
+/** The width a frame is drawn at: the terminal's, kept between 40 and 100. */
+function frameWidth(columns) {
+	const cols = columns && columns > 0 ? columns : 80;
+	return Math.max(Math.min(cols - 1, 40), Math.min(100, cols - 1));
+}
+/**
+* A rounded box around `lines`. Each line is padded (or cut) to the inside
+* width, so the right edge stays straight whatever colours a line carries.
+*/
+function renderBox(lines, opts) {
+	const { g } = opts.theme;
+	const paint = opts.border ?? opts.theme.dim;
+	const inner = Math.max(1, opts.width - 4);
+	let top = g.h.repeat(opts.width - 2);
+	if (opts.title) {
+		const t = ` ${truncate(opts.title, opts.width - 6)} `;
+		top = g.h + t + g.h.repeat(Math.max(0, opts.width - 3 - visibleWidth(t)));
+	}
+	return [
+		paint(`${g.tl}${top}${g.tr}`),
+		...lines.map((l) => `${paint(g.v)} ${padEnd(l, inner)} ${paint(g.v)}`),
+		paint(`${g.bl}${g.h.repeat(opts.width - 2)}${g.br}`)
+	];
+}
+//#endregion
+//#region src/tui/keys.ts
+let decoderReady = false;
+let owned = false;
+let restoreInstalled = false;
+function toKey(str, key) {
+	const k = {
+		name: key?.name,
+		ctrl: key?.ctrl === true,
+		meta: key?.meta === true,
+		shift: key?.shift === true
+	};
+	if (str !== void 0 && !k.ctrl && !k.meta && str.length > 0 && !/[\u0000-\u001f\u007f]/.test(str)) k.text = str;
+	return k;
+}
+/** Undo every mode the session may have switched on. Safe to call twice. */
+function restoreTerminal() {
+	process.stdout.write(`${CSI}?25h${CSI}?1l${CSI}?2004l${CSI}0m`);
+}
+/**
+* Read keys until the returned function is called. Throws if the keyboard is
+* already being read, so two readers can never race for the same key.
+*/
+function listenKeys(onKey) {
+	const stdin = process.stdin;
+	if (owned) throw new Error("the keyboard is already being read");
+	if (!decoderReady) {
+		readline$1.emitKeypressEvents(stdin, { escapeCodeTimeout: 50 });
+		decoderReady = true;
+	}
+	if (!restoreInstalled) {
+		process.on("exit", restoreTerminal);
+		restoreInstalled = true;
+	}
+	const handler = (str, key) => onKey(toKey(str, key));
+	stdin.on("keypress", handler);
+	if (!stdin.isRaw) stdin.setRawMode(true);
+	stdin.resume();
+	process.stdout.write(`${CSI}?2004h`);
+	owned = true;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		stdin.off("keypress", handler);
+		process.stdout.write(`${CSI}?2004l`);
+		stdin.pause();
+		owned = false;
+	};
+}
+/**
+* Ordinary line mode, for work that needs it: Ctrl-C as SIGINT, readline's
+* own prompts, a child's input. A no-op when raw mode is already off.
+*/
+function cookedMode() {
+	if (process.stdin.isTTY && process.stdin.isRaw) process.stdin.setRawMode(false);
+}
+//#endregion
+//#region src/tui/lineEditor.ts
+function initialEditor(history = []) {
+	return {
+		value: "",
+		cursor: 0,
+		history,
+		historyIndex: null,
+		draft: "",
+		suggestion: 0,
+		dismissed: false,
+		pasting: false
+	};
+}
+/** The commands a `/…` line could mean, best match first. */
+function suggestionsFor(value, all, limit = 8) {
+	if (!value.startsWith("/")) return [];
+	const q = value.slice(1).toLowerCase();
+	if (/\s/.test(q)) return all.filter((s) => s.name.startsWith(q) && s.name !== q).slice(0, limit);
+	const prefix = all.filter((s) => s.name.startsWith(q));
+	const word = all.filter((s) => !prefix.includes(s) && s.name.split(" ").some((w) => w.startsWith(q)));
+	const described = q.length >= 3 ? all.filter((s) => !prefix.includes(s) && !word.includes(s) && s.summary.toLowerCase().includes(q)) : [];
+	return [
+		...prefix,
+		...word,
+		...described
+	].slice(0, limit);
+}
+/** The suggestions that are on screen right now. */
+function visibleSuggestions(state, all) {
+	return state.dismissed ? [] : suggestionsFor(state.value, all);
+}
+function prevBoundary(s, i) {
+	if (i <= 0) return 0;
+	const c = s.charCodeAt(i - 1);
+	return c >= 56320 && c <= 57343 && i >= 2 ? i - 2 : i - 1;
+}
+function nextBoundary(s, i) {
+	if (i >= s.length) return s.length;
+	const c = s.charCodeAt(i);
+	return c >= 55296 && c <= 56319 && i + 1 < s.length ? i + 2 : i + 1;
+}
+/** Start of the word before the cursor (Ctrl-W, Alt-Backspace). */
+function wordStart(s, i) {
+	let j = i;
+	while (j > 0 && /\s/.test(s[j - 1])) j--;
+	while (j > 0 && !/\s/.test(s[j - 1])) j--;
+	return j;
+}
+function edit(state, value, cursor) {
+	return {
+		...state,
+		value,
+		cursor,
+		historyIndex: null,
+		draft: value,
+		suggestion: 0,
+		dismissed: false
+	};
+}
+function recall(state, index) {
+	const value = index === null ? state.draft : state.history[index] ?? state.draft;
+	return {
+		...state,
+		historyIndex: index,
+		value,
+		cursor: value.length,
+		suggestion: 0,
+		dismissed: true
+	};
+}
+function editorReducer(state, key, all) {
+	const s = state;
+	const ok = (next, event = null) => ({
+		state: next,
+		event
+	});
+	const shown = visibleSuggestions(s, all);
+	if (key.name === "paste-start") return ok({
+		...s,
+		pasting: true
+	});
+	if (key.name === "paste-end") return ok({
+		...s,
+		pasting: false
+	});
+	if (key.name === "return" || key.name === "enter") {
+		if (s.pasting) return ok(edit(s, `${s.value.slice(0, s.cursor)} ${s.value.slice(s.cursor)}`, s.cursor + 1));
+		const pick = shown[s.suggestion];
+		if (pick) {
+			const value = `/${pick.name}`;
+			return ok({
+				...s,
+				value,
+				cursor: value.length
+			}, "submit");
+		}
+		return ok(s, "submit");
+	}
+	if (key.ctrl && key.name === "c") return s.value ? ok(edit(s, "", 0)) : ok(s, "interrupt");
+	if (key.ctrl && key.name === "d") {
+		if (!s.value) return ok(s, "eof");
+		return ok(edit(s, s.value.slice(0, s.cursor) + s.value.slice(nextBoundary(s.value, s.cursor)), s.cursor));
+	}
+	if (key.name === "escape") {
+		if (shown.length > 0) return ok({
+			...s,
+			dismissed: true
+		});
+		return ok(edit(s, "", 0));
+	}
+	if (key.name === "tab") {
+		const pick = shown[s.suggestion];
+		if (!pick) return ok(s);
+		const value = `/${pick.name} `;
+		return ok({
+			...edit(s, value, value.length),
+			dismissed: true
+		});
+	}
+	if (key.name === "up" || key.ctrl && key.name === "p") {
+		if (shown.length > 0) return ok({
+			...s,
+			suggestion: (s.suggestion - 1 + shown.length) % shown.length
+		});
+		if (s.history.length === 0) return ok(s);
+		return ok(recall(s, s.historyIndex === null ? s.history.length - 1 : Math.max(0, s.historyIndex - 1)));
+	}
+	if (key.name === "down" || key.ctrl && key.name === "n") {
+		if (shown.length > 0) return ok({
+			...s,
+			suggestion: (s.suggestion + 1) % shown.length
+		});
+		if (s.historyIndex === null) return ok(s);
+		const i = s.historyIndex + 1;
+		return ok(recall(s, i >= s.history.length ? null : i));
+	}
+	if (key.name === "left" || key.ctrl && key.name === "b") return ok({
+		...s,
+		cursor: prevBoundary(s.value, s.cursor)
+	});
+	if (key.name === "right" || key.ctrl && key.name === "f") return ok({
+		...s,
+		cursor: nextBoundary(s.value, s.cursor)
+	});
+	if (key.name === "home" || key.ctrl && key.name === "a") return ok({
+		...s,
+		cursor: 0
+	});
+	if (key.name === "end" || key.ctrl && key.name === "e") return ok({
+		...s,
+		cursor: s.value.length
+	});
+	if (key.name === "backspace" || key.ctrl && key.name === "h") {
+		if (key.meta) {
+			const from = wordStart(s.value, s.cursor);
+			return ok(edit(s, s.value.slice(0, from) + s.value.slice(s.cursor), from));
+		}
+		const from = prevBoundary(s.value, s.cursor);
+		return ok(edit(s, s.value.slice(0, from) + s.value.slice(s.cursor), from));
+	}
+	if (key.name === "delete") return ok(edit(s, s.value.slice(0, s.cursor) + s.value.slice(nextBoundary(s.value, s.cursor)), s.cursor));
+	if (key.ctrl && key.name === "u") return ok(edit(s, s.value.slice(s.cursor), 0));
+	if (key.ctrl && key.name === "k") return ok(edit(s, s.value.slice(0, s.cursor), s.cursor));
+	if (key.ctrl && key.name === "w") {
+		const from = wordStart(s.value, s.cursor);
+		return ok(edit(s, s.value.slice(0, from) + s.value.slice(s.cursor), from));
+	}
+	if (key.text) {
+		const text = key.text.replace(/[\r\n\t]+/g, " ");
+		return ok(edit(s, s.value.slice(0, s.cursor) + text + s.value.slice(s.cursor), s.cursor + text.length));
+	}
+	return ok(s);
+}
+//#endregion
+//#region src/tui/region.ts
+/**
+* A block of lines at the bottom of the terminal that can be redrawn in
+* place — the prompt box, a menu. It remembers how many lines it drew and
+* where it left the cursor, so the next render can climb back to its top
+* line and draw again. Every line is cut to the terminal's width first: a
+* line the terminal wrapped would throw that count off.
+*/
+var LiveRegion = class {
+	out;
+	lines = 0;
+	cursorRow = 0;
+	constructor(out = process.stdout) {
+		this.out = out;
+	}
+	render(lines, cursor) {
+		const cols = Math.max(10, (this.out.columns || 80) - 1);
+		let s = this.lines > 0 && this.cursorRow > 0 ? `${CSI}${this.cursorRow}A` : "";
+		s += `\r${CSI}0J`;
+		s += lines.map((l) => truncate(l, cols)).join("\n");
+		const last = Math.max(0, lines.length - 1);
+		if (cursor) {
+			const up = last - cursor.row;
+			if (up > 0) s += `${CSI}${up}A`;
+			s += "\r";
+			if (cursor.col > 0) s += `${CSI}${cursor.col}C`;
+			this.cursorRow = cursor.row;
+		} else this.cursorRow = last;
+		this.lines = lines.length;
+		this.out.write(s);
+	}
+	/** Erase the region; the cursor ends where the region began. */
+	clear() {
+		if (this.lines === 0) return;
+		this.out.write(`${this.cursorRow > 0 ? `${CSI}${this.cursorRow}A` : ""}\r${CSI}0J`);
+		this.lines = 0;
+		this.cursorRow = 0;
+	}
+	/** Keep what is drawn and move to a fresh line below it. */
+	done() {
+		if (this.lines === 0) return;
+		const down = this.lines - 1 - this.cursorRow;
+		this.out.write(`${down > 0 ? `${CSI}${down}B` : ""}\n`);
+		this.lines = 0;
+		this.cursorRow = 0;
+	}
+};
+//#endregion
+//#region src/tui/theme.ts
+const FANCY = {
+	spark: "✻",
+	dot: "⏺",
+	elbow: "⎿",
+	pointer: "❯",
+	check: "✓",
+	cross: "✗",
+	bullet: "●",
+	barFull: "█",
+	barEmpty: "░",
+	tl: "╭",
+	tr: "╮",
+	bl: "╰",
+	br: "╯",
+	h: "─",
+	v: "│",
+	spinner: [
+		"·",
+		"✢",
+		"✳",
+		"✶",
+		"✻",
+		"✽",
+		"✻",
+		"✶",
+		"✳",
+		"✢"
+	]
+};
+const PLAIN = {
+	spark: "*",
+	dot: "*",
+	elbow: "└",
+	pointer: ">",
+	check: "v",
+	cross: "x",
+	bullet: "*",
+	barFull: "#",
+	barEmpty: "-",
+	tl: "┌",
+	tr: "┐",
+	bl: "└",
+	br: "┘",
+	h: "─",
+	v: "│",
+	spinner: [
+		"|",
+		"/",
+		"-",
+		"\\"
+	]
+};
+function glyphsFor(env, platform) {
+	return platform === "win32" && !env.WT_SESSION && !env.TERM_PROGRAM && !env.ConEmuANSI && !env.TERM ? PLAIN : FANCY;
+}
+function createTheme(level, g) {
+	const sgr = (open, close) => (s) => level === 0 ? s : `${CSI}${open}m${s}${CSI}${close}m`;
+	return {
+		level,
+		g,
+		accent: level === 3 ? sgr("38;2;57;255;20", "39") : sgr("92", "39"),
+		bold: sgr("1", "22"),
+		dim: sgr("2", "22"),
+		red: sgr("31", "39"),
+		yellow: sgr("33", "39"),
+		green: sgr("32", "39"),
+		inverse: sgr("7", "27")
+	};
+}
+let current;
+/** The theme for this process, decided on first use (never at import). */
+function theme() {
+	current ??= createTheme(colorLevel(process.env, process.stdout.isTTY === true), glyphsFor(process.env, process.platform));
+	return current;
+}
+//#endregion
+//#region src/tui/spinner.ts
+const NOOP = {
+	update() {},
+	stop() {}
+};
+let active = null;
+function startSpinner(label, opts = {}) {
+	const out = process.stdout;
+	const err = process.stderr;
+	if (!out.isTTY) return NOOP;
+	active?.stop();
+	const t = opts.theme ?? theme();
+	const now = opts.now ?? Date.now;
+	const started = now();
+	const outWrite = out.write;
+	const errWrite = err.write;
+	const raw = (s) => outWrite.call(out, s);
+	let text = label;
+	let frame = 0;
+	let stopped = false;
+	let timer;
+	const draw = () => {
+		const secs = Math.floor((now() - started) / 1e3);
+		const hint = opts.cancellable ? `(${secs}s · ctrl+c to cancel)` : `(${secs}s)`;
+		const glyph = t.g.spinner[frame % t.g.spinner.length];
+		frame += 1;
+		raw(`\r${CSI}2K${truncate(`${t.accent(glyph)} ${text}… ${t.dim(hint)}`, (out.columns || 80) - 1)}`);
+	};
+	const self = {
+		update(next) {
+			text = next;
+			if (!stopped) draw();
+		},
+		stop() {
+			if (stopped) return;
+			stopped = true;
+			clearInterval(timer);
+			out.write = outWrite;
+			err.write = errWrite;
+			raw(`\r${CSI}2K`);
+			if (active === self) active = null;
+		}
+	};
+	const intercepted = (orig) => function(...args) {
+		self.stop();
+		return orig.apply(this, args);
+	};
+	out.write = intercepted(outWrite);
+	err.write = intercepted(errWrite);
+	timer = setInterval(draw, 100);
+	timer.unref();
+	draw();
+	active = self;
+	return self;
+}
+/** Stop whatever spinner is running (before drawing a menu over it). */
+function stopSpinner() {
+	active?.stop();
+}
+//#endregion
+//#region src/tui/prompt.ts
+const PROMPT = "> ";
+const ARM_MS = 2e3;
+/** Wrap the typed text into box rows and find the cursor's cell. */
+function layoutInput(value, cursor, inner) {
+	const rows = [];
+	let row = PROMPT;
+	let w = 2;
+	let at = {
+		row: 0,
+		col: w
+	};
+	let i = 0;
+	for (const ch of value) {
+		const cw = charWidth(ch);
+		if (w + cw > inner) {
+			rows.push(row);
+			row = " ".repeat(2);
+			w = 2;
+		}
+		if (i === cursor) at = {
+			row: rows.length,
+			col: w
+		};
+		row += ch;
+		w += cw;
+		i += ch.length;
+	}
+	if (cursor >= value.length) {
+		if (w >= inner) {
+			rows.push(row);
+			row = " ".repeat(2);
+			w = 2;
+		}
+		at = {
+			row: rows.length,
+			col: w
+		};
+	}
+	rows.push(row);
+	return {
+		rows,
+		...at
+	};
+}
+/** The whole prompt as lines, and where the cursor goes. */
+function renderPrompt(view, t, width) {
+	const inner = width - 4;
+	const { state } = view;
+	const laid = layoutInput(state.value, state.cursor, inner);
+	const rows = laid.rows.map((r, i) => i === 0 ? `${t.bold(">")}${r.slice(1)}` : r);
+	if (!state.value) rows[0] = `${t.bold(">")} ${t.dim(view.placeholder)}`;
+	const lines = renderBox(rows, {
+		width,
+		theme: t
+	});
+	const shown = view.suggestions;
+	if (shown.length > 0) {
+		const nameWidth = Math.max(...shown.map((s) => s.name.length)) + 3;
+		shown.forEach((s, i) => {
+			const name = padEnd(`/${s.name}`, nameWidth);
+			lines.push(i === state.suggestion ? `  ${t.accent(name)}${s.summary}` : t.dim(`  ${name}${s.summary}`));
+		});
+	} else {
+		const left = view.armed ? t.yellow("Press Ctrl-C again to exit") : t.dim(view.hint);
+		const gap = width - 2 - visibleWidth(left) - visibleWidth(view.status);
+		lines.push(gap >= 2 ? `  ${left}${" ".repeat(gap)}${view.status}` : `  ${left}`);
+	}
+	return {
+		lines,
+		cursor: {
+			row: 1 + laid.row,
+			col: 2 + laid.col
+		}
+	};
+}
+/**
+* Read one line. Resolves with it on Enter, or with `exit` on Ctrl-D or a
+* second Ctrl-C within two seconds on an empty line. The box is replaced by
+* a dim echo of what was typed, as Claude Code does.
+*/
+function readPrompt(opts) {
+	stopSpinner();
+	const t = opts.theme ?? theme();
+	const out = process.stdout;
+	return new Promise((resolve) => {
+		const region = new LiveRegion(out);
+		let state = initialEditor(opts.history);
+		let armedUntil = 0;
+		let armTimer;
+		const draw = () => {
+			const { lines, cursor } = renderPrompt({
+				state,
+				suggestions: visibleSuggestions(state, opts.commands),
+				placeholder: opts.placeholder,
+				hint: opts.hint,
+				status: opts.status(),
+				armed: Date.now() < armedUntil
+			}, t, frameWidth(out.columns));
+			region.render(lines, cursor);
+		};
+		const tick = setInterval(draw, 3e4);
+		tick.unref();
+		out.on("resize", draw);
+		const finish = (result) => {
+			release();
+			clearInterval(tick);
+			clearTimeout(armTimer);
+			out.off("resize", draw);
+			if (result.kind === "line" && result.value.trim()) {
+				region.render([t.dim(`> ${result.value}`)]);
+				region.done();
+			} else region.clear();
+			resolve(result);
+		};
+		const release = listenKeys((key) => {
+			const r = editorReducer(state, key, opts.commands);
+			state = r.state;
+			if (r.event === "submit") return finish({
+				kind: "line",
+				value: state.value
+			});
+			if (r.event === "eof") return finish({ kind: "exit" });
+			if (r.event === "interrupt") {
+				if (Date.now() < armedUntil) return finish({ kind: "exit" });
+				armedUntil = Date.now() + ARM_MS;
+				clearTimeout(armTimer);
+				armTimer = setTimeout(draw, 2050);
+				armTimer.unref();
+			}
+			draw();
+		});
+		draw();
+	});
+}
+//#endregion
+//#region src/tui/select.ts
+function initialSelect(choices, start = 0) {
+	const ok = (i) => i >= 0 && i < choices.length && !choices[i].disabled;
+	const index = ok(start) ? start : choices.findIndex((c) => !c.disabled);
+	return {
+		index: Math.max(0, index),
+		done: null
+	};
+}
+function step(index, dir, choices) {
+	const n = choices.length;
+	for (let k = 1; k <= n; k++) {
+		const i = (index + dir * k + n * k) % n;
+		if (!choices[i].disabled) return i;
+	}
+	return index;
+}
+function selectReducer(state, key, choices) {
+	if (state.done) return state;
+	if (key.name === "escape" || key.ctrl && key.name === "c") return {
+		...state,
+		done: "cancelled"
+	};
+	if (key.name === "return" || key.name === "enter") return choices[state.index]?.disabled ? state : {
+		...state,
+		done: "chosen"
+	};
+	if (key.name === "up" || key.text === "k" || key.ctrl && key.name === "p") return {
+		...state,
+		index: step(state.index, -1, choices)
+	};
+	if (key.name === "down" || key.text === "j" || key.name === "tab" || key.ctrl && key.name === "n") return {
+		...state,
+		index: step(state.index, 1, choices)
+	};
+	if (key.text && /^[1-9]$/.test(key.text)) {
+		const i = Number(key.text) - 1;
+		if (i < choices.length && !choices[i].disabled) return {
+			index: i,
+			done: "chosen"
+		};
+	}
+	return state;
+}
+/** The menu as lines, inside its box, plus the key hint under it. */
+function renderSelect(state, view, t, width, maxVisible = 12) {
+	const inner = width - 4;
+	const lines = [t.bold(view.title)];
+	if (view.body && view.body.length > 0) {
+		lines.push("");
+		for (const b of view.body) lines.push(...wrap(b, inner));
+	}
+	lines.push("");
+	const labelWidth = Math.min(Math.max(...view.choices.map((c) => visibleWidth(c.label))), Math.floor(inner * .6));
+	const n = view.choices.length;
+	const first = Math.max(0, Math.min(state.index - Math.floor(maxVisible / 2), n - maxVisible));
+	const last = Math.min(n, first + maxVisible);
+	if (first > 0) lines.push(t.dim(`  ↑ ${first} more`));
+	for (let i = first; i < last; i++) {
+		const c = view.choices[i];
+		const on = i === state.index;
+		const num = `${i + 1}.`;
+		const plain = sanitize(c.label);
+		const hint = c.hint ? sanitize(c.hint) : "";
+		const label = hint ? padEnd(plain, labelWidth) : plain;
+		const text = `${num} ${label}${hint ? `  ${t.dim(hint)}` : ""}`;
+		if (c.disabled) lines.push(t.dim(`  ${num} ${label}${hint ? `  ${hint}` : ""}`));
+		else if (on) lines.push(`${t.accent(t.g.pointer)} ${t.bold(text)}`);
+		else lines.push(`  ${text}`);
+	}
+	if (last < n) lines.push(t.dim(`  ↓ ${n - last} more`));
+	return [...renderBox(lines, {
+		width,
+		theme: t,
+		border: t.accent
+	}), t.dim("  ↑↓ to move · enter to choose · esc to go back")];
+}
+/**
+* Ask, and resolve with the chosen value, or null if the person backed out.
+* The menu is replaced by a one-line record of the answer when it closes.
+*/
+function select(view, opts = {}) {
+	stopSpinner();
+	const t = opts.theme ?? theme();
+	const out = process.stdout;
+	return new Promise((resolve) => {
+		const region = new LiveRegion(out);
+		let state = initialSelect(view.choices, opts.start);
+		const draw = () => region.render(renderSelect(state, view, t, frameWidth(out.columns), Math.max(4, (out.rows || 24) - 14)));
+		out.write(`${CSI}?25l`);
+		draw();
+		out.on("resize", draw);
+		const release = listenKeys((key) => {
+			state = selectReducer(state, key, view.choices);
+			if (!state.done) return draw();
+			release();
+			out.off("resize", draw);
+			out.write(`${CSI}?25h`);
+			const chosen = state.done === "chosen" ? view.choices[state.index] : null;
+			region.render([`${t.dim(view.title)} ${t.accent(t.g.pointer)} ${chosen ? chosen.label : t.dim("back")}`]);
+			region.done();
+			resolve(chosen ? chosen.value : null);
+		});
+	});
+}
+/** Yes/No in the same style; resolves false on Esc. */
+async function confirm(title, body, yes = "Yes", no = "No") {
+	return await select({
+		title,
+		body,
+		choices: [{
+			label: yes,
+			value: true
+		}, {
+			label: no,
+			value: false
+		}]
+	}) === true;
+}
+//#endregion
+//#region ../../src/lib/session/liveCost.ts
+function computeLiveCost(i) {
+	const start = new Date(i.startTime).getTime();
+	const end = i.endTime ? new Date(i.endTime).getTime() : i.now;
+	const elapsedMs = Math.max(end - start, 0);
+	const minutes = elapsedMs / 6e4;
+	const retained = 1 - Math.min(Math.max(i.discountPct ?? 0, 0), 100) / 100;
+	const effectiveRate = i.ratePerMinute * retained;
+	return {
+		elapsedMs,
+		effectiveRate,
+		cost: i.free ? 0 : minutes * effectiveRate,
+		ended: Boolean(i.endTime)
+	};
+}
+//#endregion
+//#region ../../src/features/ActiveSessionsFeature/ActiveSessionsLogic.ts
+/**
+* A dedicated-slot holder on their reserved device pays nothing. `slotDeviceId`
+* is null unless the subscription is active on that tier, so the comparison
+* alone is the whole rule.
+*/
+function isFreeSession(session, slotDeviceId) {
+	return slotDeviceId !== null && session.deviceId === slotDeviceId;
+}
+//#endregion
+//#region ../../src/lib/ai/credits.ts
+/**
+* Monthly AI credit grant per subscription tier, applied on `invoice.paid`.
+*
+* Lives HERE rather than in pricing.ts, which is `import "server-only"`, because
+* /pricing and /deviceyai both render these numbers — /deviceyai has printed
+* them since it shipped. They are not confidential the way MARKUP is; they are
+* the offer.
+*
+* Moved 2026-09-19 so `tiers.ts` could derive its feature bullets from this
+* object instead of retyping the figures. It had one for about an hour, and the
+* retyped Pro bullet was already wrong — it claimed "the largest monthly
+* allowance" for 1,000 while a slot and enterprise get 2,000. A derived bullet
+* cannot be wrong about a number; a typed one is only ever right until someone
+* edits the other copy.
+*/
+const AI_MONTHLY_GRANT = {
+	free: 0,
+	plus: 300,
+	pro: 1e3,
+	dedicated_slot: 2e3,
+	enterprise: 2e3
+};
+//#endregion
+//#region ../../src/lib/tiers.ts
+/**
+* The DeviceyAI bullet for a tier, derived from the grant the Stripe webhook
+* actually makes rather than retyped beside it.
+*
+* Retyping lasted about an hour on 2026-09-19 before it was wrong: the Pro
+* bullet read "the largest monthly DeviceyAI allowance" for 1,000 credits while
+* a dedicated slot and enterprise each get 2,000. Superlatives in a feature list
+* are a comparison against the other rows, and nothing was checking it.
+*/
+function aiGrantFeature(tier) {
+	return `${(AI_MONTHLY_GRANT[tier] ?? 0).toLocaleString("en-GB")} AI credits a month for DeviceyAI`;
+}
+/** "€549.89" / "€1,099.89" — euros with a thousands separator. */
+function formatEur(euros) {
+	const [whole, frac] = Math.abs(euros).toFixed(2).split(".");
+	const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+	return `${euros < 0 ? "−" : ""}€${grouped}.${frac}`;
+}
+const TIERS = [
+	{
+		id: "free",
+		name: "Free",
+		tagline: "Pay-as-you-go for hobby projects",
+		monthlyPrice: 0,
+		priceLabel: "€0",
+		monthlyCredits: 0,
+		discountPct: 0,
+		features: [
+			"€0.10 per device-minute — the standard rate",
+			"€10 starter credit on signup",
+			"Automation API keys — Appium, Espresso & CI",
+			"Hosted Appium endpoint",
+			`DeviceyAI copilot — 25 credits to try it, once`,
+			"WebUSB local-device pairing"
+		]
+	},
+	{
+		id: "plus",
+		name: "Plus",
+		tagline: "For solo devs shipping a side project",
+		monthlyPrice: 29.99,
+		priceLabel: "€29.99",
+		monthlyCredits: 35,
+		discountPct: 40,
+		features: [
+			"€0.06 per device-minute (40% off)",
+			"€35 in monthly credits",
+			aiGrantFeature("plus"),
+			"12 months for the price of 11 on yearly billing",
+			"Email support"
+		],
+		priceIdEnv: "STRIPE_PRICE_PLUS",
+		yearlyPriceIdEnv: "STRIPE_PRICE_PLUS_YEARLY"
+	},
+	{
+		id: "pro",
+		name: "Pro",
+		tagline: "For teams running CI on real hardware",
+		monthlyPrice: 49.99,
+		priceLabel: "€49.99",
+		monthlyCredits: 80,
+		discountPct: 90,
+		features: [
+			"€0.01 per device-minute (90% off) — about €15/day of nonstop use",
+			"€80 in monthly credits",
+			aiGrantFeature("pro"),
+			"12 months for the price of 11 on yearly billing",
+			"Slack support · 1 business day"
+		],
+		badge: "Recommended",
+		highlight: true,
+		priceIdEnv: "STRIPE_PRICE_PRO",
+		yearlyPriceIdEnv: "STRIPE_PRICE_PRO_YEARLY"
+	},
+	{
+		id: "dedicated_slot",
+		name: "Rent a Slot",
+		tagline: "Your own device, 24/7, never billed by the minute",
+		monthlyPrice: 99.99,
+		priceLabel: "€99.99",
+		monthlyCredits: 0,
+		discountPct: 100,
+		features: [
+			"No per-minute charge at all — the meter is off",
+			"A dedicated device, auto-assigned & reserved to you",
+			"A permanently-paired device — automation with no rental to start",
+			aiGrantFeature("dedicated_slot"),
+			"24/7 availability — nobody else can rent it",
+			"Priority hardware swap on failure"
+		],
+		priceIdEnv: "STRIPE_PRICE_SLOT",
+		yearlyPriceIdEnv: "STRIPE_PRICE_SLOT_YEARLY"
+	},
+	{
+		id: "enterprise",
+		name: "Enterprise",
+		tagline: "Whitelabel the fleet for your org",
+		monthlyPrice: null,
+		priceLabel: "Custom",
+		monthlyCredits: 0,
+		discountPct: 0,
+		features: [
+			"Custom SLA + uptime guarantees",
+			aiGrantFeature("enterprise"),
+			"Whitelabeled device fleet",
+			"Dedicated account manager",
+			"On-prem racks available"
+		],
+		contactSales: true
+	}
+];
+function tierById(id) {
+	return TIERS.find((t) => t.id === id) ?? TIERS[0];
+}
+/**
+* The discount the meter will actually apply: the tier's advertised
+* percentage, but only while the subscription is `active`. That is the
+* condition consume_credits checks at charge time, so a past_due Plus
+* customer is billed list price and must be quoted list price — every
+* surface that shows a rate (session ticker, multi-rent bar, active-sessions
+* panel) goes through this one rule rather than restating it.
+*/
+function activeDiscountPct(subscription) {
+	return subscription.status === "active" ? tierById(subscription.tier).discountPct : 0;
+}
+function safeTierById(id) {
+	if (!id) return null;
+	const found = TIERS.find((t) => t.id === id);
+	return found ? found.id : null;
+}
+//#endregion
+//#region src/interactive/account.ts
+async function loadAccount(ctx, user) {
+	const [profile, sub] = await Promise.all([loadProfile(ctx, user.id), ctx.supabase.rpc("my_subscription").maybeSingle()]);
+	const row = sub.data ?? null;
+	const tier = safeTierById(row?.tier ?? profile.tier) ?? "free";
+	const status = row?.status ?? profile.subscriptionStatus;
+	return {
+		userId: user.id,
+		email: user.email ?? "",
+		wallet: profile.wallet,
+		aiCredits: profile.aiCredits,
+		planName: tierById(tier).name,
+		standing: profile.standing,
+		discountPct: activeDiscountPct({
+			status,
+			tier
+		}),
+		slotDeviceId: status === "active" && tier === "dedicated_slot" ? row?.dedicated_device_id ?? null : null
+	};
+}
+/** € a minute this account actually pays for a phone at `ratePerMinute`. */
+function yourRate(account, device) {
+	if (account.slotDeviceId === device.id) return 0;
+	return computeLiveCost({
+		startTime: (/* @__PURE__ */ new Date(0)).toISOString(),
+		ratePerMinute: device.ratePerMinute,
+		discountPct: account.discountPct,
+		now: 0
+	}).effectiveRate;
+}
+/** "€0.01/min" — or "included" on a dedicated slot. */
+function formatRate(rate) {
+	if (rate === 0) return "included in your plan";
+	return Math.round(rate * 1e3) < 10 ? `€${rate.toFixed(3)}/min` : `${eur(rate)}/min`;
+}
+/** The catalogue stores "Android 17" (or, on older rows, just "17"). */
+function androidLabel(version) {
+	const v = version.trim();
+	return /^android\b/i.test(v) ? v : `Android ${v}`;
+}
+/**
+* "● Pixel 7a #2 · 12 min · €0.12" for each running rental — computed from
+* the start time on every draw, with no network call.
+*/
+function statusLine(rentals, account, now, t) {
+	if (!account) return t.dim("not signed in");
+	if (rentals.length === 0) return t.dim("no phone rented");
+	return rentals.map((r) => {
+		const free = isFreeSession(r, account.slotDeviceId);
+		const live = computeLiveCost({
+			startTime: r.startTime,
+			ratePerMinute: r.ratePerMinute,
+			discountPct: account.discountPct,
+			free,
+			now
+		});
+		const minutes = Math.floor(live.elapsedMs / 6e4);
+		return `${t.accent(t.g.bullet)} ${r.deviceName} ${t.dim(`· ${minutes} min · ${free ? "included" : eur(live.cost)}`)}`;
+	}).join("  ");
+}
+//#endregion
+//#region ../../src/lib/ai/pricing.ts
+const AI_CREDIT_PACKS = [
+	{
+		id: "s",
+		label: "Starter",
+		priceEur: 5,
+		credits: 500,
+		priceIdEnv: "STRIPE_PRICE_AI_PACK_S"
+	},
+	{
+		id: "m",
+		label: "Standard",
+		priceEur: 12,
+		credits: 1500,
+		priceIdEnv: "STRIPE_PRICE_AI_PACK_M"
+	},
+	{
+		id: "l",
+		label: "Bulk",
+		priceEur: 30,
+		credits: 4e3,
+		priceIdEnv: "STRIPE_PRICE_AI_PACK_L"
+	}
+];
+//#endregion
+//#region ../../src/lib/ai/toolBlurbs.ts
+const TOOL_BLURBS = {
+	observe_screen: "Read the screen as a list of elements with exact positions",
+	screenshot: "Take a picture of the screen and look at it",
+	list_packages: "List the apps installed on the phone",
+	device_info: "Read the model, Android version, screen size and orientation",
+	wait: "Pause while something loads or animates",
+	list_instrumentations: "Find the exact test-runner target installed on the phone",
+	logcat_tail: "Read the tail of the device log, filtered to what matters",
+	read_device_file: "Read a text file a test wrote — a JUnit XML or coverage report",
+	tap: "Tap a point on the screen",
+	swipe: "Swipe or scroll",
+	type_text: "Type into the focused field",
+	press_key: "Press Home, Back, Recents, Power, Volume, Enter or Delete",
+	launch_app: "Open an installed app",
+	install_apk: "Install an APK you uploaded to this rental",
+	list_uploads: "See which of your files are available to install",
+	run_instrumentation: "Run an instrumentation suite already on the phone and report pass/fail",
+	save_test_file: "Keep a test file it wrote, for you to download",
+	shell: "Run an ADB shell command",
+	appium_start_session: "Open a real Appium (UiAutomator2) session on the phone",
+	appium_page_source: "Read the UI hierarchy through that session",
+	appium_find: "Prove a locator resolves on the live app before it goes into a test",
+	appium_click: "Click an element it found, rather than a raw coordinate",
+	appium_send_keys: "Type into an element it found",
+	appium_end_session: "Close the session and release the phone"
+};
+[
+	...READ_TOOLS,
+	...ACTION_TOOLS,
+	...SHELL_TOOLS,
+	...APPIUM_TOOLS
+].map((t) => t.name);
+//#endregion
+//#region src/interactive/aiChat.ts
+const KEYS = {
+	home: "Home",
+	back: "Back",
+	app_switch: "Recent apps",
+	power: "Power",
+	volume_up: "Volume up",
+	volume_down: "Volume down",
+	enter: "Enter",
+	tab: "Tab",
+	delete: "Delete"
+};
+/**
+* One line for one tool call. Typed text is NEVER shown — it may be a
+* password (mask the data, not a view of it) — only how long it is. The
+* model writes these inputs, so whatever is echoed is sanitized.
+*/
+function describeToolCall(name, input) {
+	return sanitize(describe(name, input));
+}
+function describe(name, input) {
+	const i = input ?? {};
+	const n = (v) => typeof v === "number" ? Math.round(v) : "?";
+	switch (name) {
+		case "tap": return `Tap at ${n(i.x)}, ${n(i.y)}`;
+		case "swipe": return `Swipe from ${n(i.x1)}, ${n(i.y1)} to ${n(i.x2)}, ${n(i.y2)}`;
+		case "type_text": {
+			const len = typeof i.text === "string" ? [...i.text].length : 0;
+			return `Type ${len} character${len === 1 ? "" : "s"}`;
+		}
+		case "press_key": return `Press ${KEYS[String(i.key)] ?? String(i.key ?? "a key")}`;
+		case "launch_app": return `Open ${typeof i.package === "string" ? i.package : "an app"}`;
+		case "observe_screen": return "Read the screen";
+		case "screenshot": return "Look at the screen";
+		case "wait": return "Wait for the screen to settle";
+		case "shell": return typeof i.command === "string" ? `Run: ${i.command.slice(0, 80)}` : "Run a shell command";
+		default: return TOOL_BLURBS[name] ?? name;
+	}
+}
+/**
+* Run one task. Throws AiNeedsActionsError (src/ai/loop.ts) when look-only
+* access was not enough, so the caller can ask for more and try again.
+*/
+async function runChatTask(input, task, permission, t) {
+	return withDevice(input, async (device) => {
+		const { models, credits } = await loadAiConfig(device.rental.id);
+		if (credits <= 0) throw new CliError(OUT_OF_CREDITS);
+		const model = pickModel(models, void 0);
+		const write = (s) => process.stdout.write(s);
+		let inText = false;
+		const endText = () => {
+			if (inText) write("\n");
+			inText = false;
+		};
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		input.signal?.addEventListener("abort", abort, { once: true });
+		try {
+			const result = await runAiTask(device, {
+				task,
+				provider: model.provider,
+				model: model.id,
+				allowActions: permission === "act",
+				allowShell: false
+			}, controller.signal, {
+				onText: (delta) => {
+					const text = sanitize(delta);
+					if (!text) return;
+					if (!inText) write(`${t.accent(t.g.dot)} `);
+					inText = true;
+					write(text.replace(/\n/g, "\n  "));
+				},
+				onTool: (name, toolInput) => {
+					endText();
+					write(`${t.accent(t.g.dot)} ${describeToolCall(name, toolInput)}\n`);
+				},
+				onToolDone: (_name, isError, content) => {
+					if (isError) write(`  ${t.dim(t.g.elbow)}  ${t.red(sanitize(content.split("\n")[0]).slice(0, 200))}\n`);
+				}
+			});
+			endText();
+			return result;
+		} catch (err) {
+			endText();
+			throw err;
+		} finally {
+			input.signal?.removeEventListener("abort", abort);
+		}
+	});
+}
+//#endregion
+//#region src/interactive/files.ts
+let folders;
+function existing(p) {
+	if (!p) return null;
+	try {
+		return fs.statSync(p).isDirectory() ? p : null;
+	} catch {
+		return null;
+	}
+}
+function askWindows() {
+	const script = "[Console]::OutputEncoding=[Text.Encoding]::UTF8;[Environment]::GetFolderPath('Desktop');(New-Object -ComObject Shell.Application).NameSpace('shell:Downloads').Self.Path";
+	return new Promise((resolve) => {
+		execFile(systemExe("WindowsPowerShell\\v1.0\\powershell.exe"), [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			script
+		], {
+			timeout: 5e3,
+			windowsHide: true,
+			encoding: "utf8"
+		}, (err, stdout) => {
+			const [desktop, downloads] = err ? [] : stdout.split(/\r?\n/).map((l) => l.trim());
+			resolve({
+				desktop: existing(desktop) ?? existing(path.join(os.homedir(), "Desktop")),
+				downloads: existing(downloads) ?? existing(path.join(os.homedir(), "Downloads"))
+			});
+		});
+	});
+}
+/** The person's Downloads and Desktop folders (looked up once, lazily). */
+function knownFolders() {
+	folders ??= process.platform === "win32" ? askWindows() : Promise.resolve({
+		downloads: existing(path.join(os.homedir(), "Downloads")),
+		desktop: existing(path.join(os.homedir(), "Desktop"))
+	});
+	return folders;
+}
+/** The newest `.apk` files directly inside `dirs` (not their subfolders). */
+function findApks(dirs, limit = 8) {
+	const seen = /* @__PURE__ */ new Set();
+	const found = [];
+	for (const dir of dirs) {
+		if (!dir || seen.has(dir)) continue;
+		seen.add(dir);
+		let names;
+		try {
+			names = fs.readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const name of names) {
+			if (!name.toLowerCase().endsWith(".apk")) continue;
+			const full = path.join(dir, name);
+			try {
+				const st = fs.statSync(full);
+				if (st.isFile()) found.push({
+					path: full,
+					name,
+					folder: dir,
+					bytes: st.size,
+					modified: st.mtimeMs
+				});
+			} catch {}
+		}
+	}
+	return found.sort((a, b) => b.modified - a.modified).slice(0, limit);
+}
+/** "2 h ago", "3 d ago" — for the file picker. */
+function ago(ms, now) {
+	const s = Math.max(0, Math.round((now - ms) / 1e3));
+	if (s < 90) return "just now";
+	const m = Math.round(s / 60);
+	if (m < 90) return `${m} min ago`;
+	const h = Math.round(m / 60);
+	if (h < 36) return `${h} h ago`;
+	return `${Math.round(h / 24)} d ago`;
+}
+/** A folder name a person recognises: "Downloads", not the whole path. */
+function folderLabel(dir, f, cwd) {
+	if (dir === f.downloads) return "Downloads";
+	if (dir === f.desktop) return "Desktop";
+	if (dir === cwd) return "this folder";
+	return dir;
+}
+//#endregion
+//#region src/interactive/tokenize.ts
+function tokenize(line, p) {
+	const words = [];
+	let word = "";
+	let inWord = false;
+	let quote = null;
+	const escapes = p.platform !== "win32";
+	for (let i = 0; i < line.length; i++) {
+		const ch = line[i];
+		if (quote) {
+			if (ch === quote) quote = null;
+			else if (escapes && quote === "\"" && ch === "\\" && i + 1 < line.length) word += line[++i];
+			else word += ch;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			inWord = true;
+			continue;
+		}
+		if (escapes && ch === "\\" && i + 1 < line.length) {
+			word += line[++i];
+			inWord = true;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			if (inWord) words.push(word);
+			word = "";
+			inWord = false;
+			continue;
+		}
+		word += ch;
+		inWord = true;
+	}
+	if (inWord) words.push(word);
+	return words.map((w) => expandHome(w, p));
+}
+function expandHome(word, p) {
+	if (word === "~") return p.home;
+	if (word.startsWith("~/") || p.platform === "win32" && word.startsWith("~\\")) return p.home + word.slice(1);
+	return word;
+}
+/**
+* The one path a line consists of, if it is nothing but a (dragged or pasted)
+* path: `"C:\My Apps\app.apk"`, `& 'C:\x\app.apk'`, `/Users/me/My\ App.apk`.
+* Null when the line is anything else.
+*/
+function droppedPath(line, p) {
+	let s = line.trim();
+	if (s.startsWith("& ")) s = s.slice(2).trim();
+	const words = tokenize(s, p);
+	if (words.length !== 1) return null;
+	const w = words[0];
+	return (p.platform === "win32" ? /^[a-zA-Z]:[\\/]/.test(w) || w.startsWith("\\\\") || /[\\/]/.test(w) : w.startsWith("/") || w.startsWith("./") || w.startsWith("../") || w.includes("/")) || /\.apk$/i.test(w) ? w : null;
+}
+//#endregion
+//#region src/interactive/flows.ts
+const STATUS_WORDS = {
+	available: "free",
+	busy: "in use",
+	sanitizing: "being wiped for the next person",
+	offline: "offline",
+	maintenance: "in maintenance"
+};
+const OTHER = "\0other";
+function slug(s) {
+	return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+/** A line read at a plain prompt, or null if the person pressed Ctrl-C. */
+async function ask(question) {
+	try {
+		return await promptLine(question);
+	} catch {
+		return null;
+	}
+}
+async function loginFlow(s) {
+	if (s.account) {
+		s.result(`You're signed in as ${s.account.email}.`);
+		return;
+	}
+	if (!s.ctx.config.login_enabled) {
+		s.error(`Signing in from a terminal is switched off on ${s.ctx.apiBase}.`);
+		return;
+	}
+	const how = await select({
+		title: "Sign in to DeviceRent",
+		body: ["Your browser opens devicerent.net; press Approve there and come back. Nothing secret is typed here."],
+		choices: [
+			{
+				label: "Sign in with my browser",
+				value: "browser",
+				hint: "recommended"
+			},
+			{
+				label: "Sign in with a code",
+				value: "code",
+				hint: "when the browser is on another device"
+			},
+			{
+				label: "Not now",
+				value: null
+			}
+		]
+	});
+	if (!how) return;
+	await s.run(how === "code" ? ["login", "--no-browser"] : ["login"], {
+		title: "Signing in",
+		raw: true
+	});
+	const now = signedIn(s);
+	if (now) s.say(`Signed in as ${s.t.bold(now.email)}.`);
+}
+function signedIn(s) {
+	return s.account;
+}
+async function ensureSignedIn(s) {
+	if (s.account) return true;
+	s.result("You need to sign in first.");
+	await loginFlow(s);
+	return s.account !== null;
+}
+async function logoutFlow(s) {
+	if (!s.account) return s.result("You're not signed in.");
+	if (await confirm("Sign this terminal out?", ["Your browser stays signed in. Rented phones keep running."], "Yes, sign out", "No")) await s.run(["logout"], { title: "Signing out" });
+}
+async function loadFleet(s) {
+	return s.runTask(() => loadFleetDevices(s.ctx), { spinner: "Checking which phones are free" });
+}
+async function phonesFlow(s) {
+	if (!await ensureSignedIn(s)) return;
+	const fleet = await loadFleet(s);
+	if (!fleet) return;
+	const account = s.account;
+	const groups = groupFleet(fleet, new Set(s.rentals.map((r) => r.deviceId)));
+	s.say(s.t.bold("Phones in the rack"));
+	const width = Math.max(...groups.map((g) => g.label.length));
+	groups.forEach((g, i) => {
+		const state = g.free.length > 0 ? s.t.green(`${g.free.length} of ${g.total} free`) : s.t.dim(g.why);
+		const rate = g.free.length > 0 ? `  ${s.t.dim(formatRate(yourRate(account, g.free[0])))}` : "";
+		const line = `${g.label.padEnd(width)}  ${state}${rate}`;
+		if (i === 0) s.result(line);
+		else s.write(`     ${line}`);
+	});
+	s.hint("Type rent to rent one.");
+}
+async function rentFlow(s, query) {
+	if (!await ensureSignedIn(s)) return;
+	const fleet = await loadFleet(s);
+	if (!fleet) return;
+	const account = s.account;
+	const mine = new Set(s.rentals.map((r) => r.deviceId));
+	if (!fleet.some((d) => d.rentable && !mine.has(d.id))) {
+		s.result("Every phone is busy right now. Try again in a few minutes.");
+		return;
+	}
+	let chosen = null;
+	if (query) try {
+		chosen = pickDevice(fleet, query, mine);
+	} catch (err) {
+		s.hint(err.message);
+	}
+	if (!chosen) {
+		chosen = await select({
+			title: "Which phone would you like?",
+			body: ["You pay by the minute from when you rent it until you stop it."],
+			choices: groupFleet(fleet, mine).map((g) => ({
+				label: g.label,
+				value: g.free[0],
+				disabled: g.free.length === 0,
+				hint: g.free.length > 0 ? `${formatRate(yourRate(account, g.free[0]))} · ${g.free.length} free` : g.why
+			}))
+		});
+		if (!chosen) return;
+	}
+	const rate = yourRate(account, chosen);
+	if (!await confirm(`Rent ${chosen.name}?`, [
+		rate === 0 ? "It's included in your plan." : `${formatRate(rate)} on your ${account.planName} plan, from now until you stop it.`,
+		`Your wallet: ${eur(account.wallet)}.`,
+		"A phone left idle for 30 minutes is stopped for you."
+	], "Yes, rent it", "No")) return;
+	let rented = false;
+	await s.run(["rent", chosen.id], {
+		title: `Renting ${chosen.name}`,
+		spinner: `Renting ${chosen.name}`,
+		onResult: (r) => {
+			if (r.kind === "rented") rented = true;
+		}
+	});
+	if (rented) s.hint("Next: drag your .apk onto this window to install it — or just say what to do on the phone.");
+}
+/**
+* Identical phones as ONE line ("Google Pixel 7a · Android 17 — 5 free"):
+* several share a name, and a menu of indistinguishable lines only confuses.
+* One model on two Android versions stays two lines. Pure.
+*/
+function groupFleet(fleet, mine) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const d of fleet) {
+		const key = `${d.name}\u0000${d.androidVersion}`;
+		groups.set(key, [...groups.get(key) ?? [], d]);
+	}
+	return [...groups.values()].map((all) => {
+		const d = all[0];
+		return {
+			label: `${d.name} · ${androidLabel(d.androidVersion)}`,
+			androidVersion: d.androidVersion,
+			total: all.length,
+			free: all.filter((x) => x.rentable && !mine.has(x.id)),
+			why: all.some((x) => mine.has(x.id)) ? "already yours" : STATUS_WORDS[d.status] ?? d.status
+		};
+	});
+}
+/** The rental to act on: the only one, a menu of several, or offer to rent. */
+async function pickRental(s, title) {
+	if (!await ensureSignedIn(s)) return null;
+	if (s.rentals.length === 0) {
+		if (!await confirm("You don't have a phone yet", ["Rent one now? You only pay while it's rented."], "Yes, pick a phone", "Not now")) return null;
+		await rentFlow(s);
+	}
+	if (s.rentals.length <= 1) return s.rentals[0] ?? null;
+	const now = Date.now();
+	return select({
+		title,
+		choices: s.rentals.map((r) => ({
+			label: r.deviceName,
+			value: r,
+			hint: `rented ${Math.floor(minutesSince(r.startTime, now))} min ago`
+		}))
+	});
+}
+async function stopFlow(s, arg) {
+	if (!await ensureSignedIn(s)) return;
+	if (s.rentals.length === 0) {
+		s.result("Nothing is rented, so nothing is being charged.");
+		return;
+	}
+	let target = arg === "all" ? "all" : s.rentals.length === 1 ? s.rentals[0] : null;
+	if (!target) {
+		target = await select({
+			title: "Which phone are you done with?",
+			choices: [...s.rentals.map((r) => ({
+				label: r.deviceName,
+				value: r
+			})), {
+				label: "All of them",
+				value: "all"
+			}]
+		});
+		if (!target) return;
+	}
+	const now = Date.now();
+	const names = target === "all" ? s.rentals.map((r) => r.deviceName).join(", ") : target.deviceName;
+	if (!await confirm(`Stop ${names}?`, [target === "all" ? `${s.rentals.length} phones, billing ends now.` : `It has run ${Math.floor(minutesSince(target.startTime, now))} min; billing ends now.`, "Each phone is wiped after you stop: apps and files you put on it are deleted."], "Yes, stop", "No, keep it")) return;
+	await s.run(target === "all" ? ["stop", "--all"] : ["stop", target.id], {
+		title: `Stopping ${names}`,
+		spinner: "Stopping and settling the bill"
+	});
+}
+/** An APK from the usual places, or one dragged in / typed. */
+async function pickApk(s, title) {
+	const f = await knownFolders();
+	const cwd = process.cwd();
+	const now = Date.now();
+	const apks = findApks([
+		cwd,
+		f.downloads,
+		f.desktop
+	]);
+	const choices = apks.map((a) => ({
+		label: a.name,
+		value: a.path,
+		hint: `${folderLabel(a.folder, f, cwd)} · ${formatBytes(a.bytes)} · ${ago(a.modified, now)}`
+	}));
+	choices.push({
+		label: "Another file",
+		value: OTHER,
+		hint: "drag it onto this window, or type where it is"
+	});
+	const pick = await select({
+		title,
+		body: apks.length ? [] : ["There are no .apk files in Downloads, on the Desktop or in this folder."],
+		choices
+	});
+	if (pick !== OTHER) return pick;
+	const line = await ask("  Drag the .apk onto this window (or type its path), then press Enter:\n  > ");
+	if (!line) return null;
+	const file = droppedPath(line, s.platform) ?? line.trim();
+	if (!fs.existsSync(file)) {
+		s.error(`There is no file at ${file}.`);
+		return null;
+	}
+	return file;
+}
+async function installFlow(s, file) {
+	const rental = await pickRental(s, "Install on which phone?");
+	if (!rental) return;
+	const apk = file ?? await pickApk(s, "Which app do you want to install?");
+	if (!apk) return;
+	let pkg = null;
+	if (await s.run([
+		"install",
+		apk,
+		"--rental",
+		rental.id
+	], {
+		title: `Installing ${path.basename(apk)} on ${rental.deviceName}`,
+		onResult: (r) => {
+			if (r.kind === "installed") pkg = r.apps.find((a) => a.packageName)?.packageName ?? null;
+		}
+	}) !== 0 || !pkg) return;
+	const app = pkg;
+	if (await confirm(`Open ${app} now?`, [], "Yes, open it", "Not now")) await s.run([
+		"launch",
+		app,
+		"--rental",
+		rental.id
+	], { title: `Opening ${app}` });
+	s.hint("Next: \"test my app\" runs a quick crash check — or say what to do on the phone in plain words.");
+}
+/** The apps you installed on the phone (not the system's). */
+async function listApps(s, rental) {
+	return s.runTask((signal) => withDevice(s.input(rental.id, signal), async (device) => parsePackageList(await sh(device.adb, [
+		"pm",
+		"list",
+		"packages",
+		"-3"
+	]))), { spinner: `Reading the apps on ${rental.deviceName}` });
+}
+async function pickApp(s, rental, title, extra = []) {
+	const apps = await listApps(s, rental);
+	if (!apps) return null;
+	if (apps.length === 0 && extra.length === 0) {
+		s.result(`None of your apps are on ${rental.deviceName} yet. Drag an .apk onto this window to install one.`);
+		return null;
+	}
+	return select({
+		title,
+		body: apps.length ? [] : [`None of your apps are on ${rental.deviceName} yet.`],
+		choices: [...apps.sort().map((a) => ({
+			label: a,
+			value: a
+		})), ...extra]
+	});
+}
+async function appsFlow(s) {
+	const rental = await pickRental(s, "Which phone?");
+	if (!rental) return;
+	const apps = await listApps(s, rental);
+	if (!apps) return;
+	s.say(s.t.bold(`Your apps on ${rental.deviceName}`));
+	if (apps.length === 0) s.result("None yet. Drag an .apk onto this window to install one.");
+	apps.sort().forEach((a, i) => i === 0 ? s.result(a) : s.write(`     ${a}`));
+}
+async function launchFlow(s, pkg) {
+	const rental = await pickRental(s, "On which phone?");
+	if (!rental) return;
+	const app = pkg ?? await pickApp(s, rental, "Which app should I open?");
+	if (!app) return;
+	await s.run([
+		"launch",
+		app,
+		"--rental",
+		rental.id
+	], { title: `Opening ${app}` });
+}
+async function uninstallFlow(s, pkg) {
+	const rental = await pickRental(s, "On which phone?");
+	if (!rental) return;
+	const app = pkg ?? await pickApp(s, rental, "Which app should I remove?");
+	if (!app) return;
+	if (!await confirm(`Remove ${app} from ${rental.deviceName}?`, [], "Yes, remove it", "No")) return;
+	await s.run([
+		"uninstall",
+		app,
+		"--rental",
+		rental.id
+	], { title: `Removing ${app}` });
+}
+async function testFlow(s, target) {
+	const rental = await pickRental(s, "Test on which phone?");
+	if (!rental) return;
+	let what = target ?? null;
+	if (!what) {
+		what = await pickApp(s, rental, "Which app should the quick test check?", [{
+			label: "An .apk file on this computer",
+			value: OTHER,
+			hint: "installs it first"
+		}]);
+		if (what === OTHER) what = await pickApk(s, "Which app do you want to test?");
+	}
+	if (!what) return;
+	s.hint("The quick test opens the app, taps around for a minute and reports any crash. No test code needed.");
+	await s.run([
+		"test",
+		"quick",
+		what,
+		"--rental",
+		rental.id
+	], { title: `Quick test of ${path.basename(what)} on ${rental.deviceName}` });
+}
+async function screenshotFlow(s) {
+	const rental = await pickRental(s, "Screenshot of which phone?");
+	if (!rental) return;
+	const f = await knownFolders();
+	const dir = f.downloads ?? process.cwd();
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:T]/g, "-");
+	const file = path.join(dir, `devicerent-${slug(rental.deviceName)}-${stamp}.png`);
+	let saved = null;
+	await s.run([
+		"screenshot",
+		file,
+		"--rental",
+		rental.id
+	], {
+		title: `Screenshot of ${rental.deviceName}`,
+		spinner: "Taking the screenshot",
+		onResult: (r) => {
+			if (r.kind === "screenshot") saved = r.file;
+		}
+	});
+	if (saved) s.hint(openBrowser(saved) ? `Opened it. It's in your ${folderLabel(dir, f, process.cwd())} folder.` : `It's in your ${folderLabel(dir, f, process.cwd())} folder.`);
+}
+async function logsFlow(s) {
+	const rental = await pickRental(s, "Logs from which phone?");
+	if (!rental) return;
+	await s.run([
+		"logcat",
+		"--lines",
+		"60",
+		"--rental",
+		rental.id
+	], { title: `The last lines of ${rental.deviceName}'s log` });
+	s.hint("Follow it live with: /logcat -f   (Ctrl-C stops)");
+}
+async function balanceFlow(s) {
+	if (!await ensureSignedIn(s)) return;
+	const a = s.account;
+	s.say(s.t.bold("Your account"));
+	s.result(`${a.email} · ${a.planName} plan`);
+	s.write(`     Wallet ${s.t.bold(eur(a.wallet))} · AI credits ${s.t.bold(a.aiCredits.toLocaleString("en"))}`);
+	if (a.standing !== "active") s.write(`     ${s.t.yellow(`Account ${a.standing}`)}`);
+	s.hint("Add money: topup · Change plan: plans · More AI credits: buy credits");
+}
+async function topupFlow(s, amount) {
+	if (!await ensureSignedIn(s)) return;
+	let value = amount ?? null;
+	if (!value) {
+		value = await select({
+			title: "How much would you like to add?",
+			body: [`Your wallet: ${eur(s.account.wallet)}. Payment happens on Stripe, in your browser.`],
+			choices: [
+				{
+					label: "€10",
+					value: "10"
+				},
+				{
+					label: "€20",
+					value: "20"
+				},
+				{
+					label: "€50",
+					value: "50"
+				},
+				{
+					label: "Another amount",
+					value: OTHER
+				}
+			]
+		});
+		if (value === OTHER) {
+			const typed = await ask("  How many euros? ");
+			value = typed ? typed.replace(/^€/, "").trim() : null;
+		}
+	}
+	if (!value) return;
+	if (await s.run(["topup", value], { title: `Adding €${value} to your wallet` }) === 0) s.hint("Finish the payment in your browser; your wallet updates as soon as it goes through.");
+}
+async function plansFlow(s, plan) {
+	if (!await ensureSignedIn(s)) return;
+	const sellable = TIERS.filter((t) => t.monthlyPrice !== null && t.monthlyPrice > 0);
+	const ids = {
+		plus: "plus",
+		pro: "pro",
+		dedicated_slot: "slot"
+	};
+	let choice = plan ?? null;
+	if (!choice) choice = await select({
+		title: "Plans",
+		body: [`You're on ${s.account.planName}.`],
+		choices: [...sellable.map((t) => ({
+			label: t.name,
+			value: ids[t.id] ?? t.id,
+			hint: t.name === s.account.planName ? "your plan now" : t.discountPct >= 100 ? `${formatEur(t.monthlyPrice)} a month · a phone of your own` : `${formatEur(t.monthlyPrice)} a month · ${t.discountPct}% off every minute`,
+			disabled: t.name === s.account.planName
+		})), {
+			label: "Manage my plan and invoices",
+			value: "billing",
+			hint: "opens the Stripe portal"
+		}]
+	});
+	if (!choice) return;
+	if (choice === "billing") {
+		await s.run(["billing"], { title: "Opening the billing portal" });
+		return;
+	}
+	const yearly = await select({
+		title: "Pay monthly or yearly?",
+		choices: [{
+			label: "Monthly",
+			value: false
+		}, {
+			label: "Yearly",
+			value: true,
+			hint: `1 month free`
+		}]
+	});
+	if (yearly === null) return;
+	await s.run([
+		"subscribe",
+		choice,
+		...yearly ? ["--yearly"] : []
+	], { title: "Opening Stripe" });
+}
+async function buyCreditsFlow(s) {
+	if (!await ensureSignedIn(s)) return;
+	const pack = await select({
+		title: "Buy DeviceyAI credits",
+		body: [`You have ${s.account.aiCredits.toLocaleString("en")} credits.`],
+		choices: AI_CREDIT_PACKS.map((p) => ({
+			label: p.label,
+			value: p.id,
+			hint: `${p.credits.toLocaleString("en")} credits · ${formatEur(p.priceEur)}`
+		}))
+	});
+	if (!pack) return;
+	await s.run([
+		"credits",
+		"buy",
+		pack
+	], { title: "Opening Stripe" });
+}
+async function askAiPermission(s) {
+	const answer = await select({
+		title: "Let DeviceyAI use the phone?",
+		body: [`DeviceyAI does what you ask on your rented phone and is paid for in AI credits (you have ${(s.account?.aiCredits ?? 0).toLocaleString("en")}).`, "Each message is a fresh task."],
+		choices: [
+			{
+				label: "Yes — let it tap and type",
+				value: "act"
+			},
+			{
+				label: "Yes, but only let it look",
+				value: "look",
+				hint: "it can't touch anything"
+			},
+			{
+				label: "No",
+				value: "no"
+			}
+		]
+	});
+	return answer === "act" || answer === "look" ? answer : null;
+}
+async function aiFlow(s, task) {
+	if (!await ensureSignedIn(s)) return;
+	if (s.rentals.length === 0) s.result(`DeviceyAI works on a rented phone, and you don't have one yet.`);
+	const rental = await pickRental(s, "Which phone should DeviceyAI use?");
+	if (!rental) return;
+	if (!s.aiPermission) {
+		s.aiPermission = await askAiPermission(s);
+		if (!s.aiPermission) return;
+	}
+	for (let attempt = 0; attempt < 2; attempt++) {
+		let needsActions = false;
+		const permission = s.aiPermission;
+		const result = await s.runTask((signal) => runChatTask(s.input(rental.id, signal), task, permission, s.t).catch((err) => {
+			if (!(err instanceof AiNeedsActionsError)) throw err;
+			needsActions = true;
+			return null;
+		}), {
+			raw: true,
+			spinner: "DeviceyAI is thinking"
+		});
+		if (needsActions) {
+			if (!await confirm("DeviceyAI needs to tap and type for this", ["It only had permission to look. Let it act on the phone for the rest of this session?"], "Yes, let it act", "No")) return;
+			s.aiPermission = "act";
+			continue;
+		}
+		if (!result) return;
+		if (result.stopReason === "refusal") s.result("DeviceyAI declined this request.");
+		if (result.stopReason === "stopped") s.result(s.t.dim("Stopped."));
+		if (result.stopReason === "step_limit") s.result("It ran out of steps for one message. Try a smaller, more specific request.");
+		const left = result.creditsRemaining ?? s.account?.aiCredits ?? null;
+		s.hint(`${result.creditsCharged} credit${result.creditsCharged === 1 ? "" : "s"} used${left !== null ? ` · ${left.toLocaleString("en")} left` : ""}`);
+		return;
+	}
+}
+function helpFlow(s) {
+	const t = s.t;
+	const rows = [
+		["rent", "rent a phone — you pay by the minute until you stop"],
+		["install", "put your app (.apk) on it — or just drag the file onto this window"],
+		["test my app", "a quick crash check: opens your app and taps around"],
+		["screenshot", "save a picture of the phone's screen (and open it)"],
+		["apps · logs", "what you installed · the phone's log"],
+		["stop", "give the phone back and stop paying"],
+		["balance · topup", "your wallet · add money"],
+		["plans · buy credits", "change plan · more DeviceyAI credits"],
+		["phones", "every phone and whether it's free"]
+	];
+	s.say(t.bold("What you can do"));
+	rows.forEach(([cmd, what], i) => {
+		const line = `${t.accent(cmd.padEnd(22))}${what}`;
+		if (i === 0) s.result(line);
+		else s.write(`     ${line}`);
+	});
+	s.write();
+	s.hint("Anything else, in plain words — \"open Settings and turn on dark mode\" — goes to DeviceyAI.");
+	s.hint("Type / for every command · permissions changes what DeviceyAI may do · exit to leave");
+}
+//#endregion
+//#region src/interactive/intent.ts
+/** Session-only commands: typed with or without the slash. */
+const SESSION_ACTIONS = {
+	help: "help",
+	exit: "exit",
+	quit: "exit",
+	clear: "clear",
+	permissions: "permissions",
+	phones: "phones",
+	balance: "balance",
+	plans: "plans"
+};
+/** Words that carry no meaning after a verb: "install THE APP ON MY PHONE". */
+const FILLER = new Set("a an the my me this that it its one please now phone device android app apk application rental renting session for to some another new current of screen on in up".split(" "));
+const PACKAGE_RE = /^[a-zA-Z][\w]*(\.[a-zA-Z][\w]*)+$/;
+const VERBS = [
+	[
+		"help",
+		"none",
+		[
+			"help",
+			"?",
+			"what can you do",
+			"what can i do",
+			"how does this work",
+			"commands",
+			"menu",
+			"options"
+		]
+	],
+	[
+		"exit",
+		"none",
+		[
+			"exit",
+			"quit",
+			"bye",
+			"goodbye"
+		]
+	],
+	[
+		"clear",
+		"none",
+		["clear", "cls"]
+	],
+	[
+		"rent",
+		"query",
+		[
+			"rent",
+			"hire",
+			"borrow"
+		]
+	],
+	[
+		"stop",
+		"all",
+		[
+			"stop",
+			"end",
+			"finish",
+			"return",
+			"release",
+			"i'm done",
+			"im done",
+			"i am done",
+			"done",
+			"stop renting"
+		]
+	],
+	[
+		"install",
+		"path",
+		[
+			"install",
+			"upload",
+			"add"
+		]
+	],
+	[
+		"screenshot",
+		"none",
+		[
+			"screenshot",
+			"screen shot",
+			"take a screenshot",
+			"take screenshot",
+			"capture the screen",
+			"capture screen",
+			"take a picture",
+			"picture"
+		]
+	],
+	[
+		"test",
+		"target",
+		[
+			"test",
+			"quick test",
+			"smoke test",
+			"check",
+			"try"
+		]
+	],
+	[
+		"buy-credits",
+		"none",
+		[
+			"buy credits",
+			"buy ai credits",
+			"buy deviceyai credits",
+			"more credits",
+			"credits buy"
+		]
+	],
+	[
+		"balance",
+		"none",
+		[
+			"balance",
+			"wallet",
+			"money",
+			"account",
+			"whoami",
+			"who am i",
+			"my account",
+			"my balance",
+			"how much money do i have",
+			"how much money",
+			"credits",
+			"ai credits"
+		]
+	],
+	[
+		"topup",
+		"amount",
+		[
+			"top up",
+			"topup",
+			"add money",
+			"add funds",
+			"add credit",
+			"recharge",
+			"deposit"
+		]
+	],
+	[
+		"plans",
+		"plan",
+		[
+			"plans",
+			"plan",
+			"pricing",
+			"prices",
+			"subscribe",
+			"subscription",
+			"upgrade"
+		]
+	],
+	[
+		"apps",
+		"none",
+		[
+			"apps",
+			"list apps",
+			"installed apps",
+			"show apps",
+			"what's installed",
+			"what is installed"
+		]
+	],
+	[
+		"phones",
+		"none",
+		[
+			"phones",
+			"devices",
+			"list phones",
+			"list devices",
+			"show phones",
+			"show devices",
+			"show me the phones",
+			"which phones",
+			"what phones",
+			"available phones",
+			"available"
+		]
+	],
+	[
+		"status",
+		"none",
+		[
+			"status",
+			"what's running",
+			"what is running",
+			"rentals",
+			"my rentals"
+		]
+	],
+	[
+		"login",
+		"none",
+		[
+			"login",
+			"log in",
+			"sign in",
+			"signin"
+		]
+	],
+	[
+		"logout",
+		"none",
+		[
+			"logout",
+			"log out",
+			"sign out",
+			"signout"
+		]
+	],
+	[
+		"launch",
+		"package",
+		[
+			"launch",
+			"open",
+			"start",
+			"run"
+		]
+	],
+	[
+		"uninstall",
+		"package",
+		[
+			"uninstall",
+			"remove",
+			"delete"
+		]
+	],
+	[
+		"logs",
+		"none",
+		[
+			"logs",
+			"log",
+			"logcat",
+			"show logs",
+			"show me the logs",
+			"show the logs"
+		]
+	],
+	[
+		"permissions",
+		"none",
+		["permissions"]
+	]
+];
+const RENT_PHRASE = /^(?:can i |could i |please )?(?:get|give me|i want|i need|i'd like|id like|book|start|grab)(?: me)?(?: (?:a|an|another|one|new))? (phone|device|android|pixel|galaxy|samsung)\b(.*)$/;
+function normalize(line) {
+	return line.toLowerCase().replace(/[.!?,]+$/g, "").replace(/\s+/g, " ").trim();
+}
+/** Classify the words after a verb; null when they do not fit the action. */
+function fitArgs(mode, rest, env) {
+	const meaningful = rest.filter((w) => !FILLER.has(w.toLowerCase()));
+	if (mode === "query") return meaningful.length ? { arg: meaningful.join(" ") } : {};
+	if (mode === "all" && rest.some((w) => /^(app|apk|application)s?$/i.test(w))) return null;
+	if (meaningful.length === 0) return {};
+	if (meaningful.length !== 1) return null;
+	const w = meaningful[0];
+	const lower = w.toLowerCase();
+	switch (mode) {
+		case "all": return lower === "all" || lower === "everything" ? { arg: "all" } : null;
+		case "path": return env.fileExists(w) ? { arg: w } : null;
+		case "package": return PACKAGE_RE.test(w) ? { arg: w } : null;
+		case "target": return env.fileExists(w) || PACKAGE_RE.test(w) ? { arg: w } : null;
+		case "amount": {
+			const n = Number(w.replace(/^€/, "").replace(/(eur|euros?)$/i, ""));
+			return Number.isFinite(n) && n > 0 ? { arg: String(n) } : null;
+		}
+		case "plan": return [
+			"plus",
+			"pro",
+			"slot"
+		].includes(lower) ? { arg: lower } : null;
+		default: return null;
+	}
+}
+/** What may follow a command's name for the line to count as that command. */
+function positionalsFit(name, rest, env) {
+	const positionals = rest.filter((w, i) => !w.startsWith("-") && !(i > 0 && rest[i - 1].startsWith("--") && !rest[i - 1].includes("=")));
+	if (positionals.length === 0) return true;
+	switch (name) {
+		case "shell":
+		case "ai":
+		case "keys create":
+		case "keys revoke": return true;
+		case "push": return env.fileExists(positionals[0]);
+		case "pull": return positionals[0].startsWith("/");
+		case "screenshot":
+		case "install":
+		case "test quick": return positionals.every((p) => env.fileExists(p) || PACKAGE_RE.test(p) || p.endsWith(".png"));
+		case "launch":
+		case "uninstall": return PACKAGE_RE.test(positionals[0]);
+		case "topup": return Number.isFinite(Number(positionals[0]));
+		case "subscribe": return [
+			"plus",
+			"pro",
+			"slot"
+		].includes(positionals[0]);
+		case "credits": return positionals[0] === "buy";
+		case "stop": return /^[0-9a-f][0-9a-f-]{7,}$/i.test(positionals[0]);
+		default: return false;
+	}
+}
+function matchCommand(words, names) {
+	const byLength = [...names].sort((a, b) => b.split(" ").length - a.split(" ").length);
+	for (const name of byLength) {
+		const parts = name.split(" ");
+		if (parts.every((p, i) => words[i] === p)) return {
+			name,
+			rest: words.slice(parts.length)
+		};
+	}
+	return null;
+}
+/** Edit distance with adjacent swaps ("stauts" → "status" is 1). */
+function editDistance(a, b) {
+	const d = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+	for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++) {
+		const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+		d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+		if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+	}
+	return d[a.length][b.length];
+}
+/** The commands and actions a mistyped single word was probably meant to be. */
+function nearMisses(word, env) {
+	const candidates = /* @__PURE__ */ new Set([
+		...env.commandNames.filter((n) => !n.includes(" ")),
+		...Object.keys(SESSION_ACTIONS),
+		"rent",
+		"stop",
+		"install",
+		"screenshot",
+		"topup",
+		"logs"
+	]);
+	const limit = word.length <= 4 ? 1 : 2;
+	return [...candidates].map((c) => ({
+		c,
+		d: editDistance(word, c)
+	})).filter((x) => x.d > 0 && x.d <= limit).sort((x, y) => x.d - y.d || x.c.localeCompare(y.c)).slice(0, 3).map((x) => x.c);
+}
+function interpret(line, env) {
+	const trimmed = line.trim();
+	if (!trimmed) return { kind: "empty" };
+	if (trimmed === "?") return {
+		kind: "action",
+		action: "help"
+	};
+	const dropped = droppedPath(trimmed, env);
+	if (dropped && env.fileExists(dropped)) return {
+		kind: "install-file",
+		path: dropped
+	};
+	if (trimmed.startsWith("/")) {
+		const words = tokenize(trimmed.slice(1), env);
+		if (words.length === 0) return {
+			kind: "action",
+			action: "help"
+		};
+		const session = SESSION_ACTIONS[words[0].toLowerCase()];
+		if (session && words.length === 1) return {
+			kind: "action",
+			action: session
+		};
+		return {
+			kind: "command",
+			argv: words
+		};
+	}
+	const norm = normalize(trimmed);
+	const words = tokenize(trimmed, env);
+	const normWords = norm.split(" ");
+	const rent = RENT_PHRASE.exec(norm);
+	if (rent) {
+		const query = [rent[1], ...rent[2].trim().split(" ")].filter((w) => w && !FILLER.has(w)).join(" ");
+		return {
+			kind: "action",
+			action: "rent",
+			...query ? { arg: query } : {}
+		};
+	}
+	for (const [action, mode, verbs] of VERBS) {
+		const verb = [...verbs].sort((a, b) => b.length - a.length).find((v) => norm === v || norm.startsWith(`${v} `));
+		if (!verb) continue;
+		const fit = fitArgs(mode, words.slice(verb.split(" ").length), env);
+		if (fit) return {
+			kind: "action",
+			action,
+			...fit
+		};
+	}
+	const found = matchCommand(words, env.commandNames);
+	if (found && positionalsFit(found.name, found.rest, env)) return {
+		kind: "command",
+		argv: words
+	};
+	if (normWords.length === 1) {
+		const near = nearMisses(normWords[0], env);
+		return near.length ? {
+			kind: "did-you-mean",
+			options: near
+		} : { kind: "unknown" };
+	}
+	return {
+		kind: "ai",
+		task: trimmed
+	};
+}
+//#endregion
+//#region src/interactive/session.ts
+/** Some next steps for refusals a person can fix themselves. */
+function nextStepFor(message) {
+	const m = message.toLowerCase();
+	if (m.includes("insufficient credit") || m.includes("top up")) return "Add money with: topup";
+	if (m.includes("out of deviceyai credits")) return "Buy more with: buy credits";
+	if (m.includes("not signed in")) return "Sign in with: login";
+	if (m.includes("no active rental")) return "Rent a phone with: rent";
+	if (m.includes("concurrent rental limit")) return "Stop one first with: stop";
+	return null;
+}
+const LEADING_ESCAPES = /^(?:\u001b\[[0-9;?]*[ -/]*[@-~])+/;
+/**
+* Prefix every line written to stdout/stderr while `fn` runs: "  ⎿  " on the
+* first, five spaces after. A carriage return (a progress bar or a spinner
+* redrawing its line) gets that line's prefix again, before its next visible
+* character. Returns the undo.
+*/
+function indentOutput(t) {
+	const out = process.stdout;
+	const err = process.stderr;
+	const outWrite = out.write;
+	const errWrite = err.write;
+	const first = `  ${t.dim(t.g.elbow)}  `;
+	const rest = "     ";
+	let used = false;
+	/** A new line has started and has no prefix yet. */
+	let newLine = true;
+	/** The current line was rewound with \r and needs its prefix again. */
+	let rewound = false;
+	let atLineStart = true;
+	let current = first;
+	const decoders = /* @__PURE__ */ new Map();
+	const transform = (text) => {
+		let res = "";
+		for (const part of text.split(/(\r\n|\n|\r)/)) {
+			if (part === "") continue;
+			if (part === "\n" || part === "\r\n") {
+				res += part;
+				newLine = true;
+				rewound = false;
+				atLineStart = true;
+				continue;
+			}
+			if (part === "\r") {
+				res += "\r";
+				if (!newLine) rewound = true;
+				continue;
+			}
+			const escapes = LEADING_ESCAPES.exec(part)?.[0] ?? "";
+			const visible = part.slice(escapes.length);
+			res += escapes;
+			if (!visible) continue;
+			if (newLine) {
+				current = used ? rest : first;
+				used = true;
+				res += current;
+			} else if (rewound) res += current;
+			newLine = false;
+			rewound = false;
+			atLineStart = false;
+			res += visible;
+		}
+		return res;
+	};
+	const wrap = (stream, orig) => function(chunk, ...args) {
+		let text;
+		if (typeof chunk === "string") text = chunk;
+		else if (chunk instanceof Uint8Array) {
+			let d = decoders.get(stream);
+			if (!d) decoders.set(stream, d = new TextDecoder());
+			text = d.decode(chunk, { stream: true });
+		} else text = String(chunk);
+		return orig.call(this, transform(text), ...args);
+	};
+	out.write = wrap(out, outWrite);
+	err.write = wrap(err, errWrite);
+	let undone = false;
+	return () => {
+		if (undone) return;
+		undone = true;
+		out.write = outWrite;
+		err.write = errWrite;
+		if (!atLineStart && !rewound) outWrite.call(out, "\n");
+	};
+}
+var Session = class {
+	ctx;
+	t;
+	platform;
+	account = null;
+	rentals = [];
+	aiPermission = null;
+	history = [];
+	/** A message to show before the next prompt (never over a drawn prompt). */
+	pending = [];
+	stoppedHere = /* @__PURE__ */ new Set();
+	constructor(ctx, t, platform) {
+		this.ctx = ctx;
+		this.t = t;
+		this.platform = platform;
+	}
+	write(line = "") {
+		process.stdout.write(`${line}\n`);
+	}
+	/** "⏺ text" — something happening, or an answer. */
+	say(text) {
+		this.write(`${this.t.accent(this.t.g.dot)} ${text}`);
+	}
+	/** "  ⎿  text" — the result of what was just said. */
+	result(text) {
+		this.write(`  ${this.t.dim(this.t.g.elbow)}  ${text}`);
+	}
+	hint(text) {
+		this.write(this.t.dim(`  ${text}`));
+	}
+	error(text) {
+		this.result(this.t.red(text));
+		const next = nextStepFor(text);
+		if (next) this.hint(next);
+	}
+	/** Who is signed in (null if nobody), and their running rentals. */
+	async refresh() {
+		try {
+			const user = await requireUser(this.ctx);
+			const [account, rentals] = await Promise.all([loadAccount(this.ctx, user), loadActiveRentals()]);
+			this.account = account;
+			this.noteVanished(rentals);
+			this.rentals = rentals;
+		} catch (err) {
+			if (err instanceof CliError && err.exitCode === 2) {
+				this.account = null;
+				this.rentals = [];
+				return;
+			}
+			throw err;
+		}
+	}
+	async refreshRentals() {
+		if (!this.account) return;
+		const rentals = await loadActiveRentals();
+		this.noteVanished(rentals);
+		this.rentals = rentals;
+	}
+	/** A rental that ended without our stop: the idle sweep, or the website. */
+	noteVanished(next) {
+		for (const r of this.rentals) {
+			if (next.some((n) => n.id === r.id) || this.stoppedHere.has(r.id)) continue;
+			this.pending.push(`${r.deviceName} is no longer rented — it was stopped elsewhere, or after 30 idle minutes.`);
+		}
+	}
+	/** A CommandInput for work the session runs itself (pickers, DeviceyAI). */
+	input(rentalId, signal) {
+		return {
+			ctx: this.ctx,
+			args: [],
+			opts: rentalId ? { rental: rentalId } : {},
+			json: false,
+			signal
+		};
+	}
+	/**
+	* Run `work` with Ctrl-C wired to its signal. The first Ctrl-C aborts it
+	* and is then handed back to Node, so a second one ends the process the
+	* ordinary way. The work is always awaited: a rent or stop already on its
+	* way to the database is never abandoned behind the prompt.
+	*/
+	async runTask(work, opts = {}) {
+		if (opts.title) this.say(this.t.bold(opts.title));
+		cookedMode();
+		const controller = new AbortController();
+		const onSigint = () => {
+			process.off("SIGINT", onSigint);
+			controller.abort();
+			process.stderr.write(this.t.dim("\n  Stopping…\n"));
+		};
+		process.on("SIGINT", onSigint);
+		const undoIndent = opts.raw ? () => {} : indentOutput(this.t);
+		const spin = opts.spinner ? startSpinner(opts.spinner, {
+			cancellable: true,
+			theme: this.t
+		}) : null;
+		try {
+			return await work(controller.signal);
+		} catch (err) {
+			spin?.stop();
+			undoIndent();
+			const message = err instanceof Error ? err.message : String(err);
+			if (err instanceof CliError && err.exitCode === 130) this.result(this.t.dim(message));
+			else this.error(message);
+			return null;
+		} finally {
+			spin?.stop();
+			undoIndent();
+			process.off("SIGINT", onSigint);
+			if (opts.raw) restoreTerminal();
+			await this.refresh().catch(() => {});
+		}
+	}
+	/**
+	* Run a command line exactly as `devicerent <argv>` would. Returns its exit
+	* code, or null when it failed (the error has been printed).
+	*/
+	async run(argv, opts = {}) {
+		const raw = opts.raw ?? (argv[0] === "shell" || argv[0] === "connect" || argv[0] === "logcat" && (argv.includes("-f") || argv.includes("--follow")));
+		return this.runTask(async (signal) => {
+			const outcome = await runCommandLine(async () => this.ctx, argv, {
+				signal,
+				interactive: true,
+				onResult: (r) => {
+					if (r.kind === "stopped") for (const id of r.rentalIds) this.stoppedHere.add(id);
+					opts.onResult?.(r);
+				}
+			});
+			if (outcome.kind === "unknown") {
+				const near = nearMisses(argv[0] ?? "", {
+					...this.platform,
+					fileExists: () => false,
+					commandNames: COMMANDS.map((c) => c.name)
+				});
+				throw new CliError(`There is no command "${argv.join(" ")}".${near.length ? ` Did you mean ${near.map((n) => `/${n}`).join(" or ")}?` : " Type / to see them all."}`);
+			}
+			return outcome.code;
+		}, {
+			...opts,
+			raw
+		});
+	}
+	/** True when the command named by argv acts on one rented phone. */
+	static isDeviceCommand(argv) {
+		const found = findCommand(argv);
+		return Boolean(found?.command.options && "rental" in found.command.options);
+	}
+};
+//#endregion
+//#region src/interactive/repl.ts
+const SESSION_SUMMARIES = {
+	help: "What you can do here, in plain words",
+	exit: "Leave (asks first if a phone is still rented)",
+	quit: "Leave",
+	clear: "Clear the screen",
+	permissions: "Change what DeviceyAI may do on the phone",
+	phones: "Every phone and whether it's free",
+	balance: "Your wallet, AI credits and plan",
+	plans: "Change your plan"
+};
+/** Everything the `/` menu offers: session actions first, then commands. */
+function slashMenu() {
+	return [...Object.keys(SESSION_ACTIONS).filter((k) => k !== "quit").map((name) => ({
+		name,
+		summary: SESSION_SUMMARIES[name] ?? ""
+	})), ...COMMANDS.map((c) => ({
+		name: c.name,
+		summary: c.summary
+	}))];
+}
+/** The welcome card's lines (pure). */
+function welcomeLines(account, rentals, apiBase, t, width) {
+	const card = [
+		`${t.accent(t.g.spark)} ${t.bold("Welcome to DeviceRent")} ${t.dim(CLI_VERSION)}`,
+		"",
+		"  Real Android phones, rented by the minute.",
+		account ? `  ${account.email} ${t.dim("·")} ${account.planName} ${t.dim("·")} Wallet ${t.bold(`€${account.wallet.toFixed(2)}`)} ${t.dim("·")} AI credits ${account.aiCredits.toLocaleString("en")}` : t.dim("  You're not signed in yet.")
+	];
+	if (apiBase !== "https://devicerent.net") card.push(t.dim(`  ${apiBase}`));
+	const lines = renderBox(card, {
+		width,
+		theme: t,
+		border: t.accent
+	});
+	lines.push("");
+	if (rentals.length > 0) lines.push(` ${t.accent(t.g.bullet)} You have ${rentals.map((r) => t.bold(r.deviceName)).join(", ")} rented right now.`, "");
+	lines.push(t.dim(" Tips for getting started:"), "", ` 1. Type ${t.bold("rent")} to pick a phone — you pay by the minute until you stop`, ` 2. Drag your ${t.bold(".apk")} file onto this window to install it`, ` 3. Then say what to do: ${t.bold("\"open my app and sign up with a test email\"")}`, ` 4. ${t.bold("help")} explains the rest · ${t.bold("/")} lists every command`, "");
+	return lines;
+}
+function placeholderFor(s) {
+	if (!s.account) return "Type \"login\" to sign in";
+	if (s.rentals.length === 0) return "Try \"rent a phone\"";
+	return "Try \"install\", or \"open Settings and turn on dark mode\"";
+}
+/** Guided commands typed with their own name but without their arguments. */
+async function runCommandLineGuided(s, argv) {
+	const found = findCommand(argv);
+	const name = found?.command.name;
+	const rest = found?.rest ?? [];
+	const positional = rest.filter((w) => !w.startsWith("-"));
+	if (name === "rent") return rentFlow(s, rest.join(" ") || void 0);
+	if (name === "stop" && rest.length === 0) return stopFlow(s);
+	if (name === "stop" && rest.length === 1 && rest[0] === "--all") return stopFlow(s, "all");
+	if (name === "install" && positional.length === 0) return installFlow(s);
+	if (name === "screenshot" && positional.length === 0) return screenshotFlow(s);
+	if (name === "test quick" && positional.length === 0) return testFlow(s);
+	if (name === "launch" && positional.length === 0) return launchFlow(s);
+	if (name === "uninstall" && positional.length === 0) return uninstallFlow(s);
+	if (name === "topup" && positional.length === 0) return topupFlow(s);
+	if (name === "subscribe" && positional.length === 0) return plansFlow(s);
+	if (name === "credits" && positional[0] === "buy" && positional.length === 1) return buyCreditsFlow(s);
+	if (name === "login" && rest.length === 0) return loginFlow(s);
+	if (name === "ai" && positional.length > 0 && rest.length === positional.length) return aiFlow(s, positional.join(" "));
+	let line = argv;
+	if (Session.isDeviceCommand(argv) && !argv.some((a) => a === "--rental" || a === "-r" || a.startsWith("--rental="))) {
+		if (s.rentals.length !== 1) {
+			const rental = await pickRental(s, "On which phone?");
+			if (!rental) return;
+			line = [
+				...argv,
+				"--rental",
+				rental.id
+			];
+		}
+	}
+	await s.run(line);
+}
+async function runAction(s, action, arg) {
+	switch (action) {
+		case "help": return helpFlow(s);
+		case "exit": return "exit";
+		case "clear":
+			process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+			return;
+		case "rent": return rentFlow(s, arg);
+		case "stop": return stopFlow(s, arg);
+		case "install": return installFlow(s, arg);
+		case "screenshot": return screenshotFlow(s);
+		case "test": return testFlow(s, arg);
+		case "balance": return balanceFlow(s);
+		case "topup": return topupFlow(s, arg);
+		case "plans": return plansFlow(s, arg);
+		case "buy-credits": return buyCreditsFlow(s);
+		case "apps": return appsFlow(s);
+		case "phones": return phonesFlow(s);
+		case "status":
+			await s.run(["status"], { title: "What you have rented" });
+			return;
+		case "login": return loginFlow(s);
+		case "logout": return logoutFlow(s);
+		case "launch": return launchFlow(s, arg);
+		case "uninstall": return uninstallFlow(s, arg);
+		case "logs": return logsFlow(s);
+		case "permissions": {
+			const p = await askAiPermission(s);
+			s.aiPermission = p;
+			s.result(p === "act" ? "DeviceyAI may tap and type on the phone." : p === "look" ? "DeviceyAI may only look at the phone." : "DeviceyAI will ask again next time.");
+			return;
+		}
+	}
+}
+async function dispatch(s, intent) {
+	switch (intent.kind) {
+		case "empty": return;
+		case "install-file": return installFlow(s, intent.path);
+		case "action": return runAction(s, intent.action, intent.arg);
+		case "command": return runCommandLineGuided(s, intent.argv);
+		case "did-you-mean": {
+			const pick = await select({
+				title: "Did you mean…",
+				choices: [...intent.options.map((o) => ({
+					label: o,
+					value: o
+				})), {
+					label: "None of these",
+					value: ""
+				}]
+			});
+			if (!pick) return;
+			return dispatch(s, interpret(pick, envFor(s)));
+		}
+		case "ai": return aiFlow(s, intent.task);
+		case "unknown":
+			s.result("I didn't catch that. Type help to see what you can do, or / for every command.");
+			return;
+	}
+}
+function envFor(s) {
+	return {
+		...s.platform,
+		commandNames: COMMANDS.map((c) => c.name),
+		fileExists: (p) => {
+			try {
+				return fs.statSync(p).isFile();
+			} catch {
+				return false;
+			}
+		}
+	};
+}
+/** Leaving with a phone still rented: ask, never assume. */
+async function confirmExit(s) {
+	await s.refreshRentals().catch(() => {});
+	if (s.rentals.length === 0) return true;
+	const names = s.rentals.map((r) => r.deviceName).join(", ");
+	const choice = await select({
+		title: `${names} ${s.rentals.length === 1 ? "is" : "are"} still rented`,
+		body: ["Billing continues until you stop it, or until it has sat idle for 30 minutes."],
+		choices: [
+			{
+				label: "Stop it and leave",
+				value: "stop"
+			},
+			{
+				label: "Leave it running",
+				value: "leave"
+			},
+			{
+				label: "Stay",
+				value: "stay"
+			}
+		]
+	});
+	if (choice === "stop") {
+		await s.run(["stop", "--all"], {
+			title: `Stopping ${names}`,
+			spinner: "Stopping and settling the bill"
+		});
+		return true;
+	}
+	if (choice === "leave") {
+		s.hint("It keeps running. Stop it later with: npx devicerent stop");
+		return true;
+	}
+	return false;
+}
+async function startInteractive(apiBase, helpText) {
+	const t = theme();
+	const platform = {
+		platform: process.platform,
+		home: os.homedir()
+	};
+	const spin = startSpinner("Connecting to DeviceRent", { theme: t });
+	let ctx;
+	try {
+		ctx = await startContext(apiBase);
+	} catch (err) {
+		spin.stop();
+		process.stderr.write(`${t.red(err.message)}\n\n${helpText()}\n`);
+		return 1;
+	}
+	const s = new Session(ctx, t, platform);
+	try {
+		await s.refresh();
+	} catch (err) {
+		spin.stop();
+		process.stderr.write(`${t.red(err.message)}\n`);
+		return 1;
+	}
+	spin.stop();
+	for (const line of welcomeLines(s.account, s.rentals, apiBase, t, frameWidth(process.stdout.columns))) s.write(line);
+	if (!s.account) await loginFlow(s);
+	const poll = setInterval(() => void s.refreshRentals().catch(() => {}), 6e4);
+	poll.unref();
+	const commands = slashMenu();
+	try {
+		for (;;) {
+			for (const p of s.pending.splice(0)) s.hint(p);
+			const r = await readPrompt({
+				history: s.history,
+				commands,
+				placeholder: placeholderFor(s),
+				hint: "/ for commands · ? for help",
+				status: () => statusLine(s.rentals, s.account, Date.now(), t),
+				theme: t
+			});
+			if (r.kind === "exit") {
+				if (await confirmExit(s)) break;
+				continue;
+			}
+			if (r.value.trim()) s.history.push(r.value);
+			try {
+				if (await dispatch(s, interpret(r.value, envFor(s))) === "exit" && await confirmExit(s)) break;
+			} catch (err) {
+				s.error(err instanceof CliError || err instanceof Error ? err.message : String(err));
+			}
+			s.write();
+		}
+	} finally {
+		clearInterval(poll);
+		restoreTerminal();
+	}
+	s.write(t.dim("  Bye."));
+	return 0;
+}
+//#endregion
+//#region src/main.ts
 /**
 * Global flags may come before the command, as with git and gh:
 * `devicerent --api-base http://localhost:3000 keys list`. They are lifted out
@@ -41195,6 +44247,21 @@ function helpText() {
 }
 async function main(rawArgv) {
 	const { globals, rest: argv } = splitLeadingGlobals(rawArgv);
+	if (shouldStartInteractive({
+		argv,
+		globals,
+		stdinTTY: process.stdin.isTTY === true,
+		stdoutTTY: process.stdout.isTTY === true,
+		stderrTTY: process.stderr.isTTY === true,
+		env: process.env
+	})) {
+		const { values } = parseArgs({
+			args: globals,
+			options: GLOBAL_OPTIONS,
+			strict: true
+		});
+		return startInteractive(resolveApiBase(values), helpText);
+	}
 	if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
 		printLine(helpText());
 		return 0;
@@ -41203,40 +44270,12 @@ async function main(rawArgv) {
 		printLine(CLI_VERSION);
 		return 0;
 	}
-	const found = findCommand(argv);
-	if (!found) {
+	const outcome = await runCommandLine(startContext, argv, { globals });
+	if (outcome.kind === "unknown") {
 		process.stderr.write(`${red("Unknown command:")} ${argv.join(" ")}\n\n${helpText()}\n`);
 		return 2;
 	}
-	const { command, rest } = found;
-	let values;
-	let positionals;
-	try {
-		({values, positionals} = parseArgs({
-			args: [...globals, ...rest],
-			options: {
-				...GLOBAL_OPTIONS,
-				...command.options
-			},
-			allowPositionals: true,
-			strict: true
-		}));
-	} catch (err) {
-		process.stderr.write(`${red(err.message)}\nUsage: ${command.usage}\n`);
-		return 2;
-	}
-	if (values.help === true) {
-		printLine(`${command.summary}\n\nUsage: ${command.usage}`);
-		return 0;
-	}
-	const ctx = await startContext(normalizeApiBase((typeof values["api-base"] === "string" ? values["api-base"] : void 0) ?? process.env.DEVICERENT_API_BASE ?? "https://devicerent.net"));
-	const code = await command.run({
-		ctx,
-		args: positionals,
-		opts: values,
-		json: values.json === true
-	});
-	return typeof code === "number" ? code : 0;
+	return outcome.code;
 }
 /** Grace for stray handles before a finished command is ended by force. */
 const EXIT_GRACE_MS = 3e3;
@@ -41261,4 +44300,4 @@ if (process.env.VITEST === void 0) main(process.argv.slice(2)).then(finish, (err
 	finish(err instanceof CliError ? err.exitCode : 1);
 });
 //#endregion
-export { findCommand, main, splitLeadingGlobals };
+export { findCommand, helpText, main, splitLeadingGlobals };