@dayofweek/dcli 1.4.0 → 1.6.0

package/dist/bin/dcli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { Command } from "commander";
-import { ApiError, DayOfWeekClient } from "../client.js";
+import { ApiError, DayOfWeekClient, toArrayBuffer } from "../client.js";
 import { getToken, getApiUrl, saveConfig, loadConfig, saveCredential, deleteCredential } from "../config.js";
 import { browserLogin } from "../auth/login.js";
 import { parseBrainResource } from "../uri.js";
-import { accessSync, constants, readFileSync, existsSync, statSync } from "node:fs";
+import { accessSync, constants, mkdirSync, readFileSync, existsSync, statSync, writeFileSync } from "node:fs";
 import { join, basename, resolve, relative, sep } from "node:path";
 import { homedir } from "node:os";
 import { createInterface } from "node:readline/promises";
@@ -240,6 +240,13 @@ brain
     output(await getClient().listBrainAudit(opts.area, { cursor: opts.cursor, limit: opts.limit }));
 });
 const brainSource = brain.command("source").description("Work with original shared files and recordings");
+brainSource
+    .command("list")
+    .description("List an area's sources, newest first (metadata only)")
+    .requiredOption("--area <areaId>", "Area to inventory")
+    .action(async (opts) => {
+    output(await getClient().listBrainSources(opts.area));
+});
 brainSource
     .command("get <uri>")
     .description("Read source metadata and derived text")
@@ -325,6 +332,7 @@ read
     .option("--type <entityType>", "Filter by type (Farm, Producer, Restaurant, ...)")
     .option("--parent <entityId>", "List children of an entity")
     .option("--limit <count>", "Max results", parseInt)
+    .option("--org <org>", "Organization slug or id (admin only)")
     .action(async (opts) => {
     const client = getClient();
     const result = await client.listEntities(opts);
@@ -333,9 +341,10 @@ read
 read
     .command("entity <entityId>")
     .description("Get entity details")
-    .action(async (entityId) => {
+    .option("--org <org>", "Organization slug or id (admin only)")
+    .action(async (entityId, opts) => {
     const client = getClient();
-    const result = await client.getEntity(entityId);
+    const result = await client.getEntity(entityId, opts.org);
     output(result);
 });
 read
@@ -343,6 +352,7 @@ read
     .description("List produce profiles")
     .option("--entity <entityId>", "Filter by entity")
     .option("--limit <count>", "Max results", parseInt)
+    .option("--org <org>", "Organization slug or id (admin only)")
     .action(async (opts) => {
     const client = getClient();
     const result = await client.listProduce(opts);
@@ -353,6 +363,7 @@ read
     .description("List contacts and memberships")
     .option("--entity <entityId>", "Filter by entity")
     .option("--limit <count>", "Max results", parseInt)
+    .option("--org <org>", "Organization slug or id (admin only)")
     .action(async (opts) => {
     const client = getClient();
     const result = await client.listContacts(opts);
@@ -361,9 +372,10 @@ read
 read
     .command("entity-types")
     .description("List available entity types")
-    .action(async () => {
+    .option("--org <org>", "Organization slug or id (admin only)")
+    .action(async (opts) => {
     const client = getClient();
-    const result = await client.listEntityTypes();
+    const result = await client.listEntityTypes(opts.org);
     output(result);
 });
 read
@@ -374,6 +386,7 @@ read
     .option("--type <nodeType>", "Filter by type (category, produce, variety)")
     .option("--include-categories", "Include non-selectable categories in results")
     .option("--limit <count>", "Max results", parseInt)
+    .option("--org <org>", "Organization slug or id (admin only)")
     .action(async (opts) => {
     const client = getClient();
     const result = await client.searchCatalog(opts);
@@ -462,6 +475,191 @@ agent
     const result = await client.getProposal(proposalId);
     output(result);
 });
+// ── Knowledge Commands ───────────────────────────────────────────────────────
+const MIME_BY_EXT = {
+    ".pdf": "application/pdf",
+    ".md": "text/markdown",
+    ".txt": "text/plain",
+    ".csv": "text/csv",
+    ".json": "application/json",
+    ".html": "text/html",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".doc": "application/msword",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xls": "application/vnd.ms-excel",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};
+function guessMimeType(path) {
+    const dot = path.lastIndexOf(".");
+    const ext = dot === -1 ? "" : path.slice(dot).toLowerCase();
+    return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+/** Filesystem-safe name for an exported document, keeping it recognisable. */
+function exportFileName(doc) {
+    const base = (doc.fileName || doc.title || doc.id || "document").trim();
+    const stripped = base.replace(/\.(md|txt)$/i, "");
+    const safe = stripped.replace(/[/\\:*?"<>|]+/g, "-").replace(/\s+/g, " ").slice(0, 120);
+    return `${safe || doc.id || "document"}.md`;
+}
+const knowledge = program
+    .command("knowledge")
+    .description("Read, add and export entity knowledge documents");
+knowledge
+    .command("list")
+    .description("List knowledge documents on an entity")
+    .requiredOption("--entity <entityId>", "Target entity id")
+    .option("--full", "Include each document's full content, not an excerpt")
+    .option("--org <org>", "Organization (admin only)")
+    .action(async (opts) => {
+    const client = getClient();
+    output(await client.listKnowledge({ entity: opts.entity, full: opts.full, org: opts.org }));
+});
+knowledge
+    .command("get <documentId>")
+    .description("Show one knowledge document with full content")
+    .option("--org <org>", "Organization (admin only)")
+    .action(async (documentId, opts) => {
+    const client = getClient();
+    output(await client.getKnowledge(documentId, opts.org));
+});
+knowledge
+    .command("search <query>")
+    .description("Semantic search across knowledge documents")
+    .option("--entity <entityId>", "Scope to one entity's org tree")
+    .option("--types <types>", "Comma-separated sourceType filter")
+    .option("--limit <count>", "Max hits", parseInt)
+    .option("--all-orgs", "Search every org (admin only)")
+    .option("--org <org>", "Organization (admin only)")
+    .action(async (query, opts) => {
+    const client = getClient();
+    output(await client.searchKnowledge({
+        query,
+        entity: opts.entity,
+        types: opts.types
+            ? String(opts.types).split(",").map((t) => t.trim()).filter(Boolean)
+            : undefined,
+        limit: opts.limit,
+        allOrgs: opts.allOrgs,
+        org: opts.org,
+    }));
+});
+knowledge
+    .command("add")
+    .description("Add a markdown knowledge note (proposal by default)")
+    .requiredOption("--entity <entityId>", "Target entity id")
+    .requiredOption("--title <title>", "Document title")
+    .option("--file <path>", "Markdown file to read (- for stdin)")
+    .option("--content <text>", "Inline content instead of --file")
+    .option("--source-type <type>", "research | website | competitive_intel | …", "research")
+    .option("--source-url <url>", "Where the content came from")
+    .option("--source-description <text>", "Short provenance note")
+    .option("--confidence <n>", "0-1, helps reviewers prioritize", parseFloat)
+    .option("--source-agent <name>", "Attribution for the submitting agent")
+    .option("--direct", "Write immediately instead of proposing. Admin only — ask the operator first")
+    .option("--org <org>", "Organization (admin only)")
+    .action(async (opts) => {
+    let content;
+    if (opts.content) {
+        content = String(opts.content);
+    }
+    else if (opts.file) {
+        content = opts.file === "-" ? readFileSync(0, "utf8") : readFileSync(opts.file, "utf8");
+    }
+    else {
+        throw new Error("Provide --file or --content");
+    }
+    if (!content.trim())
+        throw new Error("Content is empty");
+    const client = getClient();
+    output(await client.addKnowledge({
+        entityId: opts.entity,
+        title: opts.title,
+        content,
+        sourceType: opts.sourceType,
+        sourceUrl: opts.sourceUrl,
+        sourceDescription: opts.sourceDescription,
+        confidence: opts.confidence,
+        sourceAgent: opts.sourceAgent,
+        direct: Boolean(opts.direct),
+        org: opts.org,
+    }));
+});
+knowledge
+    .command("attach")
+    .description("Attach a file (PDF, DOCX, XLSX …) as a source. Admin only")
+    .requiredOption("--entity <entityId>", "Target entity id")
+    .requiredOption("--file <path>", "File to upload")
+    .option("--name <fileName>", "Stored file name (defaults to the file's own)")
+    .option("--mime <mimeType>", "Content type (guessed from the extension)")
+    .option("--source-type <type>", "research | website | contract | …", "other")
+    .option("--source-url <url>", "Where the file came from")
+    .option("--source-description <text>", "Short provenance note")
+    .option("--org <org>", "Organization (admin only)")
+    .action(async (opts) => {
+    if (!existsSync(opts.file))
+        throw new Error(`File not found: ${opts.file}`);
+    const data = readFileSync(opts.file);
+    if (data.byteLength === 0)
+        throw new Error("File is empty");
+    const client = getClient();
+    output(await client.attachKnowledgeFile({
+        entityId: opts.entity,
+        data: toArrayBuffer(data),
+        fileName: opts.name ?? basename(opts.file),
+        mimeType: opts.mime ?? guessMimeType(opts.file),
+        sourceType: opts.sourceType,
+        sourceUrl: opts.sourceUrl,
+        sourceDescription: opts.sourceDescription,
+        org: opts.org,
+    }));
+});
+knowledge
+    .command("export")
+    .description("Write an entity's knowledge documents to disk as markdown")
+    .requiredOption("--entity <entityId>", "Source entity id")
+    .requiredOption("--out <dir>", "Directory to write into (created if missing)")
+    .option("--org <org>", "Organization (admin only)")
+    .action(async (opts) => {
+    const client = getClient();
+    const docs = await client.listKnowledge({ entity: opts.entity, full: true, org: opts.org });
+    mkdirSync(opts.out, { recursive: true });
+    const written = [];
+    const skipped = [];
+    for (const doc of docs) {
+        const body = typeof doc.content === "string" ? doc.content : "";
+        if (!body) {
+            // A binary source whose text extraction hasn't finished has nothing to
+            // mirror yet. Report it rather than writing an empty file.
+            skipped.push({
+                id: doc.id,
+                title: doc.title,
+                reason: doc.processingStatus && doc.processingStatus !== "completed"
+                    ? `processingStatus=${doc.processingStatus}`
+                    : "no extracted content",
+            });
+            continue;
+        }
+        const frontMatter = [
+            "---",
+            `document_id: ${doc.id}`,
+            `title: ${JSON.stringify(doc.title ?? "")}`,
+            `source_type: ${doc.sourceType ?? "other"}`,
+            ...(doc.sourceUrl ? [`source_url: ${doc.sourceUrl}`] : []),
+            ...(doc.sourceDescription
+                ? [`source_description: ${JSON.stringify(doc.sourceDescription)}`]
+                : []),
+            `entity_id: ${opts.entity}`,
+            ...(doc.createdAt ? [`created_at: ${new Date(doc.createdAt).toISOString()}`] : []),
+            "exported_from: dayofweek-platform",
+            "---",
+            "",
+        ].join("\n");
+        const target = join(opts.out, exportFileName(doc));
+        writeFileSync(target, `${frontMatter}${body}\n`, "utf8");
+        written.push({ id: doc.id, file: target, bytes: Buffer.byteLength(body, "utf8") });
+    }
+    output({ entity: opts.entity, out: opts.out, total: docs.length, written, skipped });
+});
 // ── Skill Commands ───────────────────────────────────────────────────────────
 const skill = program.command("skill").description("Manage the Day of Week agent skill");
 function resolveTargetDirs(target, bundleName, customDir) {
@@ -641,6 +839,114 @@ skill
     if (!installed)
         process.exitCode = 2;
 });
+// ── Data Commands ────────────────────────────────────────────────────────────
+//
+// Generic, name-blind reads of platform datasets. The server's catalog decides
+// what exists and what the caller may see — this CLI ships no dataset names,
+// so new platform surfaces appear in `data list` without a CLI release.
+const data = program.command("data").description("Read platform datasets the server offers you");
+data
+    .command("list")
+    .description("List the datasets your credential may read")
+    .option("--org <org>", "Organization slug or id (admin only)")
+    .action(async (opts) => {
+    const client = getClient();
+    output(await client.listDatasets(opts.org));
+});
+data
+    .command("get <dataset>")
+    .description("Read one dataset's rows (names come from `data list`)")
+    .option("--limit <count>", "Max rows (default 50, max 200)", parseInt)
+    .option("--org <org>", "Organization slug or id (admin only)")
+    .action(async (dataset, opts) => {
+    const client = getClient();
+    output(await client.readDataset(dataset, { limit: opts.limit, org: opts.org }));
+});
+// ── Feedback Commands ────────────────────────────────────────────────────────
+//
+// The customer feedback backlog. Scope-gated rather than admin-gated:
+// read:feedback for the reads, write:feedback to comment, admin:feedback for
+// claim/status/priority. backOffice users implicitly hold every scope, so the
+// group stays visible and the endpoint decides what the caller may do.
+const feedback = program
+    .command("feedback")
+    .description("Read and work the customer feedback backlog");
+feedback
+    .command("list")
+    .description("List backlog items")
+    .option("--status <status>", "backlog | planned | in_progress | shipped | rejected | new")
+    .option("--priority <priority>", "urgent | high | medium | low")
+    .option("--category <category>", "Filter by category, e.g. studio")
+    .option("--limit <count>", "Max results", parseInt)
+    .action(async (opts) => {
+    const client = getClient();
+    output(await client.listFeedback({
+        status: opts.status,
+        priority: opts.priority,
+        category: opts.category,
+        limit: opts.limit,
+    }));
+});
+feedback
+    .command("next")
+    .description("What should I work on next — the prioritizer's top picks")
+    .option("--limit <count>", "How many recommendations", parseInt)
+    .action(async (opts) => {
+    const client = getClient();
+    output(await client.feedbackRecommendations(opts.limit));
+});
+feedback
+    .command("show <itemId>")
+    .description("Show one backlog item in full")
+    .action(async (itemId) => {
+    const client = getClient();
+    output(await client.getFeedbackItem(itemId));
+});
+feedback
+    .command("claim <itemId>")
+    .description("Claim an item so humans see it is being worked on")
+    .action(async (itemId) => {
+    const client = getClient();
+    output(await client.claimFeedbackItem(itemId));
+});
+feedback
+    .command("comment <itemId>")
+    .description("Add a comment to a backlog item")
+    .option("--body <text>", "Comment text")
+    .option("--file <path>", "Read the comment from a file (- for stdin)")
+    .action(async (itemId, opts) => {
+    let body;
+    if (opts.body) {
+        body = String(opts.body);
+    }
+    else if (opts.file) {
+        body = opts.file === "-" ? readFileSync(0, "utf8") : readFileSync(opts.file, "utf8");
+    }
+    else {
+        throw new Error("Provide --body or --file");
+    }
+    if (!body.trim())
+        throw new Error("Comment is empty");
+    const client = getClient();
+    output(await client.commentOnFeedbackItem(itemId, body));
+});
+feedback
+    .command("status <itemId>")
+    .description("Set status and/or priority on a backlog item")
+    .option("--status <status>", "backlog | planned | in_progress | shipped | rejected")
+    .option("--priority <priority>", "urgent | high | medium | low")
+    .option("--rejected-reason <text>", "Why it was rejected (with --status rejected)")
+    .action(async (itemId, opts) => {
+    if (!opts.status && !opts.priority) {
+        throw new Error("Provide --status and/or --priority");
+    }
+    const client = getClient();
+    output(await client.updateFeedbackItem(itemId, {
+        status: opts.status,
+        priority: opts.priority,
+        rejectedReason: opts.rejectedReason,
+    }));
+});
 // ── Admin Commands ───────────────────────────────────────────────────────────
 //
 // These are admin-only. They're registered as hidden subcommands when the
@@ -692,6 +998,224 @@ function registerAdminCommands() {
         });
         output(result);
     });
+    // ── Assortment import ──────────────────────────────────────────────────────
+    //
+    // These write real Creator rows rather than proposals, so the operator
+    // approves the parsed result first. --dry-run rehearses the whole import
+    // server-side and rolls it back; that response is what the review is built
+    // from. Writing requires --approved for the same reason email does.
+    const produce = program
+        .command("produce", { hidden: true })
+        .description("Assortment import and recipe refinement (DoW staff)");
+    produce
+        .command("import")
+        .description("Import a producer's items into Creator. Requires --dry-run or --approved")
+        .requiredOption("--file <path>", "JSON payload: { entityId, items[] } (- for stdin)")
+        .option("--dry-run", "Rehearse server-side and roll back — build the review from this")
+        .option("--skip-existing-names", "Skip items whose displayName already exists")
+        .option("--approved", "The operator approved the dry-run result")
+        .option("--org <org>", "Organization slug or id")
+        .action(async (opts) => {
+        if (!opts.dryRun && !opts.approved) {
+            throw new Error("Refusing to write: run with --dry-run first, show the operator the result, " +
+                "then repeat with --approved. This creates real Creator rows, not proposals.");
+        }
+        const raw = opts.file === "-" ? readFileSync(0, "utf8") : readFileSync(opts.file, "utf8");
+        const payload = JSON.parse(raw);
+        if (!payload?.entityId || !Array.isArray(payload.items)) {
+            throw new Error("Payload needs { entityId, items: [...] }");
+        }
+        const client = getClient();
+        output(await client.importProduce({
+            entityId: payload.entityId,
+            items: payload.items,
+            dryRun: Boolean(opts.dryRun),
+            skipExistingNames: opts.skipExistingNames ?? payload.skipExistingNames,
+            org: opts.org ?? payload.org,
+        }));
+    });
+    produce
+        .command("add-concepts")
+        .description("Add concepts to the shared produce catalog. Requires --approved")
+        .requiredOption("--file <path>", "JSON: { concepts: [...] } or a bare array (- for stdin)")
+        .option("--approved", "The operator approved these concepts")
+        .option("--org <org>", "Organization slug or id")
+        .action(async (opts) => {
+        if (!opts.approved) {
+            throw new Error("Refusing to write: the produce catalog is shared by every customer. " +
+                "Show the operator the concepts you want to add, then repeat with --approved.");
+        }
+        const raw = opts.file === "-" ? readFileSync(0, "utf8") : readFileSync(opts.file, "utf8");
+        const parsed = JSON.parse(raw);
+        const concepts = Array.isArray(parsed) ? parsed : parsed?.concepts;
+        if (!Array.isArray(concepts) || concepts.length === 0) {
+            throw new Error("Payload needs a non-empty `concepts` array");
+        }
+        const client = getClient();
+        output(await client.createCatalogConcepts({ concepts, org: opts.org ?? parsed?.org }));
+    });
+    produce
+        .command("ingredients")
+        .description("Recipe ingredients still standing in for something vaguer")
+        .requiredOption("--entity <entityId>", "Producer entity")
+        .option("--org <org>", "Organization slug or id")
+        .action(async (opts) => {
+        const client = getClient();
+        output(await client.listImpreciseIngredients(opts.entity, opts.org));
+    });
+    produce
+        .command("refine")
+        .description("Point an imprecise ingredient at what it actually is")
+        .requiredOption("--process-input <id>", "processInputId from `produce ingredients`")
+        .option("--concept <catalogConceptId>", "What it actually is")
+        .option("--material <materialId>", "Material node instead of a catalog concept")
+        .option("--role <role>", "e.g. seasoning, base")
+        .option("--qty <n>", "Quantity", parseFloat)
+        .option("--unit <unitCode>", "Unit code")
+        .option("--still-imprecise", "Narrowed but not resolved — keeps it on the worklist")
+        .option("--org <org>", "Organization slug or id")
+        .action(async (opts) => {
+        if (!opts.concept && !opts.material) {
+            throw new Error("Provide --concept or --material");
+        }
+        const client = getClient();
+        output(await client.refineIngredient({
+            processInputId: opts.processInput,
+            catalogConceptId: opts.concept,
+            materialId: opts.material,
+            role: opts.role,
+            qty: opts.qty,
+            unitCode: opts.unit,
+            stillImprecise: Boolean(opts.stillImprecise),
+            org: opts.org,
+        }));
+    });
+    admin
+        .command("customers-only")
+        .description("Entities with a customer role and no investor/partner/producer role")
+        .action(async () => {
+        const client = getClient();
+        output(await client.adminCustomersOnly());
+    });
+    admin
+        .command("press-inbox")
+        .description("Tips mailed to press@mail.dayofweek.com (Press Radar)")
+        .option("--since <date>", "ISO date or epoch ms (default 45 days back)")
+        .option("--limit <count>", "Max emails (max 200)", parseInt)
+        .action(async (opts) => {
+        const client = getClient();
+        output(await client.adminPressInbox({ since: opts.since, limit: opts.limit }));
+    });
+    // ── Customer emails ────────────────────────────────────────────────────────
+    //
+    // Mail sent to a customer's own inbox address (<slug>@mail.dayofweek.com)
+    // becomes a thread the agent can answer. Reading is free; sending is not:
+    // `reply` and `compose` refuse to run without --approved, so an agent cannot
+    // mail a customer as a side effect of "check the inbox". The human approves
+    // the exact text first — that rule lives in the skill; --approved is the
+    // mechanical backstop for it.
+    const emails = program
+        .command("emails", { hidden: true })
+        .description("Customer email threads — read, reply, compose (DoW staff)");
+    const APPROVAL_REQUIRED = "Refusing to send: pass --approved once the human has approved this exact text. " +
+        "Never send an email the human has not seen.";
+    emails
+        .command("list")
+        .description("List customer email threads")
+        .option("--status <status>", "needs_reply | manual_review | all (default all)")
+        .option("--since <date>", "ISO date (2026-07-01) or epoch ms; default 30 days back")
+        .option("--customer <entityId>", "One customer only")
+        .option("--limit <count>", "Max threads (default 50, max 200)", parseInt)
+        .option("--org <org>", "Organization slug or id")
+        .action(async (opts) => {
+        const client = getClient();
+        output(await client.listEmailThreads({
+            status: opts.status,
+            since: opts.since,
+            customer: opts.customer,
+            limit: opts.limit,
+            org: opts.org,
+        }));
+    });
+    emails
+        .command("show <threadKey>")
+        .description("Full thread: messages, attachments, and reply hints")
+        .action(async (threadKey) => {
+        const client = getClient();
+        output(await client.getEmailThread(threadKey));
+    });
+    emails
+        .command("reply <threadKey>")
+        .description("Reply in a thread. Requires --approved")
+        .option("--message <text>", "Plain-text reply body")
+        .option("--file <path>", "Read the body from a file (- for stdin)")
+        .option("--subject <text>", "Override the subject (defaults to Re: …)")
+        .option("--to <address>", "Override the recipient")
+        .option("--cc <addresses>", "Comma-separated cc list")
+        .option("--no-quote", "Do not quote the original underneath")
+        .option("--approved", "The human approved this exact text")
+        .action(async (threadKey, opts) => {
+        if (!opts.approved)
+            throw new Error(APPROVAL_REQUIRED);
+        let message;
+        if (opts.message) {
+            message = String(opts.message);
+        }
+        else if (opts.file) {
+            message = opts.file === "-" ? readFileSync(0, "utf8") : readFileSync(opts.file, "utf8");
+        }
+        else {
+            throw new Error("Provide --message or --file");
+        }
+        if (!message.trim())
+            throw new Error("Message is empty");
+        const client = getClient();
+        output(await client.replyToEmailThread(threadKey, {
+            message,
+            subject: opts.subject,
+            to: opts.to,
+            cc: splitList(opts.cc),
+            quote: opts.quote,
+        }));
+    });
+    emails
+        .command("compose")
+        .description("Start a new thread from a customer inbox. Requires --approved")
+        .option("--entity <entityId>", "Customer entity whose inbox sends the mail")
+        .option("--inbox <address>", "Inbox address instead of --entity")
+        .requiredOption("--to <address>", "Recipient")
+        .option("--cc <addresses>", "Comma-separated cc list")
+        .requiredOption("--subject <text>", "Subject line")
+        .option("--message <text>", "Plain-text body")
+        .option("--file <path>", "Read the body from a file (- for stdin)")
+        .option("--approved", "The human approved this exact text")
+        .action(async (opts) => {
+        if (!opts.approved)
+            throw new Error(APPROVAL_REQUIRED);
+        if (!opts.entity && !opts.inbox)
+            throw new Error("Provide --entity or --inbox");
+        let message;
+        if (opts.message) {
+            message = String(opts.message);
+        }
+        else if (opts.file) {
+            message = opts.file === "-" ? readFileSync(0, "utf8") : readFileSync(opts.file, "utf8");
+        }
+        else {
+            throw new Error("Provide --message or --file");
+        }
+        if (!message.trim())
+            throw new Error("Message is empty");
+        const client = getClient();
+        output(await client.composeEmail({
+            entityId: opts.entity,
+            inbox: opts.inbox,
+            to: opts.to,
+            cc: splitList(opts.cc),
+            subject: opts.subject,
+            message,
+        }));
+    });
 }
 registerAdminCommands();
 // ── Helpers ──────────────────────────────────────────────────────────────────
@@ -703,6 +1227,13 @@ async function readStdin() {
     }
     return chunks.join("\n");
 }
+/** Parse a comma-separated CLI option into a trimmed list, or undefined. */
+function splitList(value) {
+    if (!value)
+        return undefined;
+    const items = String(value).split(",").map((entry) => entry.trim()).filter(Boolean);
+    return items.length ? items : undefined;
+}
 function inferMimeType(path) {
     const extension = path.toLowerCase().split(".").at(-1);
     const types = {