@greatwait/cli 0.2.0 → 0.2.2

package/dist/catalog.js

@@ -83,6 +83,30 @@ const API_URL = {
     summary: "The GreatWait API to use, such as https://api.greatwait.dev. Defaults to the one you signed in to.",
     value: "<origin>",
 };
+const CORRELATION_FILTER_OPTIONS = [
+    {
+        flag: "--external-identifier",
+        value: "<id>",
+        summary: "Exact host application identifier, such as a request ID.",
+    },
+    {
+        flag: "--tag",
+        value: "<tag>",
+        summary: "Exact membership of one schedule tag.",
+    },
+];
+const CORRELATION_WRITE_OPTIONS = [
+    {
+        flag: "--external-identifier",
+        value: "<id>",
+        summary: "Searchable host application identifier; at most 256 UTF-8 bytes. Do not include secrets.",
+    },
+    {
+        flag: "--tags",
+        value: "<json>",
+        summary: "JSON array of up to 16 distinct tags, each at most 64 UTF-8 bytes. Inline or @file.json.",
+    },
+];
 const PAGE_OPTIONS = [
     {
         flag: "--limit",
@@ -525,12 +549,21 @@ export const COMMAND_CATALOG = [
         summary: "Start calling a disabled destination again.",
         words: "destinations enable",
     },
+    {
+        group: "Schedules",
+        operations: ["executions.list"],
+        options: [API_URL, ...CORRELATION_FILTER_OPTIONS, ...PAGE_OPTIONS],
+        positionals: [],
+        summary: "Find retained runs, newest first, by host identifier or tag.",
+        words: "executions list",
+    },
     /* --- Schedules -------------------------------------------------------- */
     {
         group: "Schedules",
         operations: ["schedules.list"],
         options: [
             API_URL,
+            ...CORRELATION_FILTER_OPTIONS,
             {
                 flag: "--endpoint",
                 summary: "Only the schedules that call this destination. Its id starts ep_.",
@@ -560,6 +593,7 @@ export const COMMAND_CATALOG = [
         operations: ["schedules.create"],
         options: [
             API_URL,
+            ...CORRELATION_WRITE_OPTIONS,
             {
                 flag: "--endpoint",
                 summary: "The destination to call, by id, starting ep_. Or use --url instead.",
@@ -641,6 +675,7 @@ export const COMMAND_CATALOG = [
         operations: ["schedules.replace"],
         options: [
             API_URL,
+            ...CORRELATION_WRITE_OPTIONS,
             {
                 flag: "--endpoint",
                 summary: "The destination to call, by id, starting ep_. Or use --url instead.",
@@ -1372,6 +1407,34 @@ export const COMMAND_CATALOG = [
         summary: "Remove your saved card. Project fees stop renewing when the paid period ends, and automatic top-up turns off.",
         words: "billing remove-card",
     },
+    {
+        group: "Planning",
+        operations: ["billing.promotions"],
+        options: [API_URL],
+        positionals: [],
+        summary: "List your promotions: promotional credit, complimentary projects, perks and discounts, with their end dates.",
+        words: "billing promotions",
+    },
+    {
+        confirms: true,
+        group: "Planning",
+        operations: ["billing.redeem"],
+        options: [
+            API_URL,
+            {
+                flag: "--target-project",
+                summary: "The project a complimentary-project code should cover.",
+                value: "<project-id>",
+            },
+            IDEMPOTENCY,
+            CONFIRM,
+        ],
+        positionals: [
+            { name: "<code>", summary: "The promotion code, as you received it." },
+        ],
+        summary: "Redeem a promotion code. Nothing is charged.",
+        words: "billing redeem",
+    },
     {
         group: "Planning",
         operations: ["billing.ledger"],
@@ -1626,11 +1689,6 @@ export const OPERATION_OMISSIONS = [
         ground: "declared",
         operation: "projects.delete",
     },
-    {
-        because: "The Executions page is the accepted project-wide history surface in this story. The generated SDK and MCP expose the operation to automation; adding a second interactive CLI design is outside it.",
-        ground: "declared",
-        operation: "executions.list",
-    },
     {
         because: "Grants are what a person gave to an application, and only that person may read them.",
         ground: "principal-unreachable",

package/dist/commands.js

@@ -6,7 +6,7 @@ import { parseDuration } from "./args.js";
 import { COMMAND_CATALOG, REQUESTED_SCOPES } from "./catalog.js";
 import { confirmChange } from "./confirm.js";
 import { directoryConcerns, originKey } from "./config.js";
-import { buildAuthorization, codeFrom, discover, exchangeCode, registerClient, revoke, } from "./oauth.js";
+import { awaitRedirect, buildAuthorization, codeFrom, discover, exchangeCode, registerClient, revoke, } from "./oauth.js";
 import { redactSecret } from "./output.js";
 import { CliError, sleepOrAbort } from "./runtime.js";
 import { publishedWait, recoveryFor, renderJourney, STEP_COMMANDS, } from "./journey.js";
@@ -65,9 +65,10 @@ const login = async (runtime, args) => {
             human: described.known
                 ? `Signed in to ${origin} with an API credential, in project ${described.context.project} (${described.context.environmentKind}).`
                 : `Stored an API credential for ${origin} without checking it.`,
-            nextMove: described.known
-                ? `Next: ${runtime.programName} journey — the published first-value sequence, with the command for each step.`
-                : `${described.reason}\n\nNext: ${runtime.programName} journey — the published first-value sequence, with the command for each step.`,
+            // **No onward step.** Signing in is not enrolment in the first-value
+            // journey, and a person who asked only to sign in was being told where to
+            // go next (FXO-3054). `greatwait --help` still names the journey.
+            ...(described.known ? {} : { nextMove: described.reason }),
         };
     }
     const server = await discover(runtime, origin);
@@ -128,8 +129,13 @@ const login = async (runtime, args) => {
         // **Printed whether or not the browser opened.** A URL shown only when
         // launching failed is a URL nobody on a remote shell ever sees, because
         // `xdg-open` there exits zero having opened nothing.
-        runtime.stderr(`${opened ? "Opened your browser. If nothing appeared, open" : "Open"} this address to approve the request:\n\n  ${authorization.authorizationUrl}\n\nWaiting for the answer on ${listener.redirectUri} …\n`);
-        const returned = await listener.received;
+        //
+        // The loopback address is not printed. It is how the browser answers this
+        // process, not something a person acts on, and it read as a second address
+        // to visit (FXO-3054). It is still in the authorization address, as
+        // `redirect_uri`, for anyone diagnosing a sign-in.
+        runtime.stderr(`${opened ? "Opened your browser. If nothing appeared, open" : "Open"} this address to approve the request:\n\n  ${authorization.authorizationUrl}\n\nWaiting for you to approve it …\n`);
+        const returned = await awaitRedirect(runtime, listener);
         const code = codeFrom(returned, authorization.state, runtime.programName);
         const tokens = await exchangeCode(runtime, server, {
             clientId,
@@ -181,9 +187,7 @@ const login = async (runtime, args) => {
             human: described.known
                 ? `Signed in to ${origin}, in project ${described.context.project} (${described.context.environmentKind}).`
                 : `Signed in to ${origin}. The grant is real — the service issued it — but it cannot say what it reaches.`,
-            nextMove: described.known
-                ? `Next: ${runtime.programName} journey — the published first-value sequence, with the command for each step.`
-                : `${described.reason}\n\nNext: ${runtime.programName} journey — the published first-value sequence, with the command for each step.`,
+            ...(described.known ? {} : { nextMove: described.reason }),
         };
     }
     finally {

package/dist/node-runtime.d.ts

@@ -19,6 +19,16 @@ import { type CliRuntime, type LoopbackListener } from "./runtime.js";
  *
  * Port zero: the operating system picks, and the port is known before the
  * client is registered for it, which RFC 8252's exact-match rule requires.
+ *
+ * **Closing it ends every connection a browser opened, not just the listening
+ * socket.** `server.close()` stops accepting and then waits for open
+ * connections to finish, and a browser keeps them open: Chrome preconnects a
+ * socket it never sends a request on, and holds the redirect's own connection
+ * alive for reuse. Either one kept the process running after `login` had
+ * printed its success — and because Ctrl-C is caught to end waits cleanly, it
+ * could not be stopped short of closing the terminal (FXO-3054). Every socket
+ * is tracked from the moment it connects and destroyed on close, and every
+ * answer says `Connection: close` so a browser does not hold one for reuse.
  */
 export declare function openLoopback(): Promise<LoopbackListener>;
 /**

package/dist/node-runtime.js

@@ -23,6 +23,16 @@ import { InterruptedError, } from "./runtime.js";
  *
  * Port zero: the operating system picks, and the port is known before the
  * client is registered for it, which RFC 8252's exact-match rule requires.
+ *
+ * **Closing it ends every connection a browser opened, not just the listening
+ * socket.** `server.close()` stops accepting and then waits for open
+ * connections to finish, and a browser keeps them open: Chrome preconnects a
+ * socket it never sends a request on, and holds the redirect's own connection
+ * alive for reuse. Either one kept the process running after `login` had
+ * printed its success — and because Ctrl-C is caught to end waits cleanly, it
+ * could not be stopped short of closing the terminal (FXO-3054). Every socket
+ * is tracked from the moment it connects and destroyed on close, and every
+ * answer says `Connection: close` so a browser does not hold one for reuse.
  */
 export async function openLoopback() {
     let deliver;
@@ -39,19 +49,29 @@ export async function openLoopback() {
     // class the refusal earned. A handler attached here is never the *only* one:
     // a caller that does await it still sees the rejection.
     received.catch(() => undefined);
+    // `IncomingMessage["socket"]` rather than an import of `node:net`, which the
+    // architecture gate would count as one more runtime dependency.
+    const sockets = new Set();
     const server = createServer((request, response) => {
         const url = new URL(request.url ?? "/", "http://127.0.0.1");
         const isRedirect = url.pathname === "/callback" &&
             (url.searchParams.has("code") || url.searchParams.has("error"));
         if (!isRedirect) {
-            response.writeHead(204);
+            response.writeHead(204, { connection: "close" });
             response.end();
             return;
         }
-        response.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+        response.writeHead(200, {
+            connection: "close",
+            "content-type": "text/plain; charset=utf-8",
+        });
         response.end("GreatWait received the answer. You can close this tab.\n");
         deliver?.(url.searchParams);
     });
+    server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.once("close", () => sockets.delete(socket));
+    });
     await new Promise((resolve, reject) => {
         server.once("error", reject);
         // `127.0.0.1` rather than every interface: this socket receives an
@@ -70,6 +90,18 @@ export async function openLoopback() {
         close: () => {
             fail?.(new Error("the sign-in was abandoned"));
             server.close();
+            // After `close`, so nothing new is accepted while these are destroyed.
+            // A refusal can close within a tick of answering the redirect, so a
+            // socket still flushing that answer is ended first and destroyed once it
+            // has, and the browser still shows the page.
+            for (const socket of sockets) {
+                if (socket.writableLength > 0) {
+                    socket.end(() => socket.destroy());
+                }
+                else {
+                    socket.destroy();
+                }
+            }
         },
         received,
         redirectUri: `http://127.0.0.1:${String(address.port)}/callback`,

package/dist/oauth.d.ts

@@ -1,4 +1,4 @@
-import { type CliRuntime } from "./runtime.js";
+import { type CliRuntime, type LoopbackListener } from "./runtime.js";
 /**
  * The delegated-authorization half of `login`, spoken as a public client.
  *
@@ -59,6 +59,20 @@ export declare function buildAuthorization(runtime: CliRuntime, server: Authoriz
     readonly redirectUri: string;
     readonly scopes: readonly string[];
 }): Promise<AuthorizationRequest>;
+/**
+ * The redirect, or the reason there will not be one.
+ *
+ * **Bounded by Ctrl-C and by the authorization request's own lifetime.** It
+ * used to await the listener alone, so Ctrl-C aborted a signal nothing here was
+ * watching and a browser closed without answering held the terminal for ever.
+ * The deadline is the service's: past it the request a person would approve
+ * has expired, and waiting longer could only end in a refusal.
+ *
+ * The timer is cancelled however the wait ends. A ten-minute timer left armed
+ * after a successful sign-in is ten minutes of a process that has finished and
+ * will not exit.
+ */
+export declare function awaitRedirect(runtime: CliRuntime, listener: LoopbackListener): Promise<URLSearchParams>;
 /**
  * Turns the redirect into a code, refusing anything that is not this run's.
  *

package/dist/oauth.js

@@ -1,4 +1,5 @@
-import { CliError } from "./runtime.js";
+import { AUTHORIZATION_REQUEST_TTL_SECONDS } from "@greatwait/contracts";
+import { CliError, InterruptedError, } from "./runtime.js";
 function base64Url(bytes) {
     return Buffer.from(bytes).toString("base64url");
 }
@@ -109,6 +110,44 @@ export async function buildAuthorization(runtime, server, options) {
     url.searchParams.set("state", state);
     return { authorizationUrl: url.toString(), state, verifier };
 }
+/**
+ * The redirect, or the reason there will not be one.
+ *
+ * **Bounded by Ctrl-C and by the authorization request's own lifetime.** It
+ * used to await the listener alone, so Ctrl-C aborted a signal nothing here was
+ * watching and a browser closed without answering held the terminal for ever.
+ * The deadline is the service's: past it the request a person would approve
+ * has expired, and waiting longer could only end in a refusal.
+ *
+ * The timer is cancelled however the wait ends. A ten-minute timer left armed
+ * after a successful sign-in is ten minutes of a process that has finished and
+ * will not exit.
+ */
+export async function awaitRedirect(runtime, listener) {
+    if (runtime.signal.aborted)
+        throw new InterruptedError();
+    const stop = new AbortController();
+    const onAbort = () => {
+        stop.abort();
+    };
+    runtime.signal.addEventListener("abort", onAbort, { once: true });
+    const deadline = runtime
+        .sleep(AUTHORIZATION_REQUEST_TTL_SECONDS * 1_000, stop.signal)
+        .then(() => {
+        if (runtime.signal.aborted)
+            throw new InterruptedError();
+        throw new CliError(`nobody approved the request within ${String(AUTHORIZATION_REQUEST_TTL_SECONDS / 60)} minutes, so this command stopped waiting`, "timeout", `Run ${runtime.programName} login again, or use an API key: ${runtime.programName} login --api-key`);
+    });
+    try {
+        return await Promise.race([listener.received, deadline]);
+    }
+    finally {
+        runtime.signal.removeEventListener("abort", onAbort);
+        stop.abort();
+        // The losing side settles after the race and nobody awaits it.
+        deadline.catch(() => undefined);
+    }
+}
 /**
  * Turns the redirect into a code, refusing anything that is not this run's.
  *

package/dist/operate.js

@@ -1,5 +1,5 @@
 import { writeFile } from "node:fs/promises";
-import { projectNotificationSettingsUpdateRequestSchema, statusSigningKeyRequestSchema, autoPauseAfterFailuresSchema, httpRequestSchema, sanitizedDiagnosticText, diagnosticBodyText, responseBodySentence, requestCaptureSentence, attemptStatusGuidance, endpointHeaderChangesSchema, billingAutoTopUpApplyRequestSchema, billingAutoTopUpPreviewRequestSchema, billingAutoTopUpPreviewSchema, billingCeilingUpdateRequestSchema, billingFundingQuoteRequestSchema, billingFundingQuoteSchema, billingNotificationSettingsUpdateRequestSchema, billingRefundRequestCreateSchema, billingRefundResolutionRequestSchema, projectBillingQuoteSchema, projectBillingQuoteRequestSchema, } from "@greatwait/contracts";
+import { projectNotificationSettingsUpdateRequestSchema, statusSigningKeyRequestSchema, autoPauseAfterFailuresSchema, httpRequestSchema, externalIdentifierSchema, scheduleTagsSchema, scheduleTagSchema, sanitizedDiagnosticText, diagnosticBodyText, responseBodySentence, requestCaptureSentence, attemptStatusGuidance, endpointHeaderChangesSchema, billingAutoTopUpApplyRequestSchema, billingAutoTopUpPreviewRequestSchema, billingAutoTopUpPreviewSchema, billingCeilingUpdateRequestSchema, billingFundingQuoteRequestSchema, billingFundingQuoteSchema, billingNotificationSettingsUpdateRequestSchema, billingRefundRequestCreateSchema, billingRefundResolutionRequestSchema, billingRedeemRequestSchema, projectBillingQuoteSchema, projectBillingQuoteRequestSchema, } from "@greatwait/contracts";
 import { parseDuration } from "./args.js";
 import { confirmChange } from "./confirm.js";
 import { redactSecret } from "./output.js";
@@ -125,8 +125,18 @@ async function scheduleRequest(runtime, args, usage) {
         throw new CliError('--auto-pause-after-failures must be a whole number from 1 to 100, or "never"', "usage");
     const latencyClass = args.options["--latency-class"];
     const partitionKey = args.options["--partition-key"];
+    const external_identifier = args.options["--external-identifier"];
+    if (external_identifier !== undefined &&
+        !externalIdentifierSchema.safeParse(external_identifier).success)
+        throw new CliError("--external-identifier must contain 1–256 UTF-8 bytes and no NUL characters", "usage");
+    const tags = await readJsonOption(runtime, "--tags", args.options["--tags"]);
+    const parsedTags = tags === undefined ? undefined : scheduleTagsSchema.safeParse(tags);
+    if (parsedTags !== undefined && !parsedTags.success)
+        throw new CliError("--tags must be up to 16 distinct strings, each 1–64 UTF-8 bytes", "usage");
     return {
         ...(data === undefined ? {} : { data }),
+        ...(external_identifier === undefined ? {} : { external_identifier }),
+        ...(parsedTags?.success ? { tags: parsedTags.data } : {}),
         ...(http?.success ? { http: http.data } : {}),
         ...(endpoint === undefined ? {} : { endpoint }),
         ...(url === undefined ? {} : { url }),
@@ -311,18 +321,51 @@ const destinationsRotateKey = async (runtime, args) => {
 /* -------------------------------------------------------------------------- */
 /* Schedules                                                                  */
 /* -------------------------------------------------------------------------- */
+function correlationFilters(args) {
+    const external_identifier = args.options["--external-identifier"];
+    const tag = args.options["--tag"];
+    if (external_identifier !== undefined &&
+        !externalIdentifierSchema.safeParse(external_identifier).success)
+        throw new CliError("--external-identifier must contain 1–256 UTF-8 bytes", "usage");
+    if (tag !== undefined && !scheduleTagSchema.safeParse(tag).success)
+        throw new CliError("--tag must contain 1–64 UTF-8 bytes", "usage");
+    return {
+        ...(external_identifier === undefined ? {} : { external_identifier }),
+        ...(tag === undefined ? {} : { tag }),
+    };
+}
+function correlationCommand(args) {
+    return ["--external-identifier", "--tag"]
+        .flatMap((flag) => args.options[flag] === undefined
+        ? []
+        : [` ${flag} ${`'${args.options[flag].replaceAll("'", "'\"'\"'")}'`}`])
+        .join("");
+}
+const executionsList = async (runtime, args) => {
+    const filters = correlationFilters(args);
+    const active = await session(runtime, args);
+    return listing(runtime, args, {
+        columns: ["STATE", "PLANNED FOR", "SCHEDULE", "RUN"],
+        command: `${runtime.programName} executions list${correlationCommand(args)}`,
+        empty: "No retained runs match these filters.",
+        read: (request) => page("executions.list", () => active.client.request("executions_list", { ...request, ...filters })),
+        row: (run) => [run.state, run.plannedFor, run.schedule, run.id],
+    });
+};
 const schedulesList = async (runtime, args) => {
+    const filters = correlationFilters(args);
     const active = await session(runtime, args);
     const endpoint = args.options["--endpoint"];
     return listing(runtime, args, {
         columns: ["STATUS", "NAME", "RECURRENCE", "DELIVERS TO", "SCHEDULE"],
-        command: `${runtime.programName} schedules list${endpoint === undefined ? "" : ` --endpoint ${endpoint}`}`,
+        command: `${runtime.programName} schedules list${endpoint === undefined ? "" : ` --endpoint ${endpoint}`}${correlationCommand(args)}`,
         empty: endpoint === undefined
             ? "This project has no schedules yet."
             : "No schedule delivers to that destination.",
         read: (request) => page("schedules.list", () => active.client.request("schedules_list", {
             ...request,
             ...(endpoint === undefined ? {} : { endpoint }),
+            ...filters,
         })),
         row: (schedule) => [
             schedule.status,
@@ -735,6 +778,16 @@ const billing = async (runtime, args) => {
             ...(view.trialExpiresAt === undefined
                 ? []
                 : [`Trial ends   ${view.trialExpiresAt}`]),
+            ...(view.credit.byKind === undefined
+                ? []
+                : ["purchased", "trial", "promotional"].flatMap((kind) => {
+                    const balance = view.credit.byKind[kind];
+                    return balance.granted.microdollars === "0"
+                        ? []
+                        : [
+                            `${kind.padEnd(12)} ${money(balance.available)} available, ${money(balance.reserved)} reserved, ${money(balance.consumed)} used${balance.forfeited.microdollars === "0" ? "" : `, ${money(balance.forfeited)} expired`}${balance.expiresAt === undefined ? "" : `; ends ${balance.expiresAt}`}`,
+                        ];
+                })),
             ...(view.activation.mode === "shadow" || view.blockingReasons.length === 0
                 ? []
                 : [`Blocked      ${view.blockingReasons.join(", ")}`]),
@@ -1050,6 +1103,63 @@ const billingAutoTopUpApply = async (runtime, args) => {
         data: { confirmation, idempotencyKey: key, ...view },
     };
 };
+function promotionGrantLine(grant) {
+    const benefit = grant.benefit;
+    const what = benefit.kind === "credit"
+        ? `${money(benefit.amount)} promotional credit`
+        : benefit.kind === "project-slot"
+            ? `complimentary project ${benefit.project}`
+            : benefit.kind === "perk"
+                ? `perk ${benefit.perk}`
+                : `${benefit.percentOff !== undefined ? `${String(benefit.percentOff)}%` : money(benefit.amountOff)} off project fees, ${benefit.duration === "once" ? "one invoice" : `${String(benefit.durationInMonths)} invoices`}`;
+    return `${grant.id}: ${what} (${grant.state}, from ${grant.source}${grant.endsAt === undefined ? "" : `, ends ${grant.endsAt}`}${grant.revokedAt === undefined ? "" : `, revoked ${grant.revokedAt}`})`;
+}
+function promotionsLines(view) {
+    return [
+        `Projects: ${String(view.projectCapacity.included)} included, ${String(view.projectCapacity.paid)} paid, ${String(view.projectCapacity.complimentary)} complimentary`,
+        ...(view.grants.length === 0
+            ? ["No promotions."]
+            : view.grants.map(promotionGrantLine)),
+        ...view.restrictions,
+    ];
+}
+const billingPromotions = async (runtime, args) => {
+    const active = await session(runtime, args);
+    const view = parseResponse("billing.promotions", await active.client.request("billing_promotions"));
+    return { data: view, human: promotionsLines(view).join("\n") };
+};
+const billingRedeem = async (runtime, args) => {
+    const parsed = billingRedeemRequestSchema.safeParse({
+        code: positionals(args, ["<code>"], `${runtime.programName} billing redeem <code> [--target-project <project-id>]`)[0],
+        confirmed: true,
+        ...(args.options["--target-project"] === undefined
+            ? {}
+            : { project: args.options["--target-project"] }),
+    });
+    if (!parsed.success)
+        throw new CliError("Provide the code, and --target-project when the code covers a project.", "usage");
+    const confirmation = await confirmChange(runtime, args, {
+        action: "Redeem this promotion code for your organization.",
+        effect: [
+            ...(parsed.data.project === undefined
+                ? []
+                : [`project ${parsed.data.project}`]),
+            "Nothing is charged. Promotional value expires, has no cash value and cannot be refunded.",
+        ],
+    });
+    const active = await session(runtime, args);
+    const key = idempotencyKey(runtime, args);
+    const view = parseResponse("billing.redeem", await active.client.request("billing_redeem", parsed.data, {
+        "Idempotency-Key": key,
+    }));
+    return {
+        data: { confirmation, idempotencyKey: key, ...view },
+        human: [
+            `Redeemed ${promotionGrantLine(view.grant)}`,
+            ...promotionsLines(view.promotions),
+        ].join("\n"),
+    };
+};
 const billingRefundRequest = async (runtime, args) => {
     const parsed = billingRefundRequestCreateSchema.safeParse({
         amount: budgetMoney(args, "--amount"),
@@ -1139,8 +1249,13 @@ function projectBillingResult(view) {
         human: [
             `Monthly project fees ${money(view.recurringProjectFees)}`,
             `Policy desired r${String(view.desiredRevision)}, effective r${String(view.effectiveRevision)}${view.pending ? " (pending)" : ""}`,
-            ...view.projects.map((project) => `${project.name} (${project.project}): ${project.access}${project.paidThroughAt ? `, paid through ${project.paidThroughAt}` : ""}${project.cancellationAt ? `, cancels ${project.cancellationAt}` : ""}${project.renewalGraceUntil ? `, renewal grace until ${project.renewalGraceUntil}` : ""}`),
+            ...view.projects.map((project) => `${project.name} (${project.project}): ${project.complimentary ? `complimentary until ${project.complimentary.endsAt}` : project.access}${project.paidThroughAt ? `, paid through ${project.paidThroughAt}` : ""}${project.cancellationAt ? `, cancels ${project.cancellationAt}` : ""}${project.renewalGraceUntil ? `, renewal grace until ${project.renewalGraceUntil}` : ""}`),
             ...view.pendingOperations.map((operation) => `${operation.project}: ${operation.state}${operation.reason ? ` (${operation.reason})` : ""}${operation.paymentUrl ? ` ${operation.paymentUrl}` : ""}`),
+            ...(view.discount === undefined
+                ? []
+                : [
+                    `Discount ${view.discount.percentOff !== undefined ? `${String(view.discount.percentOff)}% off` : `${money(view.discount.amountOff)} off`} ${view.discount.duration === "once" ? "one invoice" : `${String(view.discount.durationInMonths)} monthly invoices`} (${view.discount.state})`,
+                ]),
         ].join("\n"),
     };
 }
@@ -1151,6 +1266,11 @@ const billingProjects = async (runtime, args) => {
 function projectQuoteLines(quote) {
     return [
         `Project ${quote.project}${quote.fromProject ? `; former included ${quote.fromProject}` : ""}`,
+        ...(quote.discount === undefined
+            ? []
+            : [
+                `Before discount ${money(quote.discount.gross)}; discount ${money(quote.discount.amount)} for ${quote.discount.duration === "once" ? "this invoice" : `${String(quote.discount.durationInMonths)} monthly invoices`}`,
+            ]),
         `Charge ${money(quote.charge)}; monthly project fees ${money(quote.monthlyProjectFees)}`,
         `Effective ${quote.effectiveAt}; quote expires ${quote.expiresAt}`,
         ...(quote.formerIncludedWillBlock
@@ -1730,6 +1850,8 @@ export const OPERATE_COMMANDS = {
     "billing notification-settings": billingNotificationSettings,
     "billing update-notifications": billingNotificationSettingsUpdate,
     "billing ledger": billingLedger,
+    "billing promotions": billingPromotions,
+    "billing redeem": billingRedeem,
     "billing projects": billingProjects,
     "billing purchase": billingPurchase,
     "billing quote-funding": billingQuoteFunding,
@@ -1760,6 +1882,7 @@ export const OPERATE_COMMANDS = {
     "schedules archive": schedulesArchive,
     "schedules cancel": schedulesCancel,
     "schedules list": schedulesList,
+    "executions list": executionsList,
     "schedules pause": schedulesPause,
     "schedules replace": schedulesReplace,
     "schedules resume": schedulesResume,

package/dist/start.d.ts

@@ -1,15 +1 @@
-/**
- * The body both installed executables share.
- *
- * **Two entry files rather than one that works out what it was called.**
- * `process.argv[1]` is the *resolved* path of the main module, and npm links a
- * bin as a symlink into `node_modules/.bin`, so a program deriving its own name
- * from argv would read `main.js` — and the version that guesses correctly on
- * macOS is the version that guesses differently under a shell wrapper, on
- * Windows, or with `--preserve-symlinks-main`. The name is a property of the
- * entry point, so the entry point states it.
- *
- * `process.exitCode` rather than `process.exit`: the second truncates whatever
- * is still buffered on stdout, and this command's last act is to print.
- */
 export declare function start(programName: string): Promise<void>;

package/dist/start.js

@@ -1,4 +1,5 @@
 import { run } from "./cli.js";
+import { EXIT_CLASSES } from "./exit.js";
 import { nodeRuntime } from "./node-runtime.js";
 /**
  * The body both installed executables share.
@@ -13,14 +14,40 @@ import { nodeRuntime } from "./node-runtime.js";
  *
  * `process.exitCode` rather than `process.exit`: the second truncates whatever
  * is still buffered on stdout, and this command's last act is to print.
+ *
+ * **Catching a signal must never make the process unstoppable.** The first
+ * Ctrl-C aborts, so a wait can end with its own sentence and exit class. A
+ * second one a moment later exits at once with 130, and once the command has
+ * returned the handlers are removed, so a signal regains its default meaning.
+ * "A moment later" because one keypress under `npx` arrives twice — from the
+ * terminal to the process group, and again forwarded by npm — and treating the
+ * echo as a second Ctrl-C would skip the interruption's own sentence. Before
+ * FXO-3054 neither held: a socket left open after a successful `login` kept the
+ * process alive, every Ctrl-C was absorbed by an abort nothing was waiting on,
+ * and the only way out was closing the terminal.
  */
+/** How far apart two signals must be to count as a person asking twice. */
+const REPEATED_SIGNAL_MS = 500;
 export async function start(programName) {
     const controller = new AbortController();
-    process.on("SIGINT", () => {
-        controller.abort();
-    });
-    process.on("SIGTERM", () => {
-        controller.abort();
-    });
-    process.exitCode = await run(nodeRuntime(controller.signal, programName));
+    let firstSignalAt;
+    const onSignal = (signal) => {
+        if (firstSignalAt === undefined) {
+            firstSignalAt = Date.now();
+            controller.abort();
+            return;
+        }
+        if (Date.now() - firstSignalAt >= REPEATED_SIGNAL_MS) {
+            process.exit(signal === "SIGINT" ? EXIT_CLASSES.interrupted : 143);
+        }
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    try {
+        process.exitCode = await run(nodeRuntime(controller.signal, programName));
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+    }
 }

package/package.json

@@ -7,8 +7,8 @@
     "url": "https://github.com/flowxo/greatwait/issues"
   },
   "dependencies": {
-    "@greatwait/api-client": "0.2.0",
-    "@greatwait/contracts": "0.2.0"
+    "@greatwait/api-client": "0.2.2",
+    "@greatwait/contracts": "0.2.2"
   },
   "description": "The GreatWait command line: sign in, schedule a call to a URL, and read its delivery outcome over the public API.",
   "engines": {
@@ -48,5 +48,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.2.0"
+  "version": "0.2.2"
 }