frontpage-host 0.1.28 → 0.2.0

package/PEOPLE.md

@@ -411,6 +411,23 @@ For a reviewed cohort, submit at most 25 people in each bounded batch. Each row
 
 Run the same `person permission --file reviewed-batch.json` command. Read every row in `results`: domain conflicts include `error` and `status`, while successful rows include `emailPermission` and `duplicate`. The batch can partly succeed; receipts make a retry safe. Malformed batch input fails before any permission writes. Infrastructure errors can leave completed receipts, so retry the exact batch rather than inventing new keys. This capability works through the public API and `manage_people` too; it has no company-only endpoint.
 
+## Safe sync through public customer commands
+
+Integrations read their own sources and write through the same CLI/API/agent operations as owners. No product database write credential is needed.
+
+- `person.lookup` takes a valid `email` and/or `phone`, includes hidden matches, and refuses identities that point to different people. It never changes permission or unhides someone.
+- `person.update` takes `personId`, a `patch` and optional `expected` contact values. `expected` supports exact name/email/phone values, including null. A changed value or hidden contact returns a conflict; it does not overwrite the owner's edit. Use `people workspace person.update --data` for this conditional operation.
+- `notes.add` takes `personId`, `body`, optional `requestKey` (1–120 characters), and optional `historical` boolean. Reuse the key for the exact same note after a lost response. A changed person/body/history flag returns a conflict. A retry never restores a deleted note. Historical notes skip automation and record their processed receipt immediately.
+- `membership.add` accepts optional `historical:true` to import a membership without replaying rules. Ordinary additions keep normal automation. Preserve an owner's removed membership rather than adding it again on every sync.
+
+```sh
+frontpage people workspace person.lookup --data '{"email":"alex@example.com"}' --site YOUR_SITE --json
+frontpage people workspace person.update --data '{"personId":"PERSON_ID","patch":{"phone":"+12025550100"},"expected":{"phone":null}}' --site YOUR_SITE --json
+frontpage people workspace notes.add --data '{"personId":"PERSON_ID","body":"Verified billing context","requestKey":"NOTE_UUID","historical":true}' --site YOUR_SITE --json
+```
+
+Use a saved CSV import for a new historical cohort. Its list-wide permission choice applies only to new contacts; row values take priority and existing decisions remain saved. Check the real import status before writing notes or starting delivery. Source account or billing facts never imply marketing permission. Preserve hidden state and review identity conflicts rather than merging contacts.
+
 ## Import a customer list from CSV
 
 CSV imports accept up to 5 MB and 10,000 contact rows. Quoted commas, quoted newlines, UTF-8 BOM, and CRLF are supported. Larger lists need separate files; the UI does not render an unbounded list of failures.
@@ -508,18 +525,6 @@ frontpage mail campaign get --id DRAFT_ID --site YOUR_SITE --json
 
 Preview reports matched, eligible, no-email, suppressed, and permission-missing counts and sends nothing. Sending freezes content and eligible recipients, deduplicates email addresses, and uses the existing paced email queue. Reuse the send request key after a lost response. Check `campaign get` for queued, sent, pending, failed, and skipped work; queued does not mean delivered.
 
-## Frontpage account sync
-
-This admin-only feature adds Frontpage’s own account holders to the `landing` People workspace and keeps later signups in sync. It is not available to ordinary businesses. Businesses import their customer lists with CSV.
-
-```
-frontpage people company get --site landing --json
-frontpage people company set --enabled true --site landing --json
-frontpage people company set --enabled false --site landing --json
-```
-
-Sync uses saved batches and Frontpage user IDs to avoid duplicates. The backfill does not fire rules or grant email permission. Later signups can trigger group entry rules, subject to normal eligibility. Sync preserves owner edits. Pausing it leaves existing contacts saved. Supply an existing `groupId` through `--data` if you want a particular sync group.
-
 ## CLI, API, and agent reference
 
 The editor, public API, CLI, and site agent call the same application service. Every operation below is available without opening the UI.
@@ -612,8 +617,6 @@ The agent can create and edit saved templates and series with the existing Email
 | import.start                               | csv, mapping?, groupIds?, requestKey                                | Start a saved import.                                                                    |
 | import.get                                 | id                                                                  | Read the import cursor, outcomes, and errors.                                            |
 | import.retry                               | id                                                                  | Retry failed rows after correcting saved identity conflicts.                             |
-| company.get                                | —                                                                   | Read the admin-only Frontpage account sync.                                              |
-| company.set                                | enabled, groupId?                                                   | Start or pause that sync in landing; platform admin only.                                |
 
 ## Limits, timing, and recovery
 
@@ -628,3 +631,20 @@ The agent can create and edit saved templates and series with the existing Email
 **Keep scope clear.**
 
 People does not replace the raw Inbox, Store orders, or the email send ledger. It combines the contact’s history and organization. Those source tools and their existing CLI commands remain available.
+
+## Manual saved emails from People
+
+Templates store reusable content; series store ordered templates and delays. Neither definition stores a customer audience. Their existing API/CLI sends and rule callers remain supported. In People, use **Email → Use a template** to create an independent campaign draft with the current audience. Review the draft before sending; editing it never changes its source template. A template's **Create campaign** shortcut copies saved content, then asks for a campaign audience.
+
+The shared workspace operations are:
+
+```
+frontpage people workspace template.campaign --site YOUR_SITE --data '{"templateId":"TEMPLATE_ID","requestKey":"YOUR_STABLE_KEY","audience":{"personIds":["PERSON_ID"]}}' --json
+frontpage people workspace series.preview --site YOUR_SITE --data '{"seriesId":"SERIES_ID","personIds":["PERSON_ID"]}' --json
+```
+
+To enrol, copy each returned batch's `personIds` and `reviewToken` into `series.enrol`, adding `seriesId` and a unique stable `requestKey`. Preview returns batches of five; the service accepts at most 25 per request. Reuse the original payload and key after a lost response. Results distinguish enrolled, already enrolled, skipped and failed. A new preview uses new keys. Never enrol or send without the user's explicit instruction.
+
+Manual series starts use selected person IDs, an active series and the normal queue. Confirmation queues its first email; saved delays schedule later steps. The review lists permission exclusions and remaining allowance. It never activates a paused series or restarts an existing enrolment, including one bound to a person whose email changed. Delivery rechecks saved restrictions. Contact groups and permission stay unchanged.
+
+People supplies first-name and unsubscribe values. If content uses order, booking or other caller-only variables, edit the independent campaign or choose another series. Do not invent values or send empty required context.

package/README.md

@@ -60,3 +60,6 @@ See [AGENTS.md](./AGENTS.md) and [llms.txt](./llms.txt) in this package.
 ## People groups, stages, rules, and imports
 
 Use `frontpage people overview`, `groups`, `stages`, `membership`, `rules`, `attachments`, `import`, and `company`. Use `frontpage mail campaign` for one-off group/stage/list audiences in Emails. Every editor action is available through these commands or `frontpage people workspace OPERATION --file payload.json`. Full operations and examples: [PEOPLE.md](./PEOPLE.md); public guide: https://frontpage.host/developers/people. Automated emails select a saved template or series. Campaigns use their own drafts.
+
+
+Payments, invoices and recurring billing: see packaged [PAYMENTS.md](./PAYMENTS.md), `frontpage help payments`, and https://frontpage.host/developers/payments. Version 0.2.0 removes writable currency, Store checkout mode and Store-owned money commands; Store stays cart-only. Preview/review before sends; keep stable operation keys on retries. Autopay requires the customer’s own verified authorization.

package/dist/argv.d.ts

@@ -10,3 +10,5 @@ export declare function looksLikeFlag(token: string): boolean;
  * caller also checks them.
  */
 export declare function assertNoUnknownFlags(rest: string[], command: string): void;
+/** Required value for new command parsers; keep existing parsers unchanged. */
+export declare function takeFlagValue(rest: string[], name: string): string | undefined;

package/dist/argv.js

@@ -46,3 +46,11 @@ export function assertNoUnknownFlags(rest, command) {
         return;
     throw new CliHttpError(`Unknown flag: ${unknown}. Run: frontpage help ${command}`, EXIT_USAGE, 0, "bad_request");
 }
+/** Required value for new command parsers; keep existing parsers unchanged. */
+export function takeFlagValue(rest, name) {
+    const present = rest.some(token => token === name || token.startsWith(`${name}=`));
+    const value = takeFlag(rest, name);
+    if (present && (!value || looksLikeFlag(value)))
+        throw new CliHttpError(`${name} requires a value.`, EXIT_USAGE, 0, "bad_request");
+    return value;
+}

package/dist/bin.js

@@ -26,11 +26,13 @@ import { runExtensions } from "./commands/extensions.js";
 import { runMedia } from "./commands/media.js";
 import { runImages } from "./commands/images.js";
 import { runInbox } from "./commands/inbox.js";
+import { runCustomerInbox } from "./commands/customer-inbox.js";
 import { runSeo } from "./commands/seo.js";
 import { runRedirects } from "./commands/redirects.js";
 import { runPeople } from "./commands/people.js";
 import { runRoutines } from "./commands/routines.js";
 import { runShop } from "./commands/shop.js";
+import { runPayments } from "./commands/payments.js";
 import { runMail } from "./commands/mail.js";
 import { runArticles } from "./commands/articles.js";
 import { runSettings } from "./commands/settings.js";
@@ -62,6 +64,8 @@ async function main() {
         return runHelp([cmd, ...args]);
     }
     switch (cmd) {
+        case "payments":
+            return runPayments(args);
         case "login":
             return runLogin(args);
         case "logout":
@@ -117,6 +121,8 @@ async function main() {
             return runImages(args);
         case "inbox":
             return runInbox(args);
+        case "customer-inbox":
+            return runCustomerInbox(args);
         case "people":
             return runPeople(args);
         case "routines":

package/dist/commands/customer-inbox.d.ts

@@ -0,0 +1,14 @@
+export declare function inboxCommand(args: string[]): {
+    method: string;
+    resource: string;
+    file: undefined;
+    key: undefined;
+    out: string;
+} | {
+    method: string;
+    resource: string;
+    file: string | undefined;
+    key: string | undefined;
+    out: undefined;
+};
+export declare function runCustomerInbox(args: string[]): Promise<number>;

package/dist/commands/customer-inbox.js

@@ -0,0 +1,157 @@
+import { readFile, open, link, unlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { resolveSlug } from "../site.js";
+import { takeFlag, assertNoUnknownFlags } from "../argv.js";
+import { getApiKey } from "../auth/keychain.js";
+import { apiBase, v1Get, httpErrorFromV1, CliHttpError, EXIT_AUTH, EXIT_USAGE, EXIT_OK, exitCodeForError, } from "../http/client.js";
+import { emitOk, emitErr, isJson } from "../runtime.js";
+const RESOURCE = /^(?:status|activation|address|widget|settings|knowledge(?:\/[0-9a-f-]+(?:\/history)?)?|sources|blocks(?:\/[0-9a-f-]+\/unblock)?|jobs(?:\/[0-9a-f-]+(?:\/resume)?)?|files(?:\/[0-9a-f-]+)?|receipts(?:\/[0-9a-f-]+)?|conversations(?:\/[0-9a-f-]+(?:\/(?:messages|routing|guidance|reply|control|state|revoke-sessions))?)?)(?:\?[^#]*)?$/;
+export function inboxCommand(args) {
+    const work = [...args], verb = work.shift(), resource = work.shift(), file = takeFlag(work, "--file"), key = takeFlag(work, "--request-key"), out = takeFlag(work, "--out");
+    assertNoUnknownFlags(work, "customer-inbox");
+    if (verb === "export" || verb === "download") {
+        if (work.length ||
+            !resource ||
+            !out ||
+            file ||
+            key ||
+            !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(resource))
+            throw new CliHttpError("Use customer-inbox export|download <id> --out <new-file>.", EXIT_USAGE, 400, "bad_request");
+        return {
+            method: verb.toUpperCase(),
+            resource,
+            file: undefined,
+            key: undefined,
+            out,
+        };
+    }
+    if (out ||
+        work.length ||
+        !verb ||
+        !["get", "put", "post"].includes(verb) ||
+        !resource ||
+        !RESOURCE.test(resource))
+        throw new CliHttpError("Usage: frontpage customer-inbox get|put|post <resource> [--file <json>] [--request-key <key>] [--site <slug>]", EXIT_USAGE, 400, "bad_request");
+    if (verb !== "get" && (!file || !key || !/^[A-Za-z0-9_-]{8,128}$/.test(key)))
+        throw new CliHttpError("Writes require --file and an 8–128 character --request-key. Reuse both on retries.", EXIT_USAGE, 400, "bad_request");
+    if (verb === "get" && (file || key))
+        throw new CliHttpError("Reads do not take --file or --request-key.", EXIT_USAGE, 400, "bad_request");
+    return { method: verb.toUpperCase(), resource, file, key, out: undefined };
+}
+export async function runCustomerInbox(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args), operation = inboxCommand(rest), path = `/api/v1/sites/${encodeURIComponent(slug)}/customer-inbox/${operation.resource}`;
+        let result;
+        if (operation.method === "EXPORT" || operation.method === "DOWNLOAD") {
+            const target = operation.out, temp = target + ".inbox-" + randomUUID() + ".tmp", handle = await open(temp, "wx", 0o600);
+            let count = 0;
+            try {
+                const prefix = `/api/v1/sites/${encodeURIComponent(slug)}/customer-inbox`;
+                if (operation.method === "DOWNLOAD") {
+                    const record = await v1Get(`${prefix}/files/${operation.resource}`);
+                    const response = await fetch(record.data.downloadUrl, {
+                        redirect: "error",
+                        signal: AbortSignal.timeout(60000),
+                    });
+                    if (!response.ok || !response.body)
+                        throw new CliHttpError("Attachment download failed.", EXIT_USAGE, response.status, "download_failed");
+                    for await (const chunk of response.body) {
+                        count += chunk.byteLength;
+                        if (count > 25 * 1024 * 1024)
+                            throw new CliHttpError("Attachment exceeds 25 MB.", EXIT_USAGE, 413, "payload_too_large");
+                        await handle.writeFile(chunk);
+                    }
+                }
+                else {
+                    const conversation = await v1Get(`${prefix}/conversations/${operation.resource}`);
+                    await handle.writeFile(JSON.stringify({ type: "conversation", value: conversation.data }) +
+                        "\n");
+                    let cursor = 0;
+                    for (;;) {
+                        const page = await v1Get(`${prefix}/conversations/${operation.resource}/messages?after=${cursor}&limit=100&audience=all`);
+                        for (const message of page.data.messages) {
+                            const attachments = await v1Get(`${prefix}/files?messageId=${message.id}`);
+                            await handle.writeFile(JSON.stringify({
+                                type: "message",
+                                value: message,
+                                attachments: attachments.data,
+                            }) + "\n");
+                            count++;
+                        }
+                        if (page.data.nextCursor === null)
+                            break;
+                        if (page.data.nextCursor <= cursor)
+                            throw new Error("History cursor did not advance.");
+                        cursor = page.data.nextCursor;
+                    }
+                }
+                await handle.sync();
+                await handle.close();
+                await link(temp, target);
+                await unlink(temp);
+            }
+            catch (e) {
+                await handle.close().catch(() => { });
+                await unlink(temp).catch(() => { });
+                throw e;
+            }
+            result = {
+                path: target,
+                ...(operation.method === "EXPORT"
+                    ? { messages: count, format: "jsonl" }
+                    : { bytes: count }),
+            };
+            if (isJson())
+                emitOk("customer-inbox", result);
+            else
+                console.log(JSON.stringify(result, null, 2));
+            return EXIT_OK;
+        }
+        if (operation.method === "GET")
+            result = await v1Get(path, { timeoutMs: 20000 });
+        else {
+            const bytes = await readFile(operation.file);
+            if (bytes.length > 65536)
+                throw new CliHttpError("Inbox JSON exceeds 64 KiB.", EXIT_USAGE, 413, "payload_too_large");
+            let value;
+            try {
+                value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+            }
+            catch {
+                throw new CliHttpError("Use a valid UTF-8 JSON object.", EXIT_USAGE, 400, "bad_request");
+            }
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                throw new CliHttpError("Use a JSON object.", EXIT_USAGE, 400, "bad_request");
+            const token = await getApiKey();
+            if (!token)
+                throw new CliHttpError("Not logged in. Run: frontpage login", EXIT_AUTH, 401);
+            const response = await fetch(apiBase() + path, {
+                method: operation.method,
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    "Idempotency-Key": operation.key,
+                },
+                body: JSON.stringify(value),
+                redirect: "error",
+                signal: AbortSignal.timeout(20000),
+            });
+            const body = (await response.json());
+            if (!response.ok)
+                throw httpErrorFromV1(response.status, body);
+            result = body;
+        }
+        if (isJson())
+            emitOk("customer-inbox", result);
+        else
+            console.log(JSON.stringify(result, null, 2));
+        return EXIT_OK;
+    }
+    catch (e) {
+        if (isJson())
+            emitErr("customer-inbox", e);
+        else
+            console.error(e instanceof Error ? e.message : "Inbox request failed.");
+        return exitCodeForError(e);
+    }
+}

package/dist/commands/payments.d.ts

@@ -0,0 +1 @@
+export declare function runPayments(args: string[]): Promise<number>;

package/dist/commands/payments.js

@@ -0,0 +1,303 @@
+import { readFile } from "node:fs/promises";
+import { resolveSlug } from "../site.js";
+import { takeFlagValue as takeFlag, hasFlag, assertNoUnknownFlags } from "../argv.js";
+import { CliHttpError, EXIT_OK, EXIT_USAGE, v1Get, v1Post, v1Patch, LONG_MODULE_TIMEOUT_MS, } from "../http/client.js";
+import { emitErr, emitOk, emitUsage, isJson, requireYesOrTty, } from "../runtime.js";
+import { openBrowser, resolveOpenUrl } from "../modules/oauth.js";
+const USAGE = "frontpage payments status|connect|availability|activity|tax|invoices|recurring|customers … [--site <slug>] [--json]";
+function usage(message) {
+    throw new CliHttpError(message, EXIT_USAGE, 0, "bad_request");
+}
+function idOf(work) {
+    const id = takeFlag(work, "--id") ??
+        (!work[0]?.startsWith("-") ? work.shift() : undefined);
+    if (!id || !/^[a-zA-Z0-9_-]{2,80}$/.test(id))
+        usage("A valid record id is required. Use the id returned by list or create.");
+    return encodeURIComponent(id);
+}
+async function payload(work) {
+    const file = takeFlag(work, "--file");
+    let body = {};
+    if (file) {
+        try {
+            const value = JSON.parse(await readFile(file, "utf8"));
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                usage("--file must contain a JSON object.");
+            body = value;
+        }
+        catch (error) {
+            if (error instanceof CliHttpError)
+                throw error;
+            usage("Could not read a JSON object from --file.");
+        }
+    }
+    for (const [flag, key] of [
+        ["--title", "title"],
+        ["--amount", "amount"],
+        ["--operation-key", "operationKey"],
+        ["--preview-hash", "previewHash"],
+        ["--description", "description"],
+        ["--kind", "kind"],
+        ["--collection", "collection"],
+        ["--cadence", "cadence"],
+        ["--first-date", "firstDate"],
+        ["--time-zone", "timeZone"],
+        ["--country", "country"],
+        ["--state", "state"],
+        ["--line1", "line1"],
+        ["--city", "city"],
+        ["--postal", "postal"],
+        ["--tax-code", "taxCode"],
+    ]) {
+        const value = takeFlag(work, flag);
+        if (value !== undefined) {
+            if (!value || value.startsWith("--"))
+                usage(`${flag} requires a value.`);
+            body[key] = value;
+        }
+    }
+    for (const [flag, key] of [
+        ["--price-cents", "priceCents"],
+        ["--min-cents", "minCents"],
+        ["--amount-cents", "amountCents"],
+        ["--due-days", "dueDays"],
+    ]) {
+        const value = takeFlag(work, flag);
+        if (value !== undefined) {
+            if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)))
+                usage(`${flag} requires a whole number.`);
+            body[key] = Number(value);
+        }
+    }
+    const personId = takeFlag(work, "--person");
+    const email = takeFlag(work, "--email"), name = takeFlag(work, "--name");
+    if (personId && (email || name))
+        usage("Use either --person or an inline --email/--name customer.");
+    if (personId)
+        body.recipient = { personId };
+    else if (email || name)
+        body.recipient = {
+            ...(body.recipient && typeof body.recipient === "object"
+                ? body.recipient
+                : {}),
+            ...(email ? { email } : {}),
+            ...(name ? { name } : {}),
+        };
+    if (hasFlag(work, "--confirm-billing-contact"))
+        body.confirmBillingContact = true;
+    return body;
+}
+function noRest(work) {
+    assertNoUnknownFlags(work, "payments");
+    if (work.length)
+        usage(`Unexpected argument: ${work[0]}. Run frontpage help payments.`);
+}
+function confirm(body, action) {
+    const problem = requireYesOrTty(action);
+    if (problem)
+        usage(problem);
+    body.confirm = true;
+}
+function requireKey(body) {
+    if (typeof body.operationKey !== "string" ||
+        !/^[a-zA-Z0-9._:-]{16,120}$/.test(body.operationKey))
+        usage("Supply --operation-key with 16–120 letters, numbers, dots, colons, hyphens or underscores. Keep the same key when retrying.");
+}
+export async function runPayments(args) {
+    try {
+        const { slug, rest } = await resolveSlug(args);
+        const work = [...rest];
+        const group = work.shift();
+        if (!group)
+            return emitUsage("payments", USAGE);
+        const base = `/api/v1/sites/${encodeURIComponent(slug)}/payments`;
+        let path = "", method = "GET", body = {};
+        if (group === "status" || group === "settings")
+            path = group;
+        else if (group === "connect") {
+            const noOpen = hasFlag(work, "--no-open");
+            noRest(work);
+            const result = await v1Post(`${base}/connect`, {});
+            const url = resolveOpenUrl(result.url);
+            if (!url)
+                usage("The API did not return a trusted browser setup link.");
+            if (!noOpen && !isJson())
+                openBrowser(url);
+            if (isJson())
+                emitOk("payments", result);
+            else
+                console.log(`${result.message}\n${url}`);
+            return EXIT_OK;
+        }
+        else if (group === "availability") {
+            const mode = work.shift() ?? "preview";
+            if (!["preview", "on", "off"].includes(mode))
+                usage("Use payments availability preview|on|off.");
+            path = "availability";
+            if (mode !== "preview") {
+                body = await payload(work);
+                confirm(body, mode === "off"
+                    ? "Stop new payments, pause recurring billing and void unpaid invoices"
+                    : "Restore Payments without resuming stopped billing");
+                body.enabled = mode === "on";
+                if (!body.enabled && !body.previewHash) {
+                    const preview = await v1Get(`${base}/availability`);
+                    body.previewHash = preview.previewHash;
+                }
+                method = "POST";
+            }
+        }
+        else if (group === "buttons") {
+            const sub = work.shift() ?? "list";
+            if (sub === "list") {
+                const query = new URLSearchParams();
+                for (const key of ["limit", "offset", "archived"]) {
+                    const value = takeFlag(work, `--${key}`);
+                    if (value !== undefined)
+                        query.set(key, value);
+                }
+                path = `buttons?${query}`;
+            }
+            else if (sub === "get")
+                path = `buttons/${idOf(work)}`;
+            else if (sub === "create") {
+                const id = takeFlag(work, "--id");
+                path = "buttons";
+                method = "POST";
+                body = await payload(work);
+                if (id)
+                    body.itemId = id;
+            }
+            else if (sub === "update") {
+                path = `buttons/${idOf(work)}`;
+                method = "PATCH";
+                body = await payload(work);
+            }
+            else if (sub === "archive") {
+                path = `buttons/${idOf(work)}/archive`;
+                method = "POST";
+                body = await payload(work);
+                confirm(body, "Archive this Pay now button");
+            }
+            else
+                usage("Use payments buttons list|get|create|update|archive.");
+        }
+        else if (group === "activity") {
+            const sub = work.shift() ?? "list";
+            if (sub === "list")
+                path = "activity";
+            else if (sub === "get") {
+                const source = takeFlag(work, "--source");
+                if (source !== "order" && source !== "payment")
+                    usage("Use --source order|payment.");
+                const id = idOf(work);
+                path = `activity/${source}/${id}`;
+            }
+            else
+                usage("Use payments activity list|get.");
+        }
+        else if (group === "tax") {
+            const sub = work.shift() ?? "get";
+            if (sub === "get")
+                path = "tax";
+            else if (sub === "settings") {
+                path = "tax/settings";
+                method = "POST";
+                body = await payload(work);
+                confirm(body, "Save the supplied business tax settings");
+            }
+            else if (sub === "registrations") {
+                const verb = work.shift() ?? "list";
+                if (verb === "list")
+                    path = "tax/registrations";
+                else if (verb === "add") {
+                    path = "tax/registrations";
+                    method = "POST";
+                    body = await payload(work);
+                    confirm(body, "Add the supplied tax registration");
+                }
+                else if (verb === "end") {
+                    path = `tax/registrations/${idOf(work)}/end`;
+                    method = "POST";
+                    body = await payload(work);
+                    confirm(body, "End this tax registration");
+                }
+                else
+                    usage("Use payments tax registrations list|add|end.");
+            }
+            else
+                usage("Use payments tax get|settings|registrations.");
+        }
+        else if (group === "invoices" || group === "recurring") {
+            const sub = work.shift() ?? "list";
+            if (sub === "list") {
+                const query = new URLSearchParams();
+                for (const key of ["limit", "offset", "arrangementId"]) {
+                    const value = takeFlag(work, `--${key === "arrangementId" ? "arrangement" : key}`);
+                    if (value !== undefined)
+                        query.set(key, value);
+                }
+                path = `${group}?${query}`;
+            }
+            else if (sub === "get")
+                path = `${group}/${idOf(work)}`;
+            else if (sub === "preview" ||
+                (group === "invoices" && sub === "send") ||
+                (group === "recurring" && sub === "create")) {
+                path = sub === "create" ? "recurring" : `${group}/${sub}`;
+                method = "POST";
+                body = await payload(work);
+                if (group === "recurring")
+                    body.kind = "recurring";
+                if (sub !== "preview") {
+                    requireKey(body);
+                    confirm(body, sub === "send"
+                        ? "Send this reviewed invoice"
+                        : "Create this reviewed recurring billing request");
+                }
+            }
+            else if ((group === "invoices" && ["refresh", "resend", "void"].includes(sub)) ||
+                (group === "recurring" &&
+                    ["refresh", "cancel", "resume", "resend-invitation"].includes(sub))) {
+                path = `${group}/${idOf(work)}/${sub}`;
+                method = "POST";
+                body = await payload(work);
+                if (["resend", "resume", "resend-invitation"].includes(sub))
+                    requireKey(body);
+                if (sub !== "refresh")
+                    confirm(body, `${sub} this ${group === "invoices" ? "invoice" : "billing arrangement"}`);
+            }
+            else
+                usage(`Unknown ${group} command. Run frontpage help payments.`);
+        }
+        else if (group === "customers") {
+            const sub = work.shift();
+            if (sub !== "billing-link" && sub !== "send-billing-link")
+                usage("Use payments customers billing-link|send-billing-link.");
+            path = `customers/${idOf(work)}/${sub}`;
+            method = "POST";
+            body = await payload(work);
+            requireKey(body);
+            if (sub === "send-billing-link")
+                confirm(body, "Email a private billing link to the customer's saved billing email");
+        }
+        else
+            return emitUsage("payments", USAGE);
+        noRest(work);
+        const result = method === "GET"
+            ? await v1Get(`${base}/${path}`)
+            : method === "PATCH"
+                ? await v1Patch(`${base}/${path}`, body)
+                : await v1Post(`${base}/${path}`, body, {
+                    timeoutMs: LONG_MODULE_TIMEOUT_MS,
+                });
+        if (isJson())
+            emitOk("payments", result);
+        else
+            console.log(JSON.stringify(result, null, 2));
+        return EXIT_OK;
+    }
+    catch (error) {
+        return emitErr("payments", error);
+    }
+}

package/dist/commands/people-workspace.js

@@ -10,7 +10,6 @@ const AREAS = [
     "import",
     "attachments",
     "person",
-    "company",
 ];
 export function isPeopleWorkspaceCommand(sub) {
     return (!!sub &&
@@ -23,7 +22,7 @@ export async function runPeopleWorkspace(slug, args) {
         ? work.shift()
         : area === "overview" || area === "sources"
             ? area
-            : `${area}.${work.shift() ?? (area === "company" ? "get" : area === "audience" ? "preview" : "list")}`;
+            : `${area}.${work.shift() ?? (area === "audience" ? "preview" : "list")}`;
     const file = takeFlag(work, "--file"), json = takeFlag(work, "--data");
     if (file && json)
         throw new CliHttpError("Use --file or --data, not both.", EXIT_USAGE, 0, "bad_request");

package/dist/commands/people.js

@@ -232,12 +232,16 @@ export async function runPeople(args) {
             const work = rest.slice(1);
             const id = requireId(work);
             const body = takeFlag(work, "--body") ?? takeFlag(work, "--note");
+            const requestKey = takeFlag(work, "--request-key");
+            const historical = takeFlag(work, "--historical");
+            if (historical !== undefined && !["true", "false"].includes(historical))
+                throw new Error("historical must be true or false.");
             assertNoUnknownFlags(work, "people");
             if (!body) {
                 console.error("Usage: frontpage people note <id> --body \"…\"");
                 return EXIT_USAGE;
             }
-            const data = await v1Post(`${base}/${encodeURIComponent(id)}/events`, { body });
+            const data = await v1Post(`${base}/${encodeURIComponent(id)}/events`, { body, requestKey, ...(historical !== undefined ? { historical: historical === "true" } : {}) });
             if (isJson()) {
                 emitOk("people", data);
                 return EXIT_OK;