@floomhq/floom 1.0.0

package/dist/library.js

@@ -0,0 +1,77 @@
+import ora from "ora";
+import { getApiUrl, readConfig } from "./config.js";
+import { deleteRequest, getJson, postJson, putJson } from "./lib/api.js";
+import { c, symbols } from "./ui.js";
+import { FloomError } from "./errors.js";
+function formatLibraryRow(lib) {
+    const name = lib.name ?? c.dim("(unnamed)");
+    const vis = c.dim(`[${lib.visibility}]`);
+    return `   ${c.cyan(lib.slug.padEnd(22))}  ${name}  ${vis}`;
+}
+export async function libraryList(opts = {}) {
+    const cfg = await readConfig();
+    const apiUrl = cfg?.apiUrl ?? getApiUrl();
+    const spinner = opts.json ? null : ora({ text: c.dim("Loading libraries..."), color: "yellow" }).start();
+    let result;
+    try {
+        result = await getJson(`${apiUrl}/api/v1/libraries`, "load libraries", cfg?.accessToken);
+    }
+    finally {
+        spinner?.stop();
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`\n${symbols.dot}  ${c.bold("Public libraries")} ${c.dim(`(${result.libraries.length})`)}\n\n`);
+    if (result.libraries.length === 0) {
+        process.stdout.write(`   ${c.dim("No public libraries yet.")}\n\n`);
+        return;
+    }
+    for (const lib of result.libraries)
+        process.stdout.write(`${formatLibraryRow(lib)}\n`);
+    process.stdout.write("\n");
+}
+export async function libraryCreate(opts) {
+    const cfg = await readConfig();
+    if (!cfg)
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    const result = await postJson(`${apiUrl}/api/v1/libraries`, "create library", cfg.accessToken, {
+        slug: opts.slug,
+        name: opts.name,
+        ...(opts.description !== undefined ? { description: opts.description } : {}),
+        ...(opts.visibility ? { visibility: opts.visibility } : {}),
+    });
+    process.stdout.write(`\n${symbols.ok}  Library created: ${c.cyan(result.slug)}\n`);
+    process.stdout.write(`   ${c.dim("View:")} ${apiUrl}/library/${result.slug}\n\n`);
+}
+export async function librarySubscribe(slug) {
+    const cfg = await readConfig();
+    if (!cfg)
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    await postJson(`${apiUrl}/api/v1/me/subscriptions`, "subscribe to library", cfg.accessToken, { library_slug: slug });
+    process.stdout.write(`\n${symbols.ok}  Subscribed to ${c.cyan(slug)}\n`);
+    process.stdout.write(`   ${c.dim("Skills will sync into ~/.claude/skills/" + slug + "/")}\n\n`);
+}
+export async function libraryUnsubscribe(slug) {
+    const cfg = await readConfig();
+    if (!cfg)
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    await deleteRequest(`${apiUrl}/api/v1/me/subscriptions/${encodeURIComponent(slug)}`, "unsubscribe from library", cfg.accessToken);
+    process.stdout.write(`\n${symbols.ok}  Unsubscribed from ${c.cyan(slug)}\n\n`);
+}
+export async function moveSkill(opts) {
+    const cfg = await readConfig();
+    if (!cfg)
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    await putJson(`${apiUrl}/api/v1/me/skills/${encodeURIComponent(opts.slug)}/override`, "set skill override", cfg.accessToken, { folder: opts.folder, tags: opts.tags });
+    const folderText = opts.folder ?? c.dim("(root)");
+    const tagsText = opts.tags.length ? opts.tags.join(", ") : c.dim("(none)");
+    process.stdout.write(`\n${symbols.ok}  Moved ${c.cyan(opts.slug)}\n`);
+    process.stdout.write(`   ${c.dim("folder:")} ${folderText}\n`);
+    process.stdout.write(`   ${c.dim("tags:")}   ${tagsText}\n\n`);
+}

package/dist/list.js

@@ -0,0 +1,60 @@
+import ora from "ora";
+import { getApiUrl, readConfig } from "./config.js";
+import { getJson } from "./lib/api.js";
+import { c, symbols } from "./ui.js";
+import { FloomError } from "./errors.js";
+function formatRow(s) {
+    const title = s.title ?? c.dim("(untitled)");
+    const visibility = c.dim(`[${s.visibility}]`);
+    const type = c.dim(`[${s.asset_type ?? "skill"}]`);
+    const version = s.version ? c.dim(`v${s.version}`) : "";
+    const updated = c.dim(formatRelative(s.updated_at));
+    return `   ${c.cyan(s.slug.padEnd(14))}  ${title}  ${type}  ${visibility}  ${version}  ${updated}`;
+}
+function formatRelative(iso) {
+    const diff = Date.now() - new Date(iso).getTime();
+    if (Number.isNaN(diff))
+        return iso;
+    const sec = Math.floor(diff / 1000);
+    if (sec < 60)
+        return `${sec}s ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const day = Math.floor(hr / 24);
+    if (day < 30)
+        return `${day}d ago`;
+    return new Date(iso).toISOString().slice(0, 10);
+}
+export async function list(opts) {
+    const cfg = await readConfig();
+    if (!cfg) {
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    }
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    const spinner = opts.json ? null : ora({ text: c.dim("Loading skills..."), color: "yellow" }).start();
+    let published = [];
+    try {
+        const mine = await getJson(`${apiUrl}/api/me/skills`, "load your skills", cfg.accessToken);
+        published = mine.skills ?? [];
+    }
+    finally {
+        spinner?.stop();
+    }
+    if (opts.json) {
+        process.stdout.write(`${JSON.stringify({ published }, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`\n${symbols.dot}  ${c.bold("Published")} ${c.dim(`(${published.length})`)}\n\n`);
+    if (published.length === 0) {
+        process.stdout.write(`   ${c.dim("Nothing published yet. Try `floom publish skill.md`.")}\n`);
+    }
+    else {
+        for (const s of published)
+            process.stdout.write(`${formatRow(s)}\n`);
+    }
+    process.stdout.write("\n");
+}

package/dist/login.js

@@ -0,0 +1,163 @@
+import { createServer } from "node:http";
+import open from "open";
+import ora from "ora";
+import { getApiUrl, writeConfig } from "./config.js";
+import { c, header, symbols } from "./ui.js";
+import { FloomError, friendlyHttp, friendlyNetwork } from "./errors.js";
+const DEFAULT_PORT = 7456;
+const TIMEOUT_MS = 5 * 60 * 1000;
+export async function login() {
+    const apiUrl = getApiUrl();
+    const port = await pickPort();
+    process.stdout.write(header());
+    process.stdout.write(`${symbols.arrow}  Opening browser to sign in with Google...\n\n`);
+    const spinner = ora({
+        text: c.dim("Waiting for sign-in to complete..."),
+        color: "yellow",
+    }).start();
+    let tokens;
+    try {
+        tokens = await waitForCallback(port);
+    }
+    catch (err) {
+        spinner.stop();
+        if (err instanceof Error && /timed out/i.test(err.message)) {
+            throw new FloomError("No worries — try `floom login` again when ready.");
+        }
+        throw err;
+    }
+    spinner.text = c.dim("Verifying your account...");
+    const expiresIn = Number(tokens.expires_in ?? "3600");
+    const expiresAt = Math.floor(Date.now() / 1000) + (Number.isFinite(expiresIn) ? expiresIn : 3600);
+    let me;
+    try {
+        const meRes = await fetch(`${apiUrl}/api/me`, {
+            headers: { authorization: `Bearer ${tokens.access_token}` },
+        });
+        if (!meRes.ok) {
+            spinner.stop();
+            throw friendlyHttp(meRes.status, "verify your sign-in");
+        }
+        me = (await meRes.json());
+    }
+    catch (err) {
+        spinner.stop();
+        if (err instanceof FloomError)
+            throw err;
+        throw friendlyNetwork(err);
+    }
+    await writeConfig({
+        apiUrl,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt,
+        email: me.email,
+    });
+    spinner.stop();
+    process.stdout.write(`${symbols.ok}  Signed in as ${c.bold(me.email ?? me.id)}\n`);
+    process.stdout.write(`   ${c.dim("Your token is saved at ~/.floom/config.json")}\n\n`);
+}
+/** Reserve a free port. Defaults to 7456 (must be in Supabase uri_allow_list). */
+async function pickPort() {
+    // Supabase uri_allow_list whitelists 7456 explicitly. If it's busy, we fail
+    // loudly rather than silently using a port that won't be allowed.
+    return DEFAULT_PORT;
+}
+function waitForCallback(port) {
+    return new Promise((resolve, reject) => {
+        const apiUrl = getApiUrl();
+        let settled = false;
+        const server = createServer((req, res) => {
+            // CORS preflight from the browser bridge page.
+            const origin = req.headers.origin ?? "*";
+            if (req.method === "OPTIONS") {
+                res.writeHead(204, {
+                    "access-control-allow-origin": origin,
+                    "access-control-allow-methods": "POST, OPTIONS",
+                    "access-control-allow-headers": "content-type",
+                    "access-control-allow-private-network": "true",
+                    "access-control-max-age": "600",
+                });
+                res.end();
+                return;
+            }
+            if (req.method === "POST" && req.url === "/cli-callback") {
+                let body = "";
+                req.on("data", (chunk) => { body += chunk.toString("utf8"); });
+                req.on("end", () => {
+                    try {
+                        const data = parseCallbackBody(body, req.headers["content-type"]);
+                        if (!data.access_token || !data.refresh_token) {
+                            res.writeHead(400, {
+                                "access-control-allow-origin": origin,
+                                "access-control-allow-private-network": "true",
+                                "content-type": "text/html; charset=utf-8",
+                            });
+                            res.end(localCallbackPage("Missing tokens from OAuth response."));
+                            return;
+                        }
+                        res.writeHead(200, {
+                            "access-control-allow-origin": origin,
+                            "access-control-allow-private-network": "true",
+                            "content-type": "text/html; charset=utf-8",
+                        });
+                        res.end(localCallbackPage("Signed in. You can close this tab."));
+                        settled = true;
+                        cleanup();
+                        resolve(data);
+                    }
+                    catch {
+                        res.writeHead(400, { "content-type": "text/html; charset=utf-8", "access-control-allow-origin": origin });
+                        res.end(localCallbackPage("Invalid OAuth response."));
+                    }
+                });
+                return;
+            }
+            res.writeHead(404, { "content-type": "text/plain" });
+            res.end("Not found");
+        });
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new Error("Login timed out after 5 minutes."));
+        }, TIMEOUT_MS);
+        function cleanup() {
+            clearTimeout(timer);
+            server.close();
+        }
+        server.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(new FloomError(`Local auth server failed on port ${port}.`, `Is port ${port} already in use? (${err.message})`));
+        });
+        server.listen(port, "127.0.0.1", () => {
+            const target = `${apiUrl}/auth/cli?port=${port}`;
+            open(target).catch((e) => {
+                const msg = e instanceof Error ? e.message : String(e);
+                process.stdout.write(c.yellow(`Could not auto-open browser (${msg}).\n`) +
+                    c.dim(`Open this URL manually: ${target}\n`));
+            });
+        });
+    });
+}
+function parseCallbackBody(body, contentType) {
+    const type = Array.isArray(contentType) ? contentType.join(";") : contentType ?? "";
+    if (type.includes("application/x-www-form-urlencoded")) {
+        const params = new URLSearchParams(body);
+        const parsed = {};
+        for (const key of ["access_token", "refresh_token", "expires_in", "token_type"]) {
+            const value = params.get(key);
+            if (value)
+                parsed[key] = value;
+        }
+        return parsed;
+    }
+    return JSON.parse(body);
+}
+function localCallbackPage(message) {
+    return `<!doctype html><html><head><meta charset="utf-8"><title>Floom CLI sign-in</title></head><body style="font-family:system-ui,sans-serif;margin:48px"><h1>${message}</h1><p>Return to your terminal to continue.</p></body></html>`;
+}

package/dist/mcp.js

@@ -0,0 +1,22 @@
+import { c } from "./ui.js";
+export function printMcpSetup() {
+    const snippet = `## Floom
+- Your installed skills live in ~/.claude/skills/ and auto-sync from Floom on each session
+- To install a skill: ask me "install floom skill <slug>"
+- To publish: ask me "publish this as a floom skill"`;
+    process.stdout.write(`\n${c.bold("Floom MCP setup")}\n\n`);
+    process.stdout.write(`${c.dim("Pick your tool:")}\n\n`);
+    process.stdout.write(`  ${c.bold("Claude Code")}\n`);
+    process.stdout.write(`  ${c.cyan("claude mcp add floom -- npx -y @floomhq/floom-mcp-sync")}\n\n`);
+    process.stdout.write(`  ${c.bold("Codex CLI")}\n`);
+    process.stdout.write(`  ${c.cyan("codex mcp add floom -- npx -y @floomhq/floom-mcp-sync")}\n\n`);
+    process.stdout.write(`  ${c.bold("Gemini CLI")}\n`);
+    process.stdout.write(`  ${c.cyan("gemini mcp add -s user floom npx -y @floomhq/floom-mcp-sync")}\n\n`);
+    process.stdout.write(`  ${c.bold("Kimi CLI")}\n`);
+    process.stdout.write(`  ${c.cyan("kimi mcp add --transport stdio floom -- npx -y @floomhq/floom-mcp-sync")}\n\n`);
+    process.stdout.write(`  ${c.bold("OpenCode")}\n`);
+    process.stdout.write(`  ${c.dim("Edit ~/.config/opencode/opencode.json - see guide.")}\n\n`);
+    process.stdout.write(`${c.dim("Full guide:")} ${c.cyan("https://floom.dev/docs/mcp")}\n\n`);
+    process.stdout.write(`${c.dim("Recommended CLAUDE.md snippet:")}\n\n`);
+    process.stdout.write(`${snippet}\n\n`);
+}

package/dist/publish.js

@@ -0,0 +1,189 @@
+import { readFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import ora from "ora";
+import clipboard from "clipboardy";
+import { getApiUrl, getWebUrl, readConfig } from "./config.js";
+import { c, symbols } from "./ui.js";
+import { FloomError, friendlyHttp, friendlyNetwork } from "./errors.js";
+const ASSET_TYPES = new Set(["knowledge", "instruction", "workflow", "skill"]);
+const INSTALL_TARGETS = new Set([
+    "claude_skill",
+    "memory",
+    "rule",
+    "codex_instruction",
+    "opencode_instruction",
+    "cursor_rule",
+    "other",
+]);
+const VERSION_RE = /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/;
+function parseFrontmatter(input) {
+    const trimmed = input.replace(/^/, "");
+    if (!trimmed.startsWith("---"))
+        return { meta: {}, body: input };
+    const end = trimmed.indexOf("\n---", 3);
+    if (end === -1) {
+        return {
+            meta: {},
+            body: input,
+            error: { message: "Frontmatter opens with `---` but never closes.", line: 1 },
+        };
+    }
+    const headerBlock = trimmed.slice(3, end).trim();
+    const rest = trimmed.slice(end + 4).replace(/^\r?\n/, "");
+    const meta = {};
+    const lines = headerBlock.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const rawLine = lines[i] ?? "";
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const colon = line.indexOf(":");
+        if (colon === -1) {
+            return { meta, body: rest, error: { message: `Couldn't parse line: \`${rawLine}\``, line: i + 2 } };
+        }
+        const key = line.slice(0, colon).trim().toLowerCase();
+        let value = line.slice(colon + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key === "title"
+            || key === "description"
+            || key === "version"
+            || key === "slug"
+            || key === "type"
+            || key === "asset_type"
+            || key === "installs_as"
+            || key === "installs-as") {
+            if (key === "installs-as") {
+                meta.installs_as = value;
+            }
+            else {
+                meta[key] = value;
+            }
+        }
+    }
+    return { meta, body: rest };
+}
+function parseAssetType(value, source) {
+    if (!value)
+        return undefined;
+    if (ASSET_TYPES.has(value))
+        return value;
+    throw new FloomError(`Invalid ${source}: ${value}`, "Use one of: knowledge, instruction, workflow, skill.");
+}
+function parseInstallsAs(value, source) {
+    if (!value)
+        return undefined;
+    if (INSTALL_TARGETS.has(value))
+        return value;
+    throw new FloomError(`Invalid ${source}: ${value}`, "Use one of: claude_skill, memory, rule, codex_instruction, opencode_instruction, cursor_rule, other.");
+}
+function parseVersion(value, source) {
+    if (!value)
+        return undefined;
+    if (VERSION_RE.test(value))
+        return value;
+    throw new FloomError(`Invalid ${source}: ${value}`, "Use 1-64 characters: letters, numbers, dots, underscores, plus, or hyphen.");
+}
+export async function publish(opts) {
+    const cfg = await readConfig();
+    if (!cfg) {
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    }
+    const filePath = resolve(process.cwd(), opts.file);
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf8");
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === "ENOENT") {
+            throw new FloomError(`File not found: ${opts.file}`);
+        }
+        if (code === "EISDIR") {
+            throw new FloomError(`That's a directory, not a file: ${opts.file}`);
+        }
+        throw new FloomError(`Couldn't read ${opts.file}: ${e.message}`);
+    }
+    if (!raw.trim()) {
+        throw new FloomError(`File is empty: ${opts.file}`);
+    }
+    const { meta, error: fmError } = parseFrontmatter(raw);
+    if (fmError) {
+        throw new FloomError(`Couldn't parse frontmatter — check your YAML.`, `Line ${fmError.line}: ${fmError.message}`);
+    }
+    const assetType = opts.assetType ?? parseAssetType(meta.asset_type ?? meta.type, "frontmatter type") ?? "skill";
+    const installsAs = opts.installsAs ?? parseInstallsAs(meta.installs_as, "frontmatter installs_as") ?? null;
+    const version = opts.version ?? parseVersion(meta.version, "frontmatter version") ?? null;
+    // Later version: detect already-published when --update is missing.
+    // The current API does not return a duplicate-skill code, so we leave
+    // the actual dedupe to the server and surface the friendly hint on 409.
+    const spinner = ora({
+        text: c.dim(`Publishing ${meta.title ? c.bold(meta.title) : opts.file}...`),
+        color: "yellow",
+    }).start();
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    let res;
+    try {
+        res = await fetch(`${apiUrl}/api/skills`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${cfg.accessToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                title: meta.title ?? null,
+                description: meta.description ?? null,
+                body_md: raw,
+                visibility: opts.visibility,
+                asset_type: assetType,
+                source: "markdown",
+                installs_as: installsAs,
+                version,
+                original_filename: basename(filePath),
+                published_via: "cli",
+                shared_with_emails: opts.sharedWithEmails,
+            }),
+        });
+    }
+    catch (err) {
+        spinner.stop();
+        throw friendlyNetwork(err);
+    }
+    if (res.status === 409) {
+        spinner.stop();
+        throw new FloomError("Skill already published.", "Use `--update` to publish a new version (coming in a future release).");
+    }
+    if (!res.ok) {
+        spinner.stop();
+        throw friendlyHttp(res.status, "publish your skill");
+    }
+    const data = (await res.json());
+    // Build a humans-friendly URL: strip the trailing `.md` if the API returned one.
+    const webBase = getWebUrl();
+    const humanUrl = data.url
+        ? data.url.replace(/\.md$/, "")
+        : `${webBase}/s/${data.slug}`;
+    spinner.stop();
+    const versionTag = version ? c.dim(` (v${version})`) : "";
+    const titleLabel = data.title ? `"${data.title}"` : opts.file;
+    process.stdout.write(`\n${symbols.ok}  Published ${c.bold(titleLabel)}${versionTag}\n\n`);
+    process.stdout.write(`   ${c.cyan(humanUrl)}\n\n`);
+    if (data.visibility === "shared" && data.shared_with_emails?.length) {
+        process.stdout.write(`   ${c.dim(`Shared with ${data.shared_with_emails.join(", ")}`)}\n\n`);
+    }
+    let copied = false;
+    try {
+        await clipboard.write(humanUrl);
+        copied = true;
+    }
+    catch {
+        copied = false;
+    }
+    if (copied) {
+        process.stdout.write(`   ${c.dim("Copied to clipboard. Share it anywhere.")}\n\n`);
+    }
+    else {
+        process.stdout.write(`   ${c.dim("Share it anywhere.")}\n\n`);
+    }
+}

package/dist/share.js

@@ -0,0 +1,70 @@
+import ora from "ora";
+import { getApiUrl, readConfig } from "./config.js";
+import { friendlyHttp, friendlyNetwork, FloomError } from "./errors.js";
+import { c, symbols } from "./ui.js";
+function slugFromInput(input) {
+    const trimmed = input.trim();
+    try {
+        const url = new URL(trimmed);
+        const last = url.pathname.split("/").filter(Boolean).at(-1) ?? "";
+        return last.replace(/\.(md|json)$/i, "");
+    }
+    catch {
+        return trimmed.replace(/\.(md|json)$/i, "");
+    }
+}
+async function readJson(res) {
+    return (await res.json());
+}
+export async function share(opts) {
+    const cfg = await readConfig();
+    if (!cfg) {
+        throw new FloomError("Not signed in.", "Run `floom login` first.");
+    }
+    const slug = slugFromInput(opts.slug);
+    if (!slug) {
+        throw new FloomError("Missing skill slug.", "Try: `floom share <slug> --list`");
+    }
+    const apiUrl = cfg.apiUrl ?? getApiUrl();
+    const endpoint = `${apiUrl}/api/skills/${encodeURIComponent(slug)}/share`;
+    const spinner = ora({ text: c.dim("Updating sharing..."), color: "yellow" }).start();
+    let res;
+    try {
+        if (opts.kind === "list") {
+            spinner.text = c.dim("Loading sharing...");
+            res = await fetch(endpoint, {
+                headers: { authorization: `Bearer ${cfg.accessToken}` },
+            });
+        }
+        else {
+            res = await fetch(endpoint, {
+                method: "PATCH",
+                headers: {
+                    authorization: `Bearer ${cfg.accessToken}`,
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({ add: opts.add, remove: opts.remove }),
+            });
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        throw friendlyNetwork(err);
+    }
+    if (!res.ok) {
+        spinner.stop();
+        throw friendlyHttp(res.status, "update sharing");
+    }
+    const data = await readJson(res);
+    spinner.stop();
+    const emails = data.shared_with_emails;
+    process.stdout.write(`\n${symbols.ok}  Sharing for ${c.bold(data.slug)}\n\n`);
+    if (emails.length === 0) {
+        process.stdout.write(`   ${c.dim("No emails added.")}\n\n`);
+        return;
+    }
+    for (const email of emails) {
+        process.stdout.write(`   ${email}\n`);
+    }
+    process.stdout.write("\n");
+}