@myapihq/cli 1.0.11 → 1.0.13

package/dist/commands/domain.d.ts

@@ -2,5 +2,8 @@ export declare function check(domain: string, flags: Record<string, string | boo
 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 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 run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;

package/dist/commands/domain.js

@@ -4,17 +4,18 @@ exports.check = check;
 exports.register = register;
 exports.importDomain = importDomain;
 exports.list = list;
+exports.assign = assign;
+exports.unassign = unassign;
 exports.settings = settings;
+exports.updateSettings = updateSettings;
 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)
-        (0, output_js_1.error)("Missing --org <id> flag");
-    if (!domain)
-        (0, output_js_1.error)("Missing domain");
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>");
     const config = (0, config_js_1.requireConfig)();
     const res = await sdk_1.domain.checkDomain(config.api_key, orgId, domain);
     if (res.available) {
@@ -26,10 +27,8 @@ async function check(domain, flags) {
 }
 async function register(domain, flags) {
     const orgId = flags.org;
-    if (!orgId)
-        (0, output_js_1.error)("Missing --org <id> flag");
-    if (!domain)
-        (0, output_js_1.error)("Missing domain");
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]");
     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);
@@ -37,12 +36,10 @@ async function register(domain, flags) {
 }
 async function importDomain(domain, flags) {
     const orgId = flags.org;
-    if (!orgId)
-        (0, output_js_1.error)("Missing --org <id> flag");
-    if (!domain)
-        (0, output_js_1.error)("Missing 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>");
     if (!flags['namecheap-user'] || !flags['namecheap-key']) {
-        (0, output_js_1.error)("Missing --namecheap-user or --namecheap-key flags");
+        (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, {
@@ -55,25 +52,55 @@ async function importDomain(domain, flags) {
 async function list(flags) {
     const orgId = flags.org;
     if (!orgId)
-        (0, output_js_1.error)("Missing --org <id> flag");
+        (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 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;
+    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)();
+    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>");
+    const config = (0, config_js_1.requireConfig)();
+    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)
-        (0, output_js_1.error)("Missing --org <id> flag");
-    if (!domain)
-        (0, output_js_1.error)("Missing domain");
+    if (!orgId || !domain)
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>");
     const config = (0, config_js_1.requireConfig)();
     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]");
+    const config = (0, config_js_1.requireConfig)();
+    const payload = {};
+    if (flags.security)
+        payload.security_level = flags.security;
+    if (flags['browser-check'])
+        payload.browser_check = flags['browser-check'];
+    if (flags['purge-cache'])
+        payload.purge_cache = true;
+    const res = await sdk_1.domain.updateDomainSettings(config.api_key, orgId, domain, payload);
+    (0, output_js_1.success)(`Updated settings for ${domain}!\n${JSON.stringify(res, null, 2)}`);
+}
 async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
-        (0, output_js_1.info)('Usage: myapi domain <subcommand>\n\nSubcommands:\n  list       List domains\n  check      Check domain availability\n  register   Register a domain\n  import     Import an existing domain\n  settings   Get domain settings\n\nNote: All domain commands require the --org <id> flag.');
+        (0, output_js_1.info)('Usage: myapi domain <subcommand>\n\nSubcommands:\n  list             List domains\n  check            Check domain availability\n  register         Register a domain\n  import           Import an existing domain\n  assign           Assign domain to org\n  unassign         Unassign domain from its current org\n  settings         Get domain settings\n  update-settings  Update domain settings\n\nNote: All domain commands require the --org <id> flag.');
         return;
     }
     if (flags.help) {
@@ -85,8 +112,14 @@ async function run(subcommand, args, flags) {
             (0, output_js_1.info)('Usage: myapi domain register <domain> --org <id> [--years <num>]\n\nRegisters a new domain name.');
         else if (subcommand === 'import')
             (0, output_js_1.info)('Usage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>\n\nImports an existing domain from Namecheap.');
+        else if (subcommand === 'assign')
+            (0, output_js_1.info)('Usage: myapi domain assign <domain> --org <id> --target <target_org_id>\n\nAssigns a domain to a different organization.');
+        else if (subcommand === 'unassign')
+            (0, output_js_1.info)('Usage: myapi domain unassign <domain> --org <id>\n\nUnassigns a domain from its current organization.');
         else if (subcommand === 'settings')
             (0, output_js_1.info)('Usage: myapi domain settings <domain> --org <id>\n\nGets the DNS settings and configuration for a domain.');
+        else if (subcommand === 'update-settings')
+            (0, output_js_1.info)('Usage: myapi domain update-settings <domain> --org <id> [--security=essentially_off|medium|high|under_attack] [--browser-check=on|off] [--purge-cache]\n\nUpdates edge settings for a domain.');
         return;
     }
     if (subcommand === 'list')
@@ -97,8 +130,14 @@ async function run(subcommand, args, flags) {
         await register(args[0], flags);
     else if (subcommand === 'import')
         await importDomain(args[0], flags);
+    else if (subcommand === 'assign')
+        await assign(args[0], flags);
+    else if (subcommand === 'unassign')
+        await unassign(args[0], flags);
     else if (subcommand === 'settings')
         await settings(args[0], flags);
+    else if (subcommand === 'update-settings')
+        await updateSettings(args[0], flags);
     else
         (0, output_js_1.error)(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for a list of valid subcommands.`);
 }

package/dist/commands/email.d.ts

@@ -6,3 +6,4 @@ export declare function listTemplates(flags: Record<string, string | boolean>):
 export declare function generateTemplate(flags: Record<string, string | boolean>): Promise<void>;
 export declare function listCampaigns(flags: Record<string, string | boolean>): Promise<void>;
 export declare function campaignStats(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/email.js

@@ -8,28 +8,35 @@ exports.listTemplates = listTemplates;
 exports.generateTemplate = generateTemplate;
 exports.listCampaigns = listCampaigns;
 exports.campaignStats = campaignStats;
+exports.run = run;
 const sdk_1 = require("@myapihq/sdk");
 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) {
-    if (!flags.domain || !flags.username)
-        (0, output_js_1.error)("Missing --domain or --username 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, flags.domain, flags.username);
+    const address = await sdk_1.email.createMailbox(config.api_key, orgId, flags.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 mailboxes = await sdk_1.email.listMailboxes(config.api_key);
+    const mailboxes = await sdk_1.email.listMailboxes(config.api_key, orgId);
     (0, output_js_1.printTable)(mailboxes);
 }
 async function send(flags) {
-    if (!flags.from || !flags.to || !flags.subject || !flags.body) {
-        (0, output_js_1.error)("Missing --from, --to, --subject, or --body flags");
+    const orgId = flags.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, {
+    const res = await sdk_1.email.sendEmail(config.api_key, orgId, {
         from: flags.from,
         to: [flags.to],
         subject: flags.subject,
@@ -38,24 +45,28 @@ async function send(flags) {
     (0, output_js_1.success)(`Email sent! Message ID: ${res.message_id}`);
 }
 async function inbox(address, flags) {
-    if (!address)
-        (0, output_js_1.error)("Missing address");
+    const orgId = flags.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, address);
+    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 templates = await sdk_1.email.listTemplates(config.api_key);
+    const templates = await sdk_1.email.listTemplates(config.api_key, orgId);
     (0, output_js_1.printTable)(templates);
 }
 async function generateTemplate(flags) {
-    if (!flags['org-id'] || !flags.prompt || !flags.name) {
-        (0, output_js_1.error)("Missing --org-id, --prompt, or --name flags");
+    const orgId = flags.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, {
-        org_id: flags['org-id'],
+    const job = await sdk_1.email.generateTemplate(config.api_key, orgId, {
         prompt: flags.prompt,
         name: flags.name
     });
@@ -64,7 +75,7 @@ async function generateTemplate(flags) {
     let i = 0;
     let elapsed = 0;
     while (elapsed < 90000) {
-        const status = await sdk_1.email.getTemplateJobStatus(config.api_key, job.job_id);
+        const status = await sdk_1.email.getTemplateJobStatus(config.api_key, orgId, job.job_id);
         if (status.status === 'completed') {
             process.stdout.write('\r\x1b[K');
             (0, output_js_1.success)(`Template generated! ID: ${status.template_id}\nPreview: ${status.result?.preview_url}`);
@@ -82,14 +93,61 @@ 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 campaigns = await sdk_1.email.listCampaigns(config.api_key);
+    const campaigns = await sdk_1.email.listCampaigns(config.api_key, orgId);
     (0, output_js_1.printTable)(campaigns);
 }
 async function campaignStats(id, flags) {
-    if (!id)
-        (0, output_js_1.error)("Missing campaign id");
+    const orgId = flags.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, id);
+    const stats = await sdk_1.email.getCampaignStats(config.api_key, orgId, id);
     (0, output_js_1.printJson)(stats);
 }
+async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        (0, output_js_1.info)('Usage: myapi email <subcommand>\n\nSubcommands:\n  create-mailbox      Create a new mailbox\n  list-mailboxes      List mailboxes\n  send                Send an email\n  inbox               Read received emails\n  list-templates      List email templates\n  generate-template   Generate AI template\n  list-campaigns      List campaigns\n  campaign-stats      Get campaign stats\n\nNote: All email commands require the --org <id> flag.');
+        return;
+    }
+    if (flags.help) {
+        if (subcommand === 'create-mailbox')
+            (0, output_js_1.info)('Usage: myapi email create-mailbox --org <id> --domain <domain> --username <user>');
+        else if (subcommand === 'list-mailboxes')
+            (0, output_js_1.info)('Usage: myapi email list-mailboxes --org <id>');
+        else if (subcommand === 'send')
+            (0, output_js_1.info)('Usage: myapi email send --org <id> --from <email> --to <email> --subject <str> --body <str>');
+        else if (subcommand === 'inbox')
+            (0, output_js_1.info)('Usage: myapi email inbox <address> --org <id>');
+        else if (subcommand === 'list-templates')
+            (0, output_js_1.info)('Usage: myapi email list-templates --org <id>');
+        else if (subcommand === 'generate-template')
+            (0, output_js_1.info)('Usage: myapi email generate-template --org <id> --prompt <str> --name <str>');
+        else if (subcommand === 'list-campaigns')
+            (0, output_js_1.info)('Usage: myapi email list-campaigns --org <id>');
+        else if (subcommand === 'campaign-stats')
+            (0, output_js_1.info)('Usage: myapi email campaign-stats <campaign_id> --org <id>');
+        return;
+    }
+    if (subcommand === 'create-mailbox')
+        await createMailbox(flags);
+    else if (subcommand === 'list-mailboxes')
+        await listMailboxes(flags);
+    else if (subcommand === 'send')
+        await send(flags);
+    else if (subcommand === 'inbox')
+        await inbox(args[0], flags);
+    else if (subcommand === 'list-templates')
+        await listTemplates(flags);
+    else if (subcommand === 'generate-template')
+        await generateTemplate(flags);
+    else if (subcommand === 'list-campaigns')
+        await listCampaigns(flags);
+    else if (subcommand === 'campaign-stats')
+        await campaignStats(args[0], flags);
+    else
+        (0, output_js_1.error)(`Unknown subcommand: ${subcommand}. Run "myapi email --help" for a list of valid subcommands.`);
+}

package/dist/commands/org.js

@@ -74,7 +74,7 @@ async function importOrg(args, flags) {
     const domain = args[0];
     const orgId = flags.org;
     if (!domain || !orgId) {
-        (0, output_js_1.error)("Missing domain or --org flag. Usage: myapi org import <domain> --org <id>");
+        (0, output_js_1.error)("Missing required arguments.\nUsage: myapi org import <domain> --org <id>");
         return;
     }
     const config = (0, config_js_1.requireConfig)();

package/dist/index.js

@@ -43,6 +43,7 @@ const billingCmd = __importStar(require("./commands/billing.js"));
 const orgCmd = __importStar(require("./commands/org.js"));
 const setupCmd = __importStar(require("./commands/setup.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) {
@@ -110,6 +111,9 @@ async function main() {
             case 'domain':
                 await domainCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'email':
+                await emailCmd.run(subcommand, restArgs, flags);
+                break;
             default:
                 printHelp();
                 process.exit(0);
@@ -136,6 +140,7 @@ Commands:
   org          Manage organizations
   setup        Setup CLI credentials and view integration instructions
   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.11",
+  "version": "1.0.13",
   "description": "MyAPI command-line interface",
   "main": "dist/index.js",
   "bin": {

package/src/commands/domain.ts

@@ -4,8 +4,7 @@ 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) error("Missing --org <id> flag");
-  if (!domain) error("Missing domain");
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>");
   const config = requireConfig();
   const res = await sdkDomain.checkDomain(config.api_key, orgId, domain);
   if (res.available) {
@@ -17,8 +16,7 @@ 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) error("Missing --org <id> flag");
-  if (!domain) error("Missing domain");
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]");
   const years = parseInt(flags.years as string) || 1;
   const config = requireConfig();
   const res = await sdkDomain.registerDomain(config.api_key, orgId, domain, years);
@@ -27,10 +25,9 @@ export async function register(domain: string, flags: Record<string, string | bo
 
 export async function importDomain(domain: string, flags: Record<string, string | boolean>) {
   const orgId = flags.org as string;
-  if (!orgId) error("Missing --org <id> flag");
-  if (!domain) error("Missing domain");
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>");
   if (!flags['namecheap-user'] || !flags['namecheap-key']) {
-    error("Missing --namecheap-user or --namecheap-key flags");
+    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, {
@@ -43,25 +40,54 @@ 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 --org <id> flag");
+  if (!orgId) error("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]");
   const config = requireConfig();
   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>");
+  const config = requireConfig();
+  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>");
+  const config = requireConfig();
+  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) error("Missing --org <id> flag");
-  if (!domain) error("Missing domain");
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>");
   const config = requireConfig();
   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]");
+  const config = requireConfig();
+  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;
+  if (flags['purge-cache']) payload.purge_cache = true;
+  
+  const res = await sdkDomain.updateDomainSettings(config.api_key, orgId, domain, payload);
+  success(`Updated settings for ${domain}!\n${JSON.stringify(res, null, 2)}`);
+}
+
 export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
   if (!subcommand || (flags.help && !subcommand)) {
-    info('Usage: myapi domain <subcommand>\n\nSubcommands:\n  list       List domains\n  check      Check domain availability\n  register   Register a domain\n  import     Import an existing domain\n  settings   Get domain settings\n\nNote: All domain commands require the --org <id> flag.');
+    info('Usage: myapi domain <subcommand>\n\nSubcommands:\n  list             List domains\n  check            Check domain availability\n  register         Register a domain\n  import           Import an existing domain\n  assign           Assign domain to org\n  unassign         Unassign domain from its current org\n  settings         Get domain settings\n  update-settings  Update domain settings\n\nNote: All domain commands require the --org <id> flag.');
     return;
   }
   
@@ -70,7 +96,10 @@ export async function run(subcommand: string | undefined, args: string[], flags:
     else if (subcommand === 'check') info('Usage: myapi domain check <domain> --org <id>\n\nChecks if a domain name is available for registration.');
     else if (subcommand === 'register') info('Usage: myapi domain register <domain> --org <id> [--years <num>]\n\nRegisters a new domain name.');
     else if (subcommand === 'import') info('Usage: myapi domain import <domain> --org <id> --namecheap-user <user> --namecheap-key <key>\n\nImports an existing domain from Namecheap.');
+    else if (subcommand === 'assign') info('Usage: myapi domain assign <domain> --org <id> --target <target_org_id>\n\nAssigns a domain to a different organization.');
+    else if (subcommand === 'unassign') info('Usage: myapi domain unassign <domain> --org <id>\n\nUnassigns a domain from its current organization.');
     else if (subcommand === 'settings') info('Usage: myapi domain settings <domain> --org <id>\n\nGets the DNS settings and configuration for a domain.');
+    else if (subcommand === 'update-settings') info('Usage: myapi domain update-settings <domain> --org <id> [--security=essentially_off|medium|high|under_attack] [--browser-check=on|off] [--purge-cache]\n\nUpdates edge settings for a domain.');
     return;
   }
 
@@ -78,6 +107,9 @@ export async function run(subcommand: string | undefined, args: string[], flags:
   else if (subcommand === 'check') await check(args[0], flags);
   else if (subcommand === 'register') await register(args[0], flags);
   else if (subcommand === 'import') await importDomain(args[0], flags);
+  else if (subcommand === 'assign') await assign(args[0], flags);
+  else if (subcommand === 'unassign') await unassign(args[0], flags);
   else if (subcommand === 'settings') await settings(args[0], flags);
+  else if (subcommand === 'update-settings') await updateSettings(args[0], flags);
   else error(`Unknown subcommand: ${subcommand}. Run "myapi domain --help" for a list of valid subcommands.`);
 }

package/src/commands/email.ts

@@ -1,27 +1,33 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable, printJson } from '../output.js';
+import { success, error, printTable, printJson, info } from '../output.js';
 import { sleep } from '../utils.js';
 
 export async function createMailbox(flags: Record<string, string | boolean>) {
-  if (!flags.domain || !flags.username) error("Missing --domain or --username flags");
+  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, flags.domain as string, flags.username as string);
+  const address = await sdkEmail.createMailbox(config.api_key, orgId, flags.domain as string, 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 mailboxes = await sdkEmail.listMailboxes(config.api_key);
+  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>) {
-  if (!flags.from || !flags.to || !flags.subject || !flags.body) {
-    error("Missing --from, --to, --subject, or --body flags");
+  const orgId = flags.org as string;
+  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, {
+  const res = await sdkEmail.sendEmail(config.api_key, orgId, {
     from: flags.from as string,
     to: [flags.to as string],
     subject: flags.subject as string,
@@ -31,26 +37,29 @@ export async function send(flags: Record<string, string | boolean>) {
 }
 
 export async function inbox(address: string, flags: Record<string, string | boolean>) {
-  if (!address) error("Missing address");
+  const orgId = flags.org as string;
+  if (!orgId || !address) error("Missing required arguments.\nUsage: myapi email inbox <address> --org <id>");
   const config = requireConfig();
-  const messages = await sdkEmail.getInbox(config.api_key, address);
+  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 templates = await sdkEmail.listTemplates(config.api_key);
+  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>) {
-  if (!flags['org-id'] || !flags.prompt || !flags.name) {
-    error("Missing --org-id, --prompt, or --name flags");
+  const orgId = flags.org as string;
+  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, {
-    org_id: flags['org-id'] as string,
+  const job = await sdkEmail.generateTemplate(config.api_key, orgId, {
     prompt: flags.prompt as string,
     name: flags.name as string
   });
@@ -61,7 +70,7 @@ export async function generateTemplate(flags: Record<string, string | boolean>)
   let elapsed = 0;
   
   while (elapsed < 90000) {
-    const status = await sdkEmail.getTemplateJobStatus(config.api_key, job.job_id);
+    const status = await sdkEmail.getTemplateJobStatus(config.api_key, orgId, job.job_id);
     if (status.status === 'completed') {
       process.stdout.write('\r\x1b[K');
       success(`Template generated! ID: ${status.template_id}\nPreview: ${status.result?.preview_url}`);
@@ -80,14 +89,46 @@ 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 campaigns = await sdkEmail.listCampaigns(config.api_key);
+  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>) {
-  if (!id) error("Missing campaign id");
+  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 stats = await sdkEmail.getCampaignStats(config.api_key, id);
+  const stats = await sdkEmail.getCampaignStats(config.api_key, orgId, id);
   printJson(stats);
 }
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi email <subcommand>\n\nSubcommands:\n  create-mailbox      Create a new mailbox\n  list-mailboxes      List mailboxes\n  send                Send an email\n  inbox               Read received emails\n  list-templates      List email templates\n  generate-template   Generate AI template\n  list-campaigns      List campaigns\n  campaign-stats      Get campaign stats\n\nNote: All email commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'create-mailbox') info('Usage: myapi email create-mailbox --org <id> --domain <domain> --username <user>');
+    else if (subcommand === 'list-mailboxes') info('Usage: myapi email list-mailboxes --org <id>');
+    else if (subcommand === 'send') info('Usage: myapi email send --org <id> --from <email> --to <email> --subject <str> --body <str>');
+    else if (subcommand === 'inbox') info('Usage: myapi email inbox <address> --org <id>');
+    else if (subcommand === 'list-templates') info('Usage: myapi email list-templates --org <id>');
+    else if (subcommand === 'generate-template') info('Usage: myapi email generate-template --org <id> --prompt <str> --name <str>');
+    else if (subcommand === 'list-campaigns') info('Usage: myapi email list-campaigns --org <id>');
+    else if (subcommand === 'campaign-stats') info('Usage: myapi email campaign-stats <campaign_id> --org <id>');
+    return;
+  }
+
+  if (subcommand === 'create-mailbox') await createMailbox(flags);
+  else if (subcommand === 'list-mailboxes') await listMailboxes(flags);
+  else if (subcommand === 'send') await send(flags);
+  else if (subcommand === 'inbox') await inbox(args[0], flags);
+  else if (subcommand === 'list-templates') await listTemplates(flags);
+  else if (subcommand === 'generate-template') await generateTemplate(flags);
+  else if (subcommand === 'list-campaigns') await listCampaigns(flags);
+  else if (subcommand === 'campaign-stats') await campaignStats(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi email --help" for a list of valid subcommands.`);
+}

package/src/commands/org.ts

@@ -70,7 +70,7 @@ export async function importOrg(args: string[], flags: Record<string, string | b
   const orgId = flags.org as string;
   
   if (!domain || !orgId) {
-    error("Missing domain or --org flag. Usage: myapi org import <domain> --org <id>");
+    error("Missing required arguments.\nUsage: myapi org import <domain> --org <id>");
     return;
   }
   const config = requireConfig();

package/src/index.ts

@@ -8,6 +8,7 @@ import * as billingCmd from './commands/billing.js';
 import * as orgCmd from './commands/org.js';
 import * as setupCmd from './commands/setup.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));
@@ -58,6 +59,9 @@ async function main() {
       case 'domain':
         await domainCmd.run(subcommand, restArgs, flags);
         break;
+      case 'email':
+        await emailCmd.run(subcommand, restArgs, flags);
+        break;
       default:
         printHelp();
         process.exit(0);
@@ -82,6 +86,7 @@ Commands:
   org          Manage organizations
   setup        Setup CLI credentials and view integration instructions
   domain       Manage domain configurations
+  email        Send emails and manage templates
 
 Run "myapi <command> --help" for subcommand help.`);
 }