modelos-secure 0.3.4 → 0.3.6

package/README.md

@@ -8,35 +8,38 @@ npx modelos-secure scan .
 
 It reads the code the way an engineer would, starting where the app starts, draws the system's map and asks only what it cannot work out. Everything it decides goes into `modelos-secure.yaml`.
 
-Before it sends anything it asks once whether a model may read the code it needs, or only an outline of it, or nothing. Every answer it sends passes a filter that takes secrets out, and settings files, keys and credentials are never read. `.modelos-secure/sent.jsonl` lists what was sent, `--explain` shows the outline and what may and may not be read without sending anything, and `--offline` keeps everything on your machine.
+Before it sends anything it asks once whether a model may read the code it needs, or only an outline of it, or nothing. Every answer it sends passes a filter that takes secrets out, and settings files, keys and credentials are never sent. What leaves: the outline, the reader's answers, the map it registers, your answer key if you add one, and the last lines of the app's own output when a start fails. `.modelos-secure/sent.jsonl` lists every answer the reader sent, `--explain` shows the outline and what may and may not be read without sending anything, and `--offline` keeps everything on your machine.
 
 At a terminal, `modelos-secure` on its own starts a session about the app in the folder: ask about it in your own words, and each answer cites the files and lines it rests on, checked against the code.
 
-| Command                                       | Does                                                               |
-| --------------------------------------------- | ------------------------------------------------------------------ |
-| `modelos-secure`                              | At a terminal, a session about the app in this folder.             |
-| `modelos-secure login`                        | Saves a workspace token, and signs in with Google if needed.       |
-| `modelos-secure scan .`                       | Connects this repository. `--offline`, `--explain`, `--yes`.       |
-| `modelos-secure review`                       | Starts a review of this system. `--quick`, `--ci`, `--budget`.     |
-| `modelos-secure replay F-031`                 | Replays one finding.                                               |
-| `modelos-secure doctor`                       | Checks the setup and fixes what it can.                            |
-| `modelos-secure runner`                       | Serves a review's attempts from this machine, in the app's folder. |
-| `modelos-secure export R-1179 --format sarif` | Writes a review's findings as SARIF or JSON.                       |
-| `modelos-secure --version`                    | Prints this CLI's version.                                         |
+| Command                                       | Does                                                                                          |
+| --------------------------------------------- | --------------------------------------------------------------------------------------------- |
+| `modelos-secure`                              | At a terminal, a session about the app in this folder.                                        |
+| `modelos-secure login`                        | Saves a workspace token, and signs in with Google if needed.                                  |
+| `modelos-secure scan .`                       | Connects this repository. `--offline`, `--explain`, `--yes`, `--ci`, `--no-review`.           |
+| `modelos-secure review`                       | Starts a review of this system. `--quick`, `--ci`, `--yes`, `--budget`, `--instances`.        |
+| `modelos-secure replay F-031`                 | Replays one finding of an app the scan connected.                                             |
+| `modelos-secure doctor`                       | Checks the setup and fixes what it can.                                                       |
+| `modelos-secure runner`                       | Serves a review's attempts from this machine, in the app's folder. `--system`, `--instances`. |
+| `modelos-secure export R-1179 --format sarif` | Prints a review's findings as SARIF or JSON; `--out` writes a file.                           |
+| `modelos-secure --version`                    | Prints this CLI's version.                                                                    |
+
+Before it starts your app, a review says what the app relies on and whether each need is met on this machine: a cloud sign-in, a key, a database, a service from a compose file. A need that is not met stops the start with the command that meets it, such as `gcloud auth application-default login`; you can have the CLI run it for you, on a yes, or start anyway. Nothing on your machine is changed without that yes.
 
 A review of an app connected by the scan reaches it through a runner on the machine that runs it. `modelos-secure review` starts one itself, and keeps it while the review is paused; a review started from the app needs `modelos-secure runner` running in the app's folder, and says so if none is. A start command is checked before it runs and saved only once the app has started with it.
 
-During a review, actions are held and never run. Outside a review the hooks do nothing. Requires Node 22 or newer. Python apps need Python 3.10 or newer.
+During a review, the tools marked as held in `modelos-secure.yaml` are caught and never run; the scan marks every tool that can act, and a tool set to `run` runs for real. Outside a review the hooks do nothing. Requires Node 22 or newer. Python apps need Python 3.10 or newer.
 
 Every command says what it takes with `--help`, such as `modelos-secure scan --help`, and refuses a flag it does not take.
 
-| Exit code | Means                                                          |
-| --------- | -------------------------------------------------------------- |
-| 0         | Done.                                                          |
-| 1         | Something failed, or a fix check found a break.                |
-| 2         | The command was used wrongly.                                  |
-| 3         | There are questions only a person can answer, as `--ci` lists. |
-| 130       | Stopped with Ctrl-C. What was done is kept.                    |
+| Exit code | Means                                                                           |
+| --------- | ------------------------------------------------------------------------------- |
+| 0         | Done.                                                                           |
+| 1         | Something failed, or a fix check found a break.                                 |
+| 2         | The command was used wrongly.                                                   |
+| 3         | There are questions only a person can answer, as `--ci` lists.                  |
+| 130       | Stopped with Ctrl-C. What was done is kept.                                     |
+| 143, 129  | Stopped by a signal, or the terminal closed. The app it started is stopped too. |
 
 ## Signing in
 

package/assets/login-CFKpL6IN.js

@@ -0,0 +1 @@
+export { t as loginCommand } from "./login-DUhawk3O.js";

package/assets/{login-DeGa63BQ.js → login-DUhawk3O.js}

@@ -8,20 +8,96 @@ import { emitKeypressEvents } from "node:readline";
 import { request as request$1 } from "node:https";
 import { checkServerIdentity } from "node:tls";
 // src/ui.ts
-var color = process.stdout.isTTY && !process.env.NO_COLOR;
-var unicode = process.env.TERM !== "dumb" && !process.env.MODELOS_SECURE_ASCII;
+var env = process.env;
+var tty = Boolean(process.stdout.isTTY);
+var color = tty && !env.NO_COLOR;
+/** Whether the terminal takes 24-bit colour, so the app's own tokens can be used; else the basic eight. */
+var trueColor = color && /truecolor|24bit/i.test(env.COLORTERM ?? "") ? true : false;
+/**
+* Unicode marks, unless the terminal is known not to show them: a dumb terminal, or a Windows
+* console outside Windows Terminal, whose code page is often not UTF-8.
+*/
+var unicode = env.TERM !== "dumb" && !env.MODELOS_SECURE_ASCII && !(process.platform === "win32" && !env.WT_SESSION && !env.TERM_PROGRAM);
+/** Terminals that draw OSC 8 links as links; the rest get the address in words. */
+var linksWork = tty && Boolean(env.WT_SESSION || /^(iTerm\.app|vscode|WezTerm|Hyper|ghostty|kitty|WarpTerminal)$/.test(env.TERM_PROGRAM ?? "") || Number(env.VTE_VERSION ?? 0) >= 5e3 || env.KONSOLE_VERSION);
+var TOKENS = {
+	red: {
+		rgb: [
+			196,
+			42,
+			30
+		],
+		basic: "31"
+	},
+	blue: {
+		rgb: [
+			29,
+			88,
+			194
+		],
+		basic: "34"
+	},
+	grey: {
+		rgb: [
+			93,
+			104,
+			128
+		],
+		basic: "90"
+	}
+};
 var paint = (code, text) => color ? `\u001b[${code}m${text}\u001b[0m` : text;
-var red = (t) => paint("31", t);
-var blue = (t) => paint("34", t);
-var grey = (t) => paint("90", t);
+var tone = (name, text) => paint(trueColor ? `38;2;${TOKENS[name].rgb.join(";")}` : TOKENS[name].basic, text);
+var red = (t) => tone("red", t);
+var blue = (t) => tone("blue", t);
+var grey = (t) => tone("grey", t);
 var bold = (t) => paint("1", t);
-var interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY) && !process.env.CI;
+var interactive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY) && !env.CI;
 var pointer = unicode ? "›" : ">";
+/** The marks beside a step, a need or a result: done, not met, could not tell. Plain letters off Unicode. */
+var mark = {
+	yes: unicode ? "✓" : "+",
+	no: unicode ? "✗" : "x",
+	maybe: "?",
+	dot: unicode ? "·" : "-"
+};
+var plural = (n, one, many = `${one}s`) => `${n.toLocaleString("en-GB")} ${n === 1 ? one : many}`;
+/** The terminal's width, 80 off a terminal or when it will not say. */
+var columns = () => process.stdout.columns || 80;
+/** Visible length: escape sequences take no room. */
+var visible = (text) => text.replace(/\u001b\][^\u0007]*\u0007|\u001b\[[0-9;]*m/g, "").length;
+/**
+* Text wrapped to the terminal, each later line indented like the first word. A word longer than
+* the width is left whole, so an address is never cut.
+*/
+function wrap(text, width = columns(), indent) {
+	return text.split("\n").map((line) => {
+		if (visible(line) <= width) return line;
+		const lead = indent ?? /^\s*/.exec(line)?.[0].length ?? 0;
+		const pad = " ".repeat(lead);
+		const words = line.trim().split(/\s+/).filter(Boolean);
+		const lines = [];
+		let current = "";
+		for (const word of words) {
+			const next = current ? `${current} ${word}` : word;
+			if (current && lead + visible(next) > width) {
+				lines.push(pad + current);
+				current = word;
+			} else current = next;
+		}
+		if (current || lines.length === 0) lines.push(pad + current);
+		return lines.join("\n");
+	}).join("\n");
+}
+/** Says a line, wrapped to the terminal. Off a terminal, lines stay whole for a log. */
 function say(line = "") {
-	console.log(line);
+	console.log(tty ? wrap(line) : line);
 }
+/** An address a person can open: a link where the terminal draws one, the address in words elsewhere. */
+var link = (text, url) => linksWork ? `\u001b]8;;${url}\u0007${text}\u001b]8;;\u0007` : text === url ? url : `${text} ${grey(url)}`;
 var STEP_WIDTH = 13;
 var lastStep = "";
+var stepStarted = Date.now();
 /** The last step that finished, so a stop can say where it happened. */
 var lastFinishedStep = () => lastStep;
 /** Work to finish before the process ends on Ctrl-C, such as stopping a review it started. */
@@ -35,19 +111,51 @@ function beforeStopping(work) {
 async function finishBeforeStopping() {
 	await Promise.race([Promise.allSettled(onStop.map((work) => work())), new Promise((resolve) => setTimeout(resolve, 5e3))]);
 }
+/** A span of time in a few characters: "0.4 s", "12 s", "3 min 05 s". */
+function elapsed(ms) {
+	if (ms < 1e4) return `${(ms / 1e3).toFixed(1)} s`;
+	if (ms < 6e4) return `${Math.round(ms / 1e3).toString()} s`;
+	const minutes = Math.floor(ms / 6e4);
+	const seconds = Math.round(ms % 6e4 / 1e3);
+	return `${minutes.toString()} min ${seconds.toString().padStart(2, "0")} s`;
+}
 /**
 * One line that changes in place while work goes on, at a terminal only: what is being read now.
 * An empty line clears it. Off a terminal it writes nothing, so a log holds only finished steps.
 */
 function status(line) {
-	if (!process.stdout.isTTY) return;
-	const width = Math.max(20, (process.stdout.columns || 80) - 4);
+	if (!tty) return;
+	const width = Math.max(20, columns() - 4);
 	process.stdout.write(`\r\u001b[2K${line ? `  ${grey(line.slice(0, width))}` : ""}`);
 }
+/**
+* A step that finished: its mark, its name in a fixed column, what it found, and how long it took
+* since the step before, at the right edge. A step still asking or waiting has no mark yet.
+*/
 function step(name, detail, state = "done") {
-	if (state === "done") lastStep = name;
-	const right = state === "done" ? "done" : "";
-	say(`  ${bold(name.padEnd(STEP_WIDTH))}${detail}${right ? `  ${grey(right)}` : ""}`);
+	const now = Date.now();
+	const took = state === "done" && now - stepStarted >= 100 ? grey(elapsed(now - stepStarted)) : "";
+	if (state === "done") {
+		lastStep = name;
+		stepStarted = now;
+	}
+	const lead = `  ${state === "done" ? mark.yes : " "} ${bold(name.padEnd(STEP_WIDTH))}`;
+	const room = columns() - visible(lead) - visible(took) - 2;
+	const body = tty && visible(detail) > room && room > 20 ? wrap(detail, room, 0).split("\n").map((l, i) => i === 0 ? l : " ".repeat(visible(lead)) + l).join("\n") : detail;
+	const first = body.split("\n")[0] ?? "";
+	const gap = Math.max(2, columns() - visible(lead) - visible(first) - visible(took) - 1);
+	const rest = body.split("\n").slice(1);
+	console.log(`${lead}${first}${took ? `${" ".repeat(tty ? gap : 2)}${took}` : ""}${rest.length ? `\n${rest.join("\n")}` : ""}`);
+}
+/** Rows of label and value, the labels in one column, the values wrapped beside them. */
+function rows(items) {
+	const width = Math.max(...items.map(([label]) => label.length)) + 2;
+	for (const [label, value] of items) {
+		const lead = `  ${grey(label.padEnd(width))}`;
+		const room = columns() - 2 - width;
+		const lines = (tty ? wrap(value, room, 0) : value).split("\n");
+		console.log(`${lead}${lines[0] ?? ""}${lines.slice(1).map((l) => `\n${" ".repeat(2 + width)}${l}`).join("")}`);
+	}
 }
 var RECOMMENDED = "   (recommended)";
 /**
@@ -687,4 +795,4 @@ async function loginCommand(given = {}) {
 	const who = connection.google?.email;
 	say(`Saved. This machine now works in ${me.workspace}${who ? `, signed in to Google as ${who}` : ""}.`);
 }
-export { lastFinishedStep as _, apiClient as a, status as b, Interrupted as c, beforeStopping as d, blue as f, interactive as g, grey as h, IapRefusal as i, ask as l, finishBeforeStopping as m, parseLoginLine as n, atAddress as o, bold as p, ApiError as r, readConnection as s, loginCommand as t, askText as u, red as v, step as x, say as y };
+export { rows as C, step as E, red as S, status as T, interactive as _, apiClient as a, mark as b, Interrupted as c, beforeStopping as d, blue as f, grey as g, finishBeforeStopping as h, IapRefusal as i, ask as l, elapsed as m, parseLoginLine as n, atAddress as o, bold as p, ApiError as r, readConnection as s, loginCommand as t, askText as u, lastFinishedStep as v, say as w, plural as x, link as y };