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

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/node-runtime.js

@@ -49,7 +49,7 @@ export async function openLoopback() {
             return;
         }
         response.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
-        response.end("Greatwait received the answer. You can close this tab.\n");
+        response.end("GreatWait received the answer. You can close this tab.\n");
         deliver?.(url.searchParams);
     });
     await new Promise((resolve, reject) => {

package/dist/oauth.js

@@ -35,7 +35,7 @@ export async function discover(runtime, origin) {
     const resourceUrl = `${origin}/.well-known/oauth-protected-resource`;
     const resource = await readJson(runtime, resourceUrl);
     if (resource.status !== 200) {
-        throw new CliError(`${origin} does not publish protected-resource metadata (${String(resource.status)})`, "validation", `Check the origin. A Greatwait API answers GET /__greatwait/version with no credential; try ${runtime.programName} doctor --api-url <origin>.`);
+        throw new CliError(`${origin} does not publish protected-resource metadata (${String(resource.status)})`, "validation", `Check the origin. A GreatWait API answers GET /__greatwait/version with no credential; try ${runtime.programName} doctor --api-url <origin>.`);
     }
     const resourceBody = resource.body;
     const servers = Array.isArray(resourceBody.authorization_servers)
@@ -75,7 +75,7 @@ export async function registerClient(runtime, server, options) {
     }
     const registered = await readJson(runtime, server.registrationEndpoint, {
         body: JSON.stringify({
-            client_name: "Greatwait CLI",
+            client_name: "GreatWait CLI",
             client_uri: "https://greatwait.dev",
             grant_types: ["authorization_code", "refresh_token"],
             redirect_uris: [options.redirectUri],

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 };