@myapihq/cli 1.0.13 → 1.0.15

package/dist/commands/config.d.ts

@@ -0,0 +1,4 @@
+export declare function setOrg(id: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function setDomain(domain: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function view(flags: Record<string, string | boolean>): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/config.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setOrg = setOrg;
+exports.setDomain = setDomain;
+exports.view = view;
+exports.run = run;
+const config_js_1 = require("../config.js");
+const output_js_1 = require("../output.js");
+async function setOrg(id, flags) {
+    if (!id || flags.help) {
+        (0, output_js_1.info)("Usage: myapi config set-org <id>\n\nSets a default organization ID for subsequent commands.");
+        return;
+    }
+    const config = (0, config_js_1.requireConfig)();
+    config.default_org = id;
+    (0, config_js_1.saveConfig)(config);
+    (0, output_js_1.success)(`Default organization set to: ${id}`);
+}
+async function setDomain(domain, flags) {
+    if (!domain || flags.help) {
+        (0, output_js_1.info)("Usage: myapi config set-domain <domain>\n\nSets a default domain for subsequent commands.");
+        return;
+    }
+    const config = (0, config_js_1.requireConfig)();
+    config.default_domain = domain;
+    (0, config_js_1.saveConfig)(config);
+    (0, output_js_1.success)(`Default domain set to: ${domain}`);
+}
+async function view(flags) {
+    if (flags.help) {
+        (0, output_js_1.info)("Usage: myapi config view\n\nViews current config settings.");
+        return;
+    }
+    const config = (0, config_js_1.requireConfig)();
+    (0, output_js_1.info)(`Default Org: ${config.default_org || 'Not set'}`);
+    (0, output_js_1.info)(`Default Domain: ${config.default_domain || 'Not set'}`);
+}
+async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        (0, output_js_1.info)('Usage: myapi config <subcommand>\n\nSubcommands:\n  view         View current config\n  set-org      Set default organization\n  set-domain   Set default domain');
+        return;
+    }
+    if (subcommand === 'view')
+        await view(flags);
+    else if (subcommand === 'set-org')
+        await setOrg(args[0], flags);
+    else if (subcommand === 'set-domain')
+        await setDomain(args[0], flags);
+    else
+        (0, output_js_1.error)(`Unknown subcommand: ${subcommand}. Run "myapi config --help" for a list of valid subcommands.`);
+}

package/dist/commands/domain.d.ts

@@ -1,9 +1,9 @@
-export declare function check(domain: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function register(domain: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function importDomain(domain: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function check(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function register(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function importDomain(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
 export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function assign(domain: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function unassign(domain: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function settings(domain: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function updateSettings(domain: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function assign(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function unassign(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function settings(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function updateSettings(domainArg: string, flags: Record<string, string | boolean>): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/domain.js

@@ -12,11 +12,12 @@ exports.run = run;
 const sdk_1 = require("@myapihq/sdk");
 const config_js_1 = require("../config.js");
 const output_js_1 = require("../output.js");
-async function check(domain, flags) {
-    const orgId = flags.org;
-    if (!orgId || !domain)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>");
+async function check(domainArg, flags) {
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     const res = await sdk_1.domain.checkDomain(config.api_key, orgId, domain);
     if (res.available) {
         (0, output_js_1.info)(`${domain} — Available ✓  Price: $${(res.price_cents / 100).toFixed(2)}/yr`);
@@ -25,23 +26,25 @@ async function check(domain, flags) {
         (0, output_js_1.info)(`Not available ✗`);
     }
 }
-async function register(domain, flags) {
-    const orgId = flags.org;
+async function register(domainArg, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
     if (!orgId || !domain)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]");
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     const years = parseInt(flags.years) || 1;
-    const config = (0, config_js_1.requireConfig)();
     const res = await sdk_1.domain.registerDomain(config.api_key, orgId, domain, years);
     (0, output_js_1.success)(`Registered ${domain}!\n${JSON.stringify(res, null, 2)}`);
 }
-async function importDomain(domain, flags) {
-    const orgId = flags.org;
+async function importDomain(domainArg, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
     if (!orgId || !domain)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>");
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     if (!flags['namecheap-user'] || !flags['namecheap-key']) {
         (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>");
     }
-    const config = (0, config_js_1.requireConfig)();
     await sdk_1.domain.importDomain(config.api_key, orgId, {
         domain,
         namecheap_api_user: flags['namecheap-user'],
@@ -50,44 +53,48 @@ async function importDomain(domain, flags) {
     (0, output_js_1.success)(`Imported ${domain}`);
 }
 async function list(flags) {
-    const orgId = flags.org;
-    if (!orgId)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]");
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]\n(Or set a default org via: myapi config set-org <id>)");
     const filter = flags.filter;
     const domains = await sdk_1.domain.listDomains(config.api_key, orgId, filter);
     (0, output_js_1.printTable)(domains);
 }
-async function assign(domain, flags) {
-    const orgId = flags.org;
+async function assign(domainArg, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
     const targetOrgId = flags.target;
     if (!orgId || !domain || !targetOrgId)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id> --target <target_org_id>");
-    const config = (0, config_js_1.requireConfig)();
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id> --target <target_org_id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     const res = await sdk_1.domain.assignDomain(config.api_key, orgId, domain, targetOrgId);
     (0, output_js_1.success)(`Assigned ${domain} to org ${targetOrgId}`);
 }
-async function unassign(domain, flags) {
-    const orgId = flags.org;
-    if (!orgId || !domain)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>");
+async function unassign(domainArg, flags) {
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     const res = await sdk_1.domain.unassignDomain(config.api_key, orgId, domain);
     (0, output_js_1.success)(`Unassigned ${domain} from org ${orgId}`);
 }
-async function settings(domain, flags) {
-    const orgId = flags.org;
-    if (!orgId || !domain)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>");
+async function settings(domainArg, flags) {
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     const res = await sdk_1.domain.getDomainSettings(config.api_key, orgId, domain);
     (0, output_js_1.printJson)(res);
 }
-async function updateSettings(domain, flags) {
-    const orgId = flags.org;
-    if (!orgId || !domain)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain update-settings <domain> --org <id> [--security=...] [--browser-check=...] [--purge-cache]");
+async function updateSettings(domainArg, flags) {
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain update-settings <domain> --org <id> [--security=...] [--browser-check=...] [--purge-cache]\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     const payload = {};
     if (flags.security)
         payload.security_level = flags.security;

package/dist/commands/email.js

@@ -14,28 +14,29 @@ const config_js_1 = require("../config.js");
 const output_js_1 = require("../output.js");
 const utils_js_1 = require("../utils.js");
 async function createMailbox(flags) {
-    const orgId = flags.org;
-    if (!orgId || !flags.domain || !flags.username) {
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email create-mailbox --org <id> --domain <domain> --username <user>");
-    }
     const config = (0, config_js_1.requireConfig)();
-    const address = await sdk_1.email.createMailbox(config.api_key, orgId, flags.domain, flags.username);
+    const orgId = flags.org || config.default_org;
+    const domain = flags.domain || config.default_domain;
+    if (!orgId || !domain || !flags.username) {
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email create-mailbox --org <id> --domain <domain> --username <user>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
+    }
+    const address = await sdk_1.email.createMailbox(config.api_key, orgId, domain, flags.username);
     (0, output_js_1.success)(`Mailbox created: ${address.address}`);
 }
 async function listMailboxes(flags) {
-    const orgId = flags.org;
-    if (!orgId)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email list-mailboxes --org <id>");
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email list-mailboxes --org <id>\n(Or set a default org via: myapi config set-org <id>)");
     const mailboxes = await sdk_1.email.listMailboxes(config.api_key, orgId);
     (0, output_js_1.printTable)(mailboxes);
 }
 async function send(flags) {
-    const orgId = flags.org;
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
     if (!orgId || !flags.from || !flags.to || !flags.subject || !flags.body) {
         (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email send --org <id> --from <email> --to <email> --subject <str> --body <str>");
     }
-    const config = (0, config_js_1.requireConfig)();
     const res = await sdk_1.email.sendEmail(config.api_key, orgId, {
         from: flags.from,
         to: [flags.to],
@@ -45,27 +46,27 @@ async function send(flags) {
     (0, output_js_1.success)(`Email sent! Message ID: ${res.message_id}`);
 }
 async function inbox(address, flags) {
-    const orgId = flags.org;
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
     if (!orgId || !address)
         (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email inbox <address> --org <id>");
-    const config = (0, config_js_1.requireConfig)();
     const messages = await sdk_1.email.getInbox(config.api_key, orgId, address);
     (0, output_js_1.printTable)(messages);
 }
 async function listTemplates(flags) {
-    const orgId = flags.org;
-    if (!orgId)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email list-templates --org <id>");
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email list-templates --org <id>\n(Or set a default org via: myapi config set-org <id>)");
     const templates = await sdk_1.email.listTemplates(config.api_key, orgId);
     (0, output_js_1.printTable)(templates);
 }
 async function generateTemplate(flags) {
-    const orgId = flags.org;
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
     if (!orgId || !flags.prompt || !flags.name) {
         (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email generate-template --org <id> --prompt <str> --name <str>");
     }
-    const config = (0, config_js_1.requireConfig)();
     const job = await sdk_1.email.generateTemplate(config.api_key, orgId, {
         prompt: flags.prompt,
         name: flags.name
@@ -93,18 +94,18 @@ async function generateTemplate(flags) {
     (0, output_js_1.error)("Template generation timed out");
 }
 async function listCampaigns(flags) {
-    const orgId = flags.org;
-    if (!orgId)
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email list-campaigns --org <id>");
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email list-campaigns --org <id>\n(Or set a default org via: myapi config set-org <id>)");
     const campaigns = await sdk_1.email.listCampaigns(config.api_key, orgId);
     (0, output_js_1.printTable)(campaigns);
 }
 async function campaignStats(id, flags) {
-    const orgId = flags.org;
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
     if (!orgId || !id)
         (0, output_js_1.error)("Missing required arguments.\nUsage: myapi email campaign-stats <id> --org <id>");
-    const config = (0, config_js_1.requireConfig)();
     const stats = await sdk_1.email.getCampaignStats(config.api_key, orgId, id);
     (0, output_js_1.printJson)(stats);
 }

package/dist/commands/funnel.d.ts

@@ -1,3 +1,10 @@
 export declare function list(flags: Record<string, string | boolean>): Promise<void>;
 export declare function create(flags: Record<string, string | boolean>): Promise<void>;
+export declare function get(id: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function del(id: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function preview(id: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function publish(id: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function status(id: string, flags: Record<string, string | boolean>): Promise<void>;
 export declare function push(id: string, slug: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function verify(id: string, flags: Record<string, string | boolean>): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/funnel.js

@@ -2,27 +2,81 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.list = list;
 exports.create = create;
+exports.get = get;
+exports.del = del;
+exports.preview = preview;
+exports.publish = publish;
+exports.status = status;
 exports.push = push;
+exports.verify = verify;
+exports.run = run;
 const sdk_1 = require("@myapihq/sdk");
 const config_js_1 = require("../config.js");
 const output_js_1 = require("../output.js");
 async function list(flags) {
     const config = (0, config_js_1.requireConfig)();
-    const funnels = await sdk_1.funnel.listFunnels(config.api_key);
+    const orgId = flags.org || config.default_org;
+    if (!orgId)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const funnels = await sdk_1.funnel.listFunnels(config.api_key, orgId);
     (0, output_js_1.printTable)(funnels);
 }
 async function create(flags) {
-    if (!flags['org-id'] || !flags.domain) {
-        (0, output_js_1.error)("Missing --org-id or --domain flags");
-    }
     const config = (0, config_js_1.requireConfig)();
-    const funnel = await sdk_1.funnel.createFunnel(config.api_key, flags['org-id'], flags.domain);
+    const orgId = flags.org || config.default_org;
+    const domain = flags.domain || config.default_domain;
+    if (!orgId || !domain) {
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel create --org <id> --domain <domain>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
+    }
+    const funnel = await sdk_1.funnel.createFunnel(config.api_key, orgId, domain);
     (0, output_js_1.success)(`Funnel created! ID: ${funnel.id}`);
 }
+async function get(id, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel get <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const funnel = await sdk_1.funnel.getFunnel(config.api_key, orgId, id);
+    (0, output_js_1.printJson)(funnel);
+}
+async function del(id, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    await sdk_1.funnel.deleteFunnel(config.api_key, orgId, id);
+    (0, output_js_1.success)(`Funnel ${id} deleted`);
+}
+async function preview(id, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel preview <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const p = await sdk_1.funnel.previewFunnel(config.api_key, orgId, id);
+    (0, output_js_1.success)(`Preview deployed: ${p.preview_url}`);
+}
+async function publish(id, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel publish <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const p = await sdk_1.funnel.publishFunnel(config.api_key, orgId, id);
+    (0, output_js_1.success)(`Publish job started. Status: ${p.status}`);
+}
+async function status(id, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel status <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const s = await sdk_1.funnel.getPublishStatus(config.api_key, orgId, id);
+    (0, output_js_1.info)(`Publish Status: ${s.status}`);
+}
 async function push(id, slug, flags) {
-    if (!id || !slug)
-        (0, output_js_1.error)("Missing id or slug");
     const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id || !slug) {
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel push <funnel_id> <slug> --org <id> < index.html\n(Or set defaults via: myapi config set-org <id>)");
+    }
     const html = await new Promise((resolve, reject) => {
         let data = '';
         process.stdin.setEncoding('utf-8');
@@ -32,6 +86,64 @@ async function push(id, slug, flags) {
     });
     if (!html)
         (0, output_js_1.error)("No HTML provided via stdin");
-    await sdk_1.funnel.pushPage(config.api_key, id, slug, html);
+    await sdk_1.funnel.pushPage(config.api_key, orgId, id, slug, html);
     (0, output_js_1.success)(`Pushed page to ${slug}`);
 }
+async function verify(id, flags) {
+    const config = (0, config_js_1.requireConfig)();
+    const orgId = flags.org || config.default_org;
+    if (!orgId || !id)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi funnel verify <id> --org <id> [--slug <slug>]\n(Or set defaults via: myapi config set-org <id>)");
+    const opts = {};
+    if (flags.slug)
+        opts.slug = flags.slug;
+    const v = await sdk_1.funnel.verifyFunnel(config.api_key, orgId, id, opts);
+    (0, output_js_1.printJson)(v);
+}
+async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        (0, output_js_1.info)('Usage: myapi funnel <subcommand>\n\nSubcommands:\n  list       List funnels\n  create     Create a funnel\n  get        Get funnel details\n  delete     Delete a funnel\n  preview    Deploy to a preview domain\n  publish    Deploy to production domain\n  status     Check publish status\n  push       Push a raw HTML page to a slug\n  verify     Verify links and webhooks\n\nNote: All funnel commands require the --org <id> flag.');
+        return;
+    }
+    if (flags.help) {
+        if (subcommand === 'list')
+            (0, output_js_1.info)('Usage: myapi funnel list --org <id>');
+        else if (subcommand === 'create')
+            (0, output_js_1.info)('Usage: myapi funnel create --org <id> --domain <domain>');
+        else if (subcommand === 'get')
+            (0, output_js_1.info)('Usage: myapi funnel get <id> --org <id>');
+        else if (subcommand === 'delete')
+            (0, output_js_1.info)('Usage: myapi funnel delete <id> --org <id>');
+        else if (subcommand === 'preview')
+            (0, output_js_1.info)('Usage: myapi funnel preview <id> --org <id>');
+        else if (subcommand === 'publish')
+            (0, output_js_1.info)('Usage: myapi funnel publish <id> --org <id>');
+        else if (subcommand === 'status')
+            (0, output_js_1.info)('Usage: myapi funnel status <id> --org <id>');
+        else if (subcommand === 'push')
+            (0, output_js_1.info)('Usage: myapi funnel push <funnel_id> <slug> --org <id> < index.html\n\nPushes HTML content from stdin to the specified funnel.');
+        else if (subcommand === 'verify')
+            (0, output_js_1.info)('Usage: myapi funnel verify <id> --org <id> [--slug <slug>]\n\nVerifies syntax and structure before publishing.');
+        return;
+    }
+    if (subcommand === 'list')
+        await list(flags);
+    else if (subcommand === 'create')
+        await create(flags);
+    else if (subcommand === 'get')
+        await get(args[0], flags);
+    else if (subcommand === 'delete')
+        await del(args[0], flags);
+    else if (subcommand === 'preview')
+        await preview(args[0], flags);
+    else if (subcommand === 'publish')
+        await publish(args[0], flags);
+    else if (subcommand === 'status')
+        await status(args[0], flags);
+    else if (subcommand === 'push')
+        await push(args[0], args[1], flags);
+    else if (subcommand === 'verify')
+        await verify(args[0], flags);
+    else
+        (0, output_js_1.error)(`Unknown subcommand: ${subcommand}. Run "myapi funnel --help" for a list of valid subcommands.`);
+}

package/dist/commands/keys.js

@@ -58,11 +58,15 @@ async function createNew(flags) {
 }
 async function list(flags) {
     if (flags.help) {
-        (0, output_js_1.info)('Usage: myapi keys list\n\nLists all API keys associated with your account.');
+        (0, output_js_1.info)('Usage: myapi keys list [--json]\n\nLists all API keys associated with your account.');
         return;
     }
     const config = (0, config_js_1.requireConfig)();
     const keysList = await sdk_1.hq.listApiKeys(config.api_key);
+    if (flags.json) {
+        (0, output_js_1.printJson)(keysList);
+        return;
+    }
     const formattedKeys = keysList.map(k => {
         // Format creation date
         const createdDate = new Date(k.created_at);

package/dist/commands/org.js

@@ -71,13 +71,13 @@ async function importOrg(args, flags) {
         (0, output_js_1.info)('Usage: myapi org import <domain> --org <id>\n\nAutomatically extracts brand info from an existing website and updates the organization.\n\nNote: You must create a placeholder organization first using `myapi org create` to get an org_id.');
         return;
     }
-    const domain = args[0];
-    const orgId = flags.org;
+    const config = (0, config_js_1.requireConfig)();
+    const domain = args[0] || config.default_domain;
+    const orgId = flags.org || config.default_org;
     if (!domain || !orgId) {
-        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi org import <domain> --org <id>");
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi org import <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
         return;
     }
-    const config = (0, config_js_1.requireConfig)();
     const result = await sdk_1.hq.importOrg(config.api_key, orgId, domain);
     const importId = result.job_id;
     process.stdout.write("Importing ");

package/dist/config.d.ts

@@ -2,6 +2,8 @@ export interface Config {
     api_key: string;
     account_id: string;
     pin: string;
+    default_org?: string;
+    default_domain?: string;
 }
 export declare function loadConfig(): Config | null;
 export declare function saveConfig(config: Config): void;

package/dist/index.js

@@ -42,8 +42,8 @@ const keysCmd = __importStar(require("./commands/keys.js"));
 const billingCmd = __importStar(require("./commands/billing.js"));
 const orgCmd = __importStar(require("./commands/org.js"));
 const setupCmd = __importStar(require("./commands/setup.js"));
+const configCmd = __importStar(require("./commands/config.js"));
 const domainCmd = __importStar(require("./commands/domain.js"));
-const emailCmd = __importStar(require("./commands/email.js"));
 async function main() {
     const { args, flags } = (0, utils_js_1.parseArgs)(process.argv.slice(2));
     if (args.length === 0) {
@@ -108,12 +108,12 @@ async function main() {
                 else
                     printHelp();
                 break;
+            case 'config':
+                await configCmd.run(subcommand, restArgs, flags);
+                break;
             case 'domain':
                 await domainCmd.run(subcommand, restArgs, flags);
                 break;
-            case 'email':
-                await emailCmd.run(subcommand, restArgs, flags);
-                break;
             default:
                 printHelp();
                 process.exit(0);
@@ -139,8 +139,8 @@ Commands:
   billing      Check balance and manage billing
   org          Manage organizations
   setup        Setup CLI credentials and view integration instructions
+  config       Manage CLI defaults like org_id and domain
   domain       Manage domain configurations
-  email        Send emails and manage templates
 
 Run "myapi <command> --help" for subcommand help.`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myapihq/cli",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "MyAPI command-line interface",
   "main": "dist/index.js",
   "bin": {

package/src/commands/config.ts

@@ -0,0 +1,46 @@
+import { requireConfig, saveConfig } from '../config.js';
+import { success, error, info } from '../output.js';
+
+export async function setOrg(id: string, flags: Record<string, string | boolean>) {
+  if (!id || flags.help) {
+    info("Usage: myapi config set-org <id>\n\nSets a default organization ID for subsequent commands.");
+    return;
+  }
+  const config = requireConfig();
+  config.default_org = id;
+  saveConfig(config);
+  success(`Default organization set to: ${id}`);
+}
+
+export async function setDomain(domain: string, flags: Record<string, string | boolean>) {
+  if (!domain || flags.help) {
+    info("Usage: myapi config set-domain <domain>\n\nSets a default domain for subsequent commands.");
+    return;
+  }
+  const config = requireConfig();
+  config.default_domain = domain;
+  saveConfig(config);
+  success(`Default domain set to: ${domain}`);
+}
+
+export async function view(flags: Record<string, string | boolean>) {
+  if (flags.help) {
+     info("Usage: myapi config view\n\nViews current config settings.");
+     return;
+  }
+  const config = requireConfig();
+  info(`Default Org: ${config.default_org || 'Not set'}`);
+  info(`Default Domain: ${config.default_domain || 'Not set'}`);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi config <subcommand>\n\nSubcommands:\n  view         View current config\n  set-org      Set default organization\n  set-domain   Set default domain');
+    return;
+  }
+  
+  if (subcommand === 'view') await view(flags);
+  else if (subcommand === 'set-org') await setOrg(args[0], flags);
+  else if (subcommand === 'set-domain') await setDomain(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi config --help" for a list of valid subcommands.`);
+}

package/src/commands/domain.ts

@@ -2,10 +2,11 @@ import { domain as sdkDomain } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, info, printTable, printJson } from '../output.js';
 
-export async function check(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>");
+export async function check(domainArg: string, flags: Record<string, string | boolean>) {
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
   const res = await sdkDomain.checkDomain(config.api_key, orgId, domain);
   if (res.available) {
     info(`${domain} — Available ✓  Price: $${(res.price_cents / 100).toFixed(2)}/yr`);
@@ -14,22 +15,24 @@ export async function check(domain: string, flags: Record<string, string | boole
   }
 }
 
-export async function register(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]");
-  const years = parseInt(flags.years as string) || 1;
+export async function register(domainArg: string, flags: Record<string, string | boolean>) {
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
+  const years = parseInt(flags.years as string) || 1;
   const res = await sdkDomain.registerDomain(config.api_key, orgId, domain, years);
   success(`Registered ${domain}!\n${JSON.stringify(res, null, 2)}`);
 }
 
-export async function importDomain(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>");
+export async function importDomain(domainArg: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
   if (!flags['namecheap-user'] || !flags['namecheap-key']) {
     error("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>");
   }
-  const config = requireConfig();
   await sdkDomain.importDomain(config.api_key, orgId, {
     domain,
     namecheap_api_user: flags['namecheap-user'] as string,
@@ -39,43 +42,47 @@ export async function importDomain(domain: string, flags: Record<string, string
 }
 
 export async function list(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId) error("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]\n(Or set a default org via: myapi config set-org <id>)");
   const filter = flags.filter as 'all' | 'unassigned' | 'org' | undefined;
   const domains = await sdkDomain.listDomains(config.api_key, orgId, filter);
   printTable(domains as unknown as Record<string, unknown>[]);
 }
 
-export async function assign(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  const targetOrgId = flags.target as string;
-  if (!orgId || !domain || !targetOrgId) error("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id> --target <target_org_id>");
+export async function assign(domainArg: string, flags: Record<string, string | boolean>) {
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  const targetOrgId = flags.target as string;
+  if (!orgId || !domain || !targetOrgId) error("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id> --target <target_org_id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
   const res = await sdkDomain.assignDomain(config.api_key, orgId, domain, targetOrgId);
   success(`Assigned ${domain} to org ${targetOrgId}`);
 }
 
-export async function unassign(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>");
+export async function unassign(domainArg: string, flags: Record<string, string | boolean>) {
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
   const res = await sdkDomain.unassignDomain(config.api_key, orgId, domain);
   success(`Unassigned ${domain} from org ${orgId}`);
 }
 
-export async function settings(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>");
+export async function settings(domainArg: string, flags: Record<string, string | boolean>) {
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
   const res = await sdkDomain.getDomainSettings(config.api_key, orgId, domain);
   printJson(res);
 }
 
-export async function updateSettings(domain: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain update-settings <domain> --org <id> [--security=...] [--browser-check=...] [--purge-cache]");
+export async function updateSettings(domainArg: string, flags: Record<string, string | boolean>) {
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = domainArg || (config.default_domain as string);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain update-settings <domain> --org <id> [--security=...] [--browser-check=...] [--purge-cache]\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
   const payload: any = {};
   if (flags.security) payload.security_level = flags.security as string;
   if (flags['browser-check']) payload.browser_check = flags['browser-check'] as string;

package/src/commands/email.ts

@@ -4,29 +4,30 @@ import { success, error, printTable, printJson, info } from '../output.js';
 import { sleep } from '../utils.js';
 
 export async function createMailbox(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !flags.domain || !flags.username) {
-    error("Missing required arguments.\nUsage: myapi email create-mailbox --org <id> --domain <domain> --username <user>");
-  }
   const config = requireConfig();
-  const address = await sdkEmail.createMailbox(config.api_key, orgId, flags.domain as string, flags.username as string);
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = (flags.domain as string) || config.default_domain;
+  if (!orgId || !domain || !flags.username) {
+    error("Missing required arguments.\nUsage: myapi email create-mailbox --org <id> --domain <domain> --username <user>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
+  }
+  const address = await sdkEmail.createMailbox(config.api_key, orgId, domain, flags.username as string);
   success(`Mailbox created: ${address.address}`);
 }
 
 export async function listMailboxes(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId) error("Missing required arguments.\nUsage: myapi email list-mailboxes --org <id>");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi email list-mailboxes --org <id>\n(Or set a default org via: myapi config set-org <id>)");
   const mailboxes = await sdkEmail.listMailboxes(config.api_key, orgId);
   printTable(mailboxes as unknown as Record<string, unknown>[]);
 }
 
 export async function send(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
   if (!orgId || !flags.from || !flags.to || !flags.subject || !flags.body) {
     error("Missing required arguments.\nUsage: myapi email send --org <id> --from <email> --to <email> --subject <str> --body <str>");
   }
-  const config = requireConfig();
   const res = await sdkEmail.sendEmail(config.api_key, orgId, {
     from: flags.from as string,
     to: [flags.to as string],
@@ -37,27 +38,27 @@ export async function send(flags: Record<string, string | boolean>) {
 }
 
 export async function inbox(address: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !address) error("Missing required arguments.\nUsage: myapi email inbox <address> --org <id>");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !address) error("Missing required arguments.\nUsage: myapi email inbox <address> --org <id>");
   const messages = await sdkEmail.getInbox(config.api_key, orgId, address);
   printTable(messages as unknown as Record<string, unknown>[]);
 }
 
 export async function listTemplates(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId) error("Missing required arguments.\nUsage: myapi email list-templates --org <id>");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi email list-templates --org <id>\n(Or set a default org via: myapi config set-org <id>)");
   const templates = await sdkEmail.listTemplates(config.api_key, orgId);
   printTable(templates as unknown as Record<string, unknown>[]);
 }
 
 export async function generateTemplate(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
   if (!orgId || !flags.prompt || !flags.name) {
     error("Missing required arguments.\nUsage: myapi email generate-template --org <id> --prompt <str> --name <str>");
   }
-  const config = requireConfig();
   
   const job = await sdkEmail.generateTemplate(config.api_key, orgId, {
     prompt: flags.prompt as string,
@@ -89,17 +90,17 @@ export async function generateTemplate(flags: Record<string, string | boolean>)
 }
 
 export async function listCampaigns(flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId) error("Missing required arguments.\nUsage: myapi email list-campaigns --org <id>");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi email list-campaigns --org <id>\n(Or set a default org via: myapi config set-org <id>)");
   const campaigns = await sdkEmail.listCampaigns(config.api_key, orgId);
   printTable(campaigns as unknown as Record<string, unknown>[]);
 }
 
 export async function campaignStats(id: string, flags: Record<string, string | boolean>) {
-  const orgId = flags.org as string;
-  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi email campaign-stats <id> --org <id>");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi email campaign-stats <id> --org <id>");
   const stats = await sdkEmail.getCampaignStats(config.api_key, orgId, id);
   printJson(stats);
 }

package/src/commands/funnel.ts

@@ -1,26 +1,76 @@
 import { funnel as sdkFunnel } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable } from '../output.js';
+import { success, error, printTable, info, printJson } from '../output.js';
 import * as fs from 'fs';
 
 export async function list(flags: Record<string, string | boolean>) {
   const config = requireConfig();
-  const funnels = await sdkFunnel.listFunnels(config.api_key);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi funnel list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  const funnels = await sdkFunnel.listFunnels(config.api_key, orgId);
   printTable(funnels as unknown as Record<string, unknown>[]);
 }
 
 export async function create(flags: Record<string, string | boolean>) {
-  if (!flags['org-id'] || !flags.domain) {
-    error("Missing --org-id or --domain flags");
-  }
   const config = requireConfig();
-  const funnel = await sdkFunnel.createFunnel(config.api_key, flags['org-id'] as string, flags.domain as string);
+  const orgId = (flags.org as string) || config.default_org;
+  const domain = (flags.domain as string) || config.default_domain;
+  
+  if (!orgId || !domain) {
+    error("Missing required arguments.\nUsage: myapi funnel create --org <id> --domain <domain>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
+  }
+  
+  const funnel = await sdkFunnel.createFunnel(config.api_key, orgId, domain);
   success(`Funnel created! ID: ${funnel.id}`);
 }
 
+export async function get(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi funnel get <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  const funnel = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+  printJson(funnel);
+}
+
+export async function del(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi funnel delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  await sdkFunnel.deleteFunnel(config.api_key, orgId, id);
+  success(`Funnel ${id} deleted`);
+}
+
+export async function preview(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi funnel preview <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  const p = await sdkFunnel.previewFunnel(config.api_key, orgId, id);
+  success(`Preview deployed: ${p.preview_url}`);
+}
+
+export async function publish(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi funnel publish <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  const p = await sdkFunnel.publishFunnel(config.api_key, orgId, id);
+  success(`Publish job started. Status: ${p.status}`);
+}
+
+export async function status(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi funnel status <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  const s = await sdkFunnel.getPublishStatus(config.api_key, orgId, id);
+  info(`Publish Status: ${s.status}`);
+}
+
 export async function push(id: string, slug: string, flags: Record<string, string | boolean>) {
-  if (!id || !slug) error("Missing id or slug");
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  
+  if (!orgId || !id || !slug) {
+    error("Missing required arguments.\nUsage: myapi funnel push <funnel_id> <slug> --org <id> < index.html\n(Or set defaults via: myapi config set-org <id>)");
+  }
   
   const html = await new Promise<string>((resolve, reject) => {
     let data = '';
@@ -32,6 +82,47 @@ export async function push(id: string, slug: string, flags: Record<string, strin
 
   if (!html) error("No HTML provided via stdin");
 
-  await sdkFunnel.pushPage(config.api_key, id, slug, html);
+  await sdkFunnel.pushPage(config.api_key, orgId, id, slug, html);
   success(`Pushed page to ${slug}`);
 }
+
+export async function verify(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi funnel verify <id> --org <id> [--slug <slug>]\n(Or set defaults via: myapi config set-org <id>)");
+  const opts: any = {};
+  if (flags.slug) opts.slug = flags.slug as string;
+  const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, id, opts);
+  printJson(v);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi funnel <subcommand>\n\nSubcommands:\n  list       List funnels\n  create     Create a funnel\n  get        Get funnel details\n  delete     Delete a funnel\n  preview    Deploy to a preview domain\n  publish    Deploy to production domain\n  status     Check publish status\n  push       Push a raw HTML page to a slug\n  verify     Verify links and webhooks\n\nNote: All funnel commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'list') info('Usage: myapi funnel list --org <id>');
+    else if (subcommand === 'create') info('Usage: myapi funnel create --org <id> --domain <domain>');
+    else if (subcommand === 'get') info('Usage: myapi funnel get <id> --org <id>');
+    else if (subcommand === 'delete') info('Usage: myapi funnel delete <id> --org <id>');
+    else if (subcommand === 'preview') info('Usage: myapi funnel preview <id> --org <id>');
+    else if (subcommand === 'publish') info('Usage: myapi funnel publish <id> --org <id>');
+    else if (subcommand === 'status') info('Usage: myapi funnel status <id> --org <id>');
+    else if (subcommand === 'push') info('Usage: myapi funnel push <funnel_id> <slug> --org <id> < index.html\n\nPushes HTML content from stdin to the specified funnel.');
+    else if (subcommand === 'verify') info('Usage: myapi funnel verify <id> --org <id> [--slug <slug>]\n\nVerifies syntax and structure before publishing.');
+    return;
+  }
+
+  if (subcommand === 'list') await list(flags);
+  else if (subcommand === 'create') await create(flags);
+  else if (subcommand === 'get') await get(args[0], flags);
+  else if (subcommand === 'delete') await del(args[0], flags);
+  else if (subcommand === 'preview') await preview(args[0], flags);
+  else if (subcommand === 'publish') await publish(args[0], flags);
+  else if (subcommand === 'status') await status(args[0], flags);
+  else if (subcommand === 'push') await push(args[0], args[1], flags);
+  else if (subcommand === 'verify') await verify(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi funnel --help" for a list of valid subcommands.`);
+}

package/src/commands/keys.ts

@@ -1,6 +1,6 @@
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable, info } from '../output.js';
+import { success, error, printTable, info, printJson } from '../output.js';
 import * as readline from 'readline';
 
 export async function createNew(flags: Record<string, string | boolean>) {
@@ -24,12 +24,17 @@ export async function createNew(flags: Record<string, string | boolean>) {
 
 export async function list(flags: Record<string, string | boolean>) {
   if (flags.help) {
-    info('Usage: myapi keys list\n\nLists all API keys associated with your account.');
+    info('Usage: myapi keys list [--json]\n\nLists all API keys associated with your account.');
     return;
   }
   const config = requireConfig();
   const keysList = await hq.listApiKeys(config.api_key);
   
+  if (flags.json) {
+    printJson(keysList);
+    return;
+  }
+  
   const formattedKeys = keysList.map(k => {
     // Format creation date
     const createdDate = new Date(k.created_at);

package/src/commands/org.ts

@@ -66,14 +66,14 @@ export async function importOrg(args: string[], flags: Record<string, string | b
     info('Usage: myapi org import <domain> --org <id>\n\nAutomatically extracts brand info from an existing website and updates the organization.\n\nNote: You must create a placeholder organization first using `myapi org create` to get an org_id.');
     return;
   }
-  const domain = args[0];
-  const orgId = flags.org as string;
+  const config = requireConfig();
+  const domain = args[0] || (config.default_domain as string);
+  const orgId = (flags.org as string) || config.default_org;
   
   if (!domain || !orgId) {
-    error("Missing required arguments.\nUsage: myapi org import <domain> --org <id>");
+    error("Missing required arguments.\nUsage: myapi org import <domain> --org <id>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     return;
   }
-  const config = requireConfig();
   
   const result = await hq.importOrg(config.api_key, orgId, domain);
   const importId = result.job_id;

package/src/config.ts

@@ -6,6 +6,8 @@ export interface Config {
   api_key: string;
   account_id: string;
   pin: string;
+  default_org?: string;
+  default_domain?: string;
 }
 
 const CONFIG_DIR = path.join(os.homedir(), '.myapi');

package/src/index.ts

@@ -7,8 +7,8 @@ import * as keysCmd from './commands/keys.js';
 import * as billingCmd from './commands/billing.js';
 import * as orgCmd from './commands/org.js';
 import * as setupCmd from './commands/setup.js';
+import * as configCmd from './commands/config.js';
 import * as domainCmd from './commands/domain.js';
-import * as emailCmd from './commands/email.js';
 
 async function main() {
   const { args, flags } = parseArgs(process.argv.slice(2));
@@ -56,12 +56,12 @@ async function main() {
         else if (subcommand === 'setup') await billingCmd.setup(flags);
         else printHelp();
         break;
+      case 'config':
+        await configCmd.run(subcommand, restArgs, flags);
+        break;
       case 'domain':
         await domainCmd.run(subcommand, restArgs, flags);
         break;
-      case 'email':
-        await emailCmd.run(subcommand, restArgs, flags);
-        break;
       default:
         printHelp();
         process.exit(0);
@@ -85,8 +85,8 @@ Commands:
   billing      Check balance and manage billing
   org          Manage organizations
   setup        Setup CLI credentials and view integration instructions
+  config       Manage CLI defaults like org_id and domain
   domain       Manage domain configurations
-  email        Send emails and manage templates
 
 Run "myapi <command> --help" for subcommand help.`);
 }