@impeccable/reviews 0.1.30 → 0.1.32

package/dist/cloudflare.js

@@ -71,9 +71,9 @@ const when = (value) => (typeof value === 'string' && Number.isFinite(Date.parse
 /**
  * GitHub's record, read from the setup state's hosting record (hosting.ts) instead of GitHub: Cloudflare's check runs
  * and its bot's comments as Impeccable's copy holds them, a Workers Builds check's Worker among them; null where the
- * record lists none for the app, so GitHub is read here.
+ * record lists none for the app and is not `read` (hosting.ts `hostingRead`), so GitHub is read here.
  */
-export function cloudflareFromHosting(app) {
+export function cloudflareFromHosting(app, read = false) {
     const previews = [];
     const heads = [];
     let worker;
@@ -100,7 +100,7 @@ export function cloudflareFromHosting(app) {
         if (!heads.some((h) => h.sha === p.sha))
             heads.push({ ...(p.pull !== null ? { number: p.pull } : {}), sha: p.sha, at });
     }
-    return previews.length ? { previews, heads, failed: false, ...(worker ? { worker: { script: worker.script, build: worker.build } } : {}) } : null;
+    return previews.length || read ? { previews, heads, failed: false, ...(worker ? { worker: { script: worker.script, build: worker.build } } : {}) } : null;
 }
 /**
  * GitHub's record: the Cloudflare check run on each head (or, with `only`, that pull request's; with `branch`, the

package/dist/hosting.js

@@ -27,12 +27,45 @@ export function hostingOf(state, repo) {
             if (!p || !sha || !source)
                 return [];
             const pull = typeof p.pull === 'number' && Number.isSafeInteger(p.pull) && p.pull > 0 ? p.pull : null;
-            return [{ pull, sha, url: address(p.url), alias: address(p.alias), state: text(p.state), at: text(p.at), source, environment: text(p.environment), site: text(p.site) }];
+            const pullState = p.pullState === 'open' || p.pullState === 'closed' ? p.pullState : null;
+            return [{ pull, sha, url: address(p.url), alias: address(p.alias), state: text(p.state), at: text(p.at), source, environment: text(p.environment), site: text(p.site), pullState }];
         });
         return [{ key, liveUrl: address(a.liveUrl), previews }];
     });
-    return { apps };
+    const unread = Array.isArray(hosting.unread) ? hosting.unread.flatMap((u) => text(u) ?? []) : [];
+    return { apps, readAt: text(hosting.readAt), unread, ...(hosting.readPending === true ? { readPending: true } : {}) };
 }
+/**
+ * The record once it is whole: while the state says a read of it is pending, the state is read again every few seconds,
+ * up to a minute by the clock, each read bounded by what is left of it. Past that, its previews are left out and it
+ * counts as never read, so each host tool reads its previews itself, as it does without a record; the live addresses stay.
+ */
+export async function settledHosting(first, repo, readState, opts = {}) {
+    const { everyMs = 3_000, upToMs = 60_000, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now } = opts;
+    const deadline = now() + upToMs;
+    let hosting = hostingOf(first, repo);
+    while (hosting?.readPending && now() + everyMs < deadline) {
+        await sleep(everyMs);
+        const state = await readState(deadline - now());
+        if (state.ok)
+            hosting = hostingOf(state.data, repo) ?? hosting;
+    }
+    return hosting?.readPending ? { apps: hosting.apps.map((a) => ({ ...a, previews: [] })), readAt: null, unread: hosting.unread } : hosting;
+}
+/** The reports each host's previews are read from, besides the deployments every read takes. */
+const REPORTS = { netlify: ['statuses', 'comments'], cloudflare: ['check-runs', 'comments'], render: [] };
+/**
+ * Whether the record is the whole of GitHub's record of the host's earlier previews, an empty list included: Impeccable
+ * read the repository's copy (`readAt`), and took every report the host's previews are read from. Else a host tool
+ * reads GitHub itself where the record lists none.
+ */
+export function hostingRead(hosting, host) {
+    if (!hosting?.readAt)
+        return false;
+    return !REPORTS[host].some((report) => hosting.unread.includes(report));
+}
+/** The pull requests whose previews the app's record lists as closed: on Render, evidence of the site and the pattern, never a preview to prove. */
+export const closedPulls = (app) => new Set(app?.previews.flatMap((p) => (p.pullState === 'closed' && p.pull !== null ? [p.pull] : [])) ?? []);
 /** The record's entry for an app: the one named, or, on a repository of one app, its only one. */
 export function hostingApp(hosting, appKey) {
     if (!hosting)

package/dist/log.js

@@ -26,6 +26,30 @@ export function redact(text, secrets = []) {
 export function scrub(text, secrets = [], field) {
     return redactShapes(redact(text, secrets), field);
 }
+/** Flags whose next argument is a value of no interest to the log: gh's host, cf's profile. */
+const VALUED = new Set(['--hostname', '--profile']);
+/**
+ * A host CLI's call as one debug-log line, for counting the reads a run made: the command, its subcommand words, gh
+ * api's method and an API route without its query. It stops at the first argument that is none of those, so no flag's
+ * value (a `--data` body, a password, a token) is ever written.
+ */
+export function commandLine(name, args) {
+    const parts = [name];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--method' && /^[A-Z]{3,7}$/.test(args[i + 1] ?? ''))
+            parts.push(args[++i]);
+        else if (VALUED.has(arg))
+            i++;
+        else if (/^[A-Za-z][A-Za-z:-]{0,39}$/.test(arg))
+            parts.push(arg);
+        else if (/^\/[\w./%~-]*(?:\?.*)?$/.test(arg))
+            parts.push(arg.split('?')[0]);
+        else
+            break;
+    }
+    return parts.join(' ');
+}
 export function createLog(debug, dir = tmpdir()) {
     const secrets = new Set();
     const secret = (value) => void secrets.add(value);

package/dist/main.js

@@ -7,7 +7,7 @@ import { runAgent } from './agent.js';
 import { runSkillCommand } from './skill.js';
 import { fenceExtension, guardedFileOperations, hostsAgreed, placeOf, previewRetryState } from './fence.js';
 import { accountsSaved, focusInstructions, focusState, severalApps, signInItem } from './focus.js';
-import { hostingOf } from './hosting.js';
+import { settledHosting } from './hosting.js';
 import { requestJson } from './http.js';
 import { copyText, letTabsHear, openBrowser, progressPage, screenPrompt, setupAuth, signIn } from './login.js';
 import { checkoutJournal } from './leftovers.js';
@@ -234,6 +234,8 @@ export async function main(argv) {
         ]);
         if (!instructions.ok || !state.ok)
             throw new UserError(`Impeccable's setup API did not answer: ${instructions.error ?? state.error}.`);
+        // A hosting record behind GitHub is read again while the questions below are asked (hosting.ts `settledHosting`).
+        const hosting = settledHosting(state.data, token.repository.name, (timeoutMs) => requestJson(`${setupApi}/state`, { token: token.access_token, timeoutMs }, log));
         // When the checkout cannot tell, the setup state's own verdict decides. When it has a web front end Impeccable skipped, the person adds it first.
         if (stateSaysNoFrontEnd(state.data, token.repository.name)) {
             if (frontEnd === 'unknown')
@@ -395,7 +397,7 @@ export async function main(argv) {
                 sandbox,
                 pushAccess: push.outcome,
                 severalApps: severalApps(state.data),
-                hosting: hostingOf(state.data, token.repository.name),
+                hosting: await hosting,
                 ...(flags.app ? { app: flags.app } : {}),
                 start: checkout.start,
                 ...(flags.signedInTestDrive ? { signedInTestDrive: { accountsSaved: accountsSaved(state.data, token.repository.name) } } : {}),

package/dist/netlify.js

@@ -124,8 +124,8 @@ async function fromGitHub(owner, repo, gh, only) {
     }
     return { previews: found, heads: new Map(heads.map((head) => [head.number, head.sha])), failed };
 }
-/** What GitHub records, read from the setup state's hosting record (hosting.ts) instead of GitHub: Netlify's commit statuses and its bot's comments as Impeccable's copy holds them; null where the record lists none for the app, so GitHub is read here. */
-export function netlifyFromHosting(app) {
+/** What GitHub records, read from the setup state's hosting record (hosting.ts) instead of GitHub: Netlify's commit statuses and its bot's comments as Impeccable's copy holds them; null where the record lists none for the app and is not `read` (hosting.ts `hostingRead`), so GitHub is read here. */
+export function netlifyFromHosting(app, read = false) {
     const previews = [];
     const heads = new Map();
     // A commit status names the head and carries the build's state; a comment proves nothing of the current build, so it stands only where no status says (as from GitHub's record).
@@ -141,7 +141,7 @@ export function netlifyFromHosting(app) {
         // A bot's comment posts once the preview is ready, as from GitHub's record; a status carries its own state.
         previews.push(p.source === 'comment' ? { pullRequest: p.pull, site: p.site, url, state: 'ready', from: 'bot comment', at: when(p.at) } : { pullRequest: p.pull, site: p.site, url, state: STATES.find((s) => s === p.state) ?? null, from: 'commit status', at: when(p.at) });
     }
-    return previews.length ? { previews, heads, failed: false } : null;
+    return previews.length || read ? { previews, heads, failed: false } : null;
 }
 /** A page of the person's site list, and how many pages are read at most: what `netlify sites:list` reads. */
 const SITES_PER_PAGE = 100;

package/dist/playbook/cases/render-previews.md

@@ -8,7 +8,7 @@ Render deploys the app: impeccable_render_previews (with the app's `appKey` on a
    - **`confirmed: false`**: the person skipped the Render screen, a no that ends the setup for the app, as the playbook says.
    - **`turnedOn`** says how turning the service's previews on ended, where the CLI said they were off and the screen was the consent: `enabled`, go on; `skipped` or `refused`, push no test drive (pull-requests' "No preview, no test drive"), and say under "What was skipped, and why" that Render's pull request previews are off for the site, with the `reason`, and name the `page`; `left` stays empty, since the person was asked in this run.
    - **No `site`**: Render's previews do not show this app. Go on as server-previews says, with `unread` under "What is not verified" where the CLI did not answer.
-2. **Prove the newest preview** with impeccable_prove_preview: the address of the newest listed preview whose state is `success` (or a page on it a visitor opens without signing in), and words the page shows that the checkout holds. Done when it answers `proven: true`; when an address no longer answers (Render takes a closed pull request's preview down), try the next newest, three at most. With none listed, or none that answers, the test drive's own preview is the proof: go on to pull-requests' step 4.
+2. **Prove the newest preview** with impeccable_prove_preview: the address of the newest listed preview whose state is `success` (or a page on it a visitor opens without signing in), and words the page shows that the checkout holds; a closed pull request's preview, `pullState: "closed"`, names the site and the pattern only, and counts as none listed, since Render takes it down. Done when it answers `proven: true`; when an address no longer answers, try the next newest, three at most. With none listed, or none that answers, the test drive's own preview is the proof: go on to pull-requests' step 4.
 3. **Save the method** with impeccable_write to `preview`: `{"previewUrlPattern": "<the proof's pattern>", "intendedMethod": "preview-deploy"}`, with the app's `appKey` in a monorepo, since each app's site has a pattern of its own. Done when the answer's `keys` show both stored or unchanged.
 
 ### Reference

package/dist/tools.js

@@ -13,7 +13,7 @@ import { appsLeftOut, focusCheckup, focusInstructions, focusState, severalApps }
 import { APPS_QUESTION, cliInstallScreen, cliManualScreen, cloudflareAccessConsent, cloudflareAccessPaste, cloudflareAccessReusable, HOST_QUESTIONS, HOST_SCREENS, HOST_SIGNED_IN, namedAppQuestion, NETLIFY_PASSWORD_WHERE, netlifyPasswordReplace, renderConfirm, sentTo, startedIn, vercelBypassConsent, vercelBypassPaste } from './host-questions.js';
 import { enableNetlifyPreviews, folderOf } from './host-previews.js';
 import { checkoutNames, liveShaped, netlifySiteOf, previewHostName, provePreview, readHostedPreviews, readmeNamesApp, renderSiteOf, vercelDeploymentOf } from './hosted.js';
-import { deploymentsOf, hostingApp, liveHostOf, renderSitesOf } from './hosting.js';
+import { closedPulls, deploymentsOf, hostingApp, hostingRead, liveHostOf, renderSitesOf } from './hosting.js';
 import { enableRenderPreviews, parseRenderDeployment, readRenderService, RENDER_DASHBOARD, renderSitesNamed } from './render.js';
 import { cloudflareFromHosting, cfRunner, cfStatus, CLOUDFLARE_APP_PAGE, connectCloudflareProject, enableCloudflarePreviews, pagesProject, pagesProjectName, readCloudflarePreviews } from './cloudflare.js';
 import { passCloudflareAccess } from './cloudflare-access.js';
@@ -22,7 +22,7 @@ import { netlifyToken, passNetlifyLock, setSitePassword } from './netlify-passwo
 import { connectVercelProject, lockedDeploymentHosts, prepareFirstDeployment, projectMadeDeployment, readLinkedProject, readOwnProject, vercelDashboardScope, vercelPreviewsFact, vercelProjectFor, vercelProjectPage, vercelRepoProject, vercelStatus, vercelTeams, waitForVercelAccess, waitForVercelLock } from './vercel.js';
 import { BYPASS_HEADER, passVercelLogin, readLink } from './vercel-bypass.js';
 import { fitsTask, stagesOf, workStarted } from './stages.js';
-import { redact } from './log.js';
+import { commandLine, redact } from './log.js';
 import { scan } from './scan.js';
 import { gitEnvironment, installEnvironment, ownFolder } from './sandbox.js';
 import { openBrowser } from './login.js';
@@ -1626,6 +1626,24 @@ export function createWorkflowSynchronizer(opts = {}) {
 }
 export function createTools(ctx) {
     const text = (t, terminate = false) => ({ content: [{ type: 'text', text: t }], details: undefined, ...(terminate ? { terminate } : {}) });
+    /** A host CLI (gh, render, netlify, cf, vercel, npm) as the host tools run it: each call one line in the debug log, its command and route alone (log.ts `commandLine`), so a run's reads can be counted. */
+    const hostRunner = (name, cwd, opts) => {
+        // Made on its first call: a reader handed one it never calls runs nothing.
+        let run;
+        return async (args) => {
+            const line = `host call: ${commandLine(name, args)}`;
+            try {
+                run ??= (ctx.hostRunner ?? commandRunner)(name, cwd, opts);
+                const out = await run(args);
+                ctx.log.write(line);
+                return out;
+            }
+            catch (err) {
+                ctx.log.write(`${line} (failed)`);
+                throw err;
+            }
+        };
+    };
     const retry = previewRetryState(ctx.log);
     retry.repository ??= `${ctx.owner}/${ctx.repo}`;
     // Once the list is up: the agent's first call sets it, with the reading in progress.
@@ -1682,6 +1700,8 @@ export function createTools(ctx) {
     const workerPatterns = new Map();
     /** The origins of the successful Render previews impeccable_render_previews listed, of the app's own site. */
     const renderListed = new Set();
+    /** Of those, the ones built in this run, which its wait with `pull` listed: the only ones whose 404 is asked for again, since Render may not serve their build yet. */
+    const renderBuilt = new Set();
     let hostedPreviewProven = false;
     /**
      * The address pattern each proof answered, by the app it was proven for, and the last one under '' for a repository
@@ -1982,7 +2002,7 @@ export function createTools(ctx) {
             liveApps.set(new URL(production).origin, appKey);
     };
     const hostCli = (host, pi, signal) => {
-        const runner = (browser = false) => (ctx.hostRunner ?? commandRunner)(host, pi.cwd, { signal, browser, timeoutMs: browser ? 300_000 : 30_000 });
+        const runner = (browser = false) => hostRunner(host, pi.cwd, { signal, browser, timeoutMs: browser ? 300_000 : 30_000 });
         const cli = runner();
         if (host === 'vercel') {
             return {
@@ -2082,7 +2102,7 @@ export function createTools(ctx) {
     /** The run's own install of a host CLI's package, for installHostCli: npm's pinned global install, from the command's own folder and npm cache, as the agent's install of one runs; whether it completed. */
     const npmInstall = (pkg, signal) => async () => {
         try {
-            await (ctx.hostRunner ?? commandRunner)('npm', ownFolder(), { signal, timeoutMs: 600_000, env: installEnvironment() })(hostCliInstallArgs(pkg));
+            await hostRunner('npm', ownFolder(), { signal, timeoutMs: 600_000, env: installEnvironment() })(hostCliInstallArgs(pkg));
             return true;
         }
         catch {
@@ -2090,7 +2110,7 @@ export function createTools(ctx) {
         }
     };
     /** cf, Cloudflare's CLI, which only the tools run: where it is missing here, its install is asked first (#396). */
-    const cfPresent = async (pi, signal) => (await cfStatus(cfRunner({ checkout: pi.cwd }, ctx.hostRunner), signal)).cli !== 'missing';
+    const cfPresent = async (pi, signal) => (await cfStatus(cfRunner({ checkout: pi.cwd }, hostRunner), signal)).cli !== 'missing';
     const installCf = (pi, signal) => installHostCli('cloudflare', () => cfPresent(pi, signal), npmInstall('cf', signal), signal);
     /**
      * A host's sign-in, on `impeccable_ask` with the id `<host>-setup`: the setup screen once, worded for a CLI signed in
@@ -2194,8 +2214,8 @@ export function createTools(ctx) {
         // The site's settings change on the host: only once the person opened the Netlify setup, as the fence holds for the CLI. A site built from this repository with Deploy Previews on needs no setup (#311): the connection changes nothing on it, and only checks that Netlify's GitHub app still reads the repository, asking for its access when it does not.
         if (!hostSetupAgreed(ctx.log, 'netlify') && !previewing)
             return { connected: false, reason: 'The Netlify sign-in comes first: impeccable_ask with the id netlify-setup.' };
-        const netlify = (ctx.hostRunner ?? commandRunner)('netlify', pi.cwd, { signal });
-        const gh = (ctx.hostRunner ?? commandRunner)('gh', pi.cwd, { signal });
+        const netlify = hostRunner('netlify', pi.cwd, { signal });
+        const gh = hostRunner('gh', pi.cwd, { signal });
         const clone = ctx.hostWait?.clone;
         const result = await connectNetlifySite(ctx.owner, ctx.repo, pi.cwd, { netlify, gh, linked: linkedByRun(ctx.log), settings, signal, ...(clone ? { wait: clone } : {}), ...(directory !== undefined ? { directory } : {}), ...(previewing ? { ownSite: true } : {}) });
         netlifySite = result.site?.name ?? netlifySite;
@@ -2221,7 +2241,7 @@ export function createTools(ctx) {
     async function vercelConnect(pi, signal) {
         if (!hostSetupAgreed(ctx.log, 'vercel'))
             return { connected: false, reason: 'The Vercel sign-in comes first: impeccable_ask with the id vercel-setup.' };
-        const vercel = (ctx.hostRunner ?? commandRunner)('vercel', pi.cwd, { signal });
+        const vercel = hostRunner('vercel', pi.cwd, { signal });
         const link = await readLink(pi.cwd);
         if (!link)
             return { connected: false, reason: 'This folder is linked to no Vercel project (.vercel/project.json): run vercel link first.' };
@@ -3179,7 +3199,7 @@ export function createTools(ctx) {
             const vercel = (args) => {
                 const key = JSON.stringify(args);
                 if (!reads.has(key))
-                    reads.set(key, (ctx.hostRunner ?? commandRunner)('vercel', pi.cwd, { signal })(args));
+                    reads.set(key, hostRunner('vercel', pi.cwd, { signal })(args));
                 return reads.get(key);
             };
             for (const origin of listedPreviews)
@@ -3192,7 +3212,7 @@ export function createTools(ctx) {
             const app = appKey !== undefined ? await vercelApp(pi, appKey, vercel) : undefined;
             if (app && 'reason' in app)
                 return JSON.stringify({ appKey, deployments: [], unmatched: app.reason });
-            const raw = () => (ctx.hostedPreviewReader ?? readHostedPreviews)(ctx.owner, ctx.repo, { signal, branch });
+            const raw = () => (ctx.hostedPreviewReader ?? readHostedPreviews)(ctx.owner, ctx.repo, { signal, branch, runGh: hostRunner('gh', pi.cwd, { signal }) });
             // Vercel names each project's deployments on GitHub "Preview – <project>"; one without a name is told by the project's own record of it.
             const owned = async (d) => {
                 if (!app)
@@ -3273,7 +3293,7 @@ export function createTools(ctx) {
                 noteApp(appKey, { host_project: app.name });
             return JSON.stringify({ ...(appKey !== undefined ? { appKey, project: app.name } : {}), ...evidence, ...(production ? { production } : {}) });
         }),
-        tool('impeccable_netlify_previews', 'Netlify previews', "Read whether this repository's pull requests get Netlify deploy previews: the 10 newest, each with its site, its address, its state and where that was read: GitHub's commit status or Netlify's bot comment on the pull request (from the setup state's hosting record where it holds them, else read from GitHub here), or the Netlify CLI on this machine when it is signed in (read only: it never signs in). production is the live site's own address, for the before. cli says whether that CLI is missing, signed out, signed in or did not answer. An error says something could not be read, which is unknown rather than absent. With pull (a pull request of this run, a draft included: Netlify builds a deploy preview only for a pull request), only that pull request's, waiting up to five minutes for one to finish building, under a status line with its timer, and again on the person's yes when the time ran out. It changes nothing on Netlify and proves nothing about the page.", NETLIFY_PREVIEWS, async (p, pi, signal) => {
+        tool('impeccable_netlify_previews', 'Netlify previews', "Read whether this repository's pull requests get Netlify deploy previews: the 10 newest, each with its site, its address, its state and where that was read: GitHub's commit status or Netlify's bot comment on the pull request (from the setup state's hosting record where it lists them or carries readAt, else read from GitHub here), or the Netlify CLI on this machine when it is signed in (read only: it never signs in). production is the live site's own address, for the before. cli says whether that CLI is missing, signed out, signed in or did not answer. An error says something could not be read, which is unknown rather than absent. With pull (a pull request of this run, a draft included: Netlify builds a deploy preview only for a pull request), only that pull request's, waiting up to five minutes for one to finish building, under a status line with its timer, and again on the person's yes when the time ran out. It changes nothing on Netlify and proves nothing about the page.", NETLIFY_PREVIEWS, async (p, pi, signal) => {
             const pull = p.pull;
             const refused = appRefusal(p.appKey, 'read') ?? lockRefusal(p.appKey, 'read');
             if (refused)
@@ -3285,10 +3305,10 @@ export function createTools(ctx) {
                 return JSON.stringify({ appKey, sites: [], previews: [], unmatched: `The setup state names no folder for the app ${appKey}.` });
             // Each site's team is for the last screen alone.
             const onTeams = (teams) => Object.entries(teams).forEach(([name, team]) => accountOf.set(`netlify ${name}`, team));
-            // GitHub's record as the setup state holds it, where it lists Netlify's previews of this app; a wait on a pull request reads GitHub, since its preview is newer than the record.
+            // GitHub's record as the setup state holds it, where it lists Netlify's previews of this app, or none on a record Impeccable read; a wait on a pull request reads GitHub, since its preview is newer than the record.
             const known = pull === undefined ? hostingFor(appKey) : undefined;
-            const github = known ? netlifyFromHosting(known) : null;
-            const read = () => (ctx.netlifyPreviewReader ?? readNetlifyPreviews)(ctx.owner, ctx.repo, pi.cwd, { signal, pull, onTeams, ...(directory !== undefined ? { directory } : {}), ...(github ? { github } : {}) });
+            const github = known ? netlifyFromHosting(known, hostingRead(ctx.hosting, 'netlify')) : null;
+            const read = () => (ctx.netlifyPreviewReader ?? readNetlifyPreviews)(ctx.owner, ctx.repo, pi.cwd, { signal, pull, onTeams, gh: hostRunner('gh', pi.cwd, { signal }), netlify: hostRunner('netlify', pi.cwd, { signal }), ...(directory !== undefined ? { directory } : {}), ...(github ? { github } : {}) });
             // A pull request's preview is still building until Netlify's deploy of it is built or has failed.
             const states = ['success', 'ready', 'failure', 'error'];
             const final = (evidence) => Boolean(evidence.error) || evidence.previews.some((preview) => states.includes(preview.state ?? ''));
@@ -3325,7 +3345,7 @@ export function createTools(ctx) {
                 noteApp(appKey, { host_project: site });
             return JSON.stringify(appKey !== undefined ? { appKey, ...evidence } : evidence);
         }),
-        tool('impeccable_cloudflare_previews', 'Cloudflare Pages previews', "Read whether this repository's pull requests get Cloudflare Pages previews: the 10 newest, each with its address, the branch's alias (https://<branch>.<project>.pages.dev, which follows the branch's latest build), its state and where that was read: the check run or the pull request comment Cloudflare's GitHub app posts (from the setup state's hosting record where it holds them, else read from GitHub here), or cf, Cloudflare's CLI, on this machine when it is signed in (read only: it never signs in; where cf is not installed here, the person is asked to install it first, on its own screen). production is the project's own address, https://<project>.pages.dev, the live app, for the before. cli says whether cf is missing, signed out, signed in or did not answer. An error says something could not be read, which is unknown rather than absent, and unread says whose: GitHub or cf. pullRequestPreviews says whether the Pages project built from this repository builds previews of pull requests at all (enabled false, with the cause: source, deployments or previews); worker says Cloudflare builds a Worker from the repository (Workers Builds); where its branch builds make previews, they are listed too, on workers.dev (the alias https://<branch>-<worker>.<subdomain>.workers.dev, with the pattern it stands for), and with no Pages project production is the Worker's own address; githubApp says what gh reads of Cloudflare's GitHub app on the owner, and the page where it gets access. With pull (a pull request of this run) or branch (a branch of this run, pushed, before its pull request exists), only that one's, waiting up to five minutes for its build to finish, under a status line with its timer, and again on the person's yes when the time ran out; where the project's settings build every branch and no build came, the wait's screen opens the GitHub page where Cloudflare's app gets access to the repository instead, and waits again. It changes nothing on Cloudflare and proves nothing about the page.", CLOUDFLARE_PREVIEWS, async (p, pi, signal) => {
+        tool('impeccable_cloudflare_previews', 'Cloudflare Pages previews', "Read whether this repository's pull requests get Cloudflare Pages previews: the 10 newest, each with its address, the branch's alias (https://<branch>.<project>.pages.dev, which follows the branch's latest build), its state and where that was read: the check run or the pull request comment Cloudflare's GitHub app posts (from the setup state's hosting record where it lists them or carries readAt, else read from GitHub here), or cf, Cloudflare's CLI, on this machine when it is signed in (read only: it never signs in; where cf is not installed here, the person is asked to install it first, on its own screen). production is the project's own address, https://<project>.pages.dev, the live app, for the before. cli says whether cf is missing, signed out, signed in or did not answer. An error says something could not be read, which is unknown rather than absent, and unread says whose: GitHub or cf. pullRequestPreviews says whether the Pages project built from this repository builds previews of pull requests at all (enabled false, with the cause: source, deployments or previews); worker says Cloudflare builds a Worker from the repository (Workers Builds); where its branch builds make previews, they are listed too, on workers.dev (the alias https://<branch>-<worker>.<subdomain>.workers.dev, with the pattern it stands for), and with no Pages project production is the Worker's own address; githubApp says what gh reads of Cloudflare's GitHub app on the owner, and the page where it gets access. With pull (a pull request of this run) or branch (a branch of this run, pushed, before its pull request exists), only that one's, waiting up to five minutes for its build to finish, under a status line with its timer, and again on the person's yes when the time ran out; where the project's settings build every branch and no build came, the wait's screen opens the GitHub page where Cloudflare's app gets access to the repository instead, and waits again. It changes nothing on Cloudflare and proves nothing about the page.", CLOUDFLARE_PREVIEWS, async (p, pi, signal) => {
             const pull = p.pull;
             const branch = p.branch;
             if (pull !== undefined && branch !== undefined)
@@ -3345,10 +3365,10 @@ export function createTools(ctx) {
             let accountName;
             // A Worker Preview's build names no address: its alias is made from the pattern the plain read's Worker preview stood for.
             const pattern = cloudflareEvidence?.previews.find((preview) => preview.pattern)?.pattern;
-            // GitHub's record as the setup state holds it, where it lists Cloudflare's previews of this app; a wait on a pull request or a pushed branch reads GitHub, since its build is newer than the record.
+            // GitHub's record as the setup state holds it, where it lists Cloudflare's previews of this app, or none on a record Impeccable read; a wait on a pull request or a pushed branch reads GitHub, since its build is newer than the record.
             const known = pull === undefined && branch === undefined ? hostingFor(appKey) : undefined;
-            const github = known ? cloudflareFromHosting(known) : null;
-            const readAll = () => (ctx.cloudflarePreviewReader ?? readCloudflarePreviews)(ctx.owner, ctx.repo, pi.cwd, { signal, pull, branch, onAccountName: (name) => (accountName = name), ...(directory !== undefined && pull === undefined && branch === undefined ? { directory } : {}), ...(appProject ? { project: appProject.project } : {}), ...(pattern ? { pattern } : {}), ...(github ? { github } : {}) });
+            const github = known ? cloudflareFromHosting(known, hostingRead(ctx.hosting, 'cloudflare')) : null;
+            const readAll = () => (ctx.cloudflarePreviewReader ?? readCloudflarePreviews)(ctx.owner, ctx.repo, pi.cwd, { signal, pull, branch, gh: hostRunner('gh', pi.cwd, { signal }), run: hostRunner, onAccountName: (name) => (accountName = name), ...(directory !== undefined && pull === undefined && branch === undefined ? { directory } : {}), ...(appProject ? { project: appProject.project } : {}), ...(pattern ? { pattern } : {}), ...(github ? { github } : {}) });
             const read = async () => {
                 const evidence = await readAll();
                 return appProject ? { ...evidence, previews: evidence.previews.filter((preview) => pagesProject(preview.url) === appProject.label) } : evidence;
@@ -3430,8 +3450,8 @@ export function createTools(ctx) {
                 ...(token ? { access: token } : {}),
             });
             let proved = await prove();
-            // Render reports a preview's deploy successful before its edge serves that build (REN-1117): a page the push added answers 404 for a while, so it is asked for again here, within a bounded wait, the way a command's sleep would but the fence refuses.
-            if (!live && renderListed.has(origin) && proved.status === 404) {
+            // Render reports a preview's deploy successful before its edge serves that build (REN-1117): a page the push added answers 404 for a while, so it is asked for again here, within a bounded wait, the way a command's sleep would but the fence refuses. Only a build of this run's: an earlier preview's 404 is a preview Render took down.
+            if (!live && renderListed.has(origin) && renderBuilt.has(origin) && proved.status === 404) {
                 const wait = ctx.hostWait?.serve ?? { totalMs: 90_000, everyMs: 5_000 };
                 said('Waiting for Render to serve the new page');
                 for (const end = Date.now() + wait.totalMs; proved.status === 404 && Date.now() < end && !signal?.aborted;) {
@@ -3496,7 +3516,7 @@ export function createTools(ctx) {
                 return JSON.stringify({ ...proof, appKey: app.appKey });
             return JSON.stringify(proof);
         }),
-        tool('impeccable_render_previews', 'Render previews', "Read whether Render builds this repository's pull requests, on a repository with several apps for the app's own folder (appKey): the Render site, from the render CLI signed in on this machine (the service built from this repository, in the app's folder by its Root Directory), else the one site the setup state's hosting record names for the app (Render's deployments, its live address), else the one Render's deployments on GitHub and the checkout's files name (on a repository with several apps, a file in the app's own folder, or a line of the root README naming that app and no other); its previews as GitHub records them (from the state's record where it holds them, else read from GitHub here), each with its pull request, its address and its state (a closed pull request's address too, read from its earlier successful status, though Render took that preview down); production, the site's own address, for the before; pattern, the address every pull request's preview has; and pullRequestPreviews (enabled false, with the cause, where the service's previews are off or manual; 'unknown' without the CLI's answer). cli says whether the render CLI answered (signed-in), is missing, could not list the services (unread, with the reason), or lists none of this repository's (none). Once a site is found, it shows the person one screen naming Render, with the site's address to click, asked once for each app: confirmed true, or false when the person skipped it, which is a no that ends the setup for that app. Where the CLI says the previews are off, that screen is also the consent to turning them on, and on the yes the CLI turns them on and reads them back, with a retry screen on Render's page where it could not: turnedOn in the answer says how that ended (enabled, by run or person; skipped; refused, with the reason and the page). With pull (a pull request of this run, a draft included: Render builds the preview as soon as a pull request opens), only that pull request's preview of the site the plain read found, waiting up to five minutes for it to finish building, under a status line with its timer, and again on the person's yes when the time ran out. Never asks for an address.", RENDER_PREVIEWS, async (p, pi, signal) => {
+        tool('impeccable_render_previews', 'Render previews', "Read whether Render builds this repository's pull requests, on a repository with several apps for the app's own folder (appKey): the Render site, from the render CLI signed in on this machine (the service built from this repository, in the app's folder by its Root Directory), else the one site the setup state's hosting record names for the app (Render's deployments, its live address), else the one Render's deployments on GitHub and the checkout's files name (on a repository with several apps, a file in the app's own folder, or a line of the root README naming that app and no other); its previews as GitHub records them (from the state's record where it lists them or carries readAt, else read from GitHub here), each with its pull request, its address and its state (a closed pull request's address too, read from its earlier successful status, though Render took that preview down; pullState closed marks one the record knows is closed, and impeccable_prove_preview refuses it); production, the site's own address, for the before; pattern, the address every pull request's preview has; and pullRequestPreviews (enabled false, with the cause, where the service's previews are off or manual; 'unknown' without the CLI's answer). cli says whether the render CLI answered (signed-in), is missing, could not list the services (unread, with the reason), or lists none of this repository's (none). Once a site is found, it shows the person one screen naming Render, with the site's address to click, asked once for each app: confirmed true, or false when the person skipped it, which is a no that ends the setup for that app. Where the CLI says the previews are off, that screen is also the consent to turning them on, and on the yes the CLI turns them on and reads them back, with a retry screen on Render's page where it could not: turnedOn in the answer says how that ended (enabled, by run or person; skipped; refused, with the reason and the page). With pull (a pull request of this run, a draft included: Render builds the preview as soon as a pull request opens), only that pull request's preview of the site the plain read found, waiting up to five minutes for it to finish building, under a status line with its timer, and again on the person's yes when the time ran out. Never asks for an address.", RENDER_PREVIEWS, async (p, pi, signal) => {
             const pull = p.pull;
             const refused = appRefusal(p.appKey, 'read') ?? lockRefusal(p.appKey, 'read');
             if (refused)
@@ -3511,18 +3531,19 @@ export function createTools(ctx) {
             if (pull !== undefined && !known)
                 return `Refused: read impeccable_render_previews${appKey !== undefined ? ` with appKey ${appKey}` : ''} and no pull first: it tells which Render site builds ${appKey !== undefined ? 'that app' : 'this repository'}.`;
             // GitHub's record of the repository's deployments (with `branch`, its head's), and of those Render's previews of `site`, of `pull` alone where it is given.
-            const readEvidence = (branch) => (ctx.hostedPreviewReader ?? readHostedPreviews)(ctx.owner, ctx.repo, { signal, ...(branch !== undefined ? { branch } : {}) });
+            const readEvidence = (branch) => (ctx.hostedPreviewReader ?? readHostedPreviews)(ctx.owner, ctx.repo, { signal, runGh: hostRunner('gh', pi.cwd, { signal }), ...(branch !== undefined ? { branch } : {}) });
             const previewsOf = (evidence, site) => evidence.deployments.flatMap((d) => {
                 const preview = parseRenderDeployment(d.environment, d.url);
                 return preview && preview.site === site && (pull === undefined || preview.pull === pull) ? [{ pull: preview.pull, url: d.url, state: d.state }] : [];
             });
-            // The successful previews are the ones a proof may open, each the app's.
+            // The successful previews are the ones a proof may open, each the app's, except a closed pull request's (hosting.ts `closedPulls`): Render takes it down when the pull request closes, so it is evidence of the site and the pattern alone, marked `pullState: "closed"`.
+            const closed = closedPulls(hostingFor(appKey));
             const list = (previews) => {
                 for (const origin of renderListed)
                     listedApps.delete(origin);
                 renderListed.clear();
                 for (const preview of previews) {
-                    if (preview.state !== 'success')
+                    if (preview.state !== 'success' || closed.has(preview.pull))
                         continue;
                     renderListed.add(new URL(preview.url).origin);
                     if (appKey !== undefined)
@@ -3540,15 +3561,17 @@ export function createTools(ctx) {
                 const final = (e) => Boolean(e.error) || e.previews.some((preview) => preview.state === 'success' || preview.state === 'failure' || preview.state === 'error');
                 const waited = await awaitBuild('Render', `Waiting for Render to build ${await subjectOf(pull)}`, read, final, () => known.page, signal);
                 list(waited.previews);
+                for (const origin of renderListed)
+                    renderBuilt.add(origin);
                 return JSON.stringify({ ...forApp, site: known.site, ...waited });
             }
-            const render = (ctx.hostRunner ?? commandRunner)('render', pi.cwd, { signal });
+            const render = hostRunner('render', pi.cwd, { signal });
             const read = await readRenderService(render, repository, folder);
             const service = 'service' in read ? read.service : undefined;
-            // GitHub's record as the setup state holds it, where it lists Render's deployments of this app; else read here.
+            // GitHub's record as the setup state holds it, where it lists Render's deployments of this app, or none on a record Impeccable read; else read here.
             const record = hostingFor(appKey);
             const recorded = record ? deploymentsOf(record).filter((d) => parseRenderDeployment(d.environment, d.url)) : [];
-            const evidence = recorded.length ? { deployments: recorded } : await readEvidence();
+            const evidence = recorded.length || (record && hostingRead(ctx.hosting, 'render')) ? { deployments: recorded } : await readEvidence();
             let site = service?.site;
             // Without the CLI's answer, the one site the setup state's record names for the app (its deployments, its live address); else the one the repository names: on a repository of one app, the one Render site its deployments and files name; on one of several, the one a file in the app's own folder names, else the one a line of the root README names beside that app and no other.
             if (!site && record) {
@@ -3574,7 +3597,7 @@ export function createTools(ctx) {
             const unread = 'reason' in read ? { unread: read.reason } : {};
             if (!site)
                 return JSON.stringify({ ...forApp, previews: [], cli, ...unread, ...(evidence.error ? { error: evidence.error } : {}) });
-            const previews = previewsOf(evidence, site);
+            const previews = previewsOf(evidence, site).map((p) => (closed.has(p.pull) ? { ...p, pullState: 'closed' } : p));
             list(previews);
             const production = service?.production ?? `https://${site}.onrender.com`;
             noteProduction(production, 'render', undefined, appKey);
@@ -3652,8 +3675,8 @@ export function createTools(ctx) {
             // cf is installed here: the fact this acts on is one a read through cf found.
             const { status, ...more } = await turnOnPreviews(host, async () => {
                 if (host === 'netlify')
-                    return enableNetlifyPreviews((ctx.hostRunner ?? commandRunner)('netlify', pi.cwd, { signal }), fact.project);
-                const cf = cfRunner({ checkout: pi.cwd }, ctx.hostRunner);
+                    return enableNetlifyPreviews(hostRunner('netlify', pi.cwd, { signal }), fact.project);
+                const cf = cfRunner({ checkout: pi.cwd }, hostRunner);
                 return enableCloudflarePreviews(cf, fact.project, await cfStatus(cf, signal), signal);
             }, signal);
             return answer(status, more);
@@ -3687,8 +3710,8 @@ export function createTools(ctx) {
             if ((await ask({ ...screen, prompt: create ? `Create the Pages project ${project} for ${ctx.owner}/${ctx.repo}?` : `Connect ${ctx.owner}/${ctx.repo} to the Pages project ${project}?` })).skipped)
                 return answer('skipped', { reason: `The person skipped ${create ? 'creating the Pages project' : 'connecting the repository to the Pages project'}.` });
             // cf signed in with pages:write, as it is or after Cloudflare's sign-in in the browser, keeping the scopes it held; a sign-in that did not complete offers a retry, twice.
-            const cf = cfRunner({ checkout: pi.cwd }, ctx.hostRunner);
-            const login = cfRunner({ browser: true, timeoutMs: 300_000, checkout: pi.cwd }, ctx.hostRunner);
+            const cf = cfRunner({ checkout: pi.cwd }, hostRunner);
+            const login = cfRunner({ browser: true, timeoutMs: 300_000, checkout: pi.cwd }, hostRunner);
             const writes = (status) => status.cli === 'signed-in' && (!status.scopes || status.scopes.includes('pages:write'));
             let status = await cfStatus(cf, signal);
             // cf not on this machine (#396): its install is asked first.
@@ -3718,7 +3741,7 @@ export function createTools(ctx) {
                 }
             }
             said(create ? `Creating the Pages project ${project}` : `Connecting the repository to ${project}`);
-            const gh = (ctx.hostRunner ?? commandRunner)('gh', pi.cwd, { signal });
+            const gh = hostRunner('gh', pi.cwd, { signal });
             const outcome = await connectCloudflareProject(cf, gh, status, { owner: ctx.owner, repo: ctx.repo }, { project, ...(evidence.account ? { account: evidence.account } : {}), ...(create ? { create: { command: p.command, outputDir: p.outputDir } } : {}) }, signal);
             if (outcome.status !== 'connected')
                 return answer('refused', { reason: outcome.reason });
@@ -3757,7 +3780,7 @@ export function createTools(ctx) {
                 said("Getting past Vercel's login");
             if (at?.app)
                 lockPending.delete(at.app.appKey);
-            const vercel = (ctx.hostRunner ?? commandRunner)('vercel', pi.cwd, { signal });
+            const vercel = hostRunner('vercel', pi.cwd, { signal });
             // Before the push, the app's project as impeccable_hosted_previews reads it: the one that builds the app's folder (#281).
             let app = at?.app;
             if (before && appsRepo) {
@@ -3992,7 +4015,7 @@ export function createTools(ctx) {
             /** Netlify took a new password the run set in this call: the end screen says so, saved or not, and on a cancel too. */
             let replaced = false;
             let answer;
-            const netlify = (ctx.hostRunner ?? commandRunner)('netlify', pi.cwd, { signal });
+            const netlify = hostRunner('netlify', pi.cwd, { signal });
             // The Netlify CLI not on this machine (#396): its install is asked first, the run's own since no agent's turn comes in between, and the command runs again.
             const run = async (args) => {
                 try {
@@ -4157,8 +4180,8 @@ export function createTools(ctx) {
                             accessConsented.add(found.id);
                         return yes;
                     },
-                    cf: cfRunner({ checkout: pi.cwd }, ctx.hostRunner),
-                    login: cfRunner({ browser: true, timeoutMs: 300_000, checkout: pi.cwd }, ctx.hostRunner),
+                    cf: cfRunner({ checkout: pi.cwd }, hostRunner),
+                    login: cfRunner({ browser: true, timeoutMs: 300_000, checkout: pi.cwd }, hostRunner),
                     retry: async () => !(await ask(HOST_SCREENS['cloudflare-signin-retry'])).skipped,
                     install: async () => void (await installCf(pi, signal)),
                     status: said,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@impeccable/reviews",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Set up a repository for Impeccable for PRs from your terminal.",
   "license": "SEE LICENSE IN LICENSE",
   "private": false,