@oxygen-agent/cli 1.1014.1696 → 1.1014.1763

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.1014.1696
+Version: 1.1014.1763

package/dist/command-families/program.js

@@ -33,6 +33,8 @@ import { registerDeliverabilityFamily } from "../commands/deliverability.js";
 import { registerDirectoryFamily } from "../commands/directory.js";
 import { registerDomainsFamily } from "../commands/domains.js";
 import { registerEgressFamily } from "../commands/egress.js";
+import { registerEmailAssetsFamily } from "../commands/email-assets.js";
+import { registerEmailTemplatesFamily } from "../commands/email-templates.js";
 import { registerEmailFamily } from "../commands/email.js";
 import { registerEngagementFamily } from "../commands/engagement.js";
 import { registerEnrichColumnFamily } from "../commands/enrich-column.js";
@@ -215,6 +217,8 @@ export function createProgram() {
     registerVoiceFamily(program, handleAsyncAction);
     registerSuppressionsFamily(program, handleAsyncAction);
     registerSubscriptionsFamily(program, handleAsyncAction);
+    registerEmailAssetsFamily(program, handleAsyncAction);
+    registerEmailTemplatesFamily(program, handleAsyncAction);
     registerEmailFamily(program, handleAsyncAction);
     registerManagedInboxesFamily(program, handleAsyncAction);
     registerMailboxesFamily(program, handleAsyncAction);

package/dist/command-manifest.js

@@ -99,7 +99,7 @@ const MUTATING_VERBS = new Set([
     // `support admin todo` moves a Plain Thread back into the queue. The noun
     // reads like a state, but the command is the transition into it.
     "todo",
-    "unarchive", "unpublish", "unshare",
+    "unarchive", "unpublish", "unschedule", "unshare",
     "unbind", "unsubscribe", "update", "upload", "upsert", "use", "warm-send", "warmup",
     "withdraw", "write",
     // `voice numbers release` returns a number to the carrier: irreversible,
@@ -109,7 +109,15 @@ const MUTATING_VERBS = new Set([
 // Exact commands that must not inherit a read-only discovery label. Warmup
 // status persists state and can pause the provider; reconnect replaces its
 // connection and can restart provider history. Other status commands are reads.
+// Exact paid leaves with no approval flag: a newsletter test send emails up to
+// five member addresses at send.bulk_email each.
+const SPENDING_WITHOUT_APPROVAL_COMMANDS = new Set([
+    "sequences test-send",
+]);
 const MUTATING_COMMANDS = new Set([
+    // A newsletter test send emails members and is metered; the hyphenated leaf
+    // matches no verb (`test` is not one).
+    "sequences test-send",
     // Live DNS checks save observations; --cached explicitly reads saved evidence.
     "domains dns",
     // Creates or re-checks the Amazon SES identity and records its DKIM and
@@ -153,6 +161,9 @@ const MUTATING_COMMANDS = new Set([
     "mailboxes warmup google",
     // Immediately moves a provider proxy and may pause or resume the sender.
     "senders proxy-country",
+    // Staff stop or restart a workspace's newsletter sending (its SES tenant).
+    "admin ses tenants block",
+    "admin ses tenants unblock",
     // A noun leaf with its own action (not a group), so the default would
     // advertise a STANDING per-viewer paid-enrichment toggle as a read. `enrichment`
     // itself is not a MUTATING_VERBS entry because the other two `enrichment`
@@ -489,7 +500,8 @@ function toManifestEntry(command, path) {
                 // cap flag exists for either, so the flag heuristic alone would misreport
                 // them as free.
                 (path[0] === "copilot" &&
-                    (leafVerb === "send" || leafVerb === "approve")))),
+                    (leafVerb === "send" || leafVerb === "approve")) ||
+                SPENDING_WITHOUT_APPROVAL_COMMANDS.has(commandName))),
         mutates: operations.length ? operations.some((spec) => spec.mutates) : (!READ_ONLY_COMMANDS.has(commandName)
             && (MUTATING_COMMANDS.has(commandName)
                 || MUTATING_VERBS.has(leafVerb)

package/dist/command-support.js

@@ -66,7 +66,7 @@ export function readCollabPath(value) {
  * API refuses (focus_rank_unavailable). Unhide with the production rollout.
  */
 export function leadsTodayRankOption() {
-    return new Option("--rank <rank>", "signal (default) or focus: warmth, then ICP fit, then decayed 90-day inbound intent, each lead with reasons, evidence ids and the teammates who know them. Only where Network Mining is enabled; elsewhere the API answers focus_rank_unavailable.").hideHelp();
+    return new Option("--rank <rank>", "signal (default) or focus: warmth, then ICP fit, then decayed inbound intent over 90 days (or --within-days), each lead with reasons, evidence ids and the teammates who know them. Only where Network Mining is enabled; elsewhere the API answers focus_rank_unavailable.").hideHelp();
 }
 // One cadence vocabulary across every scheduled surface (column refresh, table
 // feed): `translateScheduleEvery` in apps/web resolves all four forms, so this

package/dist/commands/admin.js

@@ -343,5 +343,86 @@ export function registerAdminFamily(program, handleAsyncAction, binaryName) {
                 },
             });
         });
-    })));
+    })))
+        .addCommand(new Command("ses")
+        .description("The shared Amazon SES account's workspace ownership. Staff only.")
+        .addCommand(new Command("identities")
+        .description("Which workspace owns each SES identity (sending domain) on the shared account.")
+        .addCommand(new Command("list")
+        .description("List SES identity claims: owner organization, state (pending, verified, released, reserved), tenant and expiry.")
+        .option("--organization <uuid>", "Only this organization's identities.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        const org = readOption(options.organization);
+        await handleAsyncAction("admin ses identities list", options, () => requestOxygen(`/api/cli/admin/ses/identities${org ? `?organization_id=${encodeURIComponent(org)}` : ""}`));
+    }))
+        .addCommand(new Command("adopt")
+        .description("Record an identity OXYGEN already runs on the account (its own newsletter domains, or one created before ownership was tracked) as owned by an organization. Bypasses the reserved-domain rule; refuses an identity another workspace holds unless --force.")
+        .argument("<identity>", "The SES domain identity, such as updates.oxygen-agent.com.")
+        .requiredOption("--organization <uuid>", "Control organization UUID that owns it.")
+        .option("--state <state>", "reserved (OXYGEN's own, default) or verified (a workspace's).")
+        .option("--force", "Take it from the workspace that holds it now.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (identity, options) => {
+        const state = readOption(options.state);
+        await handleAsyncAction("admin ses identities adopt", options, () => requestOxygen("/api/cli/admin/ses/identities", {
+            method: "POST",
+            body: { identity, organization_id: readOption(options.organization), ...(state ? { state } : {}), ...(options.force ? { force: true } : {}) },
+        }));
+    })))
+        .addCommand(new Command("tenants")
+        .description("Each workspace's SES tenant: newsletter health, proven volume, warm-up and staff controls.")
+        .addCommand(new Command("list")
+        .description("List every workspace's SES tenant: customer and SES status, 7-day sends, bounce and complaint rates, proven volume, warm-up day, allowance override and identities. Stopped workspaces first.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("admin ses tenants list", options, () => requestOxygen("/api/cli/admin/ses/tenants"));
+    }))
+        .addCommand(sesTenantStatusCommand("pause", "Pause a workspace's newsletter sending until someone resumes it.", true, handleAsyncAction))
+        .addCommand(sesTenantStatusCommand("resume", "Resume a paused workspace's newsletter sending.", false, handleAsyncAction))
+        .addCommand(sesTenantStatusCommand("block", "Block a workspace's newsletter sending until staff unblock it.", true, handleAsyncAction))
+        .addCommand(sesTenantStatusCommand("unblock", "Lift a block; the workspace sends newsletters again.", false, handleAsyncAction))
+        .addCommand(new Command("set-allowance")
+        .description("Cap a workspace's daily newsletter allowance (emails per day; 0 stops sending). The override only lowers the plan's cap.")
+        .requiredOption("--organization <uuid>", "Control organization UUID.")
+        .option("--value <emails>", "Emails per day, 0 or more.")
+        .option("--clear", "Remove the override.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("admin ses tenants set-allowance", options, () => {
+            const value = readAllowanceValue(options.value, options.clear === true);
+            const organization = readOption(options.organization) ?? "";
+            return requestOxygen(`/api/cli/admin/ses/tenants/${encodeURIComponent(organization)}`, { method: "POST", body: { action: "set-allowance", value } });
+        });
+    }))));
+}
+/** `--value` (a whole number, 0 allowed) or `--clear` (null), exactly one. */
+function readAllowanceValue(value, clear) {
+    const trimmed = value?.trim();
+    if (clear === Boolean(trimmed)) {
+        throw new OxygenError("invalid_request", "Pass exactly one of --value <emails> or --clear.", { exitCode: 2 });
+    }
+    if (clear)
+        return null;
+    const parsed = Number(trimmed);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new OxygenError("invalid_request", "--value must be a whole number of emails per day, 0 or more.", { details: { value }, exitCode: 2 });
+    }
+    return parsed;
+}
+function sesTenantStatusCommand(action, description, needsReason, handleAsyncAction) {
+    const command = new Command(action)
+        .description(description)
+        .requiredOption("--organization <uuid>", "Control organization UUID.");
+    if (needsReason)
+        command.requiredOption("--reason <text>", "Why; shown on the staff board.");
+    return command
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        const organization = readOption(options.organization) ?? "";
+        await handleAsyncAction(`admin ses tenants ${action}`, options, () => requestOxygen(`/api/cli/admin/ses/tenants/${encodeURIComponent(organization)}`, {
+            method: "POST",
+            body: needsReason ? { action, reason: readOption(options.reason) } : { action },
+        }));
+    });
 }

package/dist/commands/billing.js

@@ -350,7 +350,7 @@ export function registerBillingFamily(program, handleAsyncAction, billingDocsUrl
         .addCommand(new Command("topup")
         .description("No amount: read-only price quote, no checkout. With --credits or a pack: create Stripe Checkout and possibly billing resources; no charge until payment. Read tax_basis and review tax and the final total in Checkout. Prices are per 100 credits (`usd_per_100_credits`); credits arrive after confirmed payment and never expire. Plan credits cost less. `usd_per_1k_credits` is a deprecated name for the same per-100 price, not a price per 1,000 credits. `default_credits` is the web form's initial custom selection, not a purchase or minimum.")
         .argument("[pack]", "A pack id from the list shown when you run without an amount.")
-        .option("--credits <n>", "Credits to buy (800-100,000 in 100-credit increments).")
+        .option("--credits <n>", "Credits to buy (800-769,200 in 100-credit increments).")
         .option("--json", "Print a JSON envelope.")
         .action(async (pack, options) => {
         const credits = readOption(options.credits);

package/dist/commands/copilot.js

@@ -1,6 +1,6 @@
 import { emitCliFailure, emitSuccess } from "../cli-output.js";
 import { readJsonObjectOption, readNonNegativeInt, readPositiveInt, readRecordString } from "../cli-values.js";
-import { collectRepeatable, readPositiveNumber } from "../command-support.js";
+import { collectRepeatable, isUuid, readPositiveNumber } from "../command-support.js";
 import { addContractFlags, readContractFlags } from "../contract-flags.js";
 import { requestOxygen } from "../http-client.js";
 import { waitForCliRun } from "../run-wait.js";
@@ -483,7 +483,8 @@ export function registerCopilotFamily(program, handleAsyncAction) {
         .option("--no-wait", "Post the turn and return immediately without streaming the reply.")
         .option("--context <json>", "Optional JSON object of surface context to attach to the turn.")
         .option("--attach <path>", "Attach a file to this message (repeatable). Spreadsheets become tables the copilot can import and enrich; text documents ground the conversation. Uploaded straight to object storage, so large files are fine.", collectRepeatable, [])
-        .option("--interrupt", "In a Copilot chat, stop a still-working turn and send this message as the next turn instead of being refused. Not with --attach or in an Oxygent chat.")
+        .option("--attachment-id <id>", "Include a ready file already uploaded to this session by you (repeatable). Use the id returned by copilot attach or attachments; may be combined with --attach local paths.", collectRepeatable, [])
+        .option("--interrupt", "In a Copilot chat, stop a still-working turn and send this message as the next turn instead of being refused. Not with attachments or in an Oxygent chat.")
         .option("--timeout-seconds <n>", "Maximum time to wait for the turn to finish. Defaults to 300.")
         .option("--interval-seconds <n>", "Polling interval while streaming. Defaults to 2.")
         .option("--json", "Print a JSON envelope.")
@@ -491,17 +492,23 @@ export function registerCopilotFamily(program, handleAsyncAction) {
         await handleAsyncAction("copilot send", options, async () => {
             const message = messageParts.join(" ");
             const context = readJsonObjectOption(options.context);
-            const attachmentIds = [];
+            const attachmentIds = new Set();
+            for (const id of options.attachmentId ?? []) {
+                if (!isUuid(id)) {
+                    throw new OxygenError("invalid_option", "--attachment-id must be a UUID returned by copilot attach or attachments.", { exitCode: 2 });
+                }
+                attachmentIds.add(id.toLowerCase());
+            }
             for (const path of options.attach ?? []) {
                 const attached = await uploadCopilotAttachment(sessionId, path);
-                attachmentIds.push(attached.id);
+                attachmentIds.add(attached.id);
             }
             const posted = await requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}/turns`, {
                 method: "POST",
                 body: {
                     message,
                     ...(context ? { context } : {}),
-                    ...(attachmentIds.length > 0 ? { attachment_ids: attachmentIds } : {}),
+                    ...(attachmentIds.size > 0 ? { attachment_ids: [...attachmentIds] } : {}),
                     ...(options.interrupt ? { interrupt: true } : {}),
                 },
             });
@@ -530,7 +537,7 @@ export function registerCopilotFamily(program, handleAsyncAction) {
         });
     }))
         .addCommand(new Command("attach")
-        .description("Attach a file to a Workspace Copilot session without sending a message yet. The file uploads straight to object storage and is described back to you (a spreadsheet's columns and row count); pass the returned id to `copilot send --attach` or just send next — unsent attachments ride the next message.")
+        .description("Attach a file to a Workspace Copilot session without sending a message yet. The file uploads straight to object storage and is described back to you (a spreadsheet's columns and row count). Include it in a turn with `copilot send --attachment-id <id>`; unsent files are not included automatically.")
         .argument("<sessionId>", "Copilot session id.")
         .argument("<path>", "Path to the file to attach.")
         .option("--json", "Print a JSON envelope.")
@@ -540,11 +547,26 @@ export function registerCopilotFamily(program, handleAsyncAction) {
         })));
     }))
         .addCommand(new Command("attachments")
-        .description("List the files attached to a Workspace Copilot session, sent and unsent.")
+        .description("List sent chat files and your own unsent files. Download originals with copilot attachment-download.")
         .argument("<sessionId>", "Copilot session id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sessionId, options) => {
         await handleAsyncAction("copilot attachments", options, () => requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}/attachments`));
+    }))
+        .addCommand(new Command("attachment-download")
+        .description("Download an original chat file. Current chat access is required; unsent files are private to their uploader.")
+        .argument("<sessionId>", "Copilot session id.")
+        .argument("<attachmentId>", "Attachment id from copilot attachments.")
+        .requiredOption("--output <path>", "New local file path; existing files are never overwritten.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sessionId, attachmentId, options) => {
+        await handleAsyncAction("copilot attachment-download", options, () => {
+            if (!isUuid(sessionId) || !isUuid(attachmentId))
+                throw new OxygenError("invalid_option", "sessionId and attachmentId must be UUIDs.", { exitCode: 2 });
+            return requestOxygen(`/api/cli/copilot/sessions/${encodeURIComponent(sessionId)}/attachments/${encodeURIComponent(attachmentId)}`, {
+                binaryOutputPath: resolve(options.output),
+            });
+        });
     }))
         .addCommand(new Command("approve")
         .description("Approve (or, with --reject, reject) an action a Workspace Copilot session is waiting on; approving re-queues the paused turn.")

package/dist/commands/domains.js

@@ -393,6 +393,13 @@ function sendingDomainsCommand(handleAsyncAction) {
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("domains sending resume", options, () => runSendingDomainPause(id, false, undefined));
+    }))
+        .addCommand(new Command("release")
+        .description("Remove a sending domain and give its domain back so it can be added again. Refused while any of its bulk emails is waiting to send.")
+        .argument("<domain>", "Sending domain id or name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("domains sending release", options, () => requestOxygen(`/api/cli/sequencer/sending-domains/${encodeURIComponent(id)}/release`, { method: "POST" }));
     }))
         .addCommand(settingsFlags(new Command("update")
         .description("Change a sending domain's daily ceiling, allowed From addresses or reply-to mailbox.")

package/dist/commands/email-assets.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerEmailAssetsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/email-assets.js

@@ -0,0 +1,78 @@
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+import { readFile, stat } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+// Newsletter image hosting: `/api/cli/email-assets`. The server re-encodes every
+// image (metadata stripped, at most 1500 px wide, JPEG/PNG, animated GIF kept,
+// never SVG) and returns a permanent public URL to place in an email.
+const MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
+const MIME_BY_EXTENSION = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".svg": "image/svg+xml",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+};
+function isUrl(source) {
+    return /^https?:\/\//i.test(source.trim());
+}
+async function uploadFromFile(path) {
+    const absolute = resolve(path);
+    let size;
+    try {
+        size = (await stat(absolute)).size;
+    }
+    catch {
+        throw new OxygenError("file_not_found", `No file at ${path}.`, { details: { field: "source" }, exitCode: 2 });
+    }
+    if (size > MAX_UPLOAD_BYTES) {
+        throw new OxygenError("email_asset_too_large", "The image is larger than 10 MB. Export a smaller image and try again.", {
+            details: { max_bytes: MAX_UPLOAD_BYTES, byte_length: size },
+            exitCode: 1,
+        });
+    }
+    const bytes = await readFile(absolute);
+    const form = new FormData();
+    const type = MIME_BY_EXTENSION[extname(absolute).toLowerCase()] ?? "application/octet-stream";
+    form.append("file", new File([bytes], basename(absolute), { type }));
+    return requestOxygen("/api/cli/email-assets", { method: "POST", formData: form });
+}
+export function registerEmailAssetsFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("email-assets")
+        .description("Host images for newsletters and emails: upload once, get a permanent public URL. Images are re-encoded (EXIF stripped, at most 1500 px wide, JPEG or PNG; animated GIFs up to 2 MB kept). 0 credits.")
+        .addCommand(new Command("upload")
+        .description("Upload a local image file or fetch a public https image URL (max 10 MB; JPEG, PNG, GIF, WebP, AVIF, SVG). The same image twice returns the first upload.")
+        .argument("<file|url>", "Path to an image file, or an https:// image URL.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (source, options) => {
+        await handleAsyncAction("email-assets upload", options, () => (isUrl(source)
+            ? requestOxygen("/api/cli/email-assets", { method: "POST", body: { source_url: source.trim() } })
+            : uploadFromFile(source)));
+    }))
+        .addCommand(new Command("list")
+        .description("List the workspace's hosted email images, newest first.")
+        .option("--limit <n>", "Images per page, 1-200 (default 50).")
+        .option("--before <timestamp>", "Page cursor: the previous page's next_before.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("email-assets list", options, () => {
+            const params = new URLSearchParams();
+            const limit = readOption(options.limit);
+            const before = readOption(options.before);
+            if (limit)
+                params.set("limit", limit);
+            if (before)
+                params.set("before", before);
+            const query = params.size > 0 ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/email-assets${query}`);
+        });
+    })));
+}

package/dist/commands/email-templates.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerEmailTemplatesFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/email-templates.js

@@ -0,0 +1,101 @@
+import { requestOxygen } from "../http-client.js";
+import { contentBody, readRevisionFlag, readSequence } from "../sequences-content-commands.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { sequenceContentStep } from "@oxygen/shared/sequences";
+import { Command } from "commander";
+async function saveTemplate(options) {
+    const fromDocument = readOption(options.fromDocument);
+    const fromStarter = readOption(options.fromStarter);
+    const sequence = readOption(options.sequence);
+    const fromFile = Boolean(options.htmlFile || options.jsonFile);
+    const sources = [fromDocument, fromStarter, sequence, fromFile].filter(Boolean).length;
+    if (sources !== 1) {
+        throw new OxygenError(sources > 1 ? "conflicting_flags" : "invalid_request", "Pass exactly one of --from-document, --from-starter, --sequence with --step, or --html-file/--json-file.", { exitCode: 2 });
+    }
+    const name = readOption(options.name);
+    const revision = readRevisionFlag(options.revision, "--revision");
+    if (revision !== undefined && !fromDocument)
+        throw new OxygenError("invalid_request", "--revision applies to --from-document.", { exitCode: 2 });
+    if (fromStarter) {
+        return requestOxygen("/api/cli/email-documents", { method: "POST", body: { role: "template", starter_id: fromStarter, ...(name ? { name } : {}) } });
+    }
+    if (fromFile) {
+        return requestOxygen("/api/cli/email-documents", { method: "POST", body: { role: "template", ...contentBody(options) } });
+    }
+    let sourceId = fromDocument;
+    let sourceRevision = revision;
+    if (sequence) {
+        const stepId = readOption(options.step);
+        if (!stepId)
+            throw new OxygenError("invalid_request", "--step is required with --sequence.", { exitCode: 2 });
+        const read = await readSequence(sequence);
+        const { bodyDocument } = sequenceContentStep(read.sequence.definition, stepId);
+        if (!bodyDocument) {
+            throw new OxygenError("email_document_not_found", "That step has no designed email to save; set one with `oxygen sequences content set` first.", {
+                details: { sequence_id: read.sequence.id, step_id: stepId }, exitCode: 4,
+            });
+        }
+        sourceId = bodyDocument.id;
+        sourceRevision = bodyDocument.revision;
+    }
+    return requestOxygen(`/api/cli/email-documents/${encodeURIComponent(sourceId)}`, {
+        method: "POST",
+        body: { action: "duplicate", role: "template", ...(sourceRevision !== undefined ? { revision: sourceRevision } : {}), ...(name ? { name } : {}) },
+    });
+}
+export function registerEmailTemplatesFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("email-templates")
+        .description("The newsletter template library: reusable email designs saved from a step, a file or a built-in starter. Start a step from one with `oxygen sequences content set --from-document <id>` (or `--from-starter <id>`). 0 credits.")
+        .addCommand(new Command("list")
+        .description("List the workspace's email templates (name, updated_at, preview text, HTML size) and the built-in read-only starters.")
+        .option("--include-archived", "Include deleted templates.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("email-templates list", options, () => requestOxygen(`/api/cli/email-documents?role=template${options.includeArchived ? "&include_archived=true" : ""}`));
+    }))
+        .addCommand(new Command("save")
+        .description("Save a template: from a step's current email (--sequence --step, save-as), an email document or template (--from-document), a built-in starter (--from-starter) or an HTML/JSON file. Copies the current revision; later edits to the source do not change it.")
+        .option("--name <name>", "Template name.")
+        .option("--sequence <id>", "With --step: save this sequence step's email as a template.")
+        .option("--step <id>", "The email_send step id (with --sequence).")
+        .option("--from-document <id>", "Copy this email document or template.")
+        .option("--revision <n>", "With --from-document: copy this revision (default its current one).")
+        .option("--from-starter <id>", "Copy a built-in starter: simple-announcement, product-update, weekly-digest.")
+        .option("--html-file <path>", "The email HTML.")
+        .option("--json-file <path>", "A JSON object { html, text?, preview_text?, editor_json? }, e.g. the editor's export.")
+        .option("--text-file <path>", "The plain-text part. Default: derived from the HTML.")
+        .option("--preview-text <text>", "The inbox preview line shown after the subject.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("email-templates save", options, () => saveTemplate(options));
+    }))
+        .addCommand(new Command("rename")
+        .description("Rename a template (no new revision).")
+        .argument("<template-id>", "Template id.")
+        .requiredOption("--name <name>", "New name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (templateId, options) => {
+        await handleAsyncAction("email-templates rename", options, () => requestOxygen(`/api/cli/email-documents/${encodeURIComponent(templateId)}`, { method: "PATCH", body: { name: options.name } }));
+    }))
+        .addCommand(new Command("duplicate")
+        .description("Copy a template into a new template (default name: \"<name> (copy)\").")
+        .argument("<template-id>", "Template id.")
+        .option("--name <name>", "Name of the copy.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (templateId, options) => {
+        await handleAsyncAction("email-templates duplicate", options, () => {
+            const name = readOption(options.name);
+            return requestOxygen(`/api/cli/email-documents/${encodeURIComponent(templateId)}`, {
+                method: "POST", body: { action: "duplicate", role: "template", ...(name ? { name } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("delete")
+        .description("Delete a template from the library. Sequences already using a copy keep it; a step's own email cannot be deleted here.")
+        .argument("<template-id>", "Template id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (templateId, options) => {
+        await handleAsyncAction("email-templates delete", options, () => requestOxygen(`/api/cli/email-documents/${encodeURIComponent(templateId)}`, { method: "DELETE" }));
+    })));
+}