@myapihq/cli 1.0.0

package/dist/config.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.requireConfig = requireConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = path.join(os.homedir(), '.myapi');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE)) {
+            return null;
+        }
+        const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (err) {
+        return null;
+    }
+}
+function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+function requireConfig() {
+    const config = loadConfig();
+    if (!config || !config.api_key) {
+        console.error("No API key found. Run: myapi account create");
+        process.exit(1);
+    }
+    return config;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("./utils.js");
+const output_js_1 = require("./output.js");
+const sdk_1 = require("@myapihq/sdk");
+const accountCmd = __importStar(require("./commands/account.js"));
+const billingCmd = __importStar(require("./commands/billing.js"));
+async function main() {
+    const { args, flags } = (0, utils_js_1.parseArgs)(process.argv.slice(2));
+    if (args.length === 0) {
+        printHelp();
+        process.exit(0);
+    }
+    const [command, subcommand, ...restArgs] = args;
+    try {
+        switch (command) {
+            case 'account':
+                if (subcommand === 'create')
+                    await accountCmd.create();
+                else if (subcommand === 'token')
+                    await accountCmd.token(flags);
+                else if (subcommand === 'keys')
+                    await accountCmd.listKeys(flags);
+                else if (subcommand === 'revoke')
+                    await accountCmd.revokeKey(restArgs[0], flags);
+                else
+                    printHelp();
+                break;
+            case 'billing':
+                if (subcommand === 'balance')
+                    await billingCmd.balance(flags);
+                else if (subcommand === 'history')
+                    await billingCmd.history(flags);
+                else if (subcommand === 'topup')
+                    await billingCmd.topup(restArgs[0], flags);
+                else if (subcommand === 'setup')
+                    await billingCmd.setup(flags);
+                else
+                    printHelp();
+                break;
+            default:
+                printHelp();
+                process.exit(0);
+        }
+    }
+    catch (err) {
+        if (err instanceof sdk_1.MyApiError) {
+            if (err.status === 402) {
+                (0, output_js_1.error)("Insufficient balance. Run: myapi billing topup <amount>");
+            }
+            else if (err.status === 401) {
+                (0, output_js_1.error)("Invalid API key. Run: myapi account create");
+            }
+        }
+        (0, output_js_1.error)(err.message || String(err));
+    }
+}
+function printHelp() {
+    (0, output_js_1.info)(`myapi - MyAPI command-line interface
+
+Usage: myapi <command> [subcommand] [args]
+
+Commands:
+  account   Manage your account and API keys
+  billing   Check balance and top up
+
+Run "myapi <command>" for subcommand help.`);
+}
+main().catch(err => {
+    (0, output_js_1.error)(err.message || String(err));
+});

package/dist/output.d.ts

@@ -0,0 +1,5 @@
+export declare function success(message: string): void;
+export declare function error(message: string): never;
+export declare function info(message: string): void;
+export declare function printJson(data: unknown): void;
+export declare function printTable(rows: Record<string, unknown>[]): void;

package/dist/output.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.error = error;
+exports.info = info;
+exports.printJson = printJson;
+exports.printTable = printTable;
+function success(message) {
+    console.log(`\x1b[32m✓\x1b[0m ${message}`);
+}
+function error(message) {
+    console.error(`\x1b[31m✗\x1b[0m ${message}`);
+    process.exit(1);
+}
+function info(message) {
+    console.log(message);
+}
+function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function printTable(rows) {
+    if (process.argv.includes('--json')) {
+        printJson(rows);
+        return;
+    }
+    if (rows.length === 0) {
+        console.log("No data found.");
+        return;
+    }
+    const columns = Object.keys(rows[0]);
+    const colWidths = columns.map(col => {
+        return Math.max(col.length, ...rows.map(row => String(row[col] ?? '').length));
+    });
+    const printRow = (row) => {
+        console.log(row.map((cell, i) => cell.padEnd(colWidths[i] + 2)).join(''));
+    };
+    printRow(columns);
+    console.log(colWidths.map(w => '-'.repeat(w + 2)).join(''));
+    for (const row of rows) {
+        printRow(columns.map(col => String(row[col] ?? '')));
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function parseArgs(argv: string[]): {
+    args: string[];
+    flags: Record<string, string | boolean>;
+};
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.sleep = sleep;
+function parseArgs(argv) {
+    const args = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            if (arg.includes('=')) {
+                const [key, value] = arg.slice(2).split('=', 2);
+                flags[key] = value;
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith('--')) {
+                    flags[arg.slice(2)] = next;
+                    i++;
+                }
+                else {
+                    flags[arg.slice(2)] = true;
+                }
+            }
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return { args, flags };
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@myapihq/cli",
+  "version": "1.0.0",
+  "description": "MyAPI command-line interface",
+  "main": "dist/index.js",
+  "bin": {
+    "myapi": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "@myapihq/sdk": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "typescript": "^5.4.0"
+  }
+}

package/src/commands/account.ts

@@ -0,0 +1,48 @@
+import { hq } from '@myapihq/sdk';
+import { saveConfig, requireConfig } from '../config.js';
+import { success, error, printTable } from '../output.js';
+import * as readline from 'readline';
+
+export async function create() {
+  const agent = await hq.createAgentAccount();
+  const keyInfo = await hq.createApiKey(agent.token, 'default');
+  
+  saveConfig({
+    api_key: keyInfo.api_key,
+    account_id: agent.account_id,
+    pin: agent.pin
+  });
+
+  success(`Account created!\n\nAPI Key:    ${keyInfo.api_key}\nAccount ID: ${agent.account_id}\nPIN:        ${agent.pin}\n\nCredentials saved to ~/.myapi/config.json\nKeep your PIN safe — it's the only way to recover your account.`);
+}
+
+export async function token(flags: Record<string, string | boolean>) {
+  let pin = flags.pin as string;
+  if (!pin) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    pin = await new Promise<string>(resolve => rl.question('Enter PIN: ', resolve));
+    rl.close();
+  }
+
+  const result = await hq.recoverAgentToken(pin);
+  const keyInfo = await hq.createApiKey(result.token, 'recovered');
+  
+  const config = requireConfig();
+  config.api_key = keyInfo.api_key;
+  saveConfig(config);
+  
+  success(`Token recovered! New API Key: ${keyInfo.api_key}`);
+}
+
+export async function listKeys(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const keys = await hq.listApiKeys(config.api_key);
+  printTable(keys as unknown as Record<string, unknown>[]);
+}
+
+export async function revokeKey(id: string, flags: Record<string, string | boolean>) {
+  if (!id) error("Missing key id");
+  const config = requireConfig();
+  await hq.revokeApiKey(config.api_key, id);
+  success(`Key ${id} revoked`);
+}

package/src/commands/billing.ts

@@ -0,0 +1,31 @@
+import { hq } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, info } from '../output.js';
+
+export async function balance(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const result = await hq.getBalance(config.api_key);
+  info(`Balance: $${(result.balance_cents / 100).toFixed(2)}  |  Payment method: ${result.has_payment_method ? 'yes' : 'no'}`);
+}
+
+export async function history(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const items = await hq.getBillingHistory(config.api_key);
+  printTable(items as unknown as Record<string, unknown>[]);
+}
+
+export async function topup(amountStr: string, flags: Record<string, string | boolean>) {
+  if (!amountStr) error("Missing amount");
+  const amount = parseFloat(amountStr);
+  if (isNaN(amount)) error("Invalid amount");
+  
+  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)}`);
+}
+
+export async function setup(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const result = await hq.setupPayment(config.api_key);
+  success(`Open this URL in your browser to set up payment:\n${result.url}`);
+}

package/src/commands/domain.ts

@@ -0,0 +1,49 @@
+import { domain as sdkDomain } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printTable, printJson } from '../output.js';
+
+export async function check(domain: string, flags: Record<string, string | boolean>) {
+  if (!domain) error("Missing domain");
+  const config = requireConfig();
+  const res = await sdkDomain.checkDomain(config.api_key, domain);
+  if (res.available) {
+    info(`${domain} — Available ✓  Price: $${(res.price_cents / 100).toFixed(2)}/yr`);
+  } else {
+    info(`Not available ✗`);
+  }
+}
+
+export async function register(domain: string, flags: Record<string, string | boolean>) {
+  if (!domain) error("Missing domain");
+  const years = parseInt(flags.years as string) || 1;
+  const config = requireConfig();
+  const res = await sdkDomain.registerDomain(config.api_key, domain, years);
+  success(`Registered ${domain}!\n${JSON.stringify(res, null, 2)}`);
+}
+
+export async function importDomain(domain: string, flags: Record<string, string | boolean>) {
+  if (!domain) error("Missing domain");
+  if (!flags['namecheap-user'] || !flags['namecheap-key']) {
+    error("Missing --namecheap-user or --namecheap-key flags");
+  }
+  const config = requireConfig();
+  await sdkDomain.importDomain(config.api_key, {
+    domain,
+    namecheap_api_user: flags['namecheap-user'] as string,
+    namecheap_api_key: flags['namecheap-key'] as string
+  });
+  success(`Imported ${domain}`);
+}
+
+export async function list(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const domains = await sdkDomain.listDomains(config.api_key);
+  printTable(domains as unknown as Record<string, unknown>[]);
+}
+
+export async function settings(domain: string, flags: Record<string, string | boolean>) {
+  if (!domain) error("Missing domain");
+  const config = requireConfig();
+  const res = await sdkDomain.getDomainSettings(config.api_key, domain);
+  printJson(res);
+}

package/src/commands/email.ts

@@ -0,0 +1,93 @@
+import { email as sdkEmail } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, printJson } 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 config = requireConfig();
+  const address = await sdkEmail.createMailbox(config.api_key, flags.domain as string, flags.username as string);
+  success(`Mailbox created: ${address.address}`);
+}
+
+export async function listMailboxes(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const mailboxes = await sdkEmail.listMailboxes(config.api_key);
+  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 config = requireConfig();
+  const res = await sdkEmail.sendEmail(config.api_key, {
+    from: flags.from as string,
+    to: [flags.to as string],
+    subject: flags.subject as string,
+    text: flags.body as string
+  });
+  success(`Email sent! Message ID: ${res.message_id}`);
+}
+
+export async function inbox(address: string, flags: Record<string, string | boolean>) {
+  if (!address) error("Missing address");
+  const config = requireConfig();
+  const messages = await sdkEmail.getInbox(config.api_key, address);
+  printTable(messages as unknown as Record<string, unknown>[]);
+}
+
+export async function listTemplates(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const templates = await sdkEmail.listTemplates(config.api_key);
+  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 config = requireConfig();
+  
+  const job = await sdkEmail.generateTemplate(config.api_key, {
+    org_id: flags['org-id'] as string,
+    prompt: flags.prompt as string,
+    name: flags.name as string
+  });
+  
+  process.stdout.write("Generating template ");
+  const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let elapsed = 0;
+  
+  while (elapsed < 90000) {
+    const status = await sdkEmail.getTemplateJobStatus(config.api_key, 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}`);
+      return;
+    }
+    if (status.status === 'failed') {
+      process.stdout.write('\r\x1b[K');
+      error("Template generation failed");
+    }
+    process.stdout.write(`\rGenerating template ${chars[i++ % chars.length]}`);
+    await sleep(3000);
+    elapsed += 3000;
+  }
+  process.stdout.write('\r\x1b[K');
+  error("Template generation timed out");
+}
+
+export async function listCampaigns(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const campaigns = await sdkEmail.listCampaigns(config.api_key);
+  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 config = requireConfig();
+  const stats = await sdkEmail.getCampaignStats(config.api_key, id);
+  printJson(stats);
+}

package/src/commands/funnel.ts

@@ -0,0 +1,37 @@
+import { funnel as sdkFunnel } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable } from '../output.js';
+import * as fs from 'fs';
+
+export async function list(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const funnels = await sdkFunnel.listFunnels(config.api_key);
+  printTable(funnels as unknown as Record<string, unknown>[]);
+}
+
+export async function create(flags: Record<string, string | boolean>) {
+  if (!flags['org-id'] || !flags.domain) {
+    error("Missing --org-id or --domain flags");
+  }
+  const config = requireConfig();
+  const funnel = await sdkFunnel.createFunnel(config.api_key, flags['org-id'] as string, flags.domain as string);
+  success(`Funnel created! ID: ${funnel.id}`);
+}
+
+export async function push(id: string, slug: string, flags: Record<string, string | boolean>) {
+  if (!id || !slug) error("Missing id or slug");
+  const config = requireConfig();
+  
+  const html = await new Promise<string>((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+
+  if (!html) error("No HTML provided via stdin");
+
+  await sdkFunnel.pushPage(config.api_key, id, slug, html);
+  success(`Pushed page to ${slug}`);
+}

package/src/commands/image.ts

@@ -0,0 +1,45 @@
+import { image as sdkImage } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable } from '../output.js';
+import { sleep } from '../utils.js';
+
+export async function generate(flags: Record<string, string | boolean>) {
+  if (!flags.prompt) error("Missing --prompt flag");
+  const config = requireConfig();
+  
+  const payload: any = { prompt: flags.prompt as string };
+  if (flags.ratio) payload.aspect_ratio = flags.ratio as string;
+  if (flags.style) payload.style = flags.style as string;
+  if (flags.colors) payload.colors = flags.colors as string;
+  
+  const res = await sdkImage.generateImage(config.api_key, payload);
+  
+  process.stdout.write("Generating image ");
+  const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let elapsed = 0;
+  
+  while (elapsed < 60000) {
+    const job = await sdkImage.getImageJob(config.api_key, res.job_id);
+    if (job.status === 'completed') {
+      process.stdout.write('\r\x1b[K');
+      success(`Image generated!\nURL: ${job.url}`);
+      return;
+    }
+    if (job.status === 'failed') {
+      process.stdout.write('\r\x1b[K');
+      error(`Image generation failed: ${job.error || 'Unknown error'}`);
+    }
+    process.stdout.write(`\rGenerating image ${chars[i++ % chars.length]}`);
+    await sleep(3000);
+    elapsed += 3000;
+  }
+  process.stdout.write('\r\x1b[K');
+  error("Image generation timed out");
+}
+
+export async function list(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const images = await sdkImage.listImages(config.api_key);
+  printTable(images as unknown as Record<string, unknown>[]);
+}

package/src/commands/org.ts

@@ -0,0 +1,64 @@
+import { hq } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, printJson } from '../output.js';
+import { sleep } from '../utils.js';
+
+export async function create(flags: Record<string, string | boolean>) {
+  if (!flags.name) error("Missing --name flag");
+  const config = requireConfig();
+  const payload: any = { name: flags.name as string };
+  if (flags.tagline) payload.tagline = flags.tagline as string;
+  if (flags.description) payload.description = flags.description as string;
+  
+  const org = await hq.createOrg(config.api_key, payload);
+  success(`Org created! ID: ${org.id}, Name: ${org.name}`);
+}
+
+export async function list(flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgs = await hq.listOrgs(config.api_key);
+  printTable(orgs as unknown as Record<string, unknown>[]);
+}
+
+export async function get(id: string, flags: Record<string, string | boolean>) {
+  if (!id) error("Missing org id");
+  const config = requireConfig();
+  const org = await hq.getOrg(config.api_key, id);
+  printJson(org);
+}
+
+export async function del(id: string, flags: Record<string, string | boolean>) {
+  if (!id) error("Missing org id");
+  const config = requireConfig();
+  await hq.deleteOrg(config.api_key, id);
+  success(`Org ${id} deleted`);
+}
+
+export async function importOrg(domain: string, flags: Record<string, string | boolean>) {
+  if (!domain) error("Missing domain");
+  const config = requireConfig();
+  
+  const result = await hq.importOrg(config.api_key, 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') {
+      process.stdout.write('\r\x1b[K');
+      break;
+    }
+    if (status.status === 'failed') {
+      process.stdout.write('\r\x1b[K');
+      error("Import failed");
+    }
+    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}`);
+}