@pikku/cli 0.12.126 → 0.12.128

package/dist/src/fabric/functions/findings-list.function.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { readSpool } from '../lib/finding-spool.js';
+import { dim, table } from '../lib/output.js';
+export const FabricFindingsListInput = z.object({});
+export const FabricFindingsListOutput = z.object({
+    findings: z.array(z.object({
+        title: z.string(),
+        kind: z.string(),
+        reason: z.string(),
+        reportedAt: z.string(),
+        projectId: z.string().nullable(),
+        file: z.string(),
+    })),
+});
+/**
+ * What is waiting to be sent. Without this the spool is invisible, and an
+ * agent has no way to tell a finding that reached fabric from one still
+ * sitting on the machine.
+ */
+export const FabricFindingsList = pikkuSessionlessFunc({
+    description: 'List the findings queued locally, waiting to be sent.',
+    input: FabricFindingsListInput,
+    output: FabricFindingsListOutput,
+    func: async () => ({
+        findings: (await readSpool()).map((entry) => ({
+            title: entry.payload.title,
+            kind: entry.payload.kind,
+            reason: entry.reason,
+            reportedAt: entry.payload.reportedAt,
+            projectId: entry.projectId,
+            file: entry.file,
+        })),
+    }),
+});
+export const renderFindingsList = (_s, { findings }) => {
+    console.log('');
+    if (findings.length === 0) {
+        console.log(dim('  Nothing queued — every finding you filed was sent.'));
+        console.log('');
+        return;
+    }
+    console.log(table(['REPORTED', 'KIND', 'HELD BECAUSE', 'TITLE'], findings.map((f) => [
+        f.reportedAt.slice(0, 16).replace('T', ' '),
+        f.kind,
+        f.reason,
+        f.title,
+    ])));
+    console.log('');
+    console.log(dim('  `pikku fabric findings flush` sends them.'));
+    console.log('');
+};

package/dist/src/fabric/functions/report.function.d.ts

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+/**
+ * Every field is optional here and the strictness lives in `FindingInput`,
+ * because `--stdin` supplies the whole finding at once and the flags then
+ * carry nothing. Whichever path was used, the same schema decides whether a
+ * finding is well-formed.
+ */
+export declare const FabricReportInput: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        product: "product";
+        harness: "harness";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    expected: z.ZodOptional<z.ZodString>;
+    actual: z.ZodOptional<z.ZodString>;
+    skill: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    passage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    command: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    error: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    repro: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    workaround: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    proposal: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    tried: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    unresolved: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    area: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    surface: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        deployed: "deployed";
+        both: "both";
+    }>>>;
+    cost: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    run: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    deployTarget: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    stdin: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const FabricReportOutput: z.ZodObject<{
+    sent: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    spooled: z.ZodBoolean;
+    queued: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FabricReport: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    title?: string | undefined;
+    kind?: "product" | "harness" | undefined;
+    model?: string | undefined;
+    expected?: string | undefined;
+    actual?: string | undefined;
+    skill?: string | undefined;
+    passage?: string | undefined;
+    command?: string | undefined;
+    error?: string | undefined;
+    repro?: string | undefined;
+    workaround?: string | undefined;
+    proposal?: string | undefined;
+    tried?: string | undefined;
+    unresolved?: boolean | undefined;
+    area?: string | undefined;
+    surface?: "local" | "deployed" | "both" | undefined;
+    cost?: string | undefined;
+    run?: string | undefined;
+    deployTarget?: string | undefined;
+    stdin?: boolean | undefined;
+}, {
+    sent: boolean;
+    spooled: boolean;
+    queued: number;
+    reason?: string | undefined;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    title?: string | undefined;
+    kind?: "product" | "harness" | undefined;
+    model?: string | undefined;
+    expected?: string | undefined;
+    actual?: string | undefined;
+    skill?: string | undefined;
+    passage?: string | undefined;
+    command?: string | undefined;
+    error?: string | undefined;
+    repro?: string | undefined;
+    workaround?: string | undefined;
+    proposal?: string | undefined;
+    tried?: string | undefined;
+    unresolved?: boolean | undefined;
+    area?: string | undefined;
+    surface?: "local" | "deployed" | "both" | undefined;
+    cost?: string | undefined;
+    run?: string | undefined;
+    deployTarget?: string | undefined;
+    stdin?: boolean | undefined;
+}, {
+    sent: boolean;
+    spooled: boolean;
+    queued: number;
+    reason?: string | undefined;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    title?: string | undefined;
+    kind?: "product" | "harness" | undefined;
+    model?: string | undefined;
+    expected?: string | undefined;
+    actual?: string | undefined;
+    skill?: string | undefined;
+    passage?: string | undefined;
+    command?: string | undefined;
+    error?: string | undefined;
+    repro?: string | undefined;
+    workaround?: string | undefined;
+    proposal?: string | undefined;
+    tried?: string | undefined;
+    unresolved?: boolean | undefined;
+    area?: string | undefined;
+    surface?: "local" | "deployed" | "both" | undefined;
+    cost?: string | undefined;
+    run?: string | undefined;
+    deployTarget?: string | undefined;
+    stdin?: boolean | undefined;
+}, {
+    sent: boolean;
+    spooled: boolean;
+    queued: number;
+    reason?: string | undefined;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;

package/dist/src/fabric/functions/report.function.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { resolveApiContext } from '../lib/config.js';
+import { collectReportEnvironment } from '../lib/report-environment.js';
+import { FindingInput, buildFindingPayload, parseFinding, parseFindingJson, postFinding, renderReceipt, validateFinding, } from '../lib/finding.js';
+import { flushSpool, readSpool, spoolFinding } from '../lib/finding-spool.js';
+/**
+ * Every field is optional here and the strictness lives in `FindingInput`,
+ * because `--stdin` supplies the whole finding at once and the flags then
+ * carry nothing. Whichever path was used, the same schema decides whether a
+ * finding is well-formed.
+ */
+export const FabricReportInput = FindingInput.partial().extend({
+    stdin: z.boolean().optional(),
+});
+export const FabricReportOutput = z.object({
+    sent: z.boolean(),
+    reason: z.string().optional(),
+    spooled: z.boolean(),
+    queued: z.number(),
+});
+const readStdin = async () => {
+    if (process.stdin.isTTY) {
+        throw new Error('--stdin expects the finding as JSON on standard input, and nothing was piped in.');
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+};
+/**
+ * Every path that cannot send holds the finding instead. The states that stop
+ * a send — logged out, fabric unreachable — are the states a finding is most
+ * likely to be describing, so dropping it loses exactly the reports worth
+ * having.
+ */
+const hold = async (payload, reason, projectId, message) => {
+    await spoolFinding({ payload, reason, projectId });
+    const queued = (await readSpool()).length;
+    console.log(`[fabric] ${message} — finding queued (${queued} waiting, sent on your next report)`);
+    return { sent: false, reason, spooled: true, queued };
+};
+export const FabricReport = pikkuSessionlessFunc({
+    description: 'Report a finding — something about pikku that cost time — to fabric.',
+    input: FabricReportInput,
+    output: FabricReportOutput,
+    func: async (_services, { stdin, ...flags }) => {
+        const parsed = stdin
+            ? parseFindingJson(await readStdin())
+            : parseFinding(flags);
+        if ('problems' in parsed) {
+            throw new Error(parsed.problems.join('\n'));
+        }
+        const problems = validateFinding(parsed.finding);
+        if (problems.length > 0) {
+            throw new Error(problems.join('\n'));
+        }
+        const payload = buildFindingPayload(parsed.finding, await collectReportEnvironment());
+        console.log(renderReceipt(payload));
+        const ctx = await resolveApiContext();
+        if (!ctx.token) {
+            return hold(payload, 'not-logged-in', ctx.projectId, 'not logged in');
+        }
+        const flushed = await flushSpool({
+            apiUrl: ctx.apiUrl,
+            token: ctx.token,
+            projectId: ctx.projectId,
+        });
+        if (flushed.sent > 0) {
+            console.log(`[fabric] sent ${flushed.sent} finding(s) held from earlier`);
+        }
+        const result = await postFinding({
+            apiUrl: ctx.apiUrl,
+            token: ctx.token,
+            projectId: ctx.projectId,
+            payload,
+        });
+        if (!result.sent) {
+            return hold(payload, result.reason ?? 'send-failed', ctx.projectId, `fabric did not accept it (${result.reason})`);
+        }
+        console.log('[fabric] finding sent');
+        return { sent: true, spooled: false, queued: flushed.remaining };
+    },
+});

package/dist/src/fabric/functions/secrets-delete.function.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const FabricSecretsDeleteInput: z.ZodObject<{
+    name: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const FabricSecretsDeleteOutput: z.ZodObject<{
+    name: z.ZodString;
+    runId: z.ZodNullable<z.ZodString>;
+    deploymentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricSecretsDelete: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    name: string;
+    branch?: string | undefined;
+    force?: boolean | undefined;
+}, {
+    name: string;
+    runId: string | null;
+    deploymentId: string | null;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    name: string;
+    branch?: string | undefined;
+    force?: boolean | undefined;
+}, {
+    name: string;
+    runId: string | null;
+    deploymentId: string | null;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    name: string;
+    branch?: string | undefined;
+    force?: boolean | undefined;
+}, {
+    name: string;
+    runId: string | null;
+    deploymentId: string | null;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;

package/dist/src/fabric/functions/secrets-delete.function.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { resolveApiContext } from '../lib/config.js';
+import { getFabricRPC } from '../lib/http.js';
+import { promptConfirm } from '../lib/prompt.js';
+import { resolveStage } from '../lib/stage.js';
+export const FabricSecretsDeleteInput = z.object({
+    name: z.string(),
+    branch: z.string().optional(),
+    force: z.boolean().optional(),
+});
+export const FabricSecretsDeleteOutput = z.object({
+    name: z.string(),
+    runId: z.string().nullable(),
+    deploymentId: z.string().nullable(),
+});
+export const FabricSecretsDelete = pikkuSessionlessFunc({
+    description: 'Remove a single stage-scoped secret. Unlike `secrets rotate`, the rest of the stage keeps its sealing key and its other secrets.',
+    input: FabricSecretsDeleteInput,
+    output: FabricSecretsDeleteOutput,
+    func: async (_services, { name, branch: requested, force }) => {
+        const ctx = await resolveApiContext();
+        if (!ctx.token)
+            throw new Error('Not logged in. Run `pikku fabric login` first.');
+        if (!ctx.projectId)
+            throw new Error('No fabric project linked. Run `pikku fabric link` first.');
+        // Resolved before the prompt so the confirmation names the stage that
+        // would actually lose the secret, not an argument that may be absent.
+        const rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+        const { stageId, branch } = await resolveStage(rpc, ctx.projectId, requested);
+        if (!force) {
+            if (!process.stdin.isTTY) {
+                throw new Error(`Refusing to delete ${name} from ${branch} without confirmation — re-run with --force to delete non-interactively.`);
+            }
+            // Fabric cannot read the sealed value back, so this is not recoverable
+            // by re-reading it — the plaintext has to be supplied again.
+            if (!(await promptConfirm(`Delete ${name} from ${branch}? It cannot be recovered — the value must be set again.`))) {
+                throw new Error('Delete aborted.');
+            }
+        }
+        const result = await rpc.invoke('deleteStageSecret', { stageId, name });
+        console.log(`[fabric] deleted ${result.name} from ${branch}`);
+        if (result.runId) {
+            console.log(`[fabric] republishing the stage as run ${result.runId} — units serve the old value until it lands`);
+        }
+        else {
+            console.log('[fabric] deploy the stage to stop its units serving the old value');
+        }
+        return result;
+    },
+});

package/dist/src/fabric/lib/finding-spool.d.ts

@@ -0,0 +1,56 @@
+import { type FindingPayload } from './finding.js';
+/**
+ * A finding that could not be sent when it was filed, held until it can be.
+ *
+ * The cases that keep a finding from leaving — no token, no linked project, a
+ * fabric that is down — are the same cases the finding is most likely to be
+ * about: a scaffold that never got far enough to log in is exactly the thing
+ * worth hearing about, and printing it and dropping it loses it. The spool
+ * lives in `~/.fabric`, not the repo, so nothing goes stale on an abandoned
+ * branch and git never sees it.
+ */
+export interface SpooledFinding {
+    file: string;
+    spooledAt: string;
+    reason: string;
+    projectId: string | null;
+    payload: FindingPayload;
+}
+/** Oldest entries past this are dropped, so a logged-out machine stays bounded. */
+export declare const SPOOL_LIMIT = 100;
+export declare function spoolDir(): string;
+export declare function spoolFinding(entry: {
+    payload: FindingPayload;
+    reason: string;
+    projectId: string | null;
+}): Promise<string>;
+/**
+ * Chronological, by the timestamp inside each finding rather than the one its
+ * name carries — the name is for a human reading the directory, and ordering
+ * the queue by it would make the send order a property of how a filename
+ * happens to sort. A file that no longer parses is skipped rather than thrown
+ * for: one corrupt entry is not a reason to lose the rest, or to fail the
+ * command that happened to notice.
+ */
+export declare function readSpool(): Promise<SpooledFinding[]>;
+export declare function clearSpool(): Promise<number>;
+export interface FlushResult {
+    sent: number;
+    remaining: number;
+    reason?: string;
+}
+/**
+ * Drain the spool oldest-first, stopping at the first entry fabric does not
+ * accept — a refusal usually means the next one will be refused too, and
+ * hammering an endpoint that just said no is the wrong thing for a command
+ * whose real job is something else.
+ *
+ * An entry keeps the project it was filed against; one spooled before the repo
+ * was linked adopts the project linked now, and sends without one if there is
+ * still none.
+ */
+export declare function flushSpool(ctx: {
+    apiUrl: string;
+    token: string;
+    projectId: string | null;
+}): Promise<FlushResult>;

package/dist/src/fabric/lib/finding-spool.js

@@ -0,0 +1,105 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { postFinding } from './finding.js';
+/** Oldest entries past this are dropped, so a logged-out machine stays bounded. */
+export const SPOOL_LIMIT = 100;
+export function spoolDir() {
+    return (process.env.FABRIC_FINDINGS_DIR ?? join(homedir(), '.fabric', 'findings'));
+}
+export async function spoolFinding(entry) {
+    const dir = spoolDir();
+    await mkdir(dir, { recursive: true });
+    const stamp = entry.payload.reportedAt.replace(/[:.]/g, '-');
+    const file = join(dir, `${stamp}-${randomBytes(3).toString('hex')}.json`);
+    await writeFile(file, JSON.stringify({
+        spooledAt: new Date().toISOString(),
+        reason: entry.reason,
+        projectId: entry.projectId,
+        payload: entry.payload,
+    }, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    await pruneSpool();
+    return file;
+}
+/**
+ * Chronological, by the timestamp inside each finding rather than the one its
+ * name carries — the name is for a human reading the directory, and ordering
+ * the queue by it would make the send order a property of how a filename
+ * happens to sort. A file that no longer parses is skipped rather than thrown
+ * for: one corrupt entry is not a reason to lose the rest, or to fail the
+ * command that happened to notice.
+ */
+export async function readSpool() {
+    const dir = spoolDir();
+    if (!existsSync(dir))
+        return [];
+    const names = (await readdir(dir)).filter((n) => n.endsWith('.json'));
+    const entries = [];
+    for (const name of names) {
+        const file = join(dir, name);
+        try {
+            const parsed = JSON.parse(await readFile(file, 'utf8'));
+            if (!parsed?.payload)
+                continue;
+            entries.push({
+                file,
+                spooledAt: parsed.spooledAt ?? '',
+                reason: parsed.reason ?? 'unknown',
+                projectId: parsed.projectId ?? null,
+                payload: parsed.payload,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries.sort((a, b) => a.payload.reportedAt.localeCompare(b.payload.reportedAt) ||
+        a.file.localeCompare(b.file));
+}
+export async function clearSpool() {
+    const entries = await readSpool();
+    for (const entry of entries)
+        await rm(entry.file, { force: true });
+    return entries.length;
+}
+async function pruneSpool() {
+    const entries = await readSpool();
+    const excess = Math.max(0, entries.length - SPOOL_LIMIT);
+    for (const entry of entries.slice(0, excess)) {
+        await rm(entry.file, { force: true });
+    }
+}
+/**
+ * Drain the spool oldest-first, stopping at the first entry fabric does not
+ * accept — a refusal usually means the next one will be refused too, and
+ * hammering an endpoint that just said no is the wrong thing for a command
+ * whose real job is something else.
+ *
+ * An entry keeps the project it was filed against; one spooled before the repo
+ * was linked adopts the project linked now, and sends without one if there is
+ * still none.
+ */
+export async function flushSpool(ctx) {
+    const entries = await readSpool();
+    let sent = 0;
+    for (const [index, entry] of entries.entries()) {
+        const result = await postFinding({
+            apiUrl: ctx.apiUrl,
+            token: ctx.token,
+            projectId: entry.projectId ?? ctx.projectId,
+            payload: entry.payload,
+        });
+        if (!result.sent) {
+            return {
+                sent,
+                remaining: entries.length - index,
+                reason: result.reason,
+            };
+        }
+        await rm(entry.file, { force: true });
+        sent++;
+    }
+    return { sent, remaining: 0 };
+}

package/dist/src/fabric/lib/finding.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import type { ReportEnvironment } from './report-environment.js';
+export declare const FindingInput: z.ZodObject<{
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        product: "product";
+        harness: "harness";
+    }>;
+    model: z.ZodString;
+    expected: z.ZodString;
+    actual: z.ZodString;
+    skill: z.ZodOptional<z.ZodString>;
+    passage: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    repro: z.ZodOptional<z.ZodString>;
+    workaround: z.ZodOptional<z.ZodString>;
+    proposal: z.ZodOptional<z.ZodString>;
+    tried: z.ZodOptional<z.ZodString>;
+    unresolved: z.ZodOptional<z.ZodBoolean>;
+    area: z.ZodOptional<z.ZodString>;
+    surface: z.ZodOptional<z.ZodEnum<{
+        local: "local";
+        deployed: "deployed";
+        both: "both";
+    }>>;
+    cost: z.ZodOptional<z.ZodString>;
+    run: z.ZodOptional<z.ZodString>;
+    deployTarget: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FindingInput = z.infer<typeof FindingInput>;
+export type ParsedFinding = {
+    finding: FindingInput;
+} | {
+    problems: string[];
+};
+/** Shape-check a finding from either path, naming every field that is wrong. */
+export declare function parseFinding(value: unknown): ParsedFinding;
+/**
+ * A finding read as JSON rather than assembled out of flags.
+ *
+ * Half the fields are prose, and prose carries apostrophes, quotes, backticks
+ * and newlines — every one of them a shell metacharacter before it is a
+ * character in a sentence. An error message pasted into `--error` breaks the
+ * command at its first newline; one carrying a backtick runs whatever follows
+ * it. JSON has its own escaping, so this path has none of that.
+ *
+ * Returns the finding or the problems with it, never throws: a malformed
+ * payload is a usage mistake worth naming precisely.
+ */
+export declare function parseFindingJson(raw: string): ParsedFinding;
+export interface FindingPayload extends Omit<FindingInput, 'run'> {
+    runId?: string;
+    environment: ReportEnvironment;
+    reportedAt: string;
+}
+/**
+ * The rules the field set exists to enforce, checked before anything is sent.
+ *
+ * A usage mistake is the agent's own and is worth failing loudly for — unlike a
+ * failed send, which must never surface as a build failure. Every problem is
+ * returned at once so a malformed call is fixed in one pass.
+ */
+export declare function validateFinding(input: FindingInput): string[];
+export declare function buildFindingPayload(input: FindingInput, environment: ReportEnvironment, now?: Date): FindingPayload;
+/**
+ * Best-effort by construction. A finding is worth having and never worth
+ * failing a build for, so a refused, slow or unreachable endpoint is reported
+ * to the terminal and swallowed.
+ */
+export declare function postFinding(opts: {
+    apiUrl: string;
+    token: string;
+    /**
+     * Provenance, not a routing key. A finding is about the framework rather
+     * than about anyone's project, and the reports worth having most — a
+     * scaffold that never produced a config, a first run that went wrong — come
+     * from checkouts that have no project to name.
+     */
+    projectId: string | null;
+    payload: FindingPayload;
+    timeoutMs?: number;
+}): Promise<{
+    sent: boolean;
+    reason?: string;
+}>;
+/**
+ * The receipt. Nothing is written to disk, so the terminal is the only place
+ * the user sees what left their machine. Printed before the request goes out,
+ * so it is there whether or not the send succeeds.
+ */
+export declare function renderReceipt(payload: FindingPayload): string;