@myapihq/cli 1.0.37 → 1.0.39

package/dist/commands/auth.js

@@ -2,6 +2,7 @@ import * as readline from 'readline';
 import { loadConfig, saveConfig, addAccount, switchAccount, listAccounts } from '../config.js';
 import { info, success, error } from '../output.js';
 import { installSkills } from './setup.js';
+import { hq } from '@myapihq/sdk';
 const API_BASE = process.env.MYAPI_API_BASE ?? 'https://api.myapihq.com';
 function ask(rl, q) {
     return new Promise(resolve => rl.question(q, resolve));
@@ -114,6 +115,13 @@ export async function whoami() {
     info(`Org:      ${config.default_org ?? '(none)'}`);
     info(`Funnel:   ${config.default_funnel ?? '(none)'}`);
     info(`Type:     ${config.is_anonymous ? 'anonymous' : 'registered'}`);
+    try {
+        const bal = await hq.getBalance(config.api_key);
+        info(`Balance:  ${bal.balance_display}  |  Credits: ${bal.credits_display}`);
+    }
+    catch {
+        // Balance fetch is best-effort; don't fail whoami if it errors.
+    }
 }
 // myapi auth switch — switch between saved accounts.
 export async function switchCmd() {

package/dist/commands/billing.js

@@ -2,6 +2,7 @@ import * as readline from 'readline';
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
+import { formatDate } from '../utils.js';
 export async function balance(flags) {
     if (flags.help) {
         info('Usage: myapi billing balance\n\nShows your current account balance, credits, and payment method status.');
@@ -10,6 +11,8 @@ export async function balance(flags) {
     const config = requireConfig();
     const result = await hq.getBalance(config.api_key);
     const pm = result.has_payment_method ? 'yes' : 'no';
+    const accountType = config.is_anonymous ? 'anonymous' : `registered (${config.email ?? ''})`;
+    info(`Account: ${accountType}`);
     info(`Balance: ${result.balance_display}  |  Credits: ${result.credits_display}  |  Payment method: ${pm}`);
 }
 export async function history(flags) {
@@ -23,17 +26,16 @@ export async function history(flags) {
         printJson(items);
         return;
     }
-    const formattedItems = items.map(item => {
-        const cleanDate = item.created_at.replace(' +0000 UTC', 'Z');
-        const date = new Date(cleanDate);
-        const dateStr = isNaN(date.getTime()) ? item.created_at : date.toLocaleString();
-        return {
-            Type: item.type || 'unknown',
-            Amount: item.amount_display,
-            Status: item.status ? item.status.charAt(0).toUpperCase() + item.status.slice(1) : '',
-            Date: dateStr,
-        };
-    });
+    if (items.length === 0) {
+        info('No transactions yet.');
+        return;
+    }
+    const formattedItems = items.map(item => ({
+        Type: item.type || 'unknown',
+        Amount: item.amount_display,
+        Status: item.status ? item.status.charAt(0).toUpperCase() + item.status.slice(1) : '',
+        Date: formatDate(item.created_at),
+    }));
     printTable(formattedItems);
 }
 export async function topup(amountStr, flags) {
@@ -41,13 +43,9 @@ export async function topup(amountStr, flags) {
         info('Usage: myapi billing topup <amount>\n\nAmount is in whole dollars (e.g. "10" charges $10).\nUse --yes to skip confirmation.\nExample: myapi billing topup 10');
         return;
     }
-    if (!amountStr) {
-        error("Missing amount. Usage: myapi billing topup <amount>\nExample: myapi billing topup 10");
-        return;
-    }
     const amount = Math.round(parseFloat(amountStr));
-    if (isNaN(amount) || amount <= 0) {
-        error("Invalid amount. Must be a positive whole number of dollars (e.g. 10)");
+    if (!amountStr || isNaN(amount) || amount <= 0) {
+        error("Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)");
         return;
     }
     if (!flags.yes && !flags.y && amount >= 50) {

package/dist/commands/domain.d.ts

@@ -4,6 +4,7 @@ export declare function importDomain(domainArg: string, flags: Record<string, st
 export declare function list(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 status(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

@@ -6,13 +6,14 @@ export async function check(domainArg, flags) {
     const orgId = flags.org || config.default_org;
     const domain = domainArg || config.default_domain;
     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>)");
+        error("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>\n(Or set defaults via: myapi auth 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`);
+        const price = res.price_display || `$${(res.price_cents / 100).toFixed(2)}`;
+        info(`${domain} — Available ✓  ${price}/yr`);
     }
     else {
-        info(`Not available ✗`);
+        info(`${domain} — ${res.message || 'Not available'} ✗`);
     }
 }
 export async function register(domainArg, flags) {
@@ -20,7 +21,7 @@ export async function register(domainArg, flags) {
     const orgId = flags.org || config.default_org;
     const domain = domainArg || config.default_domain;
     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>)");
+        error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
     const years = parseInt(flags.years) || 1;
     const res = await sdkDomain.registerDomain(config.api_key, orgId, domain, years);
     success(`Registered ${domain}!\n${JSON.stringify(res, null, 2)}`);
@@ -30,7 +31,7 @@ export async function importDomain(domainArg, flags) {
     const orgId = flags.org || config.default_org;
     const domain = domainArg || config.default_domain;
     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>)");
+        error("Missing required arguments.\nUsage: myapi domain import <domain> --org <id> [--namecheap-user <user> --namecheap-key <key>]\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
     const payload = { domain };
     if (flags['namecheap-user'])
         payload.namecheap_api_user = flags['namecheap-user'];
@@ -43,7 +44,7 @@ export async function list(flags) {
     const config = requireConfig();
     const orgId = flags.org || 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>)");
+        error("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]\n(Or set a default org via: myapi auth config set-org <id>)");
     const filter = flags.filter;
     const domains = await sdkDomain.listDomains(config.api_key, orgId, filter);
     printTable(domains);
@@ -54,8 +55,8 @@ export async function assign(domainArg, flags) {
     const domain = domainArg || config.default_domain;
     const targetOrgId = flags.target;
     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);
+        error("Missing required arguments.\nUsage: myapi domain assign <domain> --org <id> --target <target_org_id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
+    await sdkDomain.assignDomain(config.api_key, orgId, domain, targetOrgId);
     success(`Assigned ${domain} to org ${targetOrgId}`);
 }
 export async function unassign(domainArg, flags) {
@@ -63,16 +64,31 @@ export async function unassign(domainArg, flags) {
     const orgId = flags.org || config.default_org;
     const domain = domainArg || config.default_domain;
     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);
+        error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
+    await sdkDomain.unassignDomain(config.api_key, orgId, domain);
     success(`Unassigned ${domain} from org ${orgId}`);
 }
+export async function status(domainArg, flags) {
+    const config = requireConfig();
+    const orgId = flags.org || config.default_org;
+    const domain = domainArg || config.default_domain;
+    if (!orgId || !domain)
+        error("Missing required arguments.\nUsage: myapi domain status <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
+    const res = await sdkDomain.getDomainStatus(config.api_key, orgId, domain);
+    const display = {
+        domain: res.domain,
+        status: res.status,
+    };
+    if (res.expires_at)
+        display.expires_at = res.expires_at;
+    printJson(display);
+}
 export async function settings(domainArg, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
     const domain = domainArg || config.default_domain;
     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>)");
+        error("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
     const res = await sdkDomain.getDomainSettings(config.api_key, orgId, domain);
     printJson(res);
 }
@@ -81,7 +97,7 @@ export async function updateSettings(domainArg, flags) {
     const orgId = flags.org || config.default_org;
     const domain = domainArg || config.default_domain;
     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>)");
+        error("Missing required arguments.\nUsage: myapi domain update-settings <domain> --org <id> [--security=...] [--browser-check=...] [--purge-cache]\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
     const payload = {};
     if (flags.security)
         payload.security_level = flags.security;
@@ -94,7 +110,7 @@ export async function updateSettings(domainArg, flags) {
 }
 export async function run(subcommand, args, flags) {
     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  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.');
+        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  status           Get domain status\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) {
@@ -110,6 +126,8 @@ export async function run(subcommand, args, flags) {
             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 === 'status')
+            info('Usage: myapi domain status <domain> --org <id>\n\nGets the registration status of a domain.');
         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')
@@ -128,6 +146,8 @@ export async function run(subcommand, args, flags) {
         await assign(args[0], flags);
     else if (subcommand === 'unassign')
         await unassign(args[0], flags);
+    else if (subcommand === 'status')
+        await status(args[0], flags);
     else if (subcommand === 'settings')
         await settings(args[0], flags);
     else if (subcommand === 'update-settings')

package/dist/commands/org.js

@@ -1,7 +1,7 @@
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printJson, info } from '../output.js';
-import { sleep } from '../utils.js';
+import { success, error, printTable, printJson, info } from '../output.js';
+import { sleep, formatDate } from '../utils.js';
 export async function create(flags) {
     if (flags.help) {
         info('Usage: myapi org create --name="My Org" [options]\n\nOptions:\n  --name              Organization name (required)\n  --tagline           Short tagline\n  --description       Detailed description\n  --business-sector   Sector (e.g. Technology)\n  --logo-url          URL to logo image');
@@ -29,12 +29,17 @@ export async function create(flags) {
 }
 export async function list(flags) {
     if (flags.help) {
-        info('Usage: myapi org list\n\nLists all organizations in your account as JSON.');
+        info('Usage: myapi org list\n\nLists all organizations in your account.');
         return;
     }
     const config = requireConfig();
     const orgs = await hq.listOrgs(config.api_key);
-    printJson(orgs);
+    const rows = orgs.map((o) => ({
+        id: o.id,
+        name: o.name,
+        created_at: o.created_at ? formatDate(o.created_at) : '',
+    }));
+    printTable(rows);
 }
 export async function get(id, flags) {
     if (flags.help) {

package/dist/utils.d.ts

@@ -3,3 +3,8 @@ export declare function parseArgs(argv: string[]): {
     flags: Record<string, string | boolean>;
 };
 export declare function sleep(ms: number): Promise<unknown>;
+/**
+ * Formats an ISO/Go timestamp string to "YYYY-MM-DD HH:mm" (UTC).
+ * Strips Go's " +0000 UTC" suffix before parsing.
+ */
+export declare function formatDate(str: string): string;

package/dist/utils.js

@@ -28,3 +28,14 @@ export function parseArgs(argv) {
 export function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Formats an ISO/Go timestamp string to "YYYY-MM-DD HH:mm" (UTC).
+ * Strips Go's " +0000 UTC" suffix before parsing.
+ */
+export function formatDate(str) {
+    const clean = str.replace(' +0000 UTC', 'Z');
+    const date = new Date(clean);
+    if (isNaN(date.getTime()))
+        return str;
+    return date.toISOString().replace('T', ' ').slice(0, 16);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myapihq/cli",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "description": "MyAPI command-line interface",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/auth.ts

@@ -3,6 +3,7 @@ import * as readline from 'readline';
 import { loadConfig, saveConfig, addAccount, switchAccount, listAccounts } from '../config.js';
 import { info, success, error } from '../output.js';
 import { installSkills } from './setup.js';
+import { hq } from '@myapihq/sdk';
 
 const API_BASE = process.env.MYAPI_API_BASE ?? 'https://api.myapihq.com';
 
@@ -121,6 +122,13 @@ export async function whoami() {
   info(`Org:      ${config!.default_org ?? '(none)'}`);
   info(`Funnel:   ${config!.default_funnel ?? '(none)'}`);
   info(`Type:     ${config!.is_anonymous ? 'anonymous' : 'registered'}`);
+
+  try {
+    const bal = await hq.getBalance(config!.api_key);
+    info(`Balance:  ${bal.balance_display}  |  Credits: ${bal.credits_display}`);
+  } catch {
+    // Balance fetch is best-effort; don't fail whoami if it errors.
+  }
 }
 
 // myapi auth switch — switch between saved accounts.

package/src/commands/billing.ts

@@ -2,6 +2,7 @@ import * as readline from 'readline';
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
+import { formatDate } from '../utils.js';
 
 export async function balance(flags: Record<string, string | boolean>) {
   if (flags.help) {
@@ -10,8 +11,10 @@ export async function balance(flags: Record<string, string | boolean>) {
   }
   const config = requireConfig();
   const result = await hq.getBalance(config.api_key);
-  
+
   const pm = result.has_payment_method ? 'yes' : 'no';
+  const accountType = config.is_anonymous ? 'anonymous' : `registered (${config.email ?? ''})`;
+  info(`Account: ${accountType}`);
   info(`Balance: ${result.balance_display}  |  Credits: ${result.credits_display}  |  Payment method: ${pm}`);
 }
 
@@ -22,24 +25,24 @@ export async function history(flags: Record<string, string | boolean>) {
   }
   const config = requireConfig();
   const items = await hq.getBillingHistory(config.api_key);
-  
+
   if (flags.json) {
     printJson(items);
     return;
   }
-  
-  const formattedItems = items.map(item => {
-    const cleanDate = item.created_at.replace(' +0000 UTC', 'Z');
-    const date = new Date(cleanDate);
-    const dateStr = isNaN(date.getTime()) ? item.created_at : date.toLocaleString();
-    return {
-      Type: item.type || 'unknown',
-      Amount: item.amount_display,
-      Status: item.status ? item.status.charAt(0).toUpperCase() + item.status.slice(1) : '',
-      Date: dateStr,
-    };
-  });
-  
+
+  if (items.length === 0) {
+    info('No transactions yet.');
+    return;
+  }
+
+  const formattedItems = items.map(item => ({
+    Type: item.type || 'unknown',
+    Amount: item.amount_display,
+    Status: item.status ? item.status.charAt(0).toUpperCase() + item.status.slice(1) : '',
+    Date: formatDate(item.created_at),
+  }));
+
   printTable(formattedItems as unknown as Record<string, unknown>[]);
 }
 
@@ -48,13 +51,9 @@ export async function topup(amountStr: string, flags: Record<string, string | bo
     info('Usage: myapi billing topup <amount>\n\nAmount is in whole dollars (e.g. "10" charges $10).\nUse --yes to skip confirmation.\nExample: myapi billing topup 10');
     return;
   }
-  if (!amountStr) {
-    error("Missing amount. Usage: myapi billing topup <amount>\nExample: myapi billing topup 10");
-    return;
-  }
   const amount = Math.round(parseFloat(amountStr));
-  if (isNaN(amount) || amount <= 0) {
-    error("Invalid amount. Must be a positive whole number of dollars (e.g. 10)");
+  if (!amountStr || isNaN(amount) || amount <= 0) {
+    error("Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)");
     return;
   }
 

package/src/commands/domain.ts

@@ -6,12 +6,13 @@ export async function check(domainArg: string, flags: Record<string, string | bo
   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 (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain check <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
+  const res = await sdkDomain.checkDomain(config.api_key, orgId, domain) as { available: boolean; price_cents: number; price_display?: string; message?: string };
   if (res.available) {
-    info(`${domain} — Available ✓  Price: $${(res.price_cents / 100).toFixed(2)}/yr`);
+    const price = res.price_display || `$${(res.price_cents / 100).toFixed(2)}`;
+    info(`${domain} — Available ✓  ${price}/yr`);
   } else {
-    info(`Not available ✗`);
+    info(`${domain} — ${res.message || 'Not available'} ✗`);
   }
 }
 
@@ -19,7 +20,7 @@ export async function register(domainArg: string, flags: Record<string, string |
   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>)");
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain register <domain> --org <id> [--years <num>]\n(Or set defaults via: myapi auth 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)}`);
@@ -29,7 +30,7 @@ export async function importDomain(domainArg: string, flags: Record<string, stri
   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 (!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 auth config set-org <id> / set-domain <domain>)");
   const payload: { domain: string; namecheap_api_user?: string; namecheap_api_key?: string } = { domain };
   if (flags['namecheap-user']) payload.namecheap_api_user = flags['namecheap-user'] as string;
   if (flags['namecheap-key']) payload.namecheap_api_key = flags['namecheap-key'] as string;
@@ -40,7 +41,7 @@ export async function importDomain(domainArg: string, flags: Record<string, stri
 export async function list(flags: Record<string, string | boolean>) {
   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>)");
+  if (!orgId) error("Missing required arguments.\nUsage: myapi domain list --org <id> [--filter=all|unassigned|org]\n(Or set a default org via: myapi auth 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>[]);
@@ -51,8 +52,8 @@ export async function assign(domainArg: string, flags: Record<string, string | b
   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);
+  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 auth config set-org <id> / set-domain <domain>)");
+  await sdkDomain.assignDomain(config.api_key, orgId, domain, targetOrgId);
   success(`Assigned ${domain} to org ${targetOrgId}`);
 }
 
@@ -60,16 +61,30 @@ export async function unassign(domainArg: string, flags: Record<string, string |
   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);
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain unassign <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
+  await sdkDomain.unassignDomain(config.api_key, orgId, domain);
   success(`Unassigned ${domain} from org ${orgId}`);
 }
 
+export async function status(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 status <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
+  const res = await sdkDomain.getDomainStatus(config.api_key, orgId, domain);
+  const display: Record<string, unknown> = {
+    domain: res.domain,
+    status: res.status,
+  };
+  if (res.expires_at) display.expires_at = res.expires_at;
+  printJson(display);
+}
+
 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>)");
+  if (!orgId || !domain) error("Missing required arguments.\nUsage: myapi domain settings <domain> --org <id>\n(Or set defaults via: myapi auth config set-org <id> / set-domain <domain>)");
   const res = await sdkDomain.getDomainSettings(config.api_key, orgId, domain);
   printJson(res);
 }
@@ -78,22 +93,22 @@ export async function updateSettings(domainArg: string, flags: Record<string, st
   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>)");
+  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 auth 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;
   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  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.');
+    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  status           Get domain status\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) {
     if (subcommand === 'list') info('Usage: myapi domain list --org <id> [--filter=all|unassigned|org]\n\nLists all registered domains in your account.\n  --filter=all        Lists all domains owned by the account.\n  --filter=unassigned Lists domains not assigned to an org.\n  --filter=org        (Default) Lists domains assigned to the current org.');
     else if (subcommand === 'check') info('Usage: myapi domain check <domain> --org <id>\n\nChecks if a domain name is available for registration.');
@@ -101,6 +116,7 @@ export async function run(subcommand: string | undefined, args: string[], flags:
     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 === 'status') info('Usage: myapi domain status <domain> --org <id>\n\nGets the registration status of a domain.');
     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;
@@ -112,6 +128,7 @@ export async function run(subcommand: string | undefined, args: string[], 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 === 'status') await status(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/org.ts

@@ -1,7 +1,7 @@
 import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, printJson, info } from '../output.js';
-import { sleep } from '../utils.js';
+import { sleep, formatDate } from '../utils.js';
 
 export async function create(flags: Record<string, string | boolean>) {
   if (flags.help) {
@@ -18,7 +18,7 @@ export async function create(flags: Record<string, string | boolean>) {
   if (flags.description) payload.description = flags.description as string;
   if (flags['business-sector']) payload.business_sector = flags['business-sector'] as string;
   if (flags['logo-url']) payload.logo_url = flags['logo-url'] as string;
-  
+
   const org = await hq.createOrg(config.api_key, payload);
   success(`Org created! ID: ${org.id}, Name: ${org.name}`);
   if (org.preview_subdomain) {
@@ -28,12 +28,17 @@ export async function create(flags: Record<string, string | boolean>) {
 
 export async function list(flags: Record<string, string | boolean>) {
   if (flags.help) {
-    info('Usage: myapi org list\n\nLists all organizations in your account as JSON.');
+    info('Usage: myapi org list\n\nLists all organizations in your account.');
     return;
   }
   const config = requireConfig();
   const orgs = await hq.listOrgs(config.api_key);
-  printJson(orgs);
+  const rows = orgs.map((o: any) => ({
+    id: o.id,
+    name: o.name,
+    created_at: o.created_at ? formatDate(o.created_at) : '',
+  }));
+  printTable(rows as unknown as Record<string, unknown>[]);
 }
 
 export async function get(id: string, flags: Record<string, string | boolean>) {
@@ -75,19 +80,19 @@ export async function importOrg(args: string[], flags: Record<string, string | b
   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>\n(Or set defaults via: myapi config set-org <id> / set-domain <domain>)");
     return;
   }
-  
+
   const result = await hq.importOrg(config.api_key, orgId, domain);
   const importId = result.job_id;
-  
+
   process.stdout.write("Importing ");
   const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
   let i = 0;
-  
+
   while (true) {
     const status = await hq.getOrgImportStatus(config.api_key, importId);
     if (status.status === 'awaiting_confirm') {
@@ -101,7 +106,7 @@ export async function importOrg(args: string[], flags: Record<string, string | b
     process.stdout.write(`\rImporting ${chars[i++ % chars.length]}`);
     await sleep(3000);
   }
-  
+
   const org = await hq.confirmOrgImport(config.api_key, importId);
   success(`Import complete! Org ID: ${org.id}`);
 }

package/src/utils.ts

@@ -28,3 +28,14 @@ export function parseArgs(argv: string[]) {
 export function sleep(ms: number) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
+
+/**
+ * Formats an ISO/Go timestamp string to "YYYY-MM-DD HH:mm" (UTC).
+ * Strips Go's " +0000 UTC" suffix before parsing.
+ */
+export function formatDate(str: string): string {
+  const clean = str.replace(' +0000 UTC', 'Z');
+  const date = new Date(clean);
+  if (isNaN(date.getTime())) return str;
+  return date.toISOString().replace('T', ' ').slice(0, 16);
+}