@myapihq/cli 1.0.29 → 1.0.39

package/src/commands/billing.ts

@@ -1,6 +1,8 @@
+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) {
@@ -9,12 +11,11 @@ export async function balance(flags: Record<string, string | boolean>) {
   }
   const config = requireConfig();
   const result = await hq.getBalance(config.api_key);
-  
-  const bal = result.balance_display || `$${(result.balance_cents / 100).toFixed(2)}`;
-  const cred = result.credits_display || `$${((result.credits_cents || 0) / 100).toFixed(2)}`;
+
   const pm = result.has_payment_method ? 'yes' : 'no';
-  
-  info(`Balance: ${bal}  |  Credits: ${cred}  |  Payment method: ${pm}`);
+  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: Record<string, string | boolean>) {
@@ -24,52 +25,51 @@ 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 => {
-    // Attempt to parse the date cleanly (handling Go's "+0000 UTC" suffix)
-    const cleanDate = item.created_at.replace(' +0000 UTC', 'Z');
-    const date = new Date(cleanDate);
-    const dateStr = isNaN(date.getTime()) ? item.created_at : date.toLocaleString();
-    
-    // Format amount
-    const isNegative = item.amount_cents < 0;
-    const absAmount = Math.abs(item.amount_cents) / 100;
-    const amountStr = `${isNegative ? '-' : ''}$${absAmount.toFixed(2)}`;
-    
-    return {
-      Type: item.type || 'unknown',
-      Amount: amountStr,
-      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>[]);
 }
 
 export async function topup(amountStr: string, flags: Record<string, string | boolean>) {
   if (flags.help) {
-    info('Usage: myapi billing topup <amount_in_dollars>\n\nAdds funds to your account balance using your saved payment method.\nExample: myapi billing topup 10.00');
+    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_in_dollars>");
+  const amount = Math.round(parseFloat(amountStr));
+  if (!amountStr || isNaN(amount) || amount <= 0) {
+    error("Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)");
     return;
   }
-  const amount = parseFloat(amountStr);
-  if (isNaN(amount)) {
-    error("Invalid amount. Must be a number in dollars (e.g., 10.00)");
-    return;
+
+  if (!flags.yes && !flags.y && amount >= 50) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ans = await new Promise<string>(resolve => rl.question(`› Charge $${amount} to your saved payment method? (y/N) `, resolve));
+    rl.close();
+    if (ans.trim().toLowerCase() !== 'y' && ans.trim().toLowerCase() !== 'yes') {
+      info('Cancelled.');
+      return;
+    }
   }
-  
+
   const config = requireConfig();
-  const result = await hq.topUp(config.api_key, Math.round(amount * 100));
-  success(`Top up successful! New balance: $${(result.new_balance_cents / 100).toFixed(2)}`);
+  const result = await hq.topUp(config.api_key, amount);
+  success(`Top up successful! New balance: ${result.new_balance_display}`);
 }
 
 export async function setup(flags: Record<string, string | boolean>) {

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/commands/setup.ts

@@ -138,13 +138,64 @@ async function anonymousFlow(): Promise<{
 // Main setup command
 // ---------------------------------------------------------------------------
 
-export async function setup() {
+// myapi auth import-key <key> — non-interactively import a raw API key.
+export async function importKey(apiKey: string, flags: Record<string, string | boolean>) {
+  if (!apiKey) {
+    info('Usage: myapi auth import-key <api_key> [--install-skills] [--no-skills]');
+    return;
+  }
+  const auth = { Authorization: `Bearer ${apiKey}` };
+  let accountId = '';
+  let email: string | undefined;
+  let defaultOrg = '';
+  let defaultFunnel = '';
+
+  try {
+    const meRes = await fetch(`${API_BASE}/hq/account/me`, { headers: auth });
+    const meJson = await meRes.json() as any;
+    if (!meRes.ok) throw new Error(meJson.error ?? `HTTP ${meRes.status}`);
+    const me = meJson.data ?? meJson;
+    accountId = me.account_id ?? '';
+    email = me.email || undefined;
+  } catch (e: any) {
+    throw new Error(`Could not verify API key: ${e.message}`);
+  }
+
+  // Fetch org/funnel defaults.
+  try {
+    const orgRes = await fetch(`${API_BASE}/hq/orgs`, { headers: auth });
+    if (orgRes.ok) {
+      const orgs = ((await orgRes.json() as any)?.data ?? []);
+      if (orgs.length > 0) {
+        defaultOrg = orgs[orgs.length - 1].id;
+        const fRes = await fetch(`${API_BASE}/funnel/orgs/${defaultOrg}/funnels`, { headers: auth });
+        if (fRes.ok) {
+          const funnels = ((await fRes.json() as any)?.data ?? []);
+          if (funnels.length > 0) defaultFunnel = funnels[funnels.length - 1].id;
+        }
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  const wantsSkills = flags['install-skills'] ? true : flags['no-skills'] ? false : true;
+
+  addAccount({ api_key: apiKey, account_id: accountId, pin: '', email, default_org: defaultOrg, default_funnel: defaultFunnel, skills_installed: wantsSkills });
+  success(`› ✓ Key imported${email ? ` · ${email}` : ''}`);
+  if (wantsSkills) await installSkills();
+}
+
+export async function setup(flags: Record<string, string | boolean> = {}) {
+  if (flags.help) {
+    info('Usage: myapi auth setup [--anonymous] [--yes] [--install-skills|--no-skills]\n\nFlags:\n  --anonymous       Skip registration, create anonymous account\n  --yes             Skip confirmation prompts\n  --install-skills  Auto-install skills pack\n  --no-skills       Skip skills installation');
+    return;
+  }
+
   info('› Configuring MyAPI…');
 
   const existing = loadConfig();
 
   // Already configured — ask before adding a new account.
-  if (existing?.api_key) {
+  if (existing?.api_key && !flags.yes) {
     const full = loadFullConfig();
     const total = full?.accounts.length ?? 1;
     const activeLabel = existing.email ?? existing.account_id;
@@ -182,8 +233,12 @@ export async function setup() {
   let isAnonymous = false;
   let email = '';
 
+  // Determine skills preference from flags before any prompts.
+  const skillsFromFlag = flags['install-skills'] ? true : flags['no-skills'] ? false : null;
+
   try {
-    const createAns = await ask(rl, '› Create an account? (Y/n) ');
+    const useAnon = flags.anonymous || flags.anon;
+    const createAns = useAnon ? 'n' : await ask(rl, '› Create an account? (Y/n) ');
 
     if (yn(createAns)) {
       const data = await registeredFlow(rl);
@@ -203,8 +258,8 @@ export async function setup() {
       isAnonymous = true;
     }
 
-    const skillsAns = await ask(rl, '› Install the MyAPI skills pack? (Y/n) ');
-    const wantsSkills = yn(skillsAns);
+    const skillsAns = skillsFromFlag !== null ? (skillsFromFlag ? 'y' : 'n') : await ask(rl, '› Install the MyAPI skills pack? (Y/n) ');
+    const wantsSkills = skillsFromFlag !== null ? skillsFromFlag : yn(skillsAns);
 
     addAccount({
       api_key: apiKey,

package/src/commands/update.ts

@@ -1,4 +1,5 @@
 import { execSync } from 'child_process';
+import { loadConfig, saveConfig } from '../config.js';
 import { info, success } from '../output.js';
 import { installSkills } from './setup.js';
 
@@ -16,7 +17,10 @@ export async function checkForUpdate(currentVersion: string): Promise<void> {
     if (latest && isNewer(latest, currentVersion)) {
       info(`\n› New version available (${currentVersion} → ${latest}) — installing…`);
       execSync('npm install -g @myapihq/cli', { stdio: 'pipe' });
-      await installSkills();
+      const config = loadConfig();
+      if (config?.skills_installed) {
+        await installSkills();
+      }
       success(`› MyAPI CLI updated to ${latest}. Re-run your command.\n`);
       process.exit(0);
     }

package/src/config.ts

@@ -57,7 +57,7 @@ export function loadFullConfig(): FullConfig | null {
 
 // loadConfig returns the active account merged with globals — unchanged interface for all callers.
 export function loadConfig(): Config | null {
-  const envKey = process.env.MYAPI_KEY;
+  const envKey = process.env.MYAPI_API_KEY || process.env.MYAPI_KEY;
   const full = loadFullConfig();
 
   if (!full && envKey) return { api_key: envKey, account_id: '', pin: '' };

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);
+}

package/dist/skills/my-api-hq.md

@@ -1,116 +0,0 @@
----
-name: my-api-hq
-description: >
-  Core Identity and Billing hub. Manage auth, organizations (get org_id), and billing (checkout/topup).
----
-
-# MyApiHQ Skill
-Root entry point for the ecosystem. All other skills require an `api_key` and often an `org_id` from here.
-
-## Platform Conventions
-
-### Response Envelope
-Every response across all services is wrapped in:
-```json
-{
-  "success": true,
-  "data": { ... },
-  "error": null,
-  "meta": { "request_id": "...", "latency_ms": 12, "service": "...", "version": "v1" }
-}
-```
-On error, `success` is `false`, `data` is `null`, and `error` contains a string error code or object. Always check `success` before reading `data`.
-
-### Pagination
-List endpoints accept `?limit=` and `?offset=` and return `total`, `limit`, `offset` in the body.
-
-## Authentication & Key Management
-
-You need to go to myapihq.com and register an account. Generate an api key and export it to pass it to the agent (as env).
-
-### Account Login
-```
-POST /hq/account/login
-{ "email": "...", "password": "..." }
-→ { "data": { "token": "<JWT>" } }
-```
-Errors: `401` wrong password.
-
-**Refresh Token:**
-```
-POST /hq/account/refresh
-```
-
-**Google OAuth:**
-- `GET /hq/auth/google/redirect` — Initiates Google OAuth flow.
-- `GET /hq/auth/google/callback` — OAuth callback.
-
-### API Key Management
-**Generate Persistent Key:**
-```
-POST /hq/account/create/key
-Authorization: Bearer <JWT from login>
-{ "name": "MyKey" }
-→ { "data": { "api_key": "hq_live_...", "id": "...", "prefix": "..." } }
-```
-Errors: `401` no auth.
-
-Use `Authorization: Bearer <api_key>` for all subsequent requests across the entire ecosystem.
-
-**List Keys:** `GET /hq/account/keys`
-
-**Revoke Key:** `DELETE /hq/account/delete/key/{id}`
-
-### Cross-Session Storage
-**Always persist credentials immediately.** Write a `.env` file:
-```
-MYAPI_API_KEY=hq_live_...
-MYAPI_ACCOUNT_ID=...
-```
-Also save to agent memory if your runtime supports it (e.g., Claude Code memory). On every new session, check for credentials before creating a new account.
-
-## Organization Management
-**You MUST create an org to get an `org_id` for other APIs.**
-
-### Create Org (sync)
-```
-POST /hq/orgs
-{ "name": "Acme Inc" (required), "tagline", "description", "business_sector",
-  "logo_url", "favicon_url", "og_image_url",
-  "color_palette": { "primary": "#hex", ... },
-  "font_family", "imagery_style", "headline", "subheadline", "cta_text",
-  "value_propositions": ["..."],
-  "social_links": { "twitter": "url", ... },
-  "canonical_url", "privacy_policy_url", "cookie_policy_url", "terms_url",
-  "gdpr_enabled": false, "default_language": "en", "tracking": {} }
-→ { "data": { "id": "<org_id>", ... } }
-```
-Errors: `400` invalid_json · `422` name_required, invalid_field:color_palette, invalid_field:value_propositions, invalid_field:social_links, invalid_field:tracking · `402` insufficient balance (org creation has a cost on paid plan).
-
-### Async Brand Import
-```
-POST /hq/org-imports
-{ "org_id": "<id>" (required), "domain": "example.com" (required), "auto_accept": false }
-→ { "data": { "job_id": "...", "status": "pending" } }
-
-GET /hq/org-imports/{job_id}
-→ Poll until status = "awaiting_confirm". Returns brand_preview.
-
-POST /hq/org-imports/{job_id}/confirm
-{ ...optional overrides matching POST /hq/orgs payload... }
-→ { "data": { "id": "<org_id>", ... } }
-```
-
-### Manage Orgs
-- `GET /hq/orgs` — list all orgs.
-- `GET /hq/orgs/{id}` — get org details. Errors: `404` org_not_found.
-- `PATCH /hq/orgs/{id}` — partial update, same fields as create. Errors: `400` invalid_json · `404` org_not_found · `422` invalid_field:*.
-- `DELETE /hq/orgs/{id}` — delete org and cascade. Errors: `404` org_not_found.
-
-## Billing
-- **Setup Payment Method:** You need to do this from the myapihq dashboard directly.
-- **Check Balance:** `GET /hq/billing/balance` → `{ "data": { "balance_cents": 1000, "balance_display": "$10.00", "credits_cents": 500, "credits_display": "$5.00", "has_payment_method": true } }`.
-- **Billing History:** `GET /hq/billing/history`
-- **Top Up:** `POST /hq/billing/topup` — `{ "amount_cents": 1000 }` → `{ "data": { "new_balance_cents": 2000, "new_balance_display": "$20.00" } }`.
-
-**On 402 from any service:** check balance and top up here before retrying.

package/dist/skills/my-domain-api.md

@@ -1,83 +0,0 @@
----
-name: my-domain-api
-description: >
-  Register new domains, check availability and pricing, import existing domains, and manage edge settings. Use this before creating mailboxes or funnels — both require an owned domain.
----
-
-# MyDomainAPI Skill
-
-## Quick Start
-1. `GET /domain/orgs/{org_id}/list?filter=all` — lists domains owned by your account. `filter` can be `all`, `unassigned`, or `org` (default).
-2. `GET /domain/orgs/{org_id}/check/available/{domain}` — confirm availability and price.
-3. `POST /domain/orgs/{org_id}/register` with `domain` and optional `years`.
-4. Proceed to `my-email-api` for mailboxes or `my-funnel-api` for a website.
-
-DNS is fully managed by the platform — enabling seamless email deliverability, tracking pixel, and edge delivery integration. Manual DNS record management is not exposed.
-
-## Dependencies & Backlinks
-- **Auth & Billing:** 401/402 → fall back to `my-api-hq`.
-- **Next Steps:** After registration → `my-email-api` for mailboxes or `my-funnel-api` for a website.
-
-## Authentication
-`Authorization: Bearer <api_key>` (from `my-api-hq`).
-
-## Endpoints
-
-### Check Availability
-```
-GET /domain/orgs/{org_id}/check/available/{domain}
-→ { "available": true, "price_cents": 1200 }
-```
-Errors: `400` INVALID_DOMAIN, TLD_NOT_SUPPORTED.
-
-### Register Domain
-```
-POST /domain/orgs/{org_id}/register
-{ "domain": "example.com", "years": 1 }
-→ { "domain": "...", "status": "provisioning", "domain_id": "..." }
-```
-Errors: `400` invalid request, INVALID_DOMAIN, TLD_NOT_SUPPORTED · `409` DOMAIN_ALREADY_OWNED, DOMAIN_UNAVAILABLE · `402` INSUFFICIENT_BALANCE (includes `required_cents`) or UPGRADE_REQUIRED (free account) · `403` `already_owned` flag is not permitted.
-
-### Import Existing Domain
-```
-POST /domain/orgs/{org_id}/import
-{ "domain": "example.com", "namecheap_api_user": "optional", "namecheap_api_key": "optional" }
-```
-Sets up DNS and email infrastructure automatically. Optionally updates Namecheap NS if credentials are provided.
-Errors: `402` insufficient balance.
-
-To use Namecheap automation: go to **Profile > Tools > Namecheap API Access**, generate an API Key, and whitelist the MyAPI-HQ server IP — otherwise the API calls will be rejected.
-
-### List & Status
-```
-GET /domain/orgs/{org_id}/list
-GET /domain/orgs/{org_id}/{domain}/status
-```
-Errors (status): `404` DOMAIN_NOT_FOUND.
-
-### Assign / Unassign Domain
-```
-POST /domain/orgs/{org_id}/{domain}/assign
-{ "org_id": "<target_org_id>" } // Pass null to unassign
-```
-Associates a domain already in the account with a specific organization, or removes it from its current organization if `org_id` is null.
-Errors: `404` DOMAIN_NOT_FOUND · `422` ORG_NOT_FOUND.
-
-### Edge Settings
-
-**Update:**
-```
-POST /domain/orgs/{org_id}/{domain}/settings
-{
-  "security_level": "essentially_off",  // essentially_off | medium | high | under_attack
-  "browser_check": "off",               // on | off
-  "purge_cache": true
-}
-```
-*To allow AI training bots and crawlers: set `security_level: "essentially_off"` and `browser_check: "off"`.*
-
-**Get:**
-```
-GET /domain/orgs/{org_id}/{domain}/settings
-→ { "domain": "...", "security_level": "...", "browser_check": "...", "ai_bots_protection": "disabled", "is_robots_txt_managed": false }
-```