@illuminis/comprism 0.1.3 → 0.1.5

package/out/commands/update.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdUpdate = cmdUpdate;
+/**
+ * `comprism update` and `comprism update --check` (manual 1.7).
+ *
+ * The service holds the release record; this compares it with the installed
+ * version and, only when asked, installs the newer one the same way this copy
+ * was installed (manual 1.1): npm for npm, the workspace's own install script
+ * for the install script, pip for Python. It never updates itself on its own
+ * and never moves a machine from one option to another. The sign in and
+ * settings live outside the program, so an update keeps them; a failed install
+ * leaves the old version.
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ui = __importStar(require("../lib/ui"));
+const gateway_1 = require("../lib/gateway");
+const self_1 = require("../lib/self");
+const version_1 = require("../lib/version");
+const install_1 = require("./install");
+const out = (s = "") => process.stdout.write(`${s}\n`);
+const METHOD_NAME = {
+    script: "the install script",
+    npm: "npm",
+    python: "Python (pip)",
+};
+/** The command that installs `version` the way this copy was installed. */
+function updateCommand(method, version) {
+    if (method === "npm") {
+        const target = process.env.COMPRISM_UPDATE_PACKAGE || `@illuminis/comprism@${version}`;
+        return process.platform === "win32"
+            ? { file: "npm.cmd", args: ["install", "-g", target], shell: true }
+            : { file: "npm", args: ["install", "-g", target] };
+    }
+    const base = (0, install_1.tenantBaseUrl)();
+    if (method === "script") {
+        if (!base)
+            return { manual: "comprism login, then comprism update" };
+        return process.platform === "win32"
+            ? { file: "powershell.exe", args: ["-NoProfile", "-Command", `irm ${base}/install.ps1 | iex`] }
+            : { file: "/bin/sh", args: ["-c", `curl -fsSL ${base}/install.sh | sh`] };
+    }
+    // Python: the interpreter of the environment pip installed into, when this
+    // copy sits in one (a virtual environment or pipx's). Anywhere else is a
+    // Python this tool has no business changing, so it says what to run.
+    const pin = `comprism-cli==${version}`;
+    const index = base ? ["--extra-index-url", `${base}/pypi/simple/`] : [];
+    const here = path.dirname(fs.realpathSync(process.execPath));
+    for (const name of process.platform === "win32" ? ["python.exe"] : ["python3", "python"]) {
+        const python = path.join(here, name);
+        if (fs.existsSync(python))
+            return { file: python, args: ["-m", "pip", "install", "--upgrade", ...index, pin] };
+    }
+    return { manual: `python3 -m pip install --upgrade ${index.join(" ")} ${pin}`.replace(/  +/g, " ") };
+}
+async function cmdUpdate(args) {
+    const reply = await (0, gateway_1.ask)({ intent: "release", prompt: "" });
+    const data = (reply.data ?? {});
+    if (!reply.ok || !data.latest) {
+        out(ui.fail(reply.message || "The service could not say which version is newest."));
+        return reply.ok ? 1 : 6;
+    }
+    const method = (0, self_1.installMethod)();
+    out(`  installed  ${version_1.COMPRISM_VERSION}, with ${METHOD_NAME[method]}`);
+    out(`  newest     ${data.latest}`);
+    if (!data.update_available) {
+        out(ui.ok("You have the newest version."));
+        return 0;
+    }
+    if (args.includes("--check")) {
+        out(`  A newer version is available. Install it with: comprism update`);
+        return 0;
+    }
+    const how = updateCommand(method, data.latest);
+    if ("manual" in how) {
+        out(ui.fail("This copy is in a Python this tool does not change. Update it with:"));
+        out(`      ${how.manual}`);
+        return 1;
+    }
+    out(ui.c.dim(`  updating with ${METHOD_NAME[method]} ...`));
+    const r = (0, child_process_1.spawnSync)(how.file, how.args, { stdio: "inherit", shell: how.shell ?? false });
+    if (r.status !== 0) {
+        out(ui.fail(`The update did not complete, so ${version_1.COMPRISM_VERSION} is still installed and working.`));
+        return 1;
+    }
+    out(ui.ok(`Updated to ${data.latest}. Your sign in and settings are unchanged.`));
+    return 0;
+}

package/out/commands/welcome.d.ts

@@ -1 +1,25 @@
-export declare function showWelcome(): Promise<void>;
+import type { SessionOut } from '../lib/gateway';
+/**
+ * Who this machine is signed in as, and everything else the header prints.
+ *
+ * ── One call, to the one service ──────────────────────────────────────────
+ *
+ * This used to call the platform's own `whoami` for the identity, and the
+ * header then had no way at all to say how many vendor keys the account held.
+ * Two questions, two addresses, and the header could show a person facts that
+ * disagreed with each other. On 17 September 2026 it did exactly that: "User
+ * unknown" beside a company name, and a session that then announced no provider
+ * key was stored while four were stored and active.
+ *
+ * Every line below now comes from one request to the single service, so the
+ * header either shows a consistent picture or says plainly that it could not
+ * reach the workspace. There is no third state in which half of it is true.
+ *
+ * Null rather than an error when it cannot be reached. A header is the wrong
+ * place to fail: somebody on a plane still gets the local facts, and the lines
+ * needing the server say so.
+ */
+export declare function session(): Promise<SessionOut | null>;
+/** `known` is who this machine is, when the caller already has it (the last
+ *  answer, drawn at once while a fresh one is asked for). */
+export declare function showWelcome(known?: SessionOut | null, signingIn?: boolean, withMark?: boolean): Promise<void>;

package/out/commands/welcome.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.session = session;
 exports.showWelcome = showWelcome;
 /**
  * The first thing anybody sees.
@@ -95,33 +96,46 @@ async function session() {
     return reply.session;
 }
 /**
- * The mark: a prism splitting light.
+ * The mark: the app icon as a terminal can draw it cleanly. A five layer prism,
+ * each layer two blocks wider than the one above and a shade deeper, with
+ * three beams leaving its right side (up, level and down) and a ring of the
+ * icon's cyan to purple around it (owner, 28 September 2026).
  *
- * A four row pyramid, drawn only in the full block glyph. The first attempt
- * used quarter blocks and came out looking like a rendering fault, because
- * those glyphs sit differently in every terminal font and a mark cannot depend
- * on a font. A full block renders identically everywhere, so the only thing
- * carrying the design is the color, which is the point of a prism.
+ * Solid blocks only, no blended edges and no white, because a terminal draws a
+ * solid block sharply in any font and a white one vanishes on a white screen.
+ * Drawn two pixels to a character, so it is nine lines tall.
  *
- * Color is taken by COLUMN, not by row. The apex sits on the middle of the
- * spectrum and each row down widens to one more color on either side, so the
- * base carries all eight. That is a prism doing its job: one input at the top,
- * the whole spectrum at the bottom. Banding it by row would have shown four of
- * the eight and read as a striped triangle instead.
- *
- * The eight values come from the same helper as the rule beneath it, so the
- * mark and the rule can never drift apart.
+ * Without color the picture cannot be drawn, so the four row block pyramid
+ * stands in: full blocks only, which render the same in every font.
  */
-const MARK_BASE = 8;
+const ICON = [
+    '..........................................53a6ed51a1ed509cee4f98ee4d93ee4c8eee4a89ee..................................................................',
+    '..............................54abed53a6ed51a1ed..............................4984ef477fef467bef......................................................',
+    '........................54abed53a6ed......................................................4476ef4371ef................................................',
+    '..................54abed53a6ed..................................................................426cf04067f0..........................................',
+    '..................53a6ed....................................a8d8f7a8d8f7..............................3f62f0..........................................',
+    '............53a6ed51a1ed....................................a8d8f7a8d8f7..............................3f5ff0425ef0..................4292f23f8af43b82f6',
+    '............51a1ed....................................74aef074aef074aef074aef0..............................455cf0......49a2ee469af0..................',
+    '............509cee....................................74aef074aef074aef074aef0........................54bbe851b3ea4daaec..............................',
+    '............4f98ee..............................4f86e64f86e64f86e64f86e64f86e64f86e6......5bcbe458c3e6......4b59f1....................................',
+    '............4d93ee..............................4f86e64f86e64f86e64f86e64f86e64f86e6f07a36f0e35befe25aeee259ece158eae057e9df56e8de55e6de54e4dd53e3dc52',
+    '............4c8eee........................3e60d83e60d83e60d83e60d83e60d83e60d83e60d83e60d8ed7435ea6e34......5056f1....................................',
+    '............4a89ee........................3e60d83e60d83e60d83e60d83e60d83e60d83e60d83e60d8............e76932e46331e15d30..............................',
+    '............4984ef477fef............2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a......5355f15653f2......de572fdb512e..................',
+    '..................467bef............2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a......5653f2........................d84c2cd5462bd2402a',
+    '..................4476ef4371ef..................................................................5653f25952f2..........................................',
+    '........................426cf04067f0......................................................5653f25952f2................................................',
+    '..............................3f62f03f5ff0425ef0..............................5355f15653f25952f2......................................................',
+    '..........................................455cf0485bf14b59f14e58f15056f15355f15653f2..................................................................',
+];
 function mark() {
+    const picture = ui.pixelArt(ICON);
+    if (picture.length)
+        return picture;
     const rows = [];
     for (let r = 1; r <= 4; r++) {
-        const blocks = r * 2;
-        const left = (MARK_BASE - blocks) / 2;
-        let line = ' '.repeat(left);
-        for (let i = 0; i < blocks; i++)
-            line += ui.spectrumAt(left + i, '\u2588');
-        rows.push(line + ' '.repeat(left));
+        const left = 4 - r;
+        rows.push(' '.repeat(left) + '\u2588'.repeat(r * 2) + ' '.repeat(left));
     }
     return rows;
 }
@@ -133,19 +147,31 @@ function row(label, value) {
 function readable(name) {
     return name.replace(/[-_]/g, ' ').replace(/\b\w/g, (m) => m.toUpperCase());
 }
-async function showWelcome() {
+/** `known` is who this machine is, when the caller already has it (the last
+ *  answer, drawn at once while a fresh one is asked for). */
+async function showWelcome(known, signingIn = false, withMark = true) {
     const conn = (0, connection_1.readConnection)();
     const cfg = (0, config_1.loadConfig)();
     const folder = (0, settings_1.currentWorkspace)();
-    const me = await session();
-    const [m1, m2, m3, m4] = mark();
-    out();
-    out(`  ${m1}   ${ui.c.bold('CompletionPrism')} ${ui.c.dim(`v${version_1.COMPRISM_VERSION}`)}`);
-    out(`  ${m2}   ${ui.c.muted('Optimize AI completion economics by optimizing work.')}`);
-    out(`  ${m3}`);
-    out(`  ${m4}`);
-    out(ui.prismRule());
-    out();
+    const me = known !== undefined ? known : await session();
+    // The mark once per start. Signing in first draws it; the session that
+    // follows draws only the account, so nobody sees the same screen twice.
+    if (withMark) {
+        const art = mark();
+        // The name and the line under it sit beside the middle of the mark.
+        const at = Math.max(0, Math.floor(art.length / 2) - 1);
+        const beside = {
+            [at]: `${ui.c.bold('CompletionPrism')} ${ui.c.dim(`v${version_1.COMPRISM_VERSION}`)}`,
+            [at + 1]: ui.c.muted('Optimize AI completion economics by optimizing work.'),
+        };
+        out();
+        art.forEach((line, i) => out(beside[i] ? `  ${line}   ${beside[i]}` : `  ${line}`));
+        out(ui.prismRule());
+        out();
+    }
+    // Signing in comes next and says everything else itself.
+    if (signingIn && !conn?.url)
+        return;
     if (!conn?.url) {
         // Nothing else here is knowable yet, and the one useful thing to say is the
         // single command that changes that.
@@ -153,8 +179,12 @@ async function showWelcome() {
         out(row('Comparing', cfg.defaultModel || 'not set'));
         out(row('Workspace', `${folder.path}  ${ui.c.dim('(where you are)')}`));
         out();
-        out(`  ${ui.c.dim('start with')}  ${ui.c.bold('comprism login')}`);
-        out();
+        // Not said when signing in follows at once: naming a command to type, just
+        // above the sign in it would start, reads as a second step.
+        if (!signingIn) {
+            out(`  ${ui.c.dim('start with')}  ${ui.c.bold('comprism login')}`);
+            out();
+        }
         return;
     }
     const company = me?.company || readable(conn.tenant || 'unknown');
@@ -165,10 +195,16 @@ async function showWelcome() {
     // machine happens to hold. A client that can only echo its own stored address
     // can never tell a person that the address is the thing that is wrong, which
     // is exactly what happened when a machine sat pointed at a dead laptop port.
-    const address = (me?.workspace_url || conn.url).replace(/^https?:\/\//, '');
+    // Except on this laptop: there the server names its public address, which is
+    // not where this machine is talking, and "you are on production" is the
+    // single most confusing thing a developer testing locally can be told.
+    const local = (0, connection_1.isLocalAddress)(conn.url);
+    const address = local
+        ? `${conn.url.replace(/^https?:\/\//, '')} ${ui.c.dim('(this laptop)')}`
+        : (me?.workspace_url || conn.url).replace(/^https?:\/\//, '');
     out(row('User', who));
     out(row('Company', company));
-    out(row('Server', ui.c.dim(address)));
+    out(row('Server', local ? address : ui.c.dim(address)));
     out(row('Comparing', `${cfg.defaultModel || ui.c.amber('not set')}  ${ui.c.dim('change with `comprism model`')}`));
     out(row('Workspace', `${folder.path}  ${ui.c.dim(folder.source === 'cwd' ? '(where you are)' : '(saved)')}`));
     if (plan) {

package/out/commands/worktrees.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectFacts } from "../lib/project";
+/** The folder a `--worktree` job runs in, creating the worktree the first time.
+ *  Null after saying why, when it cannot be made. */
+export declare function ensureWorktree(facts: ProjectFacts, name: string, session: string): Promise<string | null>;
+export declare function cmdWorktrees(args: string[]): Promise<number>;

package/out/commands/worktrees.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureWorktree = ensureWorktree;
+exports.cmdWorktrees = cmdWorktrees;
+/**
+ * Separate copies of the repository (manual 2.11): `comprism work --worktree`,
+ * `comprism worktrees`, `open` and `remove`.
+ *
+ * This machine runs Git, because the repository is here. The service records
+ * each worktree the tool creates, decides what may be removed, and writes what
+ * a person reads. This file refuses on its own as well, immediately before
+ * removing anything, so losing work needs both to agree.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const project_ops_1 = require("../lib/project-ops");
+const ui = __importStar(require("../lib/ui"));
+const out = (s = "") => process.stdout.write(s + "\n");
+/** Git with an argument list, never a shell string. Throws on failure. */
+function git(args, cwd) {
+    return (0, node_child_process_1.execFileSync)("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+function hasBranch(root, branch) {
+    try {
+        git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], root);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The worktree folder goes in the repository's own ignore list, once. */
+function exclude(root, line) {
+    const common = git(["rev-parse", "--git-common-dir"], root).trim();
+    const file = path.join(path.resolve(root, common), "info", "exclude");
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const now = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    if (!now.split(/\r?\n/).includes(line)) {
+        fs.appendFileSync(file, `${now && !now.endsWith("\n") ? "\n" : ""}${line}\n`);
+    }
+}
+/** The folder a `--worktree` job runs in, creating the worktree the first time.
+ *  Null after saying why, when it cannot be made. */
+async function ensureWorktree(facts, name, session) {
+    try {
+        git(["rev-parse", "--git-dir"], facts.root);
+    }
+    catch {
+        out(ui.fail("A worktree needs a Git repository. This folder is not one."));
+        return null;
+    }
+    const plan = await (0, project_ops_1.call)("worktrees", "plan", { name }, facts, true);
+    if (!plan)
+        return null;
+    const { branch, path: where, exclude: line, exists } = plan.data;
+    const local = path.resolve(where);
+    if (exists && fs.existsSync(local)) {
+        out(ui.c.dim(`  using worktree ${name} at ${local}`));
+        return local;
+    }
+    try {
+        exclude(facts.root, line);
+        git(["worktree", "add", ...(hasBranch(facts.root, branch) ? [local, branch] : ["-b", branch, local])], facts.root);
+    }
+    catch (err) {
+        out(ui.fail(`Git could not create the worktree: ${String(err.stderr || err).trim()}`));
+        return null;
+    }
+    const recorded = await (0, project_ops_1.call)("worktrees", "record", { name, branch, path: local, session }, facts);
+    return recorded ? local : null;
+}
+async function remove(facts, name, discard) {
+    const listed = await (0, project_ops_1.call)("worktrees", "open", { name }, facts, true);
+    if (!listed)
+        return 1;
+    const where = String(listed.data?.path ?? "");
+    const branch = `comprism/${name}`;
+    let dirty = [];
+    let onlyHere = 0;
+    if (fs.existsSync(where)) {
+        dirty = git(["status", "--porcelain"], where).split(/\r?\n/).filter(Boolean).map((l) => l.slice(3));
+    }
+    if (hasBranch(facts.root, branch)) {
+        // Commits on this branch and on no other. The other branches are named one
+        // by one: `--exclude` with `--not --branches` silently counts nothing.
+        const others = git(["for-each-ref", "--format=%(refname)", "refs/heads"], facts.root)
+            .split(/\r?\n/).filter((r) => r && r !== `refs/heads/${branch}`);
+        const commits = git(["rev-list", `refs/heads/${branch}`, "--not", ...others], facts.root);
+        onlyHere = commits.split(/\r?\n/).filter(Boolean).length;
+    }
+    let confirmed = false;
+    if (discard) {
+        if (!process.stdin.isTTY) {
+            out(ui.fail(`--discard needs you to type the worktree's name, ${name}, at a terminal.`));
+            return 1;
+        }
+        const { ask, closePrompt } = await Promise.resolve().then(() => __importStar(require("../lib/prompt")));
+        confirmed = (await ask(`  type ${name} to discard it and anything only it holds: `)).trim() === name;
+        closePrompt();
+    }
+    const verdict = await (0, project_ops_1.call)("worktrees", "check_remove", { name, dirty, only_here: onlyHere, discard, confirmed }, facts, true);
+    if (!verdict)
+        return 1;
+    // This machine's own check, immediately before acting: never lose work that
+    // was not explicitly discarded by name.
+    if (dirty.length && !(discard && confirmed)) {
+        out(ui.fail(`${name} has uncommitted changes, so it was not removed.`));
+        return 1;
+    }
+    const d = verdict.data;
+    try {
+        if (fs.existsSync(d.remove))
+            git(["worktree", "remove", ...(d.force ? ["--force"] : []), d.remove], facts.root);
+        else
+            git(["worktree", "prune"], facts.root);
+        if (d.delete_branch && hasBranch(facts.root, d.branch))
+            git(["branch", "-D", d.branch], facts.root);
+    }
+    catch (err) {
+        out(ui.fail(`Git could not remove it: ${String(err.stderr || err).trim()}`));
+        return 1;
+    }
+    await (0, project_ops_1.call)("worktrees", "forget", { name }, facts, true);
+    for (const line of verdict.lines ?? [])
+        out(line);
+    return 0;
+}
+async function cmdWorktrees(args) {
+    const facts = await (0, project_ops_1.currentProject)();
+    const [verb, name] = args.filter((a) => !a.startsWith("--"));
+    if (!verb) {
+        const all = await (0, project_ops_1.call)("worktrees", "list", {}, facts, true);
+        if (!all)
+            return 1;
+        const rows = all.data?.worktrees ?? [];
+        const present = rows.filter((r) => fs.existsSync(r.path)).map((r) => r.name);
+        out();
+        await (0, project_ops_1.call)("worktrees", "list", { present }, facts);
+        out();
+        return 0;
+    }
+    if ((verb === "open" || verb === "remove") && !name) {
+        out(ui.fail(`Say which worktree: comprism worktrees ${verb} <name>`));
+        return 2;
+    }
+    if (verb === "open")
+        return (await (0, project_ops_1.call)("worktrees", "open", { name }, facts)) ? 0 : 1;
+    if (verb === "remove")
+        return remove(facts, name, args.includes("--discard"));
+    out(ui.fail(`\`worktrees ${verb}\` is not a command. Use open or remove.`));
+    return 2;
+}

package/out/executor/browser.d.ts

@@ -0,0 +1,14 @@
+import type { RunResult } from "./shell";
+/** The browser program on this machine, or null. `COMPRISM_BROWSER` wins. */
+export declare function findBrowser(): string | null;
+/** The actions this machine can offer, only when a browser is installed. */
+export declare const BROWSER_ACTIONS: string[];
+/** The browser for one job, started on first use and closed with the job. */
+export declare class Browser {
+    private readonly root;
+    private session;
+    constructor(root: string);
+    private page;
+    perform(name: string, a: Record<string, unknown>): Promise<RunResult>;
+    close(): void;
+}