@myapihq/cli 1.0.27 → 1.0.28

package/dist/commands/auth.d.ts

@@ -1,2 +1,3 @@
 export declare function signup(): Promise<void>;
 export declare function whoami(): Promise<void>;
+export declare function switchCmd(): Promise<void>;

package/dist/commands/auth.js

@@ -1,10 +1,16 @@
 import * as readline from 'readline';
-import { loadConfig, saveConfig } from '../config.js';
+import { loadConfig, saveConfig, addAccount, switchAccount, listAccounts } from '../config.js';
 import { info, success, error } from '../output.js';
 const API_BASE = process.env.MYAPI_API_BASE ?? 'https://api.myapihq.com';
 function ask(rl, q) {
     return new Promise(resolve => rl.question(q, resolve));
 }
+function yn(answer, defaultYes = true) {
+    const t = answer.trim().toLowerCase();
+    if (t === '')
+        return defaultYes;
+    return t === 'y' || t === 'yes';
+}
 async function post(path, body, apiKey) {
     const headers = { 'Content-Type': 'application/json' };
     if (apiKey)
@@ -34,25 +40,57 @@ async function patch(path, body, apiKey) {
 export async function signup() {
     const config = loadConfig();
     if (!config?.api_key)
-        error('Not configured. Run: myapi setup');
+        error('Not configured. Run: myapi auth setup');
     if (!config.is_anonymous)
         error('Already registered. Use your existing account.');
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     try {
         const email = (await ask(rl, '› Email? ')).trim();
-        await patch('/hq/account/upgrade', { email }, config.api_key);
+        let upgradeOk = true;
+        try {
+            await patch('/hq/account/upgrade', { email }, config.api_key);
+        }
+        catch (err) {
+            if (err.message !== 'EMAIL_TAKEN')
+                throw err;
+            upgradeOk = false;
+            info(`› That email already has an account — accounts cannot be merged.`);
+            info(`› Your anonymous account will be kept and you can switch back to it anytime.`);
+            const ans = (await ask(rl, '› Sign in and add it as a second account? (Y/n) ')).trim();
+            if (!yn(ans))
+                return;
+            await post('/hq/account/send-code', { email });
+        }
         info(`› Sent a code to ${email} · paste it below`);
         const code = (await ask(rl, '› Code? ')).trim();
         const data = await post('/hq/account/verify-code', { email, code });
-        saveConfig({
-            ...config,
-            api_key: data.api_key,
-            account_id: data.account_id,
-            default_org: data.default_org || config.default_org,
-            default_funnel: data.default_funnel || config.default_funnel,
-            is_anonymous: false,
-        });
-        success(`› Welcome! Account upgraded · ${email}`);
+        if (upgradeOk) {
+            // Upgrade: update current account in place.
+            saveConfig({
+                ...config,
+                api_key: data.api_key,
+                account_id: data.account_id,
+                email,
+                default_org: data.default_org || config.default_org,
+                default_funnel: data.default_funnel || config.default_funnel,
+                is_anonymous: false,
+            });
+            success(`› Welcome! Account upgraded · ${email}`);
+        }
+        else {
+            // Add as new account and switch to it.
+            const idx = addAccount({
+                api_key: data.api_key,
+                account_id: data.account_id,
+                email,
+                pin: '',
+                default_org: data.default_org,
+                default_funnel: data.default_funnel,
+                is_anonymous: false,
+            });
+            success(`› Signed in · ${email} (account #${idx + 1})`);
+            info(`› Use "myapi auth switch" to toggle between accounts.`);
+        }
     }
     finally {
         rl.close();
@@ -62,9 +100,42 @@ export async function signup() {
 export async function whoami() {
     const config = loadConfig();
     if (!config?.api_key)
-        error('Not configured. Run: myapi setup');
+        error('Not configured. Run: myapi auth setup');
+    if (config.email)
+        info(`Email:    ${config.email}`);
     info(`Account:  ${config.account_id}`);
     info(`Org:      ${config.default_org ?? '(none)'}`);
     info(`Funnel:   ${config.default_funnel ?? '(none)'}`);
     info(`Type:     ${config.is_anonymous ? 'anonymous' : 'registered'}`);
 }
+// myapi auth switch — switch between saved accounts.
+export async function switchCmd() {
+    const accounts = listAccounts();
+    if (accounts.length === 0)
+        error('No accounts configured. Run: myapi auth setup');
+    if (accounts.length === 1) {
+        info(`Only one account configured: ${accounts[0].email ?? accounts[0].account_id}`);
+        return;
+    }
+    info('Accounts:');
+    for (const a of accounts) {
+        const label = a.email ?? (a.is_anonymous ? `anonymous · ${a.account_id.slice(0, 8)}` : a.account_id.slice(0, 8));
+        const marker = a.active ? ' ◀ active' : '';
+        info(`  ${a.index + 1}. ${label}${marker}`);
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = (await ask(rl, `› Switch to account (1-${accounts.length})? `)).trim();
+        const idx = parseInt(ans, 10) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= accounts.length) {
+            error('Invalid selection.');
+        }
+        if (switchAccount(idx)) {
+            const a = accounts[idx];
+            success(`› Switched to ${a.email ?? a.account_id}`);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -10,6 +10,16 @@ export async function setOrg(id, flags) {
     saveConfig(config);
     success(`Default organization set to: ${id}`);
 }
+export async function setFunnel(id, flags) {
+    if (!id || flags.help) {
+        info("Usage: myapi config set-funnel <id>\n\nSets a default funnel ID for subsequent commands.");
+        return;
+    }
+    const config = requireConfig();
+    config.default_funnel = id;
+    saveConfig(config);
+    success(`Default funnel set to: ${id}`);
+}
 export async function setDomain(domain, flags) {
     if (!domain || flags.help) {
         info("Usage: myapi config set-domain <domain>\n\nSets a default domain for subsequent commands.");
@@ -26,18 +36,21 @@ export async function view(flags) {
         return;
     }
     const config = requireConfig();
-    info(`Default Org: ${config.default_org || 'Not set'}`);
+    info(`Default Org:    ${config.default_org || 'Not set'}`);
+    info(`Default Funnel: ${config.default_funnel || 'Not set'}`);
     info(`Default Domain: ${config.default_domain || 'Not set'}`);
 }
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
-        info('Usage: myapi config <subcommand>\n\nSubcommands:\n  view         View current config\n  set-org      Set default organization\n  set-domain   Set default domain');
+        info('Usage: myapi config <subcommand>\n\nSubcommands:\n  view         View current config\n  set-org      Set default organization\n  set-funnel   Set default funnel\n  set-domain   Set default domain');
         return;
     }
     if (subcommand === 'view')
         await view(flags);
     else if (subcommand === 'set-org')
         await setOrg(args[0], flags);
+    else if (subcommand === 'set-funnel')
+        await setFunnel(args[0], flags);
     else if (subcommand === 'set-domain')
         await setDomain(args[0], flags);
     else

package/dist/commands/funnel.js

@@ -41,8 +41,10 @@ export async function del(id, flags) {
 export async function push(id, slug, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
-    if (!orgId || !id || !slug) {
-        error("Missing required arguments.\nUsage: myapi funnel push <funnel_id> <slug> --org <id> < index.html\n(Or set defaults via: myapi config set-org <id>)");
+    const funnelId = id || config.default_funnel;
+    const finalSlug = slug || flags.slug || '/';
+    if (!orgId || !funnelId) {
+        error("Missing required arguments.\nUsage: myapi funnel push [funnel_id] [slug] < index.html\n(Defaults to your configured funnel and slug '/' when omitted)");
     }
     const html = await new Promise((resolve, reject) => {
         let data = '';
@@ -53,15 +55,15 @@ export async function push(id, slug, flags) {
     });
     if (!html)
         error("No HTML provided via stdin");
-    const result = await sdkFunnel.pushFunnelPage(config.api_key, orgId, id, { slug, html });
-    success(`Pushed page to ${slug}`);
+    const result = await sdkFunnel.pushFunnelPage(config.api_key, orgId, funnelId, { slug: finalSlug, html });
+    success(`Pushed page to ${finalSlug}`);
     if (result?.url) {
         info(`Preview: ${result.url}`);
     }
     else {
         const org = await hq.getOrg(config.api_key, orgId);
         if (org.preview_subdomain) {
-            info(`Preview: https://${org.preview_subdomain}.makeautonomous.com/${slug}`);
+            info(`Preview: https://${org.preview_subdomain}.makeautonomous.com${finalSlug}`);
         }
     }
 }
@@ -91,7 +93,7 @@ export async function run(subcommand, args, flags) {
         else if (subcommand === 'delete')
             info('Usage: myapi funnel delete <id> --org <id>');
         else if (subcommand === 'push')
-            info('Usage: myapi funnel push <funnel_id> <slug> --org <id> < index.html\n\nPushes HTML content from stdin to the specified funnel.');
+            info('Usage: myapi funnel push [funnel_id] [slug] < index.html\n\nPushes HTML from stdin. Uses your default funnel and slug "/" when omitted.');
         else if (subcommand === 'verify')
             info('Usage: myapi funnel verify <id> --org <id> [--slug <slug>]\n\nVerifies syntax and structure before pushing.');
         return;

package/dist/commands/setup.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import * as readline from 'readline';
-import { loadConfig, saveConfig } from '../config.js';
+import { loadConfig, saveConfig, addAccount, loadFullConfig } from '../config.js';
 import { info, success } from '../output.js';
 const API_BASE = process.env.MYAPI_API_BASE ?? 'https://api.myapihq.com';
 function ask(rl, q) {
@@ -41,30 +41,31 @@ export async function installSkills() {
         info('No bundled skills found — skipping skills install.');
         return;
     }
-    fs.mkdirSync(SKILLS_CANONICAL, { recursive: true });
+    // Each bundled file is <skill-name>.md — install as <skill-name>/SKILL.md
     const files = fs.readdirSync(BUNDLED_SKILLS_DIR).filter(f => f.endsWith('.md'));
-    for (const file of files) {
-        const src = path.join(BUNDLED_SKILLS_DIR, file);
-        const dst = path.join(SKILLS_CANONICAL, file);
-        fs.copyFileSync(src, dst);
+    const skills = files.map(f => f.replace(/\.md$/, ''));
+    // Write canonical copies: ~/.agents/skills/myapi/<skill-name>/SKILL.md
+    for (const skill of skills) {
+        const skillDir = path.join(SKILLS_CANONICAL, skill);
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.copyFileSync(path.join(BUNDLED_SKILLS_DIR, `${skill}.md`), path.join(skillDir, 'SKILL.md'));
     }
+    // Symlink each skill directory into agent dirs
     for (const [agent, dir] of Object.entries(AGENT_DIRS)) {
         try {
             fs.mkdirSync(dir, { recursive: true });
-            for (const file of files) {
-                const link = path.join(dir, file);
-                const target = path.join(SKILLS_CANONICAL, file);
+            for (const skill of skills) {
+                const link = path.join(dir, skill);
+                const target = path.join(SKILLS_CANONICAL, skill);
                 try {
-                    if (fs.existsSync(link)) {
-                        const stat = fs.lstatSync(link);
-                        if (stat.isSymbolicLink() && fs.readlinkSync(link) === target)
-                            continue;
-                        fs.unlinkSync(link);
+                    try {
+                        fs.rmSync(link, { recursive: true, force: true });
                     }
+                    catch { /* ignore */ }
                     fs.symlinkSync(target, link);
                 }
                 catch {
-                    // Non-fatal: skip this agent dir if permissions are wrong.
+                    // Non-fatal.
                 }
             }
             info(`  ✓ ${agent}`);
@@ -83,7 +84,7 @@ async function registeredFlow(rl) {
     info(`› Sent a code to ${email} · paste it below`);
     const code = (await ask(rl, '› Code? ')).trim();
     const data = await post('/hq/account/verify-code', { email, code });
-    return data;
+    return { ...data, email };
 }
 // ---------------------------------------------------------------------------
 // Anonymous flow
@@ -98,29 +99,33 @@ async function anonymousFlow() {
 export async function setup() {
     info('› Configuring MyAPI…');
     const existing = loadConfig();
-    // Already configured — just verify the key is still valid.
+    // Already configured — ask before adding a new account.
     if (existing?.api_key) {
-        try {
-            const res = await fetch(`${API_BASE}/hq/account/me`, {
-                headers: { Authorization: `Bearer ${existing.api_key}` },
-            });
-            if (res.ok) {
-                info(`› Already configured · account ${existing.account_id}`);
-                // Re-ask skills only if preference was never recorded.
-                if (existing.skills_installed === undefined) {
-                    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-                    const ans = await ask(rl, '› Install the MyAPI skills pack? (Y/n) ');
-                    rl.close();
-                    if (yn(ans)) {
-                        await installSkills();
-                        success('› Skills installed.');
-                    }
-                    saveConfig({ ...existing, skills_installed: yn(ans) });
+        const full = loadFullConfig();
+        const total = full?.accounts.length ?? 1;
+        const activeLabel = existing.email ?? existing.account_id;
+        const activeType = existing.is_anonymous ? 'anonymous' : 'registered';
+        const othersNote = total > 1 ? ` · ${total - 1} more saved` : '';
+        info(`› Connected: ${activeLabel} (${activeType})${othersNote}`);
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const add = await ask(rl, '› Connect a new account? (y/N) ');
+        if (!yn(add, false)) {
+            if (!existing.skills_installed) {
+                const ans = await ask(rl, '› Install the MyAPI skills pack? (Y/n) ');
+                rl.close();
+                if (yn(ans)) {
+                    await installSkills();
+                    success('› Skills installed.');
+                    saveConfig({ ...existing, skills_installed: true });
                 }
-                return;
             }
+            else {
+                rl.close();
+            }
+            return;
         }
-        catch { /* fall through to full setup */ }
+        rl.close();
+        // Fall through to setup flow — new account will be added to the list.
     }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     let apiKey = '';
@@ -129,6 +134,7 @@ export async function setup() {
     let defaultFunnel = '';
     let subdomainUrl = '';
     let isAnonymous = false;
+    let email = '';
     try {
         const createAns = await ask(rl, '› Create an account? (Y/n) ');
         if (yn(createAns)) {
@@ -137,6 +143,7 @@ export async function setup() {
             accountId = data.account_id;
             defaultOrg = data.default_org;
             defaultFunnel = data.default_funnel;
+            email = data.email;
         }
         else {
             info('› Continuing as anonymous — sites ship to *.makeautonomous.com');
@@ -150,10 +157,11 @@ export async function setup() {
         }
         const skillsAns = await ask(rl, '› Install the MyAPI skills pack? (Y/n) ');
         const wantsSkills = yn(skillsAns);
-        saveConfig({
+        addAccount({
             api_key: apiKey,
             account_id: accountId,
             pin: '',
+            email: email || undefined,
             default_org: defaultOrg,
             default_funnel: defaultFunnel,
             is_anonymous: isAnonymous,
@@ -163,6 +171,49 @@ export async function setup() {
         if (wantsSkills) {
             await installSkills();
         }
+        // Validate key and ensure org/funnel defaults are correct.
+        try {
+            const auth = { Authorization: `Bearer ${apiKey}` };
+            const meRes = await fetch(`${API_BASE}/hq/account/me`, { headers: auth });
+            if (!meRes.ok) {
+                info('› Warning: could not verify API key — check your connection.');
+            }
+            else {
+                // Verify default org exists; if not, fetch the most recent one.
+                let resolvedOrg = defaultOrg;
+                let resolvedFunnel = defaultFunnel;
+                const orgRes = await fetch(`${API_BASE}/hq/orgs`, { headers: auth });
+                if (orgRes.ok) {
+                    const orgs = (await orgRes.json())?.data ?? [];
+                    if (orgs.length > 0) {
+                        const latest = orgs[orgs.length - 1];
+                        if (!resolvedOrg || !orgs.find((o) => o.id === resolvedOrg)) {
+                            resolvedOrg = latest.id;
+                            info(`› Auto-selected org: ${latest.name} (${resolvedOrg})`);
+                        }
+                        // Verify default funnel exists within the org.
+                        const fRes = await fetch(`${API_BASE}/funnel/orgs/${resolvedOrg}/funnels`, { headers: auth });
+                        if (fRes.ok) {
+                            const funnels = (await fRes.json())?.data ?? [];
+                            if (funnels.length > 0 && (!resolvedFunnel || !funnels.find((f) => f.id === resolvedFunnel))) {
+                                resolvedFunnel = funnels[funnels.length - 1].id;
+                                info(`› Auto-selected funnel: ${resolvedFunnel}`);
+                            }
+                        }
+                        if (resolvedOrg !== defaultOrg || resolvedFunnel !== defaultFunnel) {
+                            const full = loadFullConfig();
+                            const idx = full.active;
+                            full.accounts[idx].default_org = resolvedOrg;
+                            full.accounts[idx].default_funnel = resolvedFunnel;
+                            fs.writeFileSync(path.join(os.homedir(), '.myapi', 'config.json'), JSON.stringify(full, null, 2), { mode: 0o600 });
+                            defaultOrg = resolvedOrg;
+                            defaultFunnel = resolvedFunnel;
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* non-fatal */ }
         if (isAnonymous) {
             success('› Setup complete. No card, no email, ready to ship.');
             if (subdomainUrl)

package/dist/commands/update.js

@@ -18,8 +18,10 @@ export async function checkForUpdate(currentVersion) {
             return;
         const data = await res.json();
         const latest = data.version;
-        if (config) {
-            saveConfig({ ...config, last_update_check: now });
+        // Re-read config at write time to avoid clobbering changes made during setup.
+        const current = loadConfig();
+        if (current) {
+            saveConfig({ ...current, last_update_check: now });
         }
         if (latest && isNewer(latest, currentVersion)) {
             info(`\n› New version available (${currentVersion} → ${latest}) — installing…`);

package/dist/config.d.ts

@@ -1,15 +1,33 @@
-export interface Config {
+export interface AccountEntry {
     api_key: string;
     account_id: string;
     pin: string;
+    email?: string;
     default_org?: string;
     default_funnel?: string;
     default_domain?: string;
     is_anonymous?: boolean;
     skills_installed?: boolean;
+}
+export interface Config extends AccountEntry {
+    last_update_check?: number;
+    autocomplete_setup?: boolean;
+}
+export interface FullConfig {
+    active: number;
+    accounts: AccountEntry[];
     last_update_check?: number;
     autocomplete_setup?: boolean;
 }
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare function loadFullConfig(): FullConfig | null;
 export declare function loadConfig(): Config | null;
 export declare function saveConfig(config: Config): void;
+export declare function addAccount(account: AccountEntry): number;
+export declare function switchAccount(index: number): boolean;
+export declare function listAccounts(): Array<AccountEntry & {
+    index: number;
+    active: boolean;
+}>;
 export declare function requireConfig(): Config;

package/dist/config.js

@@ -1,38 +1,102 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-const CONFIG_DIR = path.join(os.homedir(), '.myapi');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-export function loadConfig() {
-    let fileConfig = {};
+export const CONFIG_DIR = path.join(os.homedir(), '.myapi');
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+function ensureDir() {
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function readRaw() {
     try {
-        if (fs.existsSync(CONFIG_FILE)) {
-            const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
-            fileConfig = JSON.parse(data);
-        }
-    }
-    catch (err) {
-        // Ignore read errors
+        if (fs.existsSync(CONFIG_FILE))
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
     }
+    catch { /* ignore */ }
+    return null;
+}
+function isFullConfig(raw) {
+    return raw && Array.isArray(raw.accounts);
+}
+// Migrate a flat (legacy) config to the new multi-account shape.
+function migrate(raw) {
+    const { last_update_check, autocomplete_setup, ...account } = raw;
+    return { active: 0, accounts: [account], last_update_check, autocomplete_setup };
+}
+export function loadFullConfig() {
+    const raw = readRaw();
+    if (!raw)
+        return null;
+    return isFullConfig(raw) ? raw : migrate(raw);
+}
+// loadConfig returns the active account merged with globals — unchanged interface for all callers.
+export function loadConfig() {
     const envKey = process.env.MYAPI_KEY;
-    if (envKey) {
-        fileConfig.api_key = envKey;
-    }
-    if (Object.keys(fileConfig).length === 0) {
+    const full = loadFullConfig();
+    if (!full && envKey)
+        return { api_key: envKey, account_id: '', pin: '' };
+    if (!full)
         return null;
-    }
-    return fileConfig;
+    const active = full.accounts[full.active] ?? full.accounts[0];
+    if (!active)
+        return null;
+    const config = {
+        ...active,
+        last_update_check: full.last_update_check,
+        autocomplete_setup: full.autocomplete_setup,
+    };
+    if (envKey)
+        config.api_key = envKey;
+    return config;
 }
 export function saveConfig(config) {
-    if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    ensureDir();
+    const full = loadFullConfig() ?? { active: 0, accounts: [] };
+    const { last_update_check, autocomplete_setup, ...account } = config;
+    if (full.accounts.length === 0)
+        full.accounts.push(account);
+    else
+        full.accounts[full.active] = account;
+    if (last_update_check !== undefined)
+        full.last_update_check = last_update_check;
+    if (autocomplete_setup !== undefined)
+        full.autocomplete_setup = autocomplete_setup;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(full, null, 2), { mode: 0o600 });
+}
+export function addAccount(account) {
+    ensureDir();
+    const full = loadFullConfig() ?? { active: 0, accounts: [] };
+    // Replace if same account_id already exists.
+    const existing = full.accounts.findIndex(a => a.account_id === account.account_id);
+    if (existing >= 0) {
+        full.accounts[existing] = account;
+        full.active = existing;
+    }
+    else {
+        full.accounts.push(account);
+        full.active = full.accounts.length - 1;
     }
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(full, null, 2), { mode: 0o600 });
+    return full.active;
+}
+export function switchAccount(index) {
+    const full = loadFullConfig();
+    if (!full || index < 0 || index >= full.accounts.length)
+        return false;
+    full.active = index;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(full, null, 2), { mode: 0o600 });
+    return true;
+}
+export function listAccounts() {
+    const full = loadFullConfig();
+    if (!full)
+        return [];
+    return full.accounts.map((a, i) => ({ ...a, index: i, active: i === full.active }));
 }
 export function requireConfig() {
     const config = loadConfig();
     if (!config || !config.api_key) {
-        console.error("No API key found. Provide MYAPI_KEY env var or run: myapi setup");
+        console.error("No API key found. Provide MYAPI_KEY env var or run: myapi auth setup");
         process.exit(1);
     }
     return config;