@primitivedotdev/sdk 0.17.0 → 0.19.0

package/dist/oclif/api-command.js

@@ -1,6 +1,16 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import { Command, Errors, Flags } from "@oclif/core";
 import { operations, PrimitiveApiClient } from "../api/index.js";
+import { deleteCliCredentials, resolveCliAuth, } from "./auth.js";
+export const API_ERROR_CODES = {
+    accessDenied: "access_denied",
+    authorizationPending: "authorization_pending",
+    expiredToken: "expired_token",
+    invalidDeviceCode: "invalid_device_code",
+    notFound: "not_found",
+    slowDown: "slow_down",
+    unauthorized: "unauthorized",
+};
 function flagName(parameterName) {
     return parameterName.replace(/_/g, "-");
 }
@@ -288,7 +298,7 @@ export function extractErrorCode(payload) {
 // `--api-key` flag; this closes that gap without having to
 // special-case every command.
 const ERROR_CODE_HINTS = {
-    unauthorized: "Hint: pass --api-key explicitly, or set PRIMITIVE_API_KEY in your environment. `primitive whoami` is the fastest way to verify a key is live.",
+    [API_ERROR_CODES.unauthorized]: "Hint: run `primitive login`, pass --api-key explicitly, or set PRIMITIVE_API_KEY in your environment. `primitive whoami` is the fastest way to verify a key is live.",
 };
 // Write a server / SDK error to stderr in the canonical envelope
 // shape, plus an actionable hint when the code is one we know how
@@ -298,10 +308,66 @@ const ERROR_CODE_HINTS = {
 export function writeErrorWithHints(payload) {
     process.stderr.write(`${formatErrorPayload(payload)}\n`);
     const code = extractErrorCode(payload);
-    if (code && ERROR_CODE_HINTS[code]) {
-        process.stderr.write(`${ERROR_CODE_HINTS[code]}\n`);
+    if (code && code in ERROR_CODE_HINTS) {
+        const hint = ERROR_CODE_HINTS[code];
+        process.stderr.write(`${hint}\n`);
+    }
+}
+export function removeStaleSavedCredentialOnUnauthorized(params) {
+    if (extractErrorCode(params.payload) !== API_ERROR_CODES.unauthorized ||
+        params.auth.source !== "stored") {
+        return false;
+    }
+    const baseUrlDiffersFromSaved = params.baseUrlOverridden &&
+        params.auth.credentials !== null &&
+        params.auth.baseUrl !== params.auth.credentials.base_url;
+    if (baseUrlDiffersFromSaved) {
+        process.stderr.write("Saved Primitive CLI credentials were rejected by the overridden API base URL. The local credential was not removed; check --base-url / PRIMITIVE_API_URL, or run `primitive logout` to remove it.\n");
+        return false;
     }
+    deleteCliCredentials(params.configDir);
+    process.stderr.write("Removed saved Primitive CLI credentials because the backing API key is no longer valid. Run `primitive login` to create a new one.\n");
+    return true;
 }
+// Format milliseconds as a short human-readable wall-clock duration.
+// Sub-second uses 2 decimal places (e.g. `0.18s`); seconds use 2
+// decimals up to 60s (`12.34s`); minute-plus uses `Mm SS.SSs`.
+// Display-only; the underlying ms value is what the caller computed.
+export function formatElapsed(ms) {
+    const seconds = ms / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(2)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rem = seconds - minutes * 60;
+    return `${minutes}m ${rem.toFixed(2)}s`;
+}
+// Run `fn` and, when `enabled` is true, write a one-line wall-clock
+// timing report to stderr after it completes. Stderr keeps the row
+// data on stdout grep/jq-friendly. The timer captures the full
+// duration of the function (HTTPS round trip, server-side gate +
+// agent + delivery, polling, etc.), not just the API call's
+// server-side processing.
+//
+// Used by every `--time` callsite across the CLI: generated
+// operation commands and hand-coded shortcuts (send, whoami,
+// emails:latest, describe). Pulled out as a helper so timing is
+// uniform across commands and a single render-format change
+// propagates everywhere.
+export async function runWithTiming(enabled, fn) {
+    if (!enabled)
+        return fn();
+    const start = Date.now();
+    try {
+        return await fn();
+    }
+    finally {
+        process.stderr.write(`[time: ${formatElapsed(Date.now() - start)}]\n`);
+    }
+}
+// Shared `--time` flag definition every CLI command spreads into its
+// own static flags. Lives here so the flag's description and short
+// name stay consistent across the hand-coded and generated commands.
+export const TIME_FLAG_DESCRIPTION = "Print the wall-clock duration of this command to stderr after it completes (e.g. `[time: 1.34s]`). Useful for measuring `--wait` send latency, comparing CLI overhead, or capturing timing in scripts.";
 // Reserved flag names the body-field expander must never overwrite.
 // `--raw-body` and `--body-file` are the JSON escape hatches.
 // `--api-key`, `--base-url`, `--output` are infra. Path and query
@@ -356,13 +422,16 @@ function bodyFieldFlag(field) {
 function buildFlags(operation) {
     const flags = {
         "api-key": Flags.string({
-            description: "Primitive API key (defaults to PRIMITIVE_API_KEY)",
+            description: "Primitive API key (defaults to PRIMITIVE_API_KEY or saved `primitive login` credentials)",
             env: "PRIMITIVE_API_KEY",
         }),
         "base-url": Flags.string({
             description: "API base URL (defaults to PRIMITIVE_API_URL or production)",
             env: "PRIMITIVE_API_URL",
         }),
+        time: Flags.boolean({
+            description: TIME_FLAG_DESCRIPTION,
+        }),
     };
     for (const parameter of [...operation.pathParams, ...operation.queryParams]) {
         flags[flagName(parameter.name)] = flagForParameter(parameter);
@@ -460,101 +529,116 @@ export function createOperationCommand(operation) {
         async run() {
             const { flags } = await this.parse(OperationCommand);
             const parsedFlags = flags;
-            const apiClient = new PrimitiveApiClient({
-                apiKey: typeof parsedFlags["api-key"] === "string"
-                    ? parsedFlags["api-key"]
-                    : undefined,
-                baseUrl: typeof parsedFlags["base-url"] === "string"
-                    ? parsedFlags["base-url"]
-                    : undefined,
-            });
-            // Two body sources, merged: explicit JSON via --body /
-            // --body-file (the base) plus per-field flags (the
-            // overrides). Per-field flag values take precedence on key
-            // conflicts so a caller can pass a base payload via --body
-            // and override one field on the command line.
-            let body;
-            if (operation.hasJsonBody) {
-                const explicit = readJsonBody(parsedFlags);
-                const overrides = collectBodyFieldFlags(parsedFlags, bodyFieldFlagToProperty);
-                if (Object.keys(overrides).length > 0) {
-                    if (explicit === undefined) {
-                        body = overrides;
-                    }
-                    else if (explicit !== null &&
-                        typeof explicit === "object" &&
-                        !Array.isArray(explicit)) {
-                        body = { ...explicit, ...overrides };
+            await runWithTiming(parsedFlags.time === true, async () => {
+                const baseUrlOverridden = typeof parsedFlags["base-url"] === "string";
+                const auth = resolveCliAuth({
+                    apiKey: typeof parsedFlags["api-key"] === "string"
+                        ? parsedFlags["api-key"]
+                        : undefined,
+                    baseUrl: typeof parsedFlags["base-url"] === "string"
+                        ? parsedFlags["base-url"]
+                        : undefined,
+                    configDir: this.config.configDir,
+                });
+                const apiClient = new PrimitiveApiClient({
+                    apiKey: auth.apiKey,
+                    baseUrl: auth.baseUrl,
+                });
+                // Two body sources, merged: explicit JSON via --body /
+                // --body-file (the base) plus per-field flags (the
+                // overrides). Per-field flag values take precedence on key
+                // conflicts so a caller can pass a base payload via --body
+                // and override one field on the command line.
+                let body;
+                if (operation.hasJsonBody) {
+                    const explicit = readJsonBody(parsedFlags);
+                    const overrides = collectBodyFieldFlags(parsedFlags, bodyFieldFlagToProperty);
+                    if (Object.keys(overrides).length > 0) {
+                        if (explicit === undefined) {
+                            body = overrides;
+                        }
+                        else if (explicit !== null &&
+                            typeof explicit === "object" &&
+                            !Array.isArray(explicit)) {
+                            body = { ...explicit, ...overrides };
+                        }
+                        else {
+                            // Caller passed --raw-body as null, an array, or a
+                            // primitive AND also passed per-field flags. We can't
+                            // merge per-field overrides into a non-object body
+                            // shape, and silently dropping either source would
+                            // leave the caller's actual intent unclear. Refuse
+                            // loudly so the next attempt is unambiguous.
+                            const explicitKind = explicit === null
+                                ? "null"
+                                : Array.isArray(explicit)
+                                    ? "array"
+                                    : typeof explicit;
+                            const overrideFlags = Object.keys(overrides)
+                                .map((p) => `--${flagName(p)}`)
+                                .join(", ");
+                            throw new Errors.CLIError(`--raw-body must be a JSON object when also passing per-field flags (got ${explicitKind}); supplied per-field flags: ${overrideFlags}. Either drop --raw-body and rely on the per-field flags, or move every field into the JSON --raw-body and drop the flags.`);
+                        }
                     }
                     else {
-                        // Caller passed --raw-body as null, an array, or a
-                        // primitive AND also passed per-field flags. We can't
-                        // merge per-field overrides into a non-object body
-                        // shape, and silently dropping either source would
-                        // leave the caller's actual intent unclear. Refuse
-                        // loudly so the next attempt is unambiguous.
-                        const explicitKind = explicit === null
-                            ? "null"
-                            : Array.isArray(explicit)
-                                ? "array"
-                                : typeof explicit;
-                        const overrideFlags = Object.keys(overrides)
-                            .map((p) => `--${flagName(p)}`)
-                            .join(", ");
-                        throw new Errors.CLIError(`--raw-body must be a JSON object when also passing per-field flags (got ${explicitKind}); supplied per-field flags: ${overrideFlags}. Either drop --raw-body and rely on the per-field flags, or move every field into the JSON --raw-body and drop the flags.`);
+                        body = explicit;
                     }
                 }
-                else {
-                    body = explicit;
+                if (operation.bodyRequired && body === undefined) {
+                    throw new Errors.CLIError(`Operation ${operation.operationId} requires a body. Pass each field as a --flag (see --help) or supply JSON via --raw-body / --body-file.`);
                 }
-            }
-            if (operation.bodyRequired && body === undefined) {
-                throw new Errors.CLIError(`Operation ${operation.operationId} requires a body. Pass each field as a --flag (see --help) or supply JSON via --raw-body / --body-file.`);
-            }
-            const operationFn = operations[operation.sdkName];
-            const result = await operationFn({
-                body,
-                client: apiClient.client,
-                parseAs: operation.binaryResponse ? "blob" : "auto",
-                path: collectValues(operation.pathParams, parsedFlags),
-                query: collectValues(operation.queryParams, parsedFlags),
-                responseStyle: "fields",
-            });
-            if (result.error) {
-                writeErrorWithHints(extractErrorPayload(result.error));
-                process.exitCode = 1;
-                return;
-            }
-            if (operation.binaryResponse) {
-                const blob = result.data;
-                const bytes = Buffer.from(await blob.arrayBuffer());
-                const output = parsedFlags.output;
-                if (typeof output === "string") {
-                    writeFileSync(output, bytes);
+                const operationFn = operations[operation.sdkName];
+                const result = await operationFn({
+                    body,
+                    client: apiClient.client,
+                    parseAs: operation.binaryResponse ? "blob" : "auto",
+                    path: collectValues(operation.pathParams, parsedFlags),
+                    query: collectValues(operation.queryParams, parsedFlags),
+                    responseStyle: "fields",
+                });
+                if (result.error) {
+                    const errorPayload = extractErrorPayload(result.error);
+                    writeErrorWithHints(errorPayload);
+                    removeStaleSavedCredentialOnUnauthorized({
+                        auth,
+                        baseUrlOverridden,
+                        configDir: this.config.configDir,
+                        payload: errorPayload,
+                    });
+                    process.exitCode = 1;
                     return;
                 }
-                process.stdout.write(bytes);
-                return;
-            }
-            const envelope = result.data;
-            const cursor = envelope?.meta?.cursor;
-            if (cursor) {
-                process.stderr.write(`next cursor: ${cursor}\n`);
-            }
-            // Empty-result hint. When a list-style operation returns
-            // an empty array, emit an operation-specific note to
-            // stderr so a naive caller can distinguish "nothing here"
-            // from "something isn't set up." Stdout still gets the
-            // raw `[]` so machine-readable output is unchanged. The
-            // AGX walkthrough flagged this: `list-deliveries` returning
-            // `[]` left the agent unsure whether they had an empty
-            // delivery log or no endpoints configured at all.
-            if (Array.isArray(envelope?.data) && envelope.data.length === 0) {
-                const hint = EMPTY_RESULT_HINTS[operation.sdkName];
-                if (hint)
-                    process.stderr.write(`${hint}\n`);
-            }
-            this.log(JSON.stringify(envelope?.data ?? null, null, 2));
+                if (operation.binaryResponse) {
+                    const blob = result.data;
+                    const bytes = Buffer.from(await blob.arrayBuffer());
+                    const output = parsedFlags.output;
+                    if (typeof output === "string") {
+                        writeFileSync(output, bytes);
+                        return;
+                    }
+                    process.stdout.write(bytes);
+                    return;
+                }
+                const envelope = result.data;
+                const cursor = envelope?.meta?.cursor;
+                if (cursor) {
+                    process.stderr.write(`next cursor: ${cursor}\n`);
+                }
+                // Empty-result hint. When a list-style operation returns
+                // an empty array, emit an operation-specific note to
+                // stderr so a naive caller can distinguish "nothing here"
+                // from "something isn't set up." Stdout still gets the
+                // raw `[]` so machine-readable output is unchanged. The
+                // AGX walkthrough flagged this: `list-deliveries` returning
+                // `[]` left the agent unsure whether they had an empty
+                // delivery log or no endpoints configured at all.
+                if (Array.isArray(envelope?.data) && envelope.data.length === 0) {
+                    const hint = EMPTY_RESULT_HINTS[operation.sdkName];
+                    if (hint)
+                        process.stderr.write(`${hint}\n`);
+                }
+                this.log(JSON.stringify(envelope?.data ?? null, null, 2));
+            });
         }
     }
     return OperationCommand;

package/dist/oclif/auth.js

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_BASE_URL } from "../api/index.js";
+const CREDENTIALS_FILE = "credentials.json";
+const CREDENTIALS_LOCK_DIR = "credentials.lock";
+const CREDENTIALS_LOCK_STALE_MS = 30 * 60 * 1000;
+const MALFORMED_CREDENTIALS_HINT = "Run `primitive logout` and then `primitive login`.";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireString(value, key) {
+    const raw = value[key];
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        throw new Error(`Stored Primitive CLI credentials are malformed: ${key} must be a non-empty string. ${MALFORMED_CREDENTIALS_HINT}`);
+    }
+    return raw;
+}
+function parseCredentials(raw) {
+    if (!isRecord(raw)) {
+        throw new Error(`Stored Primitive CLI credentials are malformed: expected a JSON object. ${MALFORMED_CREDENTIALS_HINT}`);
+    }
+    const orgName = raw.org_name;
+    if (orgName !== null && typeof orgName !== "string") {
+        throw new Error(`Stored Primitive CLI credentials are malformed: org_name must be a string or null. ${MALFORMED_CREDENTIALS_HINT}`);
+    }
+    return {
+        api_key: requireString(raw, "api_key"),
+        key_id: requireString(raw, "key_id"),
+        key_prefix: requireString(raw, "key_prefix"),
+        org_id: requireString(raw, "org_id"),
+        org_name: orgName,
+        base_url: requireString(raw, "base_url"),
+        created_at: requireString(raw, "created_at"),
+    };
+}
+export function credentialsPath(configDir) {
+    return join(configDir, CREDENTIALS_FILE);
+}
+export function normalizeBaseUrl(baseUrl) {
+    const trimmed = baseUrl?.trim();
+    if (!trimmed)
+        return DEFAULT_BASE_URL;
+    return trimmed.replace(/\/+$/, "");
+}
+export function loadCliCredentials(configDir) {
+    const path = credentialsPath(configDir);
+    let contents;
+    try {
+        contents = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            error.code === "ENOENT") {
+            return null;
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read Primitive CLI credentials: ${detail}`);
+    }
+    try {
+        return parseCredentials(JSON.parse(contents));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error("Stored Primitive CLI credentials are not valid JSON. Run `primitive logout` and then `primitive login`.");
+        }
+        throw error;
+    }
+}
+export function saveCliCredentials(configDir, credentials) {
+    mkdirSync(configDir, { mode: 0o700, recursive: true });
+    const path = credentialsPath(configDir);
+    const tempPath = join(configDir, `${CREDENTIALS_FILE}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(tempPath, `${JSON.stringify(credentials, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        chmodSync(tempPath, 0o600);
+        renameSync(tempPath, path);
+        chmodSync(path, 0o600);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
+}
+export function deleteCliCredentials(configDir) {
+    rmSync(credentialsPath(configDir), { force: true });
+}
+function errorCode(error) {
+    return error && typeof error === "object"
+        ? error.code
+        : undefined;
+}
+function removeStaleCliCredentialsLock(lockPath, staleMs, now) {
+    try {
+        const stats = statSync(lockPath);
+        if (now() - stats.mtimeMs < staleMs)
+            return false;
+    }
+    catch (error) {
+        if (errorCode(error) === "ENOENT")
+            return true;
+        throw error;
+    }
+    rmSync(lockPath, { force: true, recursive: true });
+    return true;
+}
+export function acquireCliCredentialsLock(configDir, options = {}) {
+    mkdirSync(configDir, { mode: 0o700, recursive: true });
+    const lockPath = join(configDir, CREDENTIALS_LOCK_DIR);
+    const now = options.now ?? Date.now;
+    const staleMs = options.staleMs ?? CREDENTIALS_LOCK_STALE_MS;
+    let acquired = false;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            mkdirSync(lockPath, { mode: 0o700 });
+            acquired = true;
+            break;
+        }
+        catch (error) {
+            if (errorCode(error) !== "EEXIST")
+                throw error;
+            if (removeStaleCliCredentialsLock(lockPath, staleMs, now))
+                continue;
+            throw new Error("Another Primitive CLI credential operation is already in progress. Wait for it to finish, then retry.");
+        }
+    }
+    if (!acquired) {
+        throw new Error("Another Primitive CLI credential operation is already in progress. Wait for it to finish, then retry.");
+    }
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        rmSync(lockPath, { force: true, recursive: true });
+    };
+}
+export function resolveCliAuth(params) {
+    const apiKey = params.apiKey?.trim();
+    if (apiKey) {
+        return {
+            apiKey,
+            baseUrl: normalizeBaseUrl(params.baseUrl),
+            credentials: null,
+            source: "flag-or-env",
+        };
+    }
+    const credentials = loadCliCredentials(params.configDir);
+    if (credentials) {
+        return {
+            apiKey: credentials.api_key,
+            baseUrl: params.baseUrl
+                ? normalizeBaseUrl(params.baseUrl)
+                : credentials.base_url,
+            credentials,
+            source: "stored",
+        };
+    }
+    return {
+        apiKey: undefined,
+        baseUrl: normalizeBaseUrl(params.baseUrl),
+        credentials: null,
+        source: "none",
+    };
+}

package/dist/oclif/commands/emails-latest.js

@@ -1,7 +1,8 @@
 import { Command, Flags } from "@oclif/core";
 import { listEmails } from "../../api/generated/sdk.gen.js";
 import { PrimitiveApiClient } from "../../api/index.js";
-import { extractErrorPayload, writeErrorWithHints } from "../api-command.js";
+import { extractErrorPayload, removeStaleSavedCredentialOnUnauthorized, runWithTiming, TIME_FLAG_DESCRIPTION, writeErrorWithHints, } from "../api-command.js";
+import { resolveCliAuth } from "../auth.js";
 // `primitive emails:latest` is the agent-grade shortcut for "show me
 // the most recent inbound emails as something I can read at a glance."
 // `emails:list-emails` returns the full JSON envelope which is great
@@ -94,7 +95,7 @@ class EmailsLatestCommand extends Command {
     ];
     static flags = {
         "api-key": Flags.string({
-            description: "Primitive API key (defaults to PRIMITIVE_API_KEY)",
+            description: "Primitive API key (defaults to PRIMITIVE_API_KEY or saved `primitive login` credentials)",
             env: "PRIMITIVE_API_KEY",
         }),
         "base-url": Flags.string({
@@ -113,43 +114,61 @@ class EmailsLatestCommand extends Command {
         json: Flags.boolean({
             description: "Print the raw response envelope (with full UUIDs and meta) as JSON on STDOUT instead of the text table. Useful for piping into `jq`, capturing ids for follow-up commands, or scripting.",
         }),
+        time: Flags.boolean({
+            description: TIME_FLAG_DESCRIPTION,
+        }),
     };
     async run() {
         const { flags } = await this.parse(EmailsLatestCommand);
-        const apiClient = new PrimitiveApiClient({
-            apiKey: flags["api-key"],
-            baseUrl: flags["base-url"],
-        });
-        const result = await listEmails({
-            client: apiClient.client,
-            query: { limit: flags.limit },
-            responseStyle: "fields",
+        await runWithTiming(flags.time, async () => {
+            const baseUrlOverridden = flags["base-url"] !== undefined;
+            const auth = resolveCliAuth({
+                apiKey: flags["api-key"],
+                baseUrl: flags["base-url"],
+                configDir: this.config.configDir,
+            });
+            const apiClient = new PrimitiveApiClient({
+                apiKey: auth.apiKey,
+                baseUrl: auth.baseUrl,
+            });
+            const result = await listEmails({
+                client: apiClient.client,
+                query: { limit: flags.limit },
+                responseStyle: "fields",
+            });
+            if (result.error) {
+                const errorPayload = extractErrorPayload(result.error);
+                writeErrorWithHints(errorPayload);
+                removeStaleSavedCredentialOnUnauthorized({
+                    auth,
+                    baseUrlOverridden,
+                    configDir: this.config.configDir,
+                    payload: errorPayload,
+                });
+                process.exitCode = 1;
+                return;
+            }
+            const envelope = result.data;
+            if (flags.json) {
+                // Raw envelope on stdout. Mirrors the shape `emails:list-emails`
+                // emits so callers can swap one for the other when they want
+                // table vs json without remembering different command names.
+                this.log(JSON.stringify(envelope ?? null, null, 2));
+                return;
+            }
+            const rows = envelope?.data ?? [];
+            if (rows.length === 0) {
+                process.stderr.write("No inbound emails yet. Send an email to one of your verified domains to populate this list.\n");
+                return;
+            }
+            const idWidth = pickIdWidth(Boolean(process.stdout.isTTY));
+            // Header on stderr so the table itself stays grep-friendly.
+            const header = `${"ID".padEnd(idWidth)}  ${"RECEIVED (UTC)".padEnd(RECEIVED_DISPLAY_WIDTH)}  ${"FROM".padEnd(ADDRESS_DISPLAY_WIDTH)}  ${"TO".padEnd(ADDRESS_DISPLAY_WIDTH)}  SUBJECT`;
+            process.stderr.write(`${header}\n`);
+            for (const row of rows) {
+                this.log(formatRow(row, idWidth));
+            }
         });
-        if (result.error) {
-            writeErrorWithHints(extractErrorPayload(result.error));
-            process.exitCode = 1;
-            return;
-        }
-        const envelope = result.data;
-        if (flags.json) {
-            // Raw envelope on stdout. Mirrors the shape `emails:list-emails`
-            // emits so callers can swap one for the other when they want
-            // table vs json without remembering different command names.
-            this.log(JSON.stringify(envelope ?? null, null, 2));
-            return;
-        }
-        const rows = envelope?.data ?? [];
-        if (rows.length === 0) {
-            process.stderr.write("No inbound emails yet. Send an email to one of your verified domains to populate this list.\n");
-            return;
-        }
-        const idWidth = pickIdWidth(Boolean(process.stdout.isTTY));
-        // Header on stderr so the table itself stays grep-friendly.
-        const header = `${"ID".padEnd(idWidth)}  ${"RECEIVED (UTC)".padEnd(RECEIVED_DISPLAY_WIDTH)}  ${"FROM".padEnd(ADDRESS_DISPLAY_WIDTH)}  ${"TO".padEnd(ADDRESS_DISPLAY_WIDTH)}  SUBJECT`;
-        process.stderr.write(`${header}\n`);
-        for (const row of rows) {
-            this.log(formatRow(row, idWidth));
-        }
     }
 }
 export default EmailsLatestCommand;