@impeccable/reviews 0.1.0 → 0.1.2

package/dist/ui/bridge.js

@@ -120,17 +120,20 @@ async function askOnStdin(q) {
     }
     if (q.kind === 'account') {
         // An empty username keeps the one the field would hold; an empty password skips the account.
-        out.write(`\n${q.title ? `${q.title}. ` : ''}${q.prompt}\n${q.hint ? `${q.hint}\n` : ''}Username or email${q.prefill ? ` (Enter for ${q.prefill})` : ''}: `);
+        const [first, second] = q.fields ?? ['Username or email', 'Password'];
+        out.write(`\n${q.title ? `${q.title}. ` : ''}${q.prompt}\n${q.hint ? `${q.hint}\n` : ''}${first}${q.prefill ? ` (Enter for ${q.prefill})` : ''}: `);
         const username = (await nextLine())?.trim() || q.prefill;
         if (!username)
             return { skipped: true };
-        out.write('Password, or Enter to skip: ');
+        out.write(`${second}, or Enter to skip: `);
         const password = await (process.stdin.isTTY ? hiddenLine : nextLine)();
         return password ? { skipped: false, username, password } : { skipped: true };
     }
     const how = q.kind === 'text' ? (q.skippable ? '(Enter to skip)' : '') : q.kind === 'single' ? `Type a number${q.skippable ? ', or Enter to skip' : ''}:` : `Type the numbers, separated by commas${q.skippable ? ', or Enter to skip' : ''}:`;
     out.write(`\n${q.prompt}\n${q.hint ? `${q.hint}\n` : ''}`);
-    (q.options ?? []).forEach((o, i) => out.write(`  ${i + 1}. ${o.label}\n`));
+    // A multi choice that opens with picks shows them; on a pipe the numbers typed are the whole answer.
+    const marked = q.kind === 'multi' && (q.options ?? []).some((o) => o.selected);
+    (q.options ?? []).forEach((o, i) => out.write(`  ${i + 1}. ${marked ? `[${o.selected ? 'x' : ' '}] ` : ''}${o.label}\n`));
     // A sensitive answer typed at a terminal is not echoed.
     const read = q.sensitive && process.stdin.isTTY ? hiddenLine : nextLine;
     out.write(how ? `${how} ` : '');

package/dist/ui/look.js

@@ -20,6 +20,11 @@ const FIELD_WIDTH = 48;
 /** The running task's spinner: one glyph every third frame. */
 const SPINNER = ['◐', '◓', '◑', '◒'];
 const START = { heading: "Let's set up your app", text: 'This wizard detects your framework and wires up all the essentials.' };
+/** The sign-in over a run, by why it signs in again. */
+const AGAIN = {
+    'ran-out': 'Your sign-in ran out. Approve again in your browser to carry on.',
+    apps: 'Impeccable found your apps after you signed in. Approve again in your browser to set them up.',
+};
 /** The invitation to the test drive, on whichever end screen shows it; the words "test drive" stay off it. */
 export const SEE_THE_REVIEW = 'See Impeccable review a change: we opened a small pull request just for that.';
 const WORDMARK = 'I M P E C C A B L E';
@@ -162,7 +167,8 @@ function questionPage(qv, inner, st) {
         const width = Math.min(FIELD_WIDTH, inner);
         const label = (text) => `  ${st.soft(text)}`;
         const hint = q.hint ? [...wrapTextWithAnsi(q.hint, width - 2).map(label), ''] : [];
-        const fields = [...fieldBox('Username or email', qv.field(width - 2), width, qv.focus !== 1, st), ...fieldBox('Password', qv.password?.() ?? '', width, qv.focus === 1, st)];
+        const [first, second] = q.fields ?? ['Username or email', 'Password'];
+        const fields = [...fieldBox(first, qv.field(width - 2), width, qv.focus !== 1, st), ...fieldBox(second, qv.password?.() ?? '', width, qv.focus === 1, st)];
         return {
             heading: q.title ?? 'A test account',
             text: said(q.prompt, inner, st),
@@ -224,9 +230,15 @@ function runPage(scene, f, inner, st) {
                     : t.status === 'skipped' ? '–'
                         : '○';
         const ink = t.status === 'in_progress' || t.status === 'failed' ? st.full : t.status === 'skipped' ? st.faint : st.soft;
-        // The task in progress carries the wait's timer, so a screen waiting on a host's build is never still.
-        const detail = t.status === 'skipped' || t.status === 'failed' ? t.status : i === running && scene.wait ? scene.wait : undefined;
-        return ink(`${mark} ${t.title}${detail ? ` · ${detail}` : ''}`);
+        const row = (detail) => `${mark} ${t.title}${detail ? ` · ${detail}` : ''}`;
+        if (t.status === 'skipped' || t.status === 'failed')
+            return ink(row(t.status));
+        if (i !== running || !scene.wait)
+            return ink(row());
+        // The task in progress says what the run waits for and the time so far, never how long it may wait, so a screen
+        // waiting on a host's build is never still; the time alone where the words would push it off the row.
+        const waiting = row(`waiting for ${scene.wait.host ? `${scene.wait.host}'s preview` : 'the preview'} · ${scene.wait.timer}`);
+        return ink(visibleWidth(waiting) <= inner ? waiting : row(scene.wait.timer));
     });
     const counted = scene.tasks.filter((t) => t.status !== 'skipped');
     const skipped = scene.tasks.length - counted.length;
@@ -271,15 +283,17 @@ function pageOf(f, inner) {
     switch (scene.kind) {
         case 'wait':
             return { heading: START.heading, text: said(START.text, inner, st), rule: divider(inner, st), action: [center(st.faint('One moment…'), inner)] };
-        case 'intro':
-            return { heading: START.heading, text: said(START.text, inner, st), rule: divider(inner, st), action: [center(st.full("Let's start with login"), inner)], ways: [['Continue', 'Enter']] };
+        case 'intro': {
+            const note = scene.note ? ['', ...block(hang(scene.note, Math.min(TEXT_WIDTH, inner), '! ').map(st.soft), inner)] : [];
+            return { heading: START.heading, text: said(START.text, inner, st), rule: divider(inner, st), action: [center(st.full("Let's start with login"), inner), ...note], ways: [['Continue', 'Enter']] };
+        }
         case 'signin': {
             // P still takes a pasted code on a remote shell; --help says so, the screen does not.
             const under = scene.note ?? (scene.copied ? 'Copied to clipboard!' : '');
             const link = block(urlRows(scene.link, ruleWidth(inner), st.soft, st), inner);
             return {
                 heading: scene.again ? 'Sign in again' : START.heading,
-                text: said(scene.again ? 'Your sign-in ran out. Approve again in your browser to carry on.' : 'Sign in with GitHub in your browser, then approve this repository.', inner, st),
+                text: said(scene.again ? AGAIN[scene.again] : 'Sign in with GitHub in your browser, then approve this repository.', inner, st),
                 rule: divider(inner, st),
                 action: [...link, ...(under ? ['', center(st.full(under), inner)] : []), ...(scene.copied === false ? ['', copyWay(inner, st)] : [])],
             };

package/dist/ui/run-state.js

@@ -24,7 +24,7 @@ export class RunState {
     tasks = [];
     previous;
     current;
-    /** A bounded wait under way: the current line carries its timer, counting up to the limit. */
+    /** A bounded wait under way: the current line carries its timer, counting up. */
     waiting;
     /** When something last changed on screen: a status, the task list, an answered question. */
     changedAt;
@@ -51,12 +51,12 @@ export class RunState {
         this.touch();
     }
     /**
-     * The wait's timer, "1:05 of 5:00", while one is under way: the task in progress carries it on the tasks screen.
-     * `live` false gives the wait's start, "0:00 of 5:00", the same on every tick: a drawing that changes only when
-     * a wait begins or ends, so the frames record the wait once rather than once a second.
+     * The wait under way, which the task in progress carries on the tasks screen: the host whose preview it is and the
+     * time so far, "1:05". `live` false gives the wait's start, "0:00", the same on every tick: a drawing that changes
+     * only when a wait begins or ends, so the frames record the wait once rather than once a second.
      */
     timer(live = true) {
-        return this.waiting ? `${timer(live ? this.now() - this.waiting.since : 0)} of ${timer(this.waiting.limitMs)}` : undefined;
+        return this.waiting && { host: this.waiting.host, timer: timer(live ? this.now() - this.waiting.since : 0) };
     }
     setTasks(tasks) {
         this.tasks = tasks.map((t) => ({ ...t }));
@@ -70,14 +70,14 @@ export class RunState {
      * The band's two lines as they read now: after a minute with nothing new the
      * last line moves up, dimmed, under "Still working…" and the time since.
      * `quiet` is false while the person is being asked. During a bounded wait
-     * the current line carries the timer, "1:05 of 5:00", so the screen never
+     * the current line carries the timer, "1:05", so the screen never
      * looks stalled; `live` false holds the timer at the wait's start, for a
      * drawing that changes only when the words do.
      */
     band(quiet = true, live = true) {
-        if (this.waiting && this.current) {
-            return { previous: this.previous, current: `${this.current} · ${this.timer(live)}` };
-        }
+        const wait = this.timer(live);
+        if (wait && this.current)
+            return { previous: this.previous, current: `${this.current} · ${wait.timer}` };
         const silence = this.now() - this.changedAt;
         if (quiet && silence >= SILENCE_MS)
             return { previous: this.current, current: `Still working… ${elapsed(silence)}` };

package/dist/ui/screens.js

@@ -1,13 +1,17 @@
 import { readFileSync } from 'node:fs';
 import { format } from 'node:util';
 import { CURSOR_MARKER, getCapabilities, Input, KeybindingsManager, matchesKey, ProcessTerminal, setKeybindings, TUI_KEYBINDINGS, TuiAltScreen } from '@earendil-works/pi-tui';
-import { readCheckout } from '../preflight.js';
 import { copyText } from '../login.js';
 import { workStarted } from '../stages.js';
 import { mountUi } from './bridge.js';
 import { createFrameWriter, frameState } from './frames.js';
 import { drawFrame, OUTCOME, PRODUCT, palette } from './look.js';
 import { RunState } from './run-state.js';
+/** What the command does before a screen ends it at once (Ctrl+C before a run, or a signal): report the stop (main.ts), briefly. */
+let beforeExit = async () => { };
+export function onScreenExit(fn) {
+    beforeExit = fn;
+}
 /** How often what moves on screen moves: the loader, the spinner. */
 const TICK_MS = 80;
 /** The run screen's first line, before the agent has said anything. */
@@ -44,7 +48,7 @@ class Wizard {
     onExit = () => this.stop();
     onSignal = (signal) => {
         this.stop();
-        process.kill(process.pid, signal);
+        void beforeExit('terminated').finally(() => process.kill(process.pid, signal));
     };
     constructor() {
         // The alternate screen's own scrolling and search keys stay off: the wizard draws every row, and a typed answer keeps Home and End.
@@ -155,7 +159,9 @@ class Wizard {
                 this.state.touch();
                 resolve(answer);
             };
-            this.questions.push({ q, resolve: answered, field, password: q.kind === 'account' ? new Input() : undefined, focus: 0, cursor: 0, picked: new Set() });
+            // A multi choice opens with the options the question marks selected picked.
+            const picked = new Set(q.kind === 'multi' ? (q.options ?? []).flatMap((o, i) => (o.selected ? [i] : [])) : []);
+            this.questions.push({ q, resolve: answered, field, password: q.kind === 'account' ? new Input() : undefined, focus: 0, cursor: 0, picked });
             this.redraw();
         });
     }
@@ -226,7 +232,8 @@ class Wizard {
         const run = this.views.find((v) => v.kind === 'run');
         if (!run) {
             this.stop();
-            process.exit(130);
+            void beforeExit('ctrl_c').finally(() => process.exit(130));
+            return;
         }
         this.stopAsked = 0;
         for (const question of this.questions.splice(0))
@@ -289,14 +296,19 @@ class Wizard {
         else if (matchesKey(data, 'enter')) {
             if (choices && q.kind === 'single')
                 return done({ skipped: false, value: choices[question.cursor].value });
-            if (choices)
+            // A multi choice answers what is picked; with nothing picked, Skip is the way to say none.
+            if (choices && question.picked.size)
                 return done({ skipped: false, values: choices.filter((_, i) => question.picked.has(i)).map((o) => o.value) });
-            const value = question.field.getValue().trim();
-            if (value)
-                return done({ skipped: false, value });
-            if (q.skippable)
-                return done({ skipped: true });
-            question.note = 'Type an answer first.';
+            if (choices)
+                question.note = 'Pick at least one, or skip.';
+            else {
+                const value = question.field.getValue().trim();
+                if (value)
+                    return done({ skipped: false, value });
+                if (q.skippable)
+                    return done({ skipped: true });
+                question.note = 'Type an answer first.';
+            }
         }
         else if (!choices) {
             question.field.handleInput(data);
@@ -323,7 +335,7 @@ class Wizard {
         if (!view)
             return { kind: 'wait' };
         if (view.kind === 'intro')
-            return { kind: 'intro' };
+            return { kind: 'intro', note: view.note };
         if (view.kind === 'signin')
             return { kind: 'signin', link: view.link, copied: view.copied, again: view.again, note: view.pasting ? undefined : view.note };
         if (view.kind === 'pull')
@@ -394,30 +406,24 @@ function host() {
     wizard ??= new Wizard();
     return wizard;
 }
-function repository() {
-    try {
-        const checkout = readCheckout(process.cwd());
-        return `${checkout.owner}/${checkout.repo}`;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** Writes every screen into `dir` as it changes (--frames), for the eval. */
 export function recordFrames(dir) {
     frames = createFrameWriter(dir);
 }
-/** The first screen: what the command does, and the way on. Resolves true to go on, false to cancel. */
-export function showIntro() {
+/** The first screen: what the command does, a warning to read before anything runs (`note`), and the way on; without a terminal, a line naming `repository`, the owner/name being set up. Resolves true to go on, false to cancel. */
+export function showIntro(repository, note) {
     const screen = host();
     if (!screen) {
-        console.log(`${PRODUCT}: setting up ${repository() ?? 'this repository'}.`);
+        console.log(`${PRODUCT}: setting up ${repository}.`);
+        if (note)
+            console.log(`! ${note}`);
         console.log();
         return Promise.resolve(true);
     }
     return new Promise((resolve) => {
         const view = {
             kind: 'intro',
+            note,
             done: (ok) => {
                 screen.remove(view);
                 if (ok)
@@ -443,7 +449,7 @@ export function showSignIn(link, opts) {
         console.log(link);
         return { close() { } };
     }
-    const view = { kind: 'signin', link, opts, pasting: false, again: screen.views.some((v) => v.kind === 'run') };
+    const view = { kind: 'signin', link, opts, pasting: false, again: screen.views.some((v) => v.kind === 'run') && (opts.why ?? 'ran-out') };
     screen.push(view);
     screen.copy(view);
     return { close: () => screen.remove(view) };

package/dist/vercel.js

@@ -68,3 +68,80 @@ export async function waitForVercelAccess(vercel, deps) {
     }
     return result;
 }
+/**
+ * `vercel api` on the project this folder is linked to: GET /v9/projects/{id} reads it, and PATCH changes a setting
+ * through the update-project endpoint (https://vercel.com/docs/rest-api/projects/update-an-existing-project); a team's
+ * project needs its team on the request.
+ */
+const projectApi = (link, change) => [
+    'api',
+    `/v9/projects/${encodeURIComponent(link.projectId)}${link.orgId.startsWith('team_') ? `?teamId=${encodeURIComponent(link.orgId)}` : ''}`,
+    ...(change ? ['--method', 'PATCH', ...change] : []),
+    '--raw', '--non-interactive',
+];
+export const readProjectApi = (link) => projectApi(link);
+/**
+ * Vercel Authentication on All Deployments: Vercel's login in front of every address of the project, its production
+ * domains included (https://vercel.com/docs/deployment-protection#all-deployments), as the endpoint takes it
+ * (https://vercel.com/docs/deployment-protection/methods-to-protect-deployments/vercel-authentication#how-to-manage-vercel-authentication-with-the-api).
+ */
+export const lockProjectApi = (link) => projectApi(link, ['--field', 'ssoProtection={"deploymentType":"all"}']);
+const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined);
+const printedProject = async (vercel, args) => {
+    const printed = await vercel(args);
+    return record(JSON.parse(printed.slice(printed.indexOf('{'), printed.lastIndexOf('}') + 1)));
+};
+const scope = (project) => record(project?.ssoProtection)?.deploymentType;
+/** The linked project as `vercel api` prints it: its production deployment (the production target, or one among the latest) unless every one failed or was cancelled, its Git link's production branch, its protection and its deployments' hosts. Null when the CLI could not read it. */
+export async function readVercelProject(vercel, link) {
+    let project;
+    try {
+        project = await printedProject(vercel, readProjectApi(link));
+    }
+    catch {
+        return null;
+    }
+    if (project?.id !== link.projectId)
+        return null;
+    const target = record(record(project.targets)?.production);
+    const latest = (Array.isArray(project.latestDeployments) ? project.latestDeployments : []).map(record).filter((d) => d !== undefined);
+    const failed = (d) => d.readyState === 'ERROR' || d.readyState === 'CANCELED';
+    const exists = (target !== undefined && !failed(target)) || latest.some((d) => d.target === 'production' && !failed(d));
+    const branch = record(project.link)?.productionBranch;
+    const protection = scope(project);
+    const hosts = [target, ...latest].flatMap((d) => (typeof d?.url === 'string' && d.url ? [d.url.replace(/^https?:\/\//, '').toLowerCase()] : []));
+    return { production: exists ? 'exists' : 'none', ...(typeof branch === 'string' && branch ? { productionBranch: branch } : {}), protection: typeof protection === 'string' ? protection : null, deploymentHosts: new Set(hosts) };
+}
+/**
+ * The linked project before its first push: read through `vercel api`, and, with no production deployment, locked
+ * behind Vercel's login at every address, since Vercel makes a new project's first deployment Production whatever
+ * branch it builds and Standard Protection serves production domains to anyone. A project that deploys production
+ * already (live or building), or is locked already, is left as it is.
+ */
+export async function prepareFirstDeployment(vercel, link) {
+    const project = await readVercelProject(vercel, link);
+    if (!project)
+        return { production: 'unknown', locked: false, reason: 'The Vercel CLI could not read the project (vercel api): it is signed out, or this CLI has no api command.' };
+    const branch = project.productionBranch ? { productionBranch: project.productionBranch } : {};
+    if (project.production === 'exists')
+        return { production: 'exists', ...branch };
+    if (project.protection === 'all')
+        return { production: 'none', locked: true, ...branch };
+    try {
+        if (scope(await printedProject(vercel, lockProjectApi(link))) === 'all')
+            return { production: 'none', locked: true, ...branch };
+    }
+    catch {
+        // What the answer below says.
+    }
+    return { production: 'none', locked: false, ...branch, reason: "Vercel did not put its login in front of the project's addresses: that takes the Member role or Project Administrator." };
+}
+/**
+ * The hosts of the linked project's deployments while Vercel's login stands in front of every address of it, read
+ * now: a Production deployment GitHub lists for a pushed branch is its preview only when it is one of these. Empty
+ * when the project is not locked at every address, or could not be read.
+ */
+export async function lockedDeploymentHosts(vercel, link) {
+    const project = await readVercelProject(vercel, link);
+    return project?.protection === 'all' ? project.deploymentHosts : new Set();
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@impeccable/reviews",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Set up a repository for Impeccable for PRs from your terminal.",
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE",
   "private": false,
   "type": "module",
   "bin": {
@@ -24,6 +24,7 @@
     "eval": "npm run build && node dist/eval/main.js"
   },
   "dependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.78",
     "@earendil-works/pi-coding-agent": "~0.87.1",
     "@earendil-works/pi-tui": "~0.87.1"
   },