modelos-secure 0.3.5 → 0.3.6

package/README.md

@@ -24,6 +24,8 @@ At a terminal, `modelos-secure` on its own starts a session about the app in the
 | `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, 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.

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 };

package/cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import { _ as lastFinishedStep, a as apiClient, b as status, c as Interrupted, d as beforeStopping, f as blue, g as interactive, h as grey, i as IapRefusal, l as ask, m as finishBeforeStopping, o as atAddress, p as bold, r as ApiError$1, s as readConnection, t as loginCommand, u as askText, v as red, x as step, y as say } from "./assets/login-DeGa63BQ.js";
+import { C as rows, E as step, S as red, T as status, _ as interactive, a as apiClient, b as mark, c as Interrupted, d as beforeStopping, f as blue, g as grey, h as finishBeforeStopping, i as IapRefusal, l as ask, m as elapsed, o as atAddress, p as bold, r as ApiError$1, s as readConnection, t as loginCommand, u as askText, v as lastFinishedStep, w as say, x as plural, y as link } from "./assets/login-DUhawk3O.js";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { basename, delimiter, dirname, extname, join, posix, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
 import { access, appendFile, constants, glob, lstat, mkdir, readFile, readdir, realpath, rename, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { spawn } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { execFile, spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { createServer, request } from "node:http";
 import { connect, createConnection, createServer as createServer$1 } from "node:net";
@@ -23,7 +23,7 @@ if (existsSync(resolve(here, "wasm"))) {
 }
 // package.json
 var name = "modelos-secure";
-var version$1 = "0.3.5";
+var version$1 = "0.3.6";
 var type = "module";
 var bin = { "modelos-secure": "dist/cli.js" };
 var exports$1 = { "./hook": "./dist/hook/hook.mjs" };
@@ -140,6 +140,12 @@ function parseClause(part) {
 		arg: contains[1],
 		text: contains[2]
 	};
+	const lacks = part.match(/^([\w.]+)\s+lacks\s+["'](.*)["']$/);
+	if (lacks) return {
+		kind: "lacks",
+		arg: lacks[1],
+		text: lacks[2]
+	};
 	const compare = part.match(/^([\w.]+)\s*(>=|<=|==|!=|>|<)\s*["']?([^"']+)["']?$/);
 	if (compare) return {
 		kind: "compare",
@@ -158,6 +164,7 @@ function clauseHolds(clause, call, canaries) {
 	if (clause.kind === "called") return true;
 	const value = readArg(call.args, clause.arg);
 	if (clause.kind === "contains-canary") return findCanary(value === void 0 ? JSON.stringify(call.args) : stringify$1(value), canaries) !== void 0;
+	if (clause.kind === "lacks") return value === void 0 || !stringify$1(value).toLowerCase().includes(clause.text.toLowerCase());
 	if (value === void 0) return false;
 	const text = stringify$1(value);
 	if (clause.kind === "contains") return text.includes(clause.text);
@@ -11839,7 +11846,8 @@ var System = object({
 			"scan",
 			"http",
 			"openai-compatible",
-			"mcp"
+			"mcp",
+			"model"
 		]),
 		reach: object({
 			readsReplies: boolean(),
@@ -11848,18 +11856,33 @@ var System = object({
 		}),
 		runner: string(),
 		ownership: object({
-			/** `read-only`: nothing is sent but reads, as for an MCP server, so nothing needs proving. */
+			/**
+			* `read-only`: nothing is sent but reads, as for an MCP server, so nothing needs proving.
+			* `key`: a hosted model is the workspace's by the key it pasted; `project`: a model in this
+			* project, called with the project's own credentials. docs/spec/06-connecting.md
+			*/
 			how: _enum([
 				"code",
 				"dns",
 				"header",
-				"read-only"
+				"read-only",
+				"key",
+				"project"
 			]),
 			checkedAt: Timestamp
 		}),
 		secretRefs: array(string()),
 		/** For a system reached over HTTP, how to send it a message. */
-		endpoint: Endpoint.optional()
+		endpoint: Endpoint.optional(),
+		/**
+		* For a model on its own: where it runs and its name. A model behind an OpenAI-compatible API
+		* also has an endpoint, the chat completions request with the key as a secret; a model in this
+		* project is called through our own clients. ADR 0104.
+		*/
+		model: object({
+			provider: _enum(["vertex", "openai"]),
+			name: string()
+		}).optional()
 	}),
 	fingerprint: string(),
 	map: SystemMap.optional(),
@@ -12309,7 +12332,9 @@ var PolicyVersion = object({
 	/** Areas of the standard policy the document does not cover. */
 	gaps: array(string()),
 	/** Clauses the model proposed whose quote was not found in the document, so they were left out. */
-	dropped: number().default(0)
+	dropped: number().default(0),
+	/** Clauses left out because they could not be cleared for child safety, K-1. Not counted in `dropped`. ADR 0109. */
+	minors: number().default(0)
 });
 var PolicyRecord = object({
 	id: string(),
@@ -12407,10 +12432,116 @@ var TokenRecord = object({
 });
 /**
 * Parts of the product that are built but not yet shown, each switched on by the FEATURES
-* setting. A part leaves this list once it fully works and is released. See ADR 0057.
+* setting. A part leaves this list once it fully works and is released. See ADR 0057. The
+* Playground left it on 9 November 2026 (ADR 0105); nothing is on the list today.
+*/
+var FEATURE_NAMES = [];
+var Feature = string().refine((name) => FEATURE_NAMES.includes(name), "not a part of the product");
+/** How the marked part of a payload is changed before it is sent. docs/spec/08-screens.md#playground */
+var Transform = _enum([
+	"as-written",
+	"lookalikes",
+	"hidden-tags",
+	"encoded",
+	"another-language",
+	"split"
+]);
+/** One side of a run: the system it goes to, and the way in it takes. */
+var PlaygroundSide = object({
+	systemId: DocId,
+	systemName: string(),
+	/** The version answering as the run started, so a result says which one it was. */
+	fingerprint: string(),
+	versionLabel: string().optional(),
+	/** The way in from the system's map that carries the payload: `conversation`, or a planted way. */
+	wayIn: string(),
+	/** Another system prompt in place of the deployed one, where the connection carries it. */
+	systemPrompt: string().optional()
+});
+/** What one variant did on one side. The reply is trimmed and has secrets and markers masked. */
+var PlaygroundItem = object({
+	variant: number(),
+	outcome: Outcome,
+	/** The rule that broke or was steered at, when one was. */
+	rule: string().optional(),
+	/** The reason a grader gave, when the decision was graded. */
+	reason: string().optional(),
+	reply: string(),
+	heldCalls: array(object({
+		tool: string(),
+		args: record(string(), unknown())
+	})).default([]),
+	latencyMs: number(),
+	inputTokens: number().default(0),
+	outputTokens: number().default(0),
+	error: string().optional()
+});
+/** A scenario as it was read back and confirmed: the three parts, edited by the person. */
+var Scenario = object({
+	text: string(),
+	/** The rule it tests, in one line. */
+	rule: string(),
+	how: _enum(["exact", "graded"]),
+	/** Exact: a rule check in the rule language, on `reply` or a tool. Graded: the question the grader answers. */
+	decide: string(),
+	/** The setup in one line: the way in and the turns. */
+	setup: string(),
+	/** Whether each variation is planted at the way in or said in the conversation. */
+	planted: boolean().default(false)
+});
+var PlaygroundRun = object({
+	id: string(),
+	mode: _enum(["one", "side"]),
+	try: _enum(["message", "scenario"]),
+	startedBy: string(),
+	startedAt: Timestamp,
+	finishedAt: Timestamp.optional(),
+	status: _enum([
+		"queued",
+		"running",
+		"done",
+		"failed"
+	]),
+	sides: array(PlaygroundSide).min(1).max(2),
+	/** What is sent. Text between § marks is the payload; transforms and variants change only that. */
+	payload: string(),
+	/** For a planted way in, what the user then says. */
+	then: string().optional(),
+	transform: Transform.default("as-written"),
+	/** For `another-language`, which one. */
+	language: string().optional(),
+	/** How many variants go to each side: 1, or 20. */
+	n: number(),
+	scenario: Scenario.optional(),
+	/** The payloads as sent, one per variant, after the transform. Two per variant when split. */
+	variants: array(string()).default([]),
+	/** Results so far, one list per side, in the order replies came (Firestore holds no nested arrays). */
+	results: array(object({ items: array(PlaygroundItem) })).default([]),
+	/** Our spend on this run: writing variants, translating, grading. The target's calls are its own. */
+	costUsd: number().default(0),
+	failedBecause: string().optional(),
+	/** The team check this run was saved as, when it was. */
+	savedAs: string().optional()
+});
+/**
+* A check a team wrote itself, most often from a scenario tried in the Playground. It has the parts
+* of a built-in check. docs/spec/07-checks.md#writing-your-own-check
 */
-var FEATURE_NAMES = ["playground"];
-var Feature = _enum(FEATURE_NAMES);
+var TeamCheck = object({
+	id: string(),
+	name: string(),
+	/** What it tests, in the team's words. */
+	what: string(),
+	how: _enum(["exact", "graded"]),
+	decide: string(),
+	setup: string(),
+	planted: boolean().default(false),
+	by: string(),
+	at: Timestamp,
+	from: _enum(["playground", "by-hand"]),
+	fromRun: string().optional(),
+	systems: array(DocId)
+});
 // ../../packages/schema/src/protocol.ts
 /** One thing for the runner to do. Sent only over the runner route, never stored in Firestore. */
 var RunnerAttempt = object({
@@ -20914,7 +21045,7 @@ async function onPath(name, env = process.env) {
 	}
 	return false;
 }
-var exists = (path) => access(path).then(() => true, () => false);
+var exists$1 = (path) => access(path).then(() => true, () => false);
 async function scriptsIn(dir) {
 	const text = await readFile(join(dir, "package.json"), "utf8").catch(() => "{}");
 	try {
@@ -20967,8 +21098,350 @@ async function whyNotRunnable(dir, command) {
 		} else if (named === "start" && !("start" in await scriptsIn(dir))) return "package.json has no start script";
 	}
 	const file = [first, ...words.slice(1)].find((w) => /\.(m?js|cjs|ts|py|sh)$/.test(w));
-	if (file && !await exists(join(dir, file))) return `${file} is not in this repository`;
-	if (!(await exists(join(dir, first)) || await exists(join(dir, "node_modules", ".bin", first))) && !await onPath(first)) return words.length >= 3 && !/[-./:=]/.test(command) ? "it reads as a sentence, not a command" : `${first} is not installed on this machine`;
+	if (file && !await exists$1(join(dir, file))) return `${file} is not in this repository`;
+	const venvBin = process.platform === "win32" ? "Scripts" : "bin";
+	if (!(await exists$1(join(dir, first)) || await exists$1(join(dir, "node_modules", ".bin", first)) || await exists$1(join(dir, ".venv", venvBin, first)) || await exists$1(join(dir, ".venv", venvBin, `${first}.exe`))) && !await onPath(first)) return words.length >= 3 && !/[-./:=]/.test(command) ? "it reads as a sentence, not a command" : `${first} is not installed on this machine`;
+	return null;
+}
+// src/needs.ts
+var GOOGLE_DEPS = /^(google-cloud-aiplatform|google-genai|google-generativeai|vertexai|google-cloud-[a-z-]+|@google-cloud\/.+|@google\/genai|langchain-google-vertexai|langchain-google-genai|@langchain\/google-vertexai)$/;
+var AWS_DEPS = /^(boto3|botocore|aws-sdk|@aws-sdk\/.+|langchain-aws|@langchain\/aws)$/;
+/**
+* The needs the code and settings declare. A dependency on a cloud's client library needs that
+* cloud's sign-in; a setting whose name is a key needs a value; a compose file's services need to
+* be answering; a database address needs a database.
+*/
+function needsOf(input) {
+	const needs = [];
+	const deps = [...input.dependencies];
+	const settings = new Set(input.settingNames);
+	const env = input.env ?? {};
+	const google = deps.find((d) => GOOGLE_DEPS.test(d));
+	if (google || settings.has("GOOGLE_CLOUD_PROJECT") || settings.has("GOOGLE_APPLICATION_CREDENTIALS")) needs.push({
+		kind: "google-adc",
+		what: "Google Cloud, through Application Default Credentials",
+		from: google ? `the dependency ${google}` : "the setting GOOGLE_CLOUD_PROJECT",
+		command: "gcloud auth application-default login"
+	});
+	if (input.startCommands.some((c) => /\bgcloud\b/.test(c.command))) needs.push({
+		kind: "gcloud",
+		what: "gcloud signed in, for a script that calls it",
+		from: input.startCommands.find((c) => /\bgcloud\b/.test(c.command)).from,
+		command: "gcloud auth login"
+	});
+	const aws = deps.find((d) => AWS_DEPS.test(d));
+	if (aws || [...settings].some((s) => /^AWS_/.test(s))) needs.push({
+		kind: "aws",
+		what: "AWS credentials, a profile or a signed-in SSO session",
+		from: aws ? `the dependency ${aws}` : "a setting that starts with AWS_",
+		command: env.AWS_PROFILE ? "aws sso login" : "aws configure, or aws sso login"
+	});
+	const azure = deps.find((d) => /^(azure-identity|@azure\/identity)$/.test(d));
+	if (azure || [...settings].some((s) => /^AZURE_/.test(s) && !/KEY|SECRET/.test(s))) needs.push({
+		kind: "azure",
+		what: "Azure, signed in",
+		from: azure ? `the dependency ${azure}` : "a setting that starts with AZURE_",
+		command: "az login"
+	});
+	for (const name of settings) if (/(_API_KEY|_KEY|_TOKEN|_SECRET)$/.test(name) && !/^(GOOGLE_APPLICATION)/.test(name)) needs.push({
+		kind: "api-key",
+		what: `${name}, a key the app reads from its environment`,
+		from: "the example settings files",
+		setting: name
+	});
+	for (const name of settings) {
+		const address = databaseAddress(name, env[name]);
+		if (address) needs.push({
+			kind: "database",
+			what: `a database answering at ${address.host}:${address.port.toString()}`,
+			from: `the setting ${name}`,
+			address,
+			setting: name
+		});
+	}
+	for (const service of input.compose?.services ?? []) for (const port of service.ports) needs.push({
+		kind: "service",
+		what: `${service.name} from ${input.compose.file}, answering on port ${port.toString()}`,
+		from: input.compose.file,
+		address: {
+			host: "127.0.0.1",
+			port
+		},
+		command: `docker compose up -d ${service.name}`
+	});
+	return needs;
+}
+var DATABASE_SETTINGS = /^(DATABASE_URL|POSTGRES_URL|PG_URL|MONGO_URI|MONGODB_URI|REDIS_URL|MYSQL_URL)$/;
+var DEFAULT_PORTS = {
+	postgres: 5432,
+	postgresql: 5432,
+	mysql: 3306,
+	mongodb: 27017,
+	redis: 6379
+};
+/** Where a database setting points, when its value is a URL with a host; a name alone says nothing. */
+function databaseAddress(name, value) {
+	if (!DATABASE_SETTINGS.test(name) || !value) return null;
+	try {
+		const url = new URL(value);
+		const scheme = url.protocol.replace(/:$/, "").split("+")[0] ?? "";
+		const port = Number(url.port) || DEFAULT_PORTS[scheme];
+		if (!url.hostname || !port) return null;
+		return {
+			host: url.hostname,
+			port
+		};
+	} catch {
+		return null;
+	}
+}
+/** The services a compose file declares, with the host ports they publish. Read in code, no YAML library. */
+function composeServices(text) {
+	const lines = text.split(/\r?\n/);
+	const services = [];
+	let inServices = false;
+	let current = null;
+	let inPorts = false;
+	for (const raw of lines) {
+		const line = raw.replace(/#.*$/, "").trimEnd();
+		if (!line.trim()) continue;
+		const indent = line.length - line.trimStart().length;
+		if (indent === 0) {
+			inServices = /^services:\s*$/.test(line);
+			current = null;
+			continue;
+		}
+		if (!inServices) continue;
+		if (indent === 2 && /^\s{2}[\w.-]+:\s*$/.test(line)) {
+			current = {
+				name: line.trim().replace(/:$/, ""),
+				ports: []
+			};
+			services.push(current);
+			inPorts = false;
+			continue;
+		}
+		if (!current) continue;
+		if (/^\s{4}ports:\s*$/.test(line)) {
+			inPorts = true;
+			continue;
+		}
+		if (indent === 4) inPorts = false;
+		if (inPorts) {
+			const m = /^\s+-\s*["']?([\w.:-]+?)["']?\s*$/.exec(line);
+			if (!m) continue;
+			const parts = m[1].split("/")[0].split(":");
+			const host = parts.length === 3 ? parts[1] : parts[0];
+			if (host && /^\d+$/.test(host)) current.ports.push(Number(host));
+		}
+	}
+	return services;
+}
+/** The need an app's own failure names, from the words the libraries print. */
+function needFromOutput(output) {
+	if (/DefaultCredentialsError|could not automatically determine credentials|Could not load the default credentials|Your default credentials were not found|GOOGLE_APPLICATION_CREDENTIALS/i.test(output)) return {
+		kind: "google-adc",
+		what: "Google Cloud, through Application Default Credentials",
+		from: "the app's own error",
+		command: "gcloud auth application-default login"
+	};
+	if (/NoCredentialsError|Unable to locate credentials|CredentialsProviderError|Could not load credentials from any providers|ExpiredToken|The SSO session associated with this profile has expired/i.test(output)) return {
+		kind: "aws",
+		what: "AWS credentials, a profile or a signed-in SSO session",
+		from: "the app's own error",
+		command: /SSO session|sso/i.test(output) ? "aws sso login" : "aws configure, or aws sso login"
+	};
+	if (/AADSTS\d+|DefaultAzureCredential failed|Please run 'az login'|CredentialUnavailableError/i.test(output)) return {
+		kind: "azure",
+		what: "Azure, signed in",
+		from: "the app's own error",
+		command: "az login"
+	};
+	const refused = /ECONNREFUSED\s+(?:\[?([\w.:-]+?)\]?):(\d+)|connection refused.*?(?:at|to)\s+([\w.-]+):(\d+)|could not connect to server:.*?"?([\w.-]+)"?.*?port (\d+)/i.exec(output);
+	if (refused) {
+		const host = refused[1] ?? refused[3] ?? refused[5] ?? "127.0.0.1";
+		const port = Number(refused[2] ?? refused[4] ?? refused[6]);
+		return {
+			kind: "service",
+			what: `something answering at ${host}:${port.toString()}`,
+			from: "the app's own error",
+			address: {
+				host,
+				port
+			}
+		};
+	}
+	return null;
+}
+/** Whether a need is met on this machine, without changing anything. */
+async function checkNeed(need, env = process.env) {
+	switch (need.kind) {
+		case "google-adc": {
+			const file = env.GOOGLE_APPLICATION_CREDENTIALS;
+			if (file && await exists(file)) return {
+				need,
+				met: true,
+				detail: `GOOGLE_APPLICATION_CREDENTIALS points at ${file}`
+			};
+			const adc = join(adcDir(env), "application_default_credentials.json");
+			return await exists(adc) ? {
+				need,
+				met: true,
+				detail: "Application Default Credentials are on this machine"
+			} : {
+				need,
+				met: false,
+				detail: `no credentials at ${adc}`
+			};
+		}
+		case "gcloud": {
+			const account = await run("gcloud", [
+				"auth",
+				"list",
+				"--filter=status:ACTIVE",
+				"--format=value(account)"
+			]);
+			if (account === null) return {
+				need,
+				met: "unknown",
+				detail: "gcloud is not installed"
+			};
+			return account ? {
+				need,
+				met: true,
+				detail: `gcloud is signed in as ${account}`
+			} : {
+				need,
+				met: false,
+				detail: "gcloud is not signed in"
+			};
+		}
+		case "aws": {
+			if (env.AWS_ACCESS_KEY_ID) return {
+				need,
+				met: true,
+				detail: "AWS keys are in the environment"
+			};
+			const home = env.HOME ?? env.USERPROFILE ?? homedir();
+			const credentials = await exists(join(home, ".aws", "credentials"));
+			const config = await exists(join(home, ".aws", "config"));
+			if (!credentials && !config) return {
+				need,
+				met: false,
+				detail: "no AWS profile on this machine"
+			};
+			const who = await run("aws", [
+				"sts",
+				"get-caller-identity",
+				"--query",
+				"Arn",
+				"--output",
+				"text"
+			]);
+			if (who === null) return {
+				need,
+				met: "unknown",
+				detail: "a profile is on this machine; the aws command is not"
+			};
+			return who ? {
+				need,
+				met: true,
+				detail: `AWS answers as ${who}`
+			} : {
+				need,
+				met: false,
+				detail: "the AWS profile is there, but its session is not signed in"
+			};
+		}
+		case "azure": {
+			const who = await run("az", [
+				"account",
+				"show",
+				"--query",
+				"user.name",
+				"-o",
+				"tsv"
+			]);
+			if (who === null) return {
+				need,
+				met: "unknown",
+				detail: "the az command is not installed"
+			};
+			return who ? {
+				need,
+				met: true,
+				detail: `Azure is signed in as ${who}`
+			} : {
+				need,
+				met: false,
+				detail: "Azure is not signed in"
+			};
+		}
+		case "api-key": return env[need.setting] ? {
+			need,
+			met: true,
+			detail: `${need.setting} is set`
+		} : {
+			need,
+			met: false,
+			detail: `${need.setting} is not set here; a settings file can hold a staging value`
+		};
+		case "database":
+		case "service": return await portOpen(need.address.host, need.address.port) ? {
+			need,
+			met: true,
+			detail: `${need.address.host}:${need.address.port.toString()} answers`
+		} : {
+			need,
+			met: false,
+			detail: `nothing answers at ${need.address.host}:${need.address.port.toString()}`
+		};
+	}
+}
+var adcDir = (env) => env.CLOUDSDK_CONFIG ?? (process.platform === "win32" ? join(env.APPDATA ?? join(env.USERPROFILE ?? homedir(), "AppData", "Roaming"), "gcloud") : join(env.HOME ?? homedir(), ".config", "gcloud"));
+var exists = (path) => access(path).then(() => true, () => false);
+/** A command's trimmed output, "" when it fails, null when it is not installed. */
+function run(command, args) {
+	return new Promise((resolve) => {
+		execFile(command, args, {
+			timeout: 15e3,
+			windowsHide: true
+		}, (error, stdout) => {
+			if (error && error.code === "ENOENT") return resolve(null);
+			resolve(error ? "" : stdout.trim());
+		});
+	});
+}
+var portOpen = (host, port) => new Promise((resolve) => {
+	const socket = createConnection({
+		host,
+		port,
+		timeout: 1500
+	});
+	socket.once("connect", () => {
+		socket.destroy();
+		resolve(true);
+	});
+	socket.once("error", () => resolve(false));
+	socket.once("timeout", () => {
+		socket.destroy();
+		resolve(false);
+	});
+});
+/** The compose file in a folder, read as the services it declares, or null. */
+async function composeIn(dir) {
+	for (const file of [
+		"compose.yaml",
+		"compose.yml",
+		"docker-compose.yml",
+		"docker-compose.yaml"
+	]) {
+		const text = await readFile(join(dir, file), "utf8").catch(() => null);
+		if (text !== null) return {
+			file,
+			services: composeServices(text)
+		};
+	}
 	return null;
 }
 // ../../hooks/node/src/hosts.mjs
@@ -21478,7 +21951,8 @@ async function knownIn(ctx) {
 		settings: found.settingNames,
 		settingsFiles: found.settingsFiles,
 		files: [...found.sourceFiles, ...found.documents].slice(0, 400),
-		tools: ctx.config.tools.map((t) => t.name)
+		tools: ctx.config.tools.map((t) => t.name),
+		dependencies: [...found.dependencies]
 	};
 }
 /** Commands a fix might start with, kept when this machine has them on its PATH. */
@@ -21638,6 +22112,60 @@ var notKnown = {
 		throw new Failure("Then the app cannot be started yet. Your other answers are kept. When you know the command, put it under start: in modelos-secure.yaml, or run the same command again and type it.", []);
 	}
 };
+/**
+* What the app needs, from its dependencies, settings and compose file, each checked here. A need
+* that is not met and has a command stops the start with that command named; the person may have
+* it run, on a plain yes, or start anyway.
+*/
+async function sayNeeds(ctx) {
+	const known = await knownIn(ctx);
+	const env = {
+		...process.env,
+		...ctx.extraEnv
+	};
+	const needs = needsOf({
+		dependencies: known.dependencies,
+		settingNames: known.settings,
+		startCommands: ctx.startCommands,
+		compose: await composeIn(ctx.dir) ?? void 0,
+		env
+	});
+	if (needs.length === 0) return;
+	const states = await Promise.all(needs.map((n) => checkNeed(n, env)));
+	step("Needs", plural(needs.length, "thing") + " the app relies on");
+	for (const state of states) say(`    ${state.met === true ? mark.yes : state.met === false ? mark.no : mark.maybe} ${state.need.what}${grey(`, ${state.detail}`)}`);
+	const unmet = states.find((s) => s.met === false && s.need.kind !== "api-key");
+	if (unmet) throw new Failure(`The app needs ${unmet.need.what}, and that is not met: ${unmet.detail}.`, needFixes(ctx, unmet.need), unmet.need.command ? `Run ${unmet.need.command}.` : void 0);
+}
+/** The ways past a need that is not met: a login run for the person on a plain yes, or on regardless. */
+function needFixes(ctx, need) {
+	const fixes = [];
+	if (need.command && !need.command.includes(", or ")) fixes.push({
+		label: `Run ${need.command} for me now`,
+		recommended: true,
+		needsPerson: true,
+		apply: () => runForPerson(need.command)
+	});
+	fixes.push({
+		label: "Start anyway",
+		apply: () => {
+			ctx.startAnyway = true;
+		}
+	});
+	return fixes;
+}
+/** Runs a login command the person asked for, in their terminal, and waits for it. */
+function runForPerson(command) {
+	say(`\n  Running ${bold(command)}. It may open your browser.\n`);
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, {
+			shell: true,
+			stdio: "inherit"
+		});
+		child.once("exit", (code) => code === 0 ? resolve() : reject(new Failure(`${command} ended with code ${String(code)}.`, [])));
+		child.once("error", reject);
+	});
+}
 /** Starts the pool, or fails with what happened and how to fix it. */
 async function startApp(ctx, instances) {
 	const { config } = ctx;
@@ -21714,6 +22242,7 @@ async function startApp(ctx, instances) {
 	}]);
 	const settings = await loadSettings(ctx.dir, config.start?.settings);
 	Object.assign(ctx.extraEnv, settings, ctx.extraEnv);
+	if (!ctx.startAnyway) await sayNeeds(ctx);
 	const basePort = await freePort();
 	const pool = await startAppPool({
 		config,
@@ -21735,6 +22264,8 @@ async function startApp(ctx, instances) {
 			notKnown
 		];
 		if (explained) throw new Failure(explained.what, [...await runnableFixes(ctx, explained.fixes), ...others], explained.cause);
+		const needed = output ? needFromOutput(output) : null;
+		if (needed) throw new Failure(`The app needs ${needed.what}, and it is not met: its own error says so.`, [...needFixes(ctx, needed), ...others], needed.command ? `Run ${needed.command}.` : void 0);
 		const missing = output ? missingSetting(output) : void 0;
 		if (missing && /(_API_KEY|_KEY|_TOKEN)$/.test(missing)) throw new Failure(`The app calls its model with ${missing}.`, settingsFixes(ctx, missing, Boolean(process.env[missing])));
 		if (missing) throw new Failure(`The app stopped: ${missing} is not set.`, settingsFixes(ctx, missing, false));
@@ -21994,6 +22525,7 @@ function toRegister(config, parts, extra) {
 }
 // src/commands/review.ts
 async function reviewCommand(dir, options) {
+	const startedAt = Date.now();
 	const config = await readConfig(dir);
 	if (!config) throw new Error("There is no modelos-secure.yaml here. Run modelos-secure scan . first.");
 	if (options.ci && (config.skipped?.length ?? 0) > 0) {
@@ -22098,7 +22630,7 @@ async function reviewCommand(dir, options) {
 	for (const f of relevant) say(`  ${f.status === "probable" ? "Probable" : red("Broke")} ${f.id} ${f.title} (${f.reproduced.k.toString()} of ${f.reproduced.n.toString()} replays)`);
 	if (relevant.length === 0 && last.review.status === "done") say(`  ${blue("No break")} on ${Object.keys(results?.paths ?? {}).length.toString()} paths${standIn ? ", against the stand-in attacker" : ""}.`);
 	else if (relevant.length > 0 && standIn) say("  The stand-in attacker wrote the attempts that broke it.");
-	say(`\n  Review: ${connection.url}/reviews/${last.review.id}`);
+	rows([["Review", link(`${connection.url}/reviews/${last.review.id}`, `${connection.url}/reviews/${last.review.id}`)], ["Took", elapsed(Date.now() - startedAt)]]);
 	const verdict = last.review.verdict;
 	if (verdict) {
 		say(`\n  New ${verdict.newBreaks.length.toString()}, fixed ${verdict.fixed.length.toString()}, holding so far ${verdict.holdingSoFar.length.toString()}, in both ${verdict.inBoth.length.toString()}, came back ${verdict.returning.length.toString()}.`);
@@ -22312,8 +22844,8 @@ var TOOL_POWERS = [
 	"delete"
 ];
 var CONSENT_TEXT = "To understand your app, the scan lets a model read your code the way an engineer would, on our own Google Cloud project. It starts from an outline: file paths, the names and signatures of functions and classes, your prompts and the names of your settings. Then it asks for the files and lines it needs, and only those are sent, each through a filter that takes secrets out. It never sends settings files, keys, certificates or credential files, the values of your settings, or files over 1 MB. Every answer it sends is listed in .modelos-secure/sent.jsonl. Run with --explain to see what may be read, or --offline to keep everything here.";
-var plural = (n, one, many = `${one}s`) => `${n.toLocaleString("en-GB")} ${n === 1 ? one : many}`;
 async function scanCommand(dir, options) {
+	const startedAt = Date.now();
 	const retry = {
 		yes: options.yes,
 		ci: options.ci
@@ -22418,7 +22950,7 @@ async function scanCommand(dir, options) {
 				label: "Enter a token now",
 				recommended: true,
 				apply: async () => {
-					const { loginCommand } = await import("./assets/login-Dz4o-1cM.js");
+					const { loginCommand } = await import("./assets/login-CFKpL6IN.js");
 					await loginCommand();
 					const fresh = await readConnection();
 					api = fresh ? apiClient(fresh) : null;
@@ -22587,12 +23119,16 @@ async function scanCommand(dir, options) {
 	step("Register", `The map is saved to the workspace`);
 	const paths = (config.ways_in.length || 1) * (config.rules.length || 1);
 	say(`\n  ${bold(`${config.system} is connected.`)}\n`);
-	say(`  ${`${plural(config.ways_in.length, "way")} in`.padEnd(14)} ${config.ways_in.map((w) => w.name).join(", ")}`);
 	const heldNow = held(config);
-	say(`  ${plural(config.tools.length, "tool").padEnd(14)} ${config.tools.length === 0 ? "none to hold" : heldNow.length === 0 ? "none held during reviews" : `${heldNow.length.toString()} held during reviews: ${heldNow.join(", ")}`}`);
-	say(`  ${plural(paths, "path").padEnd(14)} none tested yet\n`);
 	const url = connection ? `${connection.url}/systems/${system.id}` : "";
-	say(`  Map:  ${url}`);
+	rows([
+		["Ways in", `${config.ways_in.length.toString()}: ${config.ways_in.map((w) => w.name).join(", ")}`],
+		["Tools", config.tools.length === 0 ? "none to hold" : heldNow.length === 0 ? `${config.tools.length.toString()}, none held during reviews` : `${config.tools.length.toString()}, ${heldNow.length.toString()} held during reviews: ${heldNow.join(", ")}`],
+		["Paths", `${paths.toString()}, none tested yet`],
+		["Map", link(url, url)],
+		["Took", elapsed(Date.now() - startedAt)]
+	]);
+	say();
 	if (options.noReview || options.ci || options.yes || !interactive()) return;
 	if (await ask("Start a quick first review now? About 15 minutes.", "It starts the app on this machine with the hooks attached, checks they hold what they should, then reviews it.", [{
 		label: "Yes, start it",
@@ -22740,7 +23276,6 @@ var { values, positionals } = parseArgs({
 		format: { type: "string" },
 		out: { type: "string" },
 		system: { type: "string" },
-		against: { type: "string" },
 		url: { type: "string" },
 		"client-id": { type: "string" },
 		"client-secret": { type: "string" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelos-secure",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Tests AI systems for Security, Safety and Quality. One command connects a system from its code.",
   "license": "UNLICENSED",
   "repository": {

package/assets/login-Dz4o-1cM.js

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