@oxygen-agent/cli 1.1014.135 → 1.1014.618

package/dist/commands/deliverability.js

@@ -0,0 +1,90 @@
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { Command, CommanderError, Option } from "commander";
+export function registerDeliverabilityFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("deliverability")
+        .description("External email deliverability: fleet reputation health and DIRECTIONAL inbox-placement (spam) tests via EmailGuard, Zapmail, or an explicitly configured OXYGEN placement evaluation pilot. Start with `placement-test list` and `placement-test get` to inspect existing results for 0 credits without creating or sending a test. For continuous EmailGuard account monitoring use `oxygen mailboxes emailguard connect`. Placement tests are approval-gated paid runs (managed bills Oxygen credits; own-key tests pay the in-force platform fee plus separate vendor charges — Zapmail bills your Zapmail wallet ~$2/test). OXYGEN placement evaluation is never auto-selected or generally available: it is a limited pilot with one 0-credit test for its configured eligible connected sender.")
+        .addCommand(new Command("placement-test")
+        .description("Inspect saved directional inbox-placement results with list/get (0 credits; no test email is sent). New tests use preview and approval through run/send.")
+        .addCommand(new Command("run")
+        .description("Create a placement test for one sending mailbox. Without --approved this returns a cost PREVIEW. EmailGuard creation returns exact seeds + phrase but sends nothing; next run `placement-test send <id>` to preview and approve that external email. Zapmail owns its probe delivery and completes async (2-24h). OXYGEN placement evaluation requires explicit --provider oxygen_placement plus --subject and --body, and is available only for the eligible connected sender enabled for the limited pilot. Its approval creates AND sends one probe with no separate send step: preview first, then re-run the same mailbox, provider, subject, and body with --approved --max-credits 0 --plan <plan_hash>.")
+        .argument("<mailbox>", "Sending mailbox address to test (e.g. ada@send.acme.com).")
+        .addOption(new Option("--provider <provider>", "Health provider: emailguard, zapmail, or oxygen_placement. Omit to auto-resolve EmailGuard/Zapmail. OXYGEN placement evaluation is never auto-selected and requires the sender enabled for the limited pilot.").choices(["emailguard", "zapmail", "oxygen_placement"])
+        .argParser((value) => {
+        const provider = value === "sendkit" ? "oxygen_placement" : value;
+        if (!["emailguard", "zapmail", "oxygen_placement"].includes(provider)) {
+            throw new CommanderError(2, "commander.invalidArgument", "Choose emailguard, zapmail, or oxygen_placement.");
+        }
+        return provider;
+    }))
+        .option("--subject <subject>", "Seed-message subject. Required with --provider oxygen_placement; Zapmail ignores it beyond labeling the test.")
+        .option("--body <text>", "Plain-text seed-message body. Required with --provider oxygen_placement; ignored by Zapmail.")
+        .option("--allow-paused-probe", "Opt in to one diagnostic probe while preserving campaign pause; repeat at both create and send approvals. Never permits disabled senders.")
+        .option("--approved", "Actually run the test (otherwise a preview is returned).")
+        .option("--max-credits <n>", "Credit cap the caller accepts (must be >= credits_required for managed runs).")
+        .option("--plan <hash>", "plan_hash from a fresh create preview (required with --approved).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (mailbox, options) => {
+        await handleAsyncAction("deliverability placement-test run", options, () => requestOxygen("/api/cli/deliverability/placement-tests", {
+            method: "POST",
+            body: {
+                mailbox,
+                ...(readOption(options.provider)
+                    ? { provider: readOption(options.provider) }
+                    : {}),
+                ...(readOption(options.subject)
+                    ? { subject: readOption(options.subject) }
+                    : {}),
+                ...(readOption(options.body)
+                    ? { body_text: readOption(options.body) }
+                    : {}),
+                ...(options.approved ? { approved: true } : {}),
+                ...(options.allowPausedProbe ? { allow_paused_probe: true } : {}),
+                ...(readOption(options.maxCredits)
+                    ? {
+                        max_credits: Number(readOption(options.maxCredits)),
+                    }
+                    : {}),
+                ...(readOption(options.plan)
+                    ? { plan_hash: readOption(options.plan) }
+                    : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("send")
+        .description("Preview or send the exact EmailGuard seed message for a provider-created test. Preview returns sender, all recipients, exact content, and plan_hash. Live send requires --approved --plan <hash>, costs 0 additional credits, and sends one message only.")
+        .argument("<id>", "Oxygen placement-test id returned by `placement-test run`.")
+        .option("--allow-paused-probe", "Opt in to one diagnostic probe while preserving campaign pause; repeat at both create and send approvals. Never permits disabled senders.")
+        .option("--approved", "Send the exact previewed seed message (otherwise preview only).")
+        .option("--plan <hash>", "plan_hash from a fresh send preview (required with --approved).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("deliverability placement-test send", options, () => requestOxygen(`/api/cli/deliverability/placement-tests/${encodeURIComponent(id)}/send`, {
+            method: "POST",
+            body: {
+                ...(options.approved ? { approved: true } : {}),
+                ...(options.allowPausedProbe ? { allow_paused_probe: true } : {}),
+                ...(readOption(options.plan)
+                    ? { plan_hash: readOption(options.plan) }
+                    : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("list")
+        .description("Inspect recent directional inbox-placement tests, their status, results, and credits used, plus `pricing`: EmailGuard monitoring credits per inbox-month, two included tests per inbox per cycle, and the managed extra-test price in force. Covered tests cost no extra credits. The allowance resets each UTC calendar month; unused tests do not roll over. Own-key tests pay the quoted OXYGEN platform fee separately from provider charges. The returned web link opens Accounts; use get for an exact result link. Costs 0 credits and never creates or sends a test; active tests may refresh their observations.")
+        .option("--limit <n>", "Max rows (default 50, cap 200).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("deliverability placement-test list", options, () => {
+            const limit = readOption(options.limit);
+            return requestOxygen(`/api/cli/deliverability/placement-tests${limit ? `?limit=${encodeURIComponent(limit)}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Inspect one saved directional inbox-placement test by id: status, seed counts, per-provider results, and a web result link. Costs 0 credits and never creates or sends a test; active tests may refresh their observations. Zapmail results land async (2-24h); keep polling while status is awaiting_results.")
+        .argument("<id>", "Placement test id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("deliverability placement-test get", options, () => requestOxygen(`/api/cli/deliverability/placement-tests/${encodeURIComponent(id)}`));
+    }))));
+}

package/dist/commands/directory.d.ts

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

package/dist/commands/directory.js

@@ -0,0 +1,101 @@
+import { buildDirectoryProfileBody } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES } from "@oxygen/shared/directory";
+import { Command } from "commander";
+function directoryLogoMimeType(extension) {
+    switch (extension.toLowerCase()) {
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".svg":
+            return "image/svg+xml";
+        default:
+            throw new OxygenError("invalid_request", "--logo-file must be a .png, .jpg, .jpeg, .webp, or .svg image.", { exitCode: 1 });
+    }
+}
+async function uploadDirectoryLogo(logoPath) {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const buffer = await fs.readFile(logoPath);
+    const form = new FormData();
+    form.append("file", new File([buffer], path.basename(logoPath), { type: directoryLogoMimeType(path.extname(logoPath)) }));
+    return await requestOxygen("/api/cli/directory/listing/logo", {
+        method: "POST",
+        formData: form,
+    });
+}
+export function registerDirectoryFamily(program, handleAsyncAction, directoryDocsUrl, billingDocsUrl) {
+    program
+        .command("directory")
+        .description("Manage this organization's public OXYGEN agency directory listing.")
+        .addHelpText("after", `\nPartner bonus: billing balance reports partner_bonus and may apply due plan grants or credit expiry. Billing policy: ${billingDocsUrl}#agency-partner-bonus\nDocs: ${directoryDocsUrl}\n`)
+        .addCommand(new Command("get")
+        .description("Read-only, 0 credits. Read the listing, publish state, and public/settings deep-links.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("directory get", options, () => requestOxygen("/api/cli/directory/listing"));
+    }))
+        .addCommand(new Command("update")
+        .description("Update listing fields. Changes to a published listing are public immediately. Only invited organizations can edit.")
+        .option("--name <text>", "Agency display name.")
+        .option("--slug <slug>", "Public URL slug (lowercase letters, digits, dashes).")
+        .option("--logo-url <url>", "Logo image URL.")
+        .option("--tagline <text>", "One-line pitch shown on the directory card.")
+        .option("--description <text>", "Full profile description (plain text; blank lines separate paragraphs).")
+        .option("--description-file <path>", "Path to a plain-text file with the description.")
+        .option("--website <url>", "Company website URL.")
+        .option("--company-linkedin <url>", "Company LinkedIn page URL.")
+        .option("--founders-json <json>", "JSON array of founding-team members: [{\"name\", \"title\", \"linkedin_url\"}].")
+        .option("--booking-url <url>", "Book-a-call URL (Cal.com, Calendly, ...).")
+        .option("--contact-email <email>", "Public contact email.")
+        .option("--logo-file <path>", "Upload a local png/jpeg/webp/svg logo instead of passing --logo-url.")
+        .option("--services <csv>", `Comma-separated services from the curated set: ${AGENCY_DIRECTORY_SERVICES.join(", ")}.`)
+        .option("--regions <csv>", `Comma-separated regions from the curated set: ${AGENCY_DIRECTORY_REGIONS.join(", ")}.`)
+        .option("--profile-json <json>", "JSON object with any listing fields; flags override it. Use null values to clear fields.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("directory update", options, async () => {
+            const logoPath = readOption(options.logoFile);
+            const uploaded = logoPath ? await uploadDirectoryLogo(logoPath) : null;
+            const profile = await buildDirectoryProfileBody(options);
+            if (Object.keys(profile).length === 0 && uploaded)
+                return uploaded;
+            return requestOxygen("/api/cli/directory/listing/update", {
+                method: "POST",
+                body: { profile },
+            });
+        });
+    }))
+        .addCommand(new Command("publish")
+        .description("Publish at https://oxygen-agent.com/agencies. Requires a tagline, description, and at least one contact method (website, booking link, email, or LinkedIn).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("directory publish", options, () => requestOxygen("/api/cli/directory/listing/publish", { method: "POST", body: {} }));
+    }))
+        .addCommand(new Command("unpublish")
+        .description("Remove the listing from the public directory (keeps the draft editable).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("directory unpublish", options, () => requestOxygen("/api/cli/directory/listing/unpublish", { method: "POST", body: {} }));
+    }))
+        .addCommand(new Command("apply")
+        .description("Apply to be listed in the public agency directory (reviewed by the OXYGEN team).")
+        .option("--message <text>", "What you do, who you serve, and how you use OXYGEN for client work.")
+        .option("--website <url>", "Your agency website URL.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("directory apply", options, () => requestOxygen("/api/cli/directory/apply", {
+            method: "POST",
+            body: {
+                ...(readOption(options.message) ? { message: readOption(options.message) } : {}),
+                ...(readOption(options.website) ? { website: readOption(options.website) } : {}),
+            },
+        }));
+    }));
+}

package/dist/commands/domains.d.ts

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