@myapihq/cli 1.0.84 → 1.1.0-wip.1

package/dist/commands/funnel.d.ts

@@ -1,7 +1,10 @@
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function create(flags: Record<string, string | boolean>): Promise<void>;
-export declare function get(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function del(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function push(slug: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function verify(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function list(flags: Flags): Promise<void>;
+export declare function create(flags: Flags): Promise<void>;
+export declare function get(id: string, flags: Flags): Promise<void>;
+export declare function del(id: string, flags: Flags): Promise<void>;
+export declare function push(slug: string, flags: Flags): Promise<void>;
+export declare function verify(id: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/funnel.js

@@ -1,12 +1,16 @@
 import { funnel as sdkFunnel, hq } from '@myapihq/sdk';
-import { requireConfig, saveConfig } from '../config.js';
+import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
+import { requireOrg } from '../helpers.js';
+export const SCHEMA = {
+    org: 'string',
+    funnel: 'string',
+    slug: 'string',
+};
 export async function list(flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId)
-        error("Missing required arguments.\nUsage: myapi funnel list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi funnel list [--org <id>]');
     const funnels = await sdkFunnel.listFunnels(config.api_key, orgId);
     if (flags.json) {
         printJson(funnels);
@@ -18,18 +22,14 @@ export async function list(flags) {
         created_at: formatDate(f.created_at),
         updated_at: formatDate(f.updated_at),
     }));
-    if (rows.length === 0) {
-        info('No funnels found. Create one with: myapi funnel create');
-        return;
-    }
-    printTable(rows);
+    printTable(rows, {
+        flags,
+        empty: 'No funnels found. Create one with: myapi funnel create',
+    });
 }
 export async function create(flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId) {
-        error("Missing required arguments.\nUsage: myapi funnel create --org <id>\n(Or set defaults via: myapi config set-org <id>)");
-    }
+    const orgId = requireOrg(flags, config, 'myapi funnel create [--org <id>]');
     const result = await sdkFunnel.createFunnel(config.api_key, orgId);
     success(`Funnel created! ID: ${result.funnel.id}`);
     if (result.domain_url)
@@ -39,10 +39,14 @@ export async function create(flags) {
 }
 export async function get(id, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !id)
-        error("Missing required arguments.\nUsage: myapi funnel get <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi funnel get <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi funnel get <id> [--org <id>]');
     const raw = await sdkFunnel.getFunnel(config.api_key, orgId, id);
+    // Backend response shape varies between two layouts:
+    //   1) { funnel: {...}, subdomain_url, domain_url }    (newer, wrapped)
+    //   2) { id, ..., subdomain_url, domain_url }          (older, flat)
+    // Coalesce both so this works regardless of which shape we get back.
     const funnel = raw.funnel ?? raw;
     const subdomain_url = raw.subdomain_url ?? funnel.subdomain_url;
     const domain_url = raw.domain_url ?? funnel.domain_url;
@@ -64,27 +68,28 @@ export async function get(id, flags) {
 }
 export async function del(id, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !id)
-        error("Missing required arguments.\nUsage: myapi funnel delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi funnel delete <id> [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi funnel delete <id> [--org <id>]');
     await sdkFunnel.deleteFunnel(config.api_key, orgId, id);
     success(`Funnel ${id} deleted`);
 }
 export async function push(slug, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId)
-        error("Missing org. Set a default with: myapi config set-org <id>");
+    const orgId = requireOrg(flags, config, 'myapi funnel push [slug] [--funnel <id>] [--org <id>]');
     const rawSlug = slug || flags.slug || '/';
     const finalSlug = rawSlug.startsWith('/') ? rawSlug : `/${rawSlug}`;
     let funnelId = flags.funnel || config.default_funnel;
+    let resolvedFromOrg = false;
     if (!funnelId) {
         const existing = await sdkFunnel.listFunnels(config.api_key, orgId);
         if (existing.length === 0)
-            error("No funnel found for this org. Try: myapi auth config set-org <id>");
+            error('No funnel found for this org. Create one with: myapi funnel create');
+        if (existing.length > 1) {
+            error(`Multiple funnels exist for this org and no default is set.\nPick one with --funnel <id>, or set a default:\n  myapi config set-funnel <id>\n\nFunnels:\n${existing.map(f => `  ${f.id}`).join('\n')}`);
+        }
         funnelId = existing[0].id;
-        config.default_funnel = funnelId;
-        saveConfig(config);
+        resolvedFromOrg = true;
     }
     if (process.stdin.isTTY) {
         error("No content provided via stdin. Use a pipe or file:\n  echo '<h1>Hello</h1>' | myapi funnel push /\n  cat page.html | myapi funnel push /about");
@@ -100,6 +105,9 @@ export async function push(slug, flags) {
         error("No content provided via stdin. Usage: echo '<h1>Hello</h1>' | myapi funnel push [slug]");
     const result = await sdkFunnel.pushFunnelPage(config.api_key, orgId, funnelId, { slug: finalSlug, html });
     success(`Pushed page to ${finalSlug}`);
+    if (resolvedFromOrg) {
+        info(`(Used the org's only funnel: ${funnelId}. Set a default with: myapi config set-funnel ${funnelId})`);
+    }
     if (result?.url) {
         info(`Preview: ${result.url}`);
     }
@@ -112,47 +120,63 @@ export async function push(slug, flags) {
 }
 export async function verify(id, flags) {
     const config = requireConfig();
-    const orgId = flags.org || config.default_org;
-    if (!orgId || !id)
-        error("Missing required arguments.\nUsage: myapi funnel verify <id> --org <id> [--slug <slug>]\n(Or set defaults via: myapi config set-org <id>)");
+    const orgId = requireOrg(flags, config, 'myapi funnel verify <id> [--slug <slug>] [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi funnel verify <id> [--slug <slug>] [--org <id>]');
     const opts = {};
     if (flags.slug)
         opts.slug = flags.slug;
     const v = await sdkFunnel.verifyFunnel(config.api_key, orgId, id, opts);
     printJson(v);
 }
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'list': 'myapi funnel list [--org <id>] [--json]',
+    'create': 'myapi funnel create [--org <id>]',
+    'get': 'myapi funnel get <id> [--org <id>] [--json]',
+    'delete': 'myapi funnel delete <id> [--org <id>]',
+    'push': `myapi funnel push [slug] [--funnel <id>] [--slug <path>] [--org <id>] < page.html
+
+Reads HTML from stdin and publishes to <slug> on your funnel. Funnel is resolved
+from --funnel, the default funnel, or (only if the org has exactly one) auto-picked.
+
+Examples:
+  echo '<h1>Hello</h1>' | myapi funnel push /
+  cat about.html | myapi funnel push /about
+  myapi funnel push < index.html
+  cat p.html | myapi funnel push /pricing --funnel <uuid>`,
+    'verify': 'myapi funnel verify <id> [--slug <slug>] [--org <id>]',
+};
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
-        info('Usage: myapi funnel <subcommand>\n\nSubcommands:\n  list       List funnels\n  create     Create a funnel\n  get        Get funnel details\n  delete     Delete a funnel\n  push       Push a raw HTML page to a slug\n\nNote: Most funnel commands require the --org <id> flag (or set a default via myapi auth config set-org <id>).');
+        info(`Usage: myapi funnel <subcommand>
+
+Subcommands:
+  list       List funnels
+  create     Create a funnel
+  get <id>   Get funnel details
+  delete     Delete a funnel
+  push       Push a raw HTML page from stdin to a slug
+  verify     Verify a published page is reachable
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;
     }
     if (flags.help) {
-        if (subcommand === 'list')
-            info('Usage: myapi funnel list --org <id> [--json]\n\nLists all funnels (websites) in the organization.\n\nFlags:\n  --org <id>   Organization ID (or set default via myapi auth config set-org)\n  --json       Output raw JSON');
-        else if (subcommand === 'create')
-            info('Usage: myapi funnel create --org <id>\n\nCreates a new funnel in the organization.\n\nFlags:\n  --org <id>   Organization ID (or set default via myapi auth config set-org)');
-        else if (subcommand === 'get')
-            info('Usage: myapi funnel get <id> --org <id>\n\nFetches details of a specific funnel including its pages and settings.\n\nFlags:\n  --org <id>   Organization ID (or set default via myapi auth config set-org)');
-        else if (subcommand === 'delete')
-            info('Usage: myapi funnel delete <id> --org <id>\n\nDeletes a funnel permanently.\n\nFlags:\n  --org <id>   Organization ID (or set default via myapi auth config set-org)');
-        else if (subcommand === 'push')
-            info('Usage: myapi funnel push [slug] < page.html\n\nPublishes an HTML page from stdin to a path within your funnel (website).\nThe funnel is always resolved from your default or --funnel flag.\n\nFlags:\n  --org <id>      Organization ID (or set default via myapi config set-org)\n  --funnel <id>   Funnel ID (or set default via myapi config set-funnel)\n  --slug <path>   Alternative way to specify the slug\n\nExamples:\n  echo \'<h1>Hello</h1>\' | myapi funnel push /        # push to /\n  cat about.html | myapi funnel push /about           # push to /about\n  myapi funnel push < index.html                      # push to / on default funnel\n  cat p.html | myapi funnel push /pricing --funnel <uuid>');
-        else if (subcommand === 'pull')
-            info('Usage: myapi funnel pull [funnel_id] [slug]\n\nFetches the HTML content of a funnel page.');
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi funnel --help" for the list.`);
         return;
     }
-    if (subcommand === 'list')
-        await list(flags);
-    else if (subcommand === 'create')
-        await create(flags);
-    else if (subcommand === 'get')
-        await get(args[0], flags);
-    else if (subcommand === 'delete')
-        await del(args[0], flags);
-    else if (subcommand === 'push')
-        await push(args[0], flags);
-    else if (subcommand === 'verify')
-        await verify(args[0], flags);
-    else
-        error(`Unknown subcommand: ${subcommand}. Run "myapi funnel --help" for a list of valid subcommands.`);
+    switch (subcommand) {
+        case 'list': return list(flags);
+        case 'create': return create(flags);
+        case 'get': return get(args[0], flags);
+        case 'delete': return del(args[0], flags);
+        case 'push': return push(args[0], flags);
+        case 'verify': return verify(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi funnel --help" for a list of valid subcommands.`);
+    }
 }

package/dist/commands/image.js

@@ -61,26 +61,36 @@ export async function del(id, flags) {
     await sdkImage.deleteImage(config.api_key, orgId, id);
     success(`Image deleted! (Job ${id} history retained, URL nullified)`);
 }
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'list': 'myapi image list [--org <id>] [--json]',
+    'generate': 'myapi image generate --prompt "<text>" [--ratio <1:1|16:9>] [--style <style>] [--colors <hex_list>] [--org <id>]',
+    'delete': 'myapi image delete <job_id> [--org <id>]',
+};
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
-        info('Usage: myapi image <subcommand>\n\nSubcommands:\n  list       List all your generated images\n  generate   Generate a new AI image from a prompt\n  delete     Delete the physical image file for a job\n\nNote: All image commands require the --org <id> flag.');
+        info(`Usage: myapi image <subcommand>
+
+Subcommands:
+  list       List all your generated images
+  generate   Generate a new AI image from a prompt ($0.05 per generation)
+  delete     Delete the physical image file for a job (history retained, URL nullified)
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
         return;
     }
     if (flags.help) {
-        if (subcommand === 'list')
-            info('Usage: myapi image list --org <id> [--json]');
-        else if (subcommand === 'generate')
-            info('Usage: myapi image generate --prompt "<text>" [--ratio <1:1|16:9>] [--style <style>] [--colors <hex_list>] --org <id>\n\nGenerates an AI image and polls until the public URL is ready. Costs $0.05 per generation.');
-        else if (subcommand === 'delete')
-            info('Usage: myapi image delete <job_id> --org <id>\n\nDeletes the physical image file from storage. The generation job history is kept, but its URL will become null.');
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for the list.`);
         return;
     }
-    if (subcommand === 'list')
-        await list(flags);
-    else if (subcommand === 'generate')
-        await generate(flags);
-    else if (subcommand === 'delete')
-        await del(args[0], flags);
-    else
-        error(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for a list of valid subcommands.`);
+    switch (subcommand) {
+        case 'list': return list(flags);
+        case 'generate': return generate(flags);
+        case 'delete': return del(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi image --help" for a list of valid subcommands.`);
+    }
 }

package/dist/commands/keys.d.ts

@@ -1,3 +1,8 @@
-export declare function createNew(flags: Record<string, string | boolean>): Promise<void>;
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function revoke(id: string, flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import type { Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
+export declare function runApiKeys(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;
+export declare function createNew(flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function revoke(id: string, _flags: Flags): Promise<void>;

package/dist/commands/keys.js

@@ -2,59 +2,95 @@ import { hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
-import * as readline from 'readline';
-export async function createNew(flags) {
+import { ask } from '../prompt.js';
+import { requireArg } from '../helpers.js';
+export const SCHEMA = {
+    name: 'string',
+};
+const KEYS_HEADER = `Usage: myapi keys <subcommand>
+
+Manage programmatic API keys for your account.
+
+Subcommands:
+  list             List all API keys with IDs and creation dates
+  create           Create a new API key (the key value is shown once)
+  revoke <id>      Permanently revoke an API key by ID
+
+Alias for: myapi auth api-keys`;
+const API_KEYS_HEADER = `Usage: myapi auth api-keys <subcommand>
+
+Manage programmatic API keys for your account.
+
+Subcommands:
+  list             List all API keys with IDs and creation dates
+  create           Create a new API key (the key value is shown once)
+  revoke <id>      Permanently revoke an API key by ID
+
+Alias: myapi keys <subcommand>`;
+function subcommandUsage(prefix) {
+    return {
+        'list': `myapi ${prefix} list [--json]`,
+        'create': `myapi ${prefix} create [--name <name>]\n\nCreates a new API key. If --name is omitted you will be prompted.`,
+        'revoke': `myapi ${prefix} revoke <id>\n\nPermanently revokes an API key by ID. The key stops working immediately and the action cannot be undone.`,
+    };
+}
+async function dispatch(prefix, subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(prefix === 'keys' ? KEYS_HEADER : API_KEYS_HEADER);
+        return;
+    }
     if (flags.help) {
-        info('Usage: myapi auth api-keys create [--name <name>]\n\nCreates a new API key.\n\nFlags:\n  --name <name>   Key name (skips prompt)');
+        const usage = subcommandUsage(prefix)[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi ${prefix} --help" for the list.`);
         return;
     }
+    switch (subcommand) {
+        case 'create': return createNew(flags);
+        case 'list': return list(flags);
+        case 'revoke': return revoke(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi ${prefix} --help" for available subcommands.`);
+    }
+}
+export async function run(subcommand, args, flags) {
+    return dispatch('keys', subcommand, args, flags);
+}
+export async function runApiKeys(subcommand, args, flags) {
+    return dispatch('auth api-keys', subcommand, args, flags);
+}
+export async function createNew(flags) {
     const config = requireConfig();
     let name = flags.name || '';
-    if (!name) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        name = await new Promise(resolve => rl.question('Enter a name for the new key: ', resolve));
-        rl.close();
-    }
-    if (!name.trim()) {
+    if (!name)
+        name = await ask('Enter a name for the new key: ');
+    if (!name.trim())
         error('Key name cannot be empty. Use --name <name>');
-        return;
-    }
     const keyInfo = await hq.createApiKey(config.api_key, name.trim());
     success(`New API key created!\n\nName: ${keyInfo.prefix}...\nKey:  ${keyInfo.api_key}\n\nMake sure to copy your new API key now. You won't be able to see it again!`);
 }
 export async function list(flags) {
-    if (flags.help) {
-        info('Usage: myapi auth api-keys list [--json]\n\nLists all API keys associated with your account.\n\nAlias: myapi keys list\n\nFlags:\n  --json   Output raw JSON');
-        return;
-    }
     const config = requireConfig();
     const keysList = await hq.listApiKeys(config.api_key);
     if (flags.json) {
         printJson(keysList);
         return;
     }
-    const formattedKeys = keysList.map(k => {
-        const createdStr = formatDate(k.created_at);
-        const lastUsedStr = k.last_used_at ? formatDate(k.last_used_at) : 'Never';
-        return {
-            Name: k.name || 'Unnamed',
-            Prefix: k.prefix,
-            ID: k.id,
-            'Created At': createdStr,
-            'Last Used': lastUsedStr
-        };
+    const formattedKeys = keysList.map(k => ({
+        Name: k.name || 'Unnamed',
+        Prefix: k.prefix,
+        ID: k.id,
+        'Created At': formatDate(k.created_at),
+        'Last Used': k.last_used_at ? formatDate(k.last_used_at) : 'Never',
+    }));
+    printTable(formattedKeys, {
+        flags,
+        empty: 'No API keys yet. Create one with: myapi keys create',
     });
-    printTable(formattedKeys);
 }
-export async function revoke(id, flags) {
-    if (flags.help) {
-        info('Usage: myapi auth api-keys revoke <id>\n\nPermanently revokes an API key by ID. This action cannot be undone.\nThe key stops working immediately.\n\nAlias: myapi keys revoke <id>');
-        return;
-    }
-    if (!id) {
-        error("Missing key ID. Usage: myapi keys revoke <id>");
-        return;
-    }
+export async function revoke(id, _flags) {
+    requireArg(id, 'id', 'myapi keys revoke <id>');
     const config = requireConfig();
     await hq.revokeApiKey(config.api_key, id);
     success(`Key ${id} revoked successfully.`);

package/dist/commands/org.d.ts

@@ -1,5 +1,9 @@
-export declare function create(restArgs: string[], flags: Record<string, string | boolean>): Promise<void>;
-export declare function list(flags: Record<string, string | boolean>): Promise<void>;
-export declare function get(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function del(id: string, flags: Record<string, string | boolean>): Promise<void>;
-export declare function importOrg(args: string[], flags: Record<string, string | boolean>): Promise<void>;
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+export declare const SCHEMA: FlagSchema;
+export declare function create(restArgs: string[], flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function get(id: string, flags: Flags): Promise<void>;
+export declare function del(id: string, _flags: Flags): Promise<void>;
+export declare function importOrg(args: string[], flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;