@illuminis/comprism 0.1.3 → 0.1.4

package/out/lib/readiness.js

@@ -1,4 +1,37 @@
 "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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,6 +40,8 @@ exports.REQUIREMENTS = void 0;
 exports.present = present;
 exports.howToInstall = howToInstall;
 exports.check = check;
+exports.systemName = systemName;
+exports.diagnose = diagnose;
 /**
  * What this machine needs before the work can be done on it, and what to type
  * when something is missing.
@@ -38,6 +73,10 @@ exports.check = check;
  */
 const node_child_process_1 = require("node:child_process");
 const node_os_1 = __importDefault(require("node:os"));
+const install_1 = require("../commands/install");
+const connection_1 = require("./connection");
+const gateway_1 = require("./gateway");
+const node_fs_1 = __importDefault(require("node:fs"));
 exports.REQUIREMENTS = [
     {
         purpose: 'working with a repository',
@@ -57,7 +96,11 @@ exports.REQUIREMENTS = [
 /** Is this program on the machine, by name, without running anything of theirs. */
 function present(program) {
     try {
-        (0, node_child_process_1.execFileSync)('/usr/bin/env', ['which', program], { stdio: 'ignore' });
+        // Windows has no /usr/bin/env, so every program read as missing there.
+        if (node_os_1.default.platform() === 'win32')
+            (0, node_child_process_1.execFileSync)('where', [program], { stdio: 'ignore' });
+        else
+            (0, node_child_process_1.execFileSync)('/usr/bin/env', ['which', program], { stdio: 'ignore' });
         return true;
     }
     catch {
@@ -105,3 +148,129 @@ function check() {
     }
     return { ready: missing.length === 0, lines, fix: howToInstall(missing) };
 }
+/** The system this is, in the words its owner would use. */
+function systemName() {
+    try {
+        if (node_os_1.default.platform() === 'darwin') {
+            const v = (0, node_child_process_1.execFileSync)('sw_vers', ['-productVersion'], { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+            return `macOS ${v} ${node_os_1.default.arch()}`;
+        }
+        if (node_os_1.default.platform() === 'linux') {
+            const release = node_fs_1.default.readFileSync('/etc/os-release', 'utf8').match(/^PRETTY_NAME="?([^"\n]+)"?/m);
+            return `${release ? release[1] : 'Linux'} ${node_os_1.default.arch()}`;
+        }
+        if (node_os_1.default.platform() === 'win32')
+            return `${node_os_1.default.version()} ${node_os_1.default.arch()}`;
+    }
+    catch { /* fall through to the plain name */ }
+    return `${node_os_1.default.type()} ${node_os_1.default.release()} ${node_os_1.default.arch()}`;
+}
+function version(program, args) {
+    try {
+        const text = (0, node_child_process_1.execFileSync)(program, args, { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+        return text.match(/\d+\.\d+(\.\d+)?/)?.[0] ?? '';
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Everything `comprism check` reports (manual 1.6).
+ *
+ * Required: Node 22 or newer (built in for the install script and Python
+ * installs), a sign in, and a service that answers. Anything
+ * else is optional and never makes the check fail. Whether the service still
+ * accepts this machine is asked of the service itself, on the same session
+ * operation `status` uses, so the two can never disagree.
+ */
+async function diagnose() {
+    const found = [];
+    found.push({ ok: true, required: false, line: systemName() });
+    // Which proxy and certificate file are in use (manual 1.11).
+    const proxy = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+    if (proxy) {
+        const bypass = process.env.NO_PROXY || process.env.no_proxy;
+        found.push({ ok: true, required: false, line: `proxy ${proxy.replace(/\/\/[^@/]*@/, '//***@')}`
+                + (bypass ? `, not used for ${bypass}` : '') });
+    }
+    const caFile = process.env.NODE_EXTRA_CA_CERTS;
+    if (caFile) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        found.push(fs.existsSync(caFile)
+            ? { ok: true, required: false, line: `extra certificate authorities from ${caFile}` }
+            : { ok: false, required: true, line: `NODE_EXTRA_CA_CERTS names ${caFile}, which does not exist`,
+                fix: 'point NODE_EXTRA_CA_CERTS at your company certificate authority file' });
+    }
+    const node = process.versions.node;
+    const major = Number(node.split('.')[0]);
+    // The install script and Python installs carry their own Node (manual 1.1),
+    // so the line says so rather than asking for a Node nobody installed.
+    const { installMethod, isStandalone } = await Promise.resolve().then(() => __importStar(require('./self')));
+    if (isStandalone()) {
+        const how = installMethod() === 'script' ? 'the install script' : 'Python (pip)';
+        found.push({ ok: true, required: true, line: `installed with ${how}; Node ${node} is built in, nothing else needed` });
+    }
+    else
+        found.push(major >= 22
+            ? { ok: true, required: true, line: `Node ${node} (22 or newer needed)` }
+            : { ok: false, required: true, line: `Node ${node} is too old: 22 or newer needed`,
+                fix: 'install Node 22 or newer from https://nodejs.org' });
+    const connection = (0, connection_1.readConnection)();
+    if (!connection?.url || !connection.workspaceKey) {
+        found.push({ ok: false, required: true, line: 'not signed in', fix: 'comprism login' });
+    }
+    else {
+        const started = Date.now();
+        const reply = await (0, gateway_1.ask)({ intent: 'session', prompt: '' });
+        const ms = Date.now() - started;
+        if (!reply.ok && !reply.httpStatus && /certificate problem/.test(reply.message || '')) {
+            found.push({ ok: false, required: true, line: `service at ${connection.url}: ${reply.message}`,
+                fix: 'set NODE_EXTRA_CA_CERTS to your company certificate authority file' });
+        }
+        else if (!reply.ok && !reply.httpStatus) {
+            found.push({ ok: false, required: true, line: `service at ${connection.url} did not answer`,
+                fix: 'check your network, then comprism status' });
+        }
+        else if (reply.httpStatus === 401 || (reply.ok && reply.session && !reply.session.signed_in)) {
+            found.push({ ok: false, required: true, line: "signed out: this machine's key was revoked or has expired",
+                fix: 'comprism login' });
+            found.push({ ok: true, required: true, line: `service reachable in ${ms} ms` });
+        }
+        else {
+            found.push({ ok: true, required: true,
+                line: `signed in to ${reply.session?.company || connection.url}` });
+            found.push({ ok: true, required: true, line: `service reachable in ${ms} ms` });
+        }
+    }
+    const { powershellProfiles } = await Promise.resolve().then(() => __importStar(require('../commands/install')));
+    const profile = [...powershellProfiles(), ...(0, install_1.shellProfiles)()].find(install_1.profileHasSetup);
+    const home = node_os_1.default.homedir();
+    if (profile) {
+        found.push({ ok: true, required: false,
+            line: `shell profile line present in ${profile.startsWith(home) ? `~${profile.slice(home.length)}` : profile}` });
+    }
+    else if (node_os_1.default.platform() === 'win32') {
+        found.push({ ok: false, required: false,
+            line: 'no PowerShell profile line, so other AI tools here are not measured', fix: 'comprism install' });
+    }
+    else {
+        found.push({ ok: false, required: false, line: 'no shell profile line, so other AI tools here are not measured',
+            fix: 'comprism install' });
+    }
+    const git = version('git', ['--version']);
+    found.push(git !== null
+        ? { ok: true, required: false, line: `git ${git}` }
+        : { ok: false, required: false, line: 'git not found: reading, branching and committing a project will not work',
+            fix: howToInstall(['git']) });
+    const rg = version('rg', ['--version']);
+    found.push(rg !== null
+        ? { ok: true, required: false, line: `ripgrep ${rg}` }
+        : { ok: false, required: false, line: 'ripgrep not found: searches will be slower',
+            fix: howToInstall(['ripgrep']) });
+    const pdf = exports.REQUIREMENTS[1];
+    found.push(pdf.anyOf.some(present)
+        ? { ok: true, required: false, line: 'a PDF reader' }
+        : { ok: false, required: false, line: `no PDF reader: ${pdf.without} will not work`,
+            fix: howToInstall(['pdftotext']) });
+    return found;
+}

package/out/lib/self.d.ts

@@ -0,0 +1,23 @@
+/** True when running as the ready to run program rather than under Node. */
+export declare function isStandalone(): boolean;
+/** Where the install script keeps the program: `~/.comprism/bin`. */
+export declare function standaloneBinDir(): string;
+export type InstallMethod = "script" | "npm" | "python";
+/**
+ * Which of the three install options put this copy here.
+ *
+ * The program is only ever distributed two ways, so where it sits decides it:
+ * in `~/.comprism/bin` it came from the install script, anywhere else pip put
+ * it. Under Node it came from npm.
+ */
+export declare function installMethod(): InstallMethod;
+/** The command and arguments that start another copy of this tool. */
+export declare function selfLaunch(args: string[], nodeFlags?: string[]): [string, string[]];
+/**
+ * A file shipped beside the code, as a path on disk.
+ *
+ * Under npm it sits in the package. Inside the program it is carried as an
+ * asset and written once to `~/.comprism/assets`, because the programs it is
+ * handed to (Python, for the reader script) need a real file.
+ */
+export declare function shippedFile(name: string, packagePath: string): string;

package/out/lib/self.js

@@ -0,0 +1,124 @@
+"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.isStandalone = isStandalone;
+exports.standaloneBinDir = standaloneBinDir;
+exports.installMethod = installMethod;
+exports.selfLaunch = selfLaunch;
+exports.shippedFile = shippedFile;
+/**
+ * How this copy of the tool was installed, and how it starts another copy of
+ * itself (manual 1.1).
+ *
+ * The same code ships two ways. Through npm it is a script that Node runs, so
+ * `process.argv[1]` is the script and a second copy is `node <script> <args>`.
+ * Through the install script and the Python package it is one ready to run
+ * program with Node built in, where `process.argv[1]` is the program again and
+ * a second copy is just `<program> <args>`. Passing the program's own path as
+ * the first argument there would read as a command called "/Users/me/...", so
+ * every place that starts a copy of the tool asks here instead of guessing.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+let sea;
+/** True when running as the ready to run program rather than under Node. */
+function isStandalone() {
+    if (sea === undefined) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            sea = Boolean(require("node:sea").isSea());
+        }
+        catch {
+            sea = false;
+        }
+    }
+    return sea;
+}
+/** Where the install script keeps the program: `~/.comprism/bin`. */
+function standaloneBinDir() {
+    return path.join((0, config_1.homeDir)(), "bin");
+}
+/**
+ * Which of the three install options put this copy here.
+ *
+ * The program is only ever distributed two ways, so where it sits decides it:
+ * in `~/.comprism/bin` it came from the install script, anywhere else pip put
+ * it. Under Node it came from npm.
+ */
+function installMethod() {
+    if (!isStandalone())
+        return "npm";
+    try {
+        const here = fs.realpathSync(process.execPath);
+        const bin = fs.realpathSync(standaloneBinDir());
+        if (path.dirname(here) === bin)
+            return "script";
+    }
+    catch {
+        // No `~/.comprism/bin`: not an install script install.
+    }
+    return "python";
+}
+/** The command and arguments that start another copy of this tool. */
+function selfLaunch(args, nodeFlags = []) {
+    if (isStandalone())
+        return [process.execPath, args];
+    return [process.execPath, [...nodeFlags, process.argv[1] ?? "", ...args]];
+}
+/**
+ * A file shipped beside the code, as a path on disk.
+ *
+ * Under npm it sits in the package. Inside the program it is carried as an
+ * asset and written once to `~/.comprism/assets`, because the programs it is
+ * handed to (Python, for the reader script) need a real file.
+ */
+function shippedFile(name, packagePath) {
+    if (!isStandalone())
+        return packagePath;
+    const target = path.join((0, config_1.homeDir)(), "assets", name);
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const text = require("node:sea").getAsset(name, "utf8");
+        if (!fs.existsSync(target) || fs.readFileSync(target, "utf8") !== text) {
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, text);
+        }
+    }
+    catch {
+        // An asset that cannot be written leaves the caller's own fallback in charge.
+    }
+    return target;
+}

package/out/lib/sessions.d.ts

@@ -0,0 +1,19 @@
+import type { GatewayReply } from './gateway';
+/** Ask the service one sessions question, with where this machine is. */
+export declare function sessions(op: 'list' | 'resume' | 'latest' | 'opened' | 'rename' | 'branch' | 'export' | 'by_pr' | 'remote_on' | 'remote_poll' | 'remote_off' | 'lease' | 'read' | 'steering' | 'steer', extra?: Record<string, unknown>, folder?: string): Promise<GatewayReply>;
+/** Why a sessions question got no answer, in the service's words when it has them. */
+export declare function failure(reply: GatewayReply): string;
+/** The exit number for a sessions question that got no answer (Appendix B). */
+export declare function exitFor(reply: GatewayReply): number;
+/**
+ * Choose one line with the arrow keys; Enter picks, Esc or Ctrl+C leaves.
+ * Resolves with the index chosen, or null. Without a terminal it asks for a
+ * number instead, so a script is never left waiting on keys it cannot send.
+ */
+export declare function pick(lines: string[]): Promise<number | null>;
+/**
+ * `comprism sessions` and its words (manual 8.5 to 8.7, 8.10). Every answer,
+ * every line and every refusal is the service's; the export is written to
+ * standard output exactly as it came, so `> session.md` holds the file.
+ */
+export declare function cmdSessions(args: string[]): Promise<number>;

package/out/lib/sessions.js

@@ -0,0 +1,221 @@
+"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.sessions = sessions;
+exports.failure = failure;
+exports.exitFor = exitFor;
+exports.pick = pick;
+exports.cmdSessions = cmdSessions;
+/**
+ * A person's sessions, as the service keeps them (manual chapter 8).
+ *
+ * Nothing about a session is decided or stored here. The list, the numbers,
+ * the names, the costs, whether the conversation was kept and the words of
+ * every line come from the service's `sessions` intent; this file sends the
+ * question, draws the answer, and runs the arrow key list for `--resume`.
+ */
+const ui = __importStar(require("./ui"));
+const gateway_1 = require("./gateway");
+const out = (s = '') => process.stdout.write(s + '\n');
+/** Ask the service one sessions question, with where this machine is. */
+async function sessions(op, extra = {}, folder) {
+    const { resolveProject, asWire } = await Promise.resolve().then(() => __importStar(require('./project')));
+    const { currentWorkspace } = await Promise.resolve().then(() => __importStar(require('../commands/settings')));
+    const facts = resolveProject(folder ?? currentWorkspace().path, []);
+    return (0, gateway_1.ask)({
+        intent: 'sessions',
+        prompt: '',
+        sessionsPayload: {
+            op,
+            project: asWire(facts),
+            // The service writes the times, in this machine's own clock.
+            tz_minutes: -new Date().getTimezoneOffset(),
+            ...extra,
+        },
+    });
+}
+/** Why a sessions question got no answer, in the service's words when it has them. */
+function failure(reply) {
+    if (reply.served === false) {
+        return 'Your workspace is running a build without sessions yet.';
+    }
+    return reply.message || 'Your workspace could not be reached.';
+}
+/** The exit number for a sessions question that got no answer (Appendix B). */
+function exitFor(reply) {
+    if (reply.message === 'this machine is not signed in')
+        return 3;
+    if (!reply.ok && reply.message === 'the service could not be reached')
+        return 6;
+    return 1;
+}
+/**
+ * Choose one line with the arrow keys; Enter picks, Esc or Ctrl+C leaves.
+ * Resolves with the index chosen, or null. Without a terminal it asks for a
+ * number instead, so a script is never left waiting on keys it cannot send.
+ */
+async function pick(lines) {
+    if (lines.length === 0)
+        return null;
+    if (!process.stdin.isTTY) {
+        lines.forEach((l, i) => out(`${String(i + 1).padStart(3)}. ${l.trimStart()}`));
+        const { ask: askLine, closePrompt } = await Promise.resolve().then(() => __importStar(require('./prompt')));
+        const said = (await askLine('  which one? ')).trim();
+        closePrompt();
+        const n = Number(said);
+        return Number.isInteger(n) && n >= 1 && n <= lines.length ? n - 1 : null;
+    }
+    const stdin = process.stdin;
+    let at = 0;
+    const draw = (first) => {
+        if (!first)
+            process.stdout.write(`\x1b[${lines.length}A`);
+        lines.forEach((l, i) => {
+            const mark = i === at ? ui.c.bold('> ') : '  ';
+            process.stdout.write(`\x1b[2K${mark}${i === at ? ui.c.bold(l.trimStart()) : l.trimStart()}\n`);
+        });
+    };
+    out(ui.c.dim('  Up and Down to choose, Enter to resume, Esc to leave.'));
+    draw(true);
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    return new Promise((resolve) => {
+        const done = (chosen) => {
+            stdin.off('data', onKey);
+            stdin.setRawMode(Boolean(wasRaw));
+            stdin.pause();
+            resolve(chosen);
+        };
+        const onKey = (buf) => {
+            const key = buf.toString();
+            if (key === '\x1b[A' || key === 'k') {
+                at = (at + lines.length - 1) % lines.length;
+                draw(false);
+            }
+            else if (key === '\x1b[B' || key === 'j') {
+                at = (at + 1) % lines.length;
+                draw(false);
+            }
+            else if (key === '\r' || key === '\n')
+                done(at);
+            else if (key === '\x1b' || key === '\x03' || key === 'q')
+                done(null);
+        };
+        stdin.on('data', onKey);
+    });
+}
+/** Print what the service sent, or why it sent nothing. */
+function answered(reply) {
+    out();
+    if (!reply.ok || !reply.sessions) {
+        out(ui.fail(failure(reply)));
+        out();
+        return exitFor(reply);
+    }
+    for (const line of reply.sessions.lines)
+        out(line);
+    out();
+    return 0;
+}
+const USAGE = [
+    'comprism sessions [--search <words>] [--pr <number>]',
+    'comprism sessions rename <number> "<name>"',
+    'comprism sessions branch <number>',
+    'comprism sessions export <number> [--format json]',
+];
+/**
+ * `comprism sessions` and its words (manual 8.5 to 8.7, 8.10). Every answer,
+ * every line and every refusal is the service's; the export is written to
+ * standard output exactly as it came, so `> session.md` holds the file.
+ */
+async function cmdSessions(args) {
+    const [word, key, ...rest] = args;
+    if (word === 'rename') {
+        const name = rest.join(' ').trim();
+        if (!key || !name) {
+            out(ui.fail(`Say which session and the new name: ${USAGE[1]}`));
+            return 2;
+        }
+        return answered(await sessions('rename', { key, name }));
+    }
+    if (word === 'branch') {
+        if (!key) {
+            out(ui.fail(`Say which session to branch: ${USAGE[2]}`));
+            return 2;
+        }
+        return answered(await sessions('branch', { key }));
+    }
+    if (word === 'export') {
+        const at = rest.indexOf('--format');
+        const format = at === -1 ? 'markdown' : rest[at + 1];
+        if (!key || (format !== 'markdown' && format !== 'json' && format !== 'md')) {
+            process.stderr.write(ui.fail(`Say which session, and json or markdown: ${USAGE[3]}`) + '\n');
+            return 2;
+        }
+        const reply = await sessions('export', { key, format: format === 'json' ? 'json' : 'markdown' });
+        const got = reply.sessions;
+        if (!reply.ok || !got) {
+            process.stderr.write(ui.fail(failure(reply)) + '\n');
+            return exitFor(reply);
+        }
+        process.stdout.write(got.format === 'json'
+            ? `${JSON.stringify(got.document, null, 2)}\n`
+            : `${String(got.text ?? '')}\n`);
+        return 0;
+    }
+    const prAt = args.indexOf('--pr');
+    if (prAt !== -1) {
+        const pr = args[prAt + 1];
+        if (!pr) {
+            out(ui.fail('Say which pull request: comprism sessions --pr 42'));
+            return 2;
+        }
+        return answered(await sessions('by_pr', { pr }));
+    }
+    const at = args.indexOf('--search');
+    const search = at === -1 ? '' : args.slice(at + 1).join(' ').trim();
+    if (at !== -1 && !search) {
+        out(ui.fail('Say what to search for: comprism sessions --search parser'));
+        return 2;
+    }
+    if (word && !word.startsWith('-')) {
+        out(ui.fail(`There is no sessions command called "${word}".`));
+        for (const u of USAGE)
+            out(`      ${ui.c.dim(u)}`);
+        return 2;
+    }
+    return answered(await sessions('list', { search, limit: 20 }));
+}

package/out/lib/stdin.d.ts

@@ -0,0 +1,32 @@
+import * as tty from 'node:tty';
+import * as attach from './attach';
+/** The name piped text is attached under. */
+export declare const STDIN_NAME = "standard input";
+/**
+ * Everything piped in, read to the end. Null when standard input is a
+ * terminal, and empty when the pipe closed with nothing on it.
+ *
+ * A pipe that stays open with nothing coming (a command still running, or one
+ * that never closes) is announced after two seconds on standard error, so the
+ * person is not left looking at a still screen. Ctrl+C ends it as usual.
+ */
+export declare function readPiped(input?: NodeJS.ReadableStream & {
+    isTTY?: boolean;
+}, say?: (line: string) => void): Promise<string | null>;
+/**
+ * The piped text, uploaded as `standard input`. Written to a temporary file so
+ * it travels exactly like any attachment, and the file removed straight after.
+ */
+export declare function attachPiped(text: string, baseUrl: string, credential: string): Promise<{
+    attached: attach.Attached[];
+    refused: {
+        file: string;
+        why: string;
+    }[];
+}>;
+/**
+ * The terminal the person is sitting at, when standard input is a pipe.
+ * Null when there is none (a script, a scheduler, a container), which makes
+ * the job unattended.
+ */
+export declare function openTerminal(platform?: string): tty.ReadStream | null;