@greatwait/cli 0.1.0-alpha.5 → 0.1.0-alpha.6

package/dist/commands.js

@@ -1,5 +1,7 @@
+import { readPrivateJsonOption } from "./support.js";
+import { MEMBER_IMPLEMENTATIONS } from "./member-commands.js";
 import { GreatwaitClientError, createGreatwaitClient, } from "@greatwait/api-client";
-import { isTerminalOccurrenceState, responseSchemaFor, } from "@greatwait/contracts";
+import { endpointHeaderChangesSchema, isTerminalOccurrenceState, responseSchemaFor, } from "@greatwait/contracts";
 import { parseDuration } from "./args.js";
 import { COMMAND_CATALOG, REQUESTED_SCOPES } from "./catalog.js";
 import { confirmChange } from "./confirm.js";
@@ -9,7 +11,7 @@ import { redactSecret } from "./output.js";
 import { CliError, sleepOrAbort } from "./runtime.js";
 import { publishedWait, recoveryFor, renderJourney, STEP_COMMANDS, } from "./journey.js";
 import { anonymousClient, ENVIRONMENT_NAMES, openSession, resolveOrigin, storeFor, } from "./session.js";
-import { OPERATE_COMMANDS, scheduleRequest } from "./operate.js";
+import { OPERATE_COMMANDS, destinationLines, scheduleRequest } from "./operate.js";
 import { apiUrlOption, expectNoExtraArguments, parseResponse, positionals, } from "./support.js";
 /* -------------------------------------------------------------------------- */
 /* Signing in                                                                 */
@@ -571,8 +573,17 @@ const destinationsCreate = async (runtime, args) => {
     if (url === undefined) {
         throw new CliError(`${runtime.programName} destinations create needs --url`, "usage", `Usage: ${runtime.programName} destinations create --url https://your-receiver.example.com/greatwait`);
     }
+    const headerInput = await readPrivateJsonOption(runtime, "--headers", args.options["--headers"]);
+    const headers = headerInput === undefined
+        ? undefined
+        : endpointHeaderChangesSchema.safeParse(headerInput);
+    if (headers !== undefined && !headers.success)
+        throw new CliError("--headers settings are invalid", "usage", headers.error.issues.map((issue) => issue.message).join("; "));
     const session = await openSession(runtime, { apiUrl: apiUrlOption(args) });
-    const created = responseSchemaFor("endpoints.create")?.parse(await session.client.request("endpoints_create", { url }));
+    const created = responseSchemaFor("endpoints.create")?.parse(await session.client.request("endpoints_create", {
+        url,
+        ...(headers?.success ? { headers: headers.data } : {}),
+    }));
     return {
         // **The secret is here and in no later output.** The service returns it
         // from this call and from no other, which is the product behaviour rather
@@ -628,16 +639,27 @@ const destinationsDisable = async (runtime, args) => {
 /* Schedules                                                                  */
 /* -------------------------------------------------------------------------- */
 const schedulesCreate = async (runtime, args) => {
-    const usage = `${runtime.programName} schedules create --endpoint <destination> (--in <duration> | --at <instant> | --every <duration> | --cron <expression>)`;
-    if (args.options["--endpoint"] === undefined) {
-        throw new CliError(`${runtime.programName} schedules create needs --endpoint`, "usage", `Usage: ${usage}`);
+    const usage = `${runtime.programName} schedules create (--endpoint <destination> | --url <https url>) (--in <duration> | --at <instant> | --every <duration> | --cron <expression>) [--wait]`;
+    if (args.options["--endpoint"] === undefined &&
+        args.options["--url"] === undefined) {
+        throw new CliError(`${runtime.programName} schedules create needs --url or --endpoint`, "usage", `Usage: ${usage}`);
+    }
+    const wait = args.booleans.has("--wait");
+    // Parsed before anything is sent: a typo in --timeout found after the create
+    // would exit without the schedule's id or retry key, and the corrected rerun
+    // would make a second schedule.
+    const timeoutMs = wait ? waitTimeoutMs(args) : undefined;
+    if (!wait && args.options["--timeout"] !== undefined) {
+        // Refused rather than ignored: somebody who passed a timeout believes the
+        // command will wait for something.
+        throw new CliError("--timeout only means something with --wait", "usage", `Usage: ${usage} [--timeout <duration>]`);
     }
     expectNoExtraArguments(args, 0, usage);
     const session = await openSession(runtime, { apiUrl: apiUrlOption(args) });
     // **The same builder `schedules replace` uses.** The two send the identical
     // definition — a replace is a create with an identifier — and writing the
     // recurrence rules out twice is how one of them comes to accept a cron
-    // expression the other does not.
+    // expression the other does not. It also refuses `--url` with `--endpoint`.
     const request = await scheduleRequest(runtime, args, usage);
     // **Generated when it is not given, and printed either way.** A create that
     // silently invented a fresh key on every run would make a retry a second
@@ -648,30 +670,125 @@ const schedulesCreate = async (runtime, args) => {
     const answer = await session.client.requestDetailed("schedules_create", request, { "Idempotency-Key": idempotencyKey });
     const created = parseResponse("schedules.create", answer.body);
     const replayed = answer.headers["Idempotency-Replayed"] === "true";
+    const schedule = created.schedule.id;
+    const occurrence = created.occurrence.id;
+    const data = {
+        ...(created.endpointSigningSecret === undefined
+            ? {}
+            : {
+                endpoint: created.schedule.endpoint,
+                endpointSigningSecret: created.endpointSigningSecret,
+            }),
+        idempotencyKey,
+        occurrence,
+        plannedFor: created.occurrence.plannedFor,
+        replayed,
+        schedule,
+    };
+    const human = [
+        `Schedule     ${schedule}`,
+        `Occurrence   ${occurrence}`,
+        `Planned for  ${created.occurrence.plannedFor}`,
+        `Retry key    ${idempotencyKey}`,
+        ...destinationLines(created.schedule, created.endpointSigningSecret, args.options["--url"]),
+        ...(replayed
+            ? [
+                ``,
+                `This key had already been used for this exact request, so nothing was`,
+                `created a second time and no second callback will be delivered.`,
+            ]
+            : []),
+    ];
+    const watchLater = `${runtime.programName} occurrences wait ${schedule} ${occurrence}`;
+    if (!wait) {
+        return {
+            data,
+            human: human.join("\n"),
+            nextMove: `Next: ${watchLater}`,
+        };
+    }
+    const repeats = created.schedule.recurrence.kind !== "at";
+    if (timeoutMs === undefined)
+        throw new CliError("--wait lost its timeout", "internal");
+    const dueInMs = Date.parse(created.occurrence.plannedFor) - runtime.now();
+    if (dueInMs > timeoutMs) {
+        // **Said at once rather than discovered at the deadline.** Polling for
+        // three minutes towards a call due tomorrow would end in the same timeout
+        // with nothing learned; the schedule exists either way.
+        return {
+            data: {
+                ...data,
+                wait: { settled: false, state: created.occurrence.state },
+            },
+            exit: "timeout",
+            human: [
+                ...human,
+                ``,
+                `Not waiting: the first call is due at ${created.occurrence.plannedFor}, after the wait would end.`,
+            ].join("\n"),
+            nextMove: `Watch it nearer the time: ${watchLater}`,
+        };
+    }
+    // The schedule's identifiers before the wait, so a person who interrupts it
+    // still has them. A machine reads them from the JSON at the end.
+    if (!args.booleans.has("--json")) {
+        runtime.stderr(`${human.join("\n")}\n\n`);
+    }
+    const watched = await watchOccurrence(runtime, session, schedule, occurrence, timeoutMs);
+    const repeating = repeats
+        ? [
+            ``,
+            `This schedule repeats. Only its first call was waited for, and it keeps running.`,
+        ]
+        : [];
+    if (!watched.settled) {
+        return {
+            data: { ...data, wait: { settled: false, state: watched.state } },
+            exit: "timeout",
+            human: [
+                `The first call was still ${watched.state} when the wait ended.`,
+                ...repeating,
+            ].join("\n"),
+            ...(() => {
+                const nextMove = recoveryFor("await-occurrence", "not-settled");
+                return nextMove === undefined ? {} : { nextMove };
+            })(),
+        };
+    }
+    const attempts = parseResponse("attempts.list", await session.client.request("attempts_list", schedule, occurrence)).data;
+    const delivered = watched.occurrence.state === "succeeded";
     return {
         data: {
-            idempotencyKey,
-            occurrence: created.occurrence.id,
-            plannedFor: created.occurrence.plannedFor,
-            replayed,
-            schedule: created.schedule.id,
+            ...data,
+            wait: { attempts, occurrence: watched.occurrence, settled: true },
         },
         human: [
-            `Schedule     ${created.schedule.id}`,
-            `Occurrence   ${created.occurrence.id}`,
-            `Planned for  ${created.occurrence.plannedFor}`,
-            `Retry key    ${idempotencyKey}`,
-            ...(replayed
-                ? [
-                    ``,
-                    `This key had already been used for this exact request, so nothing was`,
-                    `created a second time and no second callback will be delivered.`,
-                ]
-                : []),
+            delivered
+                ? `Delivered. ${outcomeOf(attempts.find((attempt) => attempt.state === "succeeded"))}`
+                : `Not delivered: the first call settled ${watched.occurrence.state}.`,
+            // The attempt rows only when they explain something: a delivered call
+            // has said all it needs to in the line above.
+            ...(delivered || attempts.length === 0
+                ? []
+                : [``, ...attempts.map(attemptLine)]),
+            ...repeating,
         ].join("\n"),
-        nextMove: `Next: ${runtime.programName} occurrences wait ${created.schedule.id} ${created.occurrence.id}`,
+        ...(delivered
+            ? {}
+            : (() => {
+                const nextMove = recoveryFor("read-attempt", "attempt-failed");
+                return nextMove === undefined ? {} : { nextMove };
+            })()),
     };
 };
+function attemptLine(attempt) {
+    return `${attempt.state.padEnd(20)}${attempt.responseStatus === undefined ? "no response" : `answered ${String(attempt.responseStatus)}`}${attempt.diagnostic === undefined ? "" : `  ${attempt.diagnostic}`}${attempt.remediation === undefined ? "" : ` / ${attempt.remediation}`}`;
+}
+function outcomeOf(attempt) {
+    return attempt?.responseStatus === undefined
+        ? "Your receiver accepted the call."
+        : `Your receiver answered ${String(attempt.responseStatus)}.`;
+}
 const schedulesRead = async (runtime, args) => {
     const id = args.command[0];
     if (id === undefined) {
@@ -767,21 +884,28 @@ const exportsCancel = async (runtime, args) => {
 /* -------------------------------------------------------------------------- */
 /* Waiting                                                                    */
 /* -------------------------------------------------------------------------- */
-const occurrencesWait = async (runtime, args) => {
-    const schedule = args.command[0];
-    const occurrence = args.command[1];
-    if (schedule === undefined || occurrence === undefined) {
-        throw new CliError(`${runtime.programName} occurrences wait needs a schedule and an occurrence`, "usage", `Usage: ${runtime.programName} occurrences wait <schedule> <occurrence>`);
-    }
-    expectNoExtraArguments(args, 2, `${runtime.programName} occurrences wait <schedule> <occurrence>`);
-    const session = await openSession(runtime, { apiUrl: apiUrlOption(args) });
-    // The interval and the deadline come from the published journey. A number
-    // here would be a fourth answer to a question the website, the curl page and
-    // the JavaScript page already answer identically.
-    const { intervalMs, timeoutMs } = publishedWait();
+/**
+ * How long a wait lasts: `--timeout`, or the published journey's deadline.
+ *
+ * The interval and the deadline come from the published journey. A number
+ * here would be a fourth answer to a question the website, the curl page and
+ * the JavaScript page already answer identically.
+ */
+function waitTimeoutMs(args) {
     const override = args.options["--timeout"];
-    const deadline = runtime.now() +
-        (override === undefined ? timeoutMs : parseDuration(override) * 1000);
+    return override === undefined
+        ? publishedWait().timeoutMs
+        : parseDuration(override) * 1000;
+}
+/**
+ * Reads one occurrence until it settles or the deadline passes, reporting each
+ * new state on standard error. Shared by `occurrences wait` and `schedules
+ * create --wait`, so the two cannot come to disagree about what settled means
+ * or how long the wait lasts.
+ */
+async function watchOccurrence(runtime, session, schedule, occurrence, timeoutMs) {
+    const { intervalMs } = publishedWait();
+    const deadline = runtime.now() + timeoutMs;
     const seen = [];
     for (;;) {
         const view = responseSchemaFor("occurrences.read")?.parse(await session.client.request("occurrences_read", schedule, occurrence));
@@ -791,24 +915,43 @@ const occurrencesWait = async (runtime, args) => {
             runtime.stderr(`  ${state}\n`);
         }
         if (isTerminalOccurrenceState(state)) {
-            return {
-                data: {
-                    attempts: view.occurrence.attemptCount,
-                    occurrence,
-                    schedule,
-                    settled: true,
-                    state,
-                    states: seen,
-                },
-                human: `Occurrence ${occurrence} settled ${state} after ${String(view.occurrence.attemptCount)} ${view.occurrence.attemptCount === 1 ? "attempt" : "attempts"}.`,
-                nextMove: `Next: ${runtime.programName} attempts list ${schedule} ${occurrence}`,
-            };
+            return { occurrence: view.occurrence, settled: true, states: seen };
         }
-        if (runtime.now() >= deadline) {
-            throw new CliError(`occurrence ${occurrence} was still ${state} when the deadline passed`, "timeout", recoveryFor("await-occurrence", "not-settled"));
+        const remaining = deadline - runtime.now();
+        if (remaining <= 0) {
+            return { settled: false, state, states: seen };
         }
-        await sleepOrAbort(runtime, intervalMs);
+        // Cut to the time left, so the last read happens at the deadline rather
+        // than an interval past it — a --timeout that is not a multiple of the
+        // interval means what it says.
+        await sleepOrAbort(runtime, Math.min(intervalMs, remaining));
+    }
+}
+const occurrencesWait = async (runtime, args) => {
+    const schedule = args.command[0];
+    const occurrence = args.command[1];
+    if (schedule === undefined || occurrence === undefined) {
+        throw new CliError(`${runtime.programName} occurrences wait needs a schedule and an occurrence`, "usage", `Usage: ${runtime.programName} occurrences wait <schedule> <occurrence>`);
     }
+    expectNoExtraArguments(args, 2, `${runtime.programName} occurrences wait <schedule> <occurrence>`);
+    const session = await openSession(runtime, { apiUrl: apiUrlOption(args) });
+    const watched = await watchOccurrence(runtime, session, schedule, occurrence, waitTimeoutMs(args));
+    if (!watched.settled) {
+        throw new CliError(`occurrence ${occurrence} was still ${watched.state} when the deadline passed`, "timeout", recoveryFor("await-occurrence", "not-settled"));
+    }
+    const { attemptCount, state } = watched.occurrence;
+    return {
+        data: {
+            attempts: attemptCount,
+            occurrence,
+            schedule,
+            settled: true,
+            state,
+            states: watched.states,
+        },
+        human: `Occurrence ${occurrence} settled ${state} after ${String(attemptCount)} ${attemptCount === 1 ? "attempt" : "attempts"}.`,
+        nextMove: `Next: ${runtime.programName} attempts list ${schedule} ${occurrence}`,
+    };
 };
 const attemptsList = async (runtime, args) => {
     const schedule = args.command[0];
@@ -824,9 +967,7 @@ const attemptsList = async (runtime, args) => {
         data: { attempts: page.data, occurrence, schedule },
         human: page.data.length === 0
             ? "No attempt has been made yet."
-            : page.data
-                .map((attempt) => `${attempt.state.padEnd(20)}${attempt.responseStatus === undefined ? "no response" : `answered ${String(attempt.responseStatus)}`}${attempt.diagnostic === undefined ? "" : `  ${attempt.diagnostic}`}${attempt.remediation === undefined ? "" : ` / ${attempt.remediation}`}`)
-                .join("\n"),
+            : page.data.map(attemptLine).join("\n"),
         // **The journey's own sentence, not a paraphrase of the code.**
         // `diagnostic` and `remediation` are closed vocabularies rather than prose
         // — the step's `observe` says to read them, and its recovery entry is the
@@ -854,6 +995,7 @@ const attemptsList = async (runtime, args) => {
  */
 const IMPLEMENTATIONS = {
     ...OPERATE_COMMANDS,
+    ...MEMBER_IMPLEMENTATIONS,
     "attempts list": attemptsList,
     context,
     "destinations create": destinationsCreate,

package/dist/member-catalog.d.ts

@@ -0,0 +1 @@
+export { MEMBER_COMMANDS } from "./catalog.js";

package/dist/member-catalog.js

@@ -0,0 +1 @@
+export { MEMBER_COMMANDS } from "./catalog.js";

package/dist/member-commands.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedArguments } from "./args.js";
+import type { CommandResult } from "./output.js";
+import { type CliRuntime } from "./runtime.js";
+export declare const MEMBER_IMPLEMENTATIONS: {
+    [k: string]: (runtime: CliRuntime, args: ParsedArguments) => Promise<CommandResult>;
+};

package/dist/member-commands.js

@@ -0,0 +1,192 @@
+import { findOperation, invitationListSchema, memberActionSchema, memberListSchema, responseSchemaFor, } from "@greatwait/contracts";
+import { usageLine } from "./catalog.js";
+import { MEMBER_COMMANDS } from "./member-catalog.js";
+import { confirmChange } from "./confirm.js";
+import { CliError } from "./runtime.js";
+import { openSession } from "./session.js";
+import { apiUrlOption, positionals } from "./support.js";
+/**
+ * The member and invitation commands (W1-09), shipped in alpha.6 (W9-46).
+ *
+ * **Flags rather than a JSON body.** Until alpha.6 these took `--body` JSON,
+ * which is how a request is spelled in curl and not how a person invites a
+ * teammate; the docs' Teammates page lists these commands, so they read as
+ * commands. Every request still passes the operation's own schema before it is
+ * sent, so a flag cannot produce a body the contract refuses.
+ *
+ * **The retry key is generated when it is not given, and printed.** The same
+ * rule `schedules create` keeps: a change whose answer was lost is retried
+ * with the key it printed, and runs once.
+ */
+const ROLES = ["admin", "member"];
+function roleOption(args, fallback) {
+    const role = args.options["--role"] ?? fallback;
+    if (role === undefined) {
+        throw new CliError("--role is required: admin or member", "usage");
+    }
+    if (!ROLES.includes(role)) {
+        throw new CliError(`--role is admin or member, not ${role}`, "usage");
+    }
+    return role;
+}
+function projectsOption(args) {
+    const value = args.options["--projects"];
+    if (value === undefined)
+        return [];
+    return value
+        .split(",")
+        .map((project) => project.trim())
+        .filter((project) => project.length > 0);
+}
+function rows(table) {
+    const widths = (table[0] ?? []).map((_, column) => Math.max(...table.map((row) => (row[column] ?? "").length)));
+    return table
+        .map((row) => row
+        .map((cell, column) => column === row.length - 1 ? cell : cell.padEnd(widths[column] ?? 0))
+        .join("  "))
+        .join("\n");
+}
+export const MEMBER_IMPLEMENTATIONS = Object.fromEntries(MEMBER_COMMANDS.map((declaration) => [
+    declaration.words,
+    async (runtime, args) => {
+        const operation = findOperation(declaration.operations[0]);
+        const ids = positionals(args, declaration.positionals.map((positional) => positional.name), usageLine(declaration, runtime.programName));
+        const session = await openSession(runtime, {
+            apiUrl: apiUrlOption(args),
+        });
+        if (declaration.words === "members list") {
+            const { data } = memberListSchema.parse(await session.client.request("members_list"));
+            return {
+                data: { data },
+                human: data.length === 0
+                    ? "No members yet."
+                    : rows([
+                        ["ROLE", "EMAIL", "PROJECTS", "MEMBER"],
+                        ...data.map((member) => [
+                            member.role,
+                            `${member.email}${member.self ? " (you)" : ""}`,
+                            member.allProjects
+                                ? "all"
+                                : member.projects.join(",") || "none",
+                            member.id,
+                        ]),
+                    ]),
+            };
+        }
+        if (declaration.words === "invitations list") {
+            const { data } = invitationListSchema.parse(await session.client.request("invitations_list"));
+            return {
+                data: { data },
+                human: data.length === 0
+                    ? "No invitations yet."
+                    : rows([
+                        ["STATUS", "ROLE", "EMAIL", "PROJECTS", "INVITATION"],
+                        ...data.map((invitation) => [
+                            invitation.status,
+                            invitation.role,
+                            invitation.email,
+                            invitation.projects.join(",") || "none",
+                            invitation.id,
+                        ]),
+                    ]),
+            };
+        }
+        const [first, second] = ids;
+        const body = operation.id === "invitations.create"
+            ? {
+                email: args.options["--email"] ??
+                    (() => {
+                        throw new CliError("--email is required: the address to send the invitation to", "usage", `Usage: ${usageLine(declaration, runtime.programName)}`);
+                    })(),
+                projects: projectsOption(args),
+                role: roleOption(args, "member"),
+            }
+            : operation.id === "members.role"
+                ? { role: roleOption(args) }
+                : operation.id === "invitations.resend" ||
+                    operation.id === "projectmembers.add"
+                    ? {}
+                    : { confirmed: true };
+        const parsed = operation.request.safeParse(body);
+        if (!parsed.success) {
+            throw new CliError(`That isn't a valid ${declaration.words}: ${parsed.error.issues
+                .map((issue) => `${issue.path.join(".")} ${issue.message}`.trim())
+                .join("; ")}`, "usage");
+        }
+        const key = args.options["--idempotency-key"] ??
+            `greatwait-cli-${runtime.randomUuid()}`;
+        const effect = () => {
+            switch (operation.id) {
+                case "invitations.create":
+                    return [
+                        `email      ${String(body["email"])}`,
+                        `role       ${String(body["role"])}`,
+                        `projects   ${body["projects"].join(", ") || "none"}`,
+                    ];
+                case "invitations.resend":
+                    return [`invitation ${first}`];
+                case "invitations.revoke":
+                    return [`invitation ${first}`, "Its link stops working."];
+                case "members.remove":
+                    return [
+                        `member     ${first}`,
+                        "API keys the organization owns keep working. Revoke them separately if you need to.",
+                    ];
+                case "members.role":
+                    return [
+                        `member     ${first}`,
+                        `role       ${String(body["role"])}`,
+                    ];
+                default:
+                    return [`member     ${first}`, `project    ${second}`];
+            }
+        };
+        const confirmation = await confirmChange(runtime, args, {
+            action: `${declaration.summary}`,
+            effect: effect(),
+        });
+        // Before sending, so a lost answer still leaves the key on screen: the
+        // retry that reuses it changes nothing twice.
+        runtime.stderr(`Retry key  ${key}. Reuse it with --idempotency-key if the answer is lost.\n`);
+        const headers = { "Idempotency-Key": key };
+        const send = () => {
+            switch (operation.id) {
+                case "invitations.create":
+                    return session.client.request("invitations_create", parsed.data, headers);
+                case "invitations.resend":
+                    return session.client.request("invitations_resend", first, {}, headers);
+                case "invitations.revoke":
+                    return session.client.request("invitations_revoke", first, { confirmed: true }, headers);
+                case "members.role":
+                    return session.client.request("members_role", first, parsed.data, headers);
+                case "members.remove":
+                    return session.client.request("members_remove", first, { confirmed: true }, headers);
+                case "projectmembers.add":
+                    return session.client.request("projectmembers_add", second, first, {}, headers);
+                case "projectmembers.remove":
+                    return session.client.request("projectmembers_remove", second, first, { confirmed: true }, headers);
+                default:
+                    throw new CliError(`${operation.id} has no command`, "internal");
+            }
+        };
+        // Each answer through its operation's own schema: an invitation comes
+        // back as the invitation, every other change as an acknowledgement.
+        const done = (responseSchemaFor(operation.id) ?? memberActionSchema).parse(await send());
+        const said = {
+            "invitations.create": `Invited ${String(body["email"])} as ${String(body["role"])}. Invitation ${done.id}.`,
+            "invitations.resend": `Sent invitation ${done.id} again.`,
+            "invitations.revoke": `Revoked invitation ${done.id}. Its link no longer works.`,
+            "members.remove": `Removed ${done.id} from the organization.`,
+            "members.role": `${done.id} is now ${String(body["role"])}.`,
+            "projectmembers.add": `${done.id} can now see ${second}.`,
+            "projectmembers.remove": `${done.id} can no longer see ${second}.`,
+        };
+        return {
+            data: { ...done, confirmation, idempotencyKey: key },
+            human: [
+                said[operation.id] ?? `Done. ${done.id}.`,
+                `Retry key  ${key}`,
+            ].join("\n"),
+        };
+    },
+]));

package/dist/operate.d.ts

@@ -1,3 +1,4 @@
+import { type SigningSecretNotice } from "@greatwait/contracts";
 import { type ParsedArguments } from "./args.js";
 import { type CommandResult } from "./output.js";
 import { type CliRuntime } from "./runtime.js";
@@ -34,6 +35,26 @@ type Command = (runtime: CliRuntime, args: ParsedArguments) => Promise<CommandRe
  * and on a build runner.
  */
 declare function scheduleRequest(runtime: CliRuntime, args: ParsedArguments, usage: string): Promise<Readonly<Record<string, unknown>>>;
+/**
+ * Where a schedule written with `--url` delivers, and where its signing
+ * secret is.
+ *
+ * **Only the API's notice, never a secret.** A schedule write that names a
+ * `url` answers with `endpointSigningSecret` — `returned: false` and the
+ * dashboard page where a member reveals the secret — and nothing else about
+ * it, so there is nothing here that could print one. Absent when the write
+ * named `--endpoint`: that caller already holds the destination it chose.
+ */
+export declare function destinationLines(schedule: {
+    readonly endpoint?: string;
+    readonly endpointUrl?: string;
+}, notice: SigningSecretNotice | undefined, 
+/**
+ * The `--url` that was sent. A schedule write answers without
+ * `endpointUrl` (only reads carry it), and the address is the one the
+ * destination was found or made at.
+ */
+requestedUrl?: string): string[];
 /** The operate-and-diagnose commands, keyed by the words that select them. */
 export declare const OPERATE_COMMANDS: Readonly<Record<string, Command>>;
 export { scheduleRequest, type Command };