@myapihq/cli 1.0.16 → 1.0.18

package/src/commands/image.ts

@@ -1,18 +1,22 @@
 import { image as sdkImage } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable } from '../output.js';
+import { success, error, printTable, info, printJson } 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 orgId = (flags.org as string) || config.default_org;
+  
+  if (!orgId || !flags.prompt) {
+    error("Missing required arguments.\nUsage: myapi image generate --prompt <text> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
   
   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);
+  const res = await sdkImage.generateImage(config.api_key, orgId, payload);
   
   process.stdout.write("Generating image ");
   const chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -20,10 +24,11 @@ export async function generate(flags: Record<string, string | boolean>) {
   let elapsed = 0;
   
   while (elapsed < 60000) {
-    const job = await sdkImage.getImageJob(config.api_key, res.job_id);
+    const job = await sdkImage.getImageJob(config.api_key, orgId, res.job_id);
     if (job.status === 'completed') {
       process.stdout.write('\r\x1b[K');
-      success(`Image generated!\nURL: ${job.url}`);
+      if (flags.json) printJson(job);
+      else success(`Image generated!\nURL: ${job.url}`);
       return;
     }
     if (job.status === 'failed') {
@@ -40,6 +45,41 @@ export async function generate(flags: Record<string, string | boolean>) {
 
 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>[]);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi image list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  const images = await sdkImage.listImages(config.api_key, orgId);
+  if (flags.json) printJson(images);
+  else printTable(images as unknown as Record<string, unknown>[]);
+}
+
+export async function del(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  
+  if (!orgId || !id) {
+    error("Missing required arguments.\nUsage: myapi image delete <job_id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
+
+  await sdkImage.deleteImage(config.api_key, orgId, id);
+  success(`Image deleted! (Job ${id} history retained, URL nullified)`);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  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.');
+    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.');
+    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.`);
 }

package/src/commands/pixel.ts

@@ -0,0 +1,62 @@
+import { pixel as sdkPixel } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, info, printJson } from '../output.js';
+
+export async function interactions(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 pixel interactions --org <id> [--website <domain>] [--campaign-id <id>] [--domain <domain>]\n(Or set defaults via: myapi config set-org <id>)");
+  }
+
+  const params: any = {};
+  if (flags.website) params.website = flags.website as string;
+  if (flags['campaign-id']) params.campaign_id = flags['campaign-id'] as string;
+  if (flags.domain) params.domain = flags.domain as string;
+  if (flags.from) params.from = flags.from as string;
+  if (flags.to) params.to = flags.to as string;
+  if (flags.limit) params.limit = parseInt(flags.limit as string, 10);
+  if (flags.offset) params.offset = parseInt(flags.offset as string, 10);
+
+  if (!params.website && !params.campaign_id && !params.domain) {
+    error("You must provide at least one filter: --website, --campaign-id, or --domain");
+  }
+
+  const res = await sdkPixel.getInteractions(config.api_key, orgId, params);
+  if (flags.json) {
+    printJson(res);
+  } else {
+    printTable(res.interactions as unknown as Record<string, unknown>[]);
+    info(`Total Visits: ${res.total_visits} | Total Events: ${res.total_events} | Showing: ${res.limit} | Offset: ${res.offset}`);
+  }
+}
+
+export async function identity(pixelId: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  
+  if (!orgId || !pixelId) {
+    error("Missing required arguments.\nUsage: myapi pixel identity <pixel_id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
+
+  const res = await sdkPixel.getIdentity(config.api_key, orgId, pixelId);
+  printJson(res);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi pixel <subcommand>\n\nSubcommands:\n  interactions   Get a unified timeline of visits and events\n  identity       Resolve the identity graph for a pixel ID\n\nNote: All pixel commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'interactions') info('Usage: myapi pixel interactions --org <id> [--website <domain>] [--campaign-id <id>] [--domain <domain>] [--from <iso8601>] [--to <iso8601>] [--limit <num>] [--offset <num>] [--json]\n\nRetrieves a merged timeline of web visits and email events. Requires at least one filter (--website, --campaign-id, or --domain).');
+    else if (subcommand === 'identity') info('Usage: myapi pixel identity <pixel_id> --org <id>\n\nResolves the full identity graph (emails, IPs, profiles) for a specific pixel tracker ID.');
+    return;
+  }
+
+  if (subcommand === 'interactions') await interactions(flags);
+  else if (subcommand === 'identity') await identity(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi pixel --help" for a list of valid subcommands.`);
+}

package/src/commands/storage.ts

@@ -1,32 +1,56 @@
 import { storage as sdkStorage } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable } from '../output.js';
-
-function getOrgId(flags: Record<string, string | boolean>, config: any): string {
-  const orgId = flags.org || config.org_id;
-  if (!orgId) error("Missing org-id. Pass --org or set it in config.");
-  return orgId as string;
-}
+import { success, error, printTable, info, printJson } from '../output.js';
 
 export async function list(flags: Record<string, string | boolean>) {
   const config = requireConfig();
-  const orgId = getOrgId(flags, config);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi storage list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
   const assets = await sdkStorage.listAssets(config.api_key, orgId);
-  printTable(assets as unknown as Record<string, unknown>[]);
+  if (flags.json) printJson(assets);
+  else printTable(assets as unknown as Record<string, unknown>[]);
 }
 
 export async function ingest(url: string, flags: Record<string, string | boolean>) {
-  if (!url) error("Missing url");
   const config = requireConfig();
-  const orgId = getOrgId(flags, config);
+  const orgId = (flags.org as string) || config.default_org;
+  
+  if (!orgId || !url) {
+    error("Missing required arguments.\nUsage: myapi storage ingest <url> [--name <name>] --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
+  
   const res = await sdkStorage.ingestAsset(config.api_key, orgId, url, flags.name as string);
   success(`Asset ingested! ID: ${res.asset_id}\nHosted URL: ${res.url}`);
 }
 
 export async function del(id: string, flags: Record<string, string | boolean>) {
-  if (!id) error("Missing id");
   const config = requireConfig();
-  const orgId = getOrgId(flags, config);
+  const orgId = (flags.org as string) || config.default_org;
+  
+  if (!orgId || !id) {
+    error("Missing required arguments.\nUsage: myapi storage delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
+  
   await sdkStorage.deleteAsset(config.api_key, orgId, id);
   success(`Asset ${id} deleted`);
 }
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi storage <subcommand>\n\nSubcommands:\n  list       List all your uploaded assets\n  ingest     Ingest a public image URL into your edge storage\n  delete     Delete a stored asset\n\nNote: All storage commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'list') info('Usage: myapi storage list --org <id> [--json]');
+    else if (subcommand === 'ingest') info('Usage: myapi storage ingest <url> [--name <name>] --org <id>\n\nDownloads a public image (JPEG/PNG) and permanently hosts it on your MyAPI storage. Returns the new URL.');
+    else if (subcommand === 'delete') info('Usage: myapi storage delete <asset_id> --org <id>');
+    return;
+  }
+
+  if (subcommand === 'list') await list(flags);
+  else if (subcommand === 'ingest') await ingest(args[0], flags);
+  else if (subcommand === 'delete') await del(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi storage --help" for a list of valid subcommands.`);
+}

package/src/commands/url.ts

@@ -0,0 +1,28 @@
+import { url as sdkUrl } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printJson } from '../output.js';
+
+export async function shorten(targetUrl: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !targetUrl) error("Missing required arguments.\nUsage: myapi url shorten <url> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  const res = await sdkUrl.shortenUrl(config.api_key, orgId, targetUrl);
+  if (flags.json) printJson(res);
+  else success(`Shortened URL: ${res.short_url}\nCode: ${res.short_code}`);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi url <subcommand>\n\nSubcommands:\n  shorten    Shorten a long URL\n\nNote: All url commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'shorten') info('Usage: myapi url shorten <url> --org <id> [--json]\n\nShortens a long URL and returns the compact myurlto.com link.');
+    return;
+  }
+
+  if (subcommand === 'shorten') await shorten(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi url --help" for a list of valid subcommands.`);
+}

package/src/commands/webhook.ts

@@ -1,25 +1,66 @@
 import { webhook as sdkWebhook } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable } from '../output.js';
+import { success, error, printTable, info, printJson } from '../output.js';
 
 export async function list(flags: Record<string, string | boolean>) {
   const config = requireConfig();
-  const endpoints = await sdkWebhook.listEndpoints(config.api_key);
-  printTable(endpoints as unknown as Record<string, unknown>[]);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi webhook list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  const endpoints = await sdkWebhook.listEndpoints(config.api_key, orgId);
+  if (flags.json) printJson(endpoints);
+  else printTable(endpoints as unknown as Record<string, unknown>[]);
 }
 
 export async function create(flags: Record<string, string | boolean>) {
-  if (!flags['org-id'] || !flags.name || !flags.description) {
-    error("Missing --org-id, --name, or --description flags");
-  }
   const config = requireConfig();
-  const res = await sdkWebhook.createEndpoint(config.api_key, flags['org-id'] as string, flags.name as string, flags.description as string);
+  const orgId = (flags.org as string) || config.default_org;
+  const name = flags.name as string;
+  const description = flags.description as string;
+
+  if (!orgId || !name) {
+    error("Missing required arguments.\nUsage: myapi webhook create --name <name> [--description <desc>] --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
+  
+  const res = await sdkWebhook.createEndpoint(config.api_key, orgId, name, description);
   success(`Webhook created! ID: ${res.id}\nInbound URL: ${res.inbound_url}`);
 }
 
 export async function del(id: string, flags: Record<string, string | boolean>) {
-  if (!id) error("Missing id");
   const config = requireConfig();
-  await sdkWebhook.deleteEndpoint(config.api_key, id);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi webhook delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  await sdkWebhook.deleteEndpoint(config.api_key, orgId, id);
   success(`Webhook ${id} deleted`);
 }
+
+export async function delivery(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi webhook delivery <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  const res = await sdkWebhook.getDelivery(config.api_key, orgId, id);
+  printJson(res);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi webhook <subcommand>\n\nSubcommands:\n  list       List all inbound webhook endpoints\n  create     Create a new endpoint to receive data (returns an inbound URL)\n  delete     Delete a webhook endpoint\n  delivery   Inspect a specific webhook delivery (headers, payload, status)\n\nNote: All webhook commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'list') info('Usage: myapi webhook list --org <id> [--json]\n\nLists all webhook endpoints for the organization, including their IDs and inbound slugs.');
+    else if (subcommand === 'create') info('Usage: myapi webhook create --name <name> [--description <desc>] --org <id>\n\nCreates a new inbound webhook endpoint. Returns the unique inbound URL to give to third parties.');
+    else if (subcommand === 'delete') info('Usage: myapi webhook delete <id> --org <id>\n\nPermanently deletes the specified webhook endpoint.');
+    else if (subcommand === 'delivery') info('Usage: myapi webhook delivery <delivery_id> --org <id>\n\nRetrieves the exact HTTP headers, JSON payload, and processing status of a specific received webhook. Useful for debugging inbound data.');
+    return;
+  }
+
+  if (subcommand === 'list') await list(flags);
+  else if (subcommand === 'create') await create(flags);
+  else if (subcommand === 'delete') await del(args[0], flags);
+  else if (subcommand === 'delivery') await delivery(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi webhook --help" for a list of valid subcommands.`);
+}

package/src/commands/workflow.ts

@@ -1,18 +1,26 @@
 import { workflow as sdkWorkflow } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
-import { success, error, printTable } from '../output.js';
+import { success, error, printTable, info, printJson } from '../output.js';
 
 export async function list(flags: Record<string, string | boolean>) {
   const config = requireConfig();
-  const workflows = await sdkWorkflow.listWorkflows(config.api_key);
-  printTable(workflows as unknown as Record<string, unknown>[]);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId) error("Missing required arguments.\nUsage: myapi workflow list --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  const workflows = await sdkWorkflow.listWorkflows(config.api_key, orgId);
+  if (flags.json) printJson(workflows);
+  else printTable(workflows as unknown as Record<string, unknown>[]);
 }
 
 export async function create(flags: Record<string, string | boolean>) {
-  if (!flags['org-id'] || !flags.name || !flags['endpoint-id'] || !flags.steps) {
-    error("Missing --org-id, --name, --endpoint-id, or --steps flags");
-  }
   const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  const name = flags.name as string;
+  const endpointId = flags['endpoint-id'] as string;
+  
+  if (!orgId || !name || !endpointId || !flags.steps) {
+    error("Missing required arguments.\nUsage: myapi workflow create --name <name> --endpoint-id <id> --steps <json> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  }
   
   let steps;
   try {
@@ -21,34 +29,74 @@ export async function create(flags: Record<string, string | boolean>) {
     error("Invalid JSON for --steps");
   }
   
-  const wf = await sdkWorkflow.createWorkflow(config.api_key, {
-    org_id: flags['org-id'] as string,
-    name: flags.name as string,
-    trigger_config: { endpoint_id: flags['endpoint-id'] as string },
+  const wf = await sdkWorkflow.createWorkflow(config.api_key, orgId, {
+    name,
+    trigger_config: { endpoint_id: endpointId },
     steps
   });
   
-  await sdkWorkflow.enableWorkflow(config.api_key, wf.id);
+  await sdkWorkflow.enableWorkflow(config.api_key, orgId, wf.id);
   success(`Workflow created and enabled! ID: ${wf.id}`);
 }
 
 export async function enable(id: string, flags: Record<string, string | boolean>) {
-  if (!id) error("Missing id");
   const config = requireConfig();
-  await sdkWorkflow.enableWorkflow(config.api_key, id);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi workflow enable <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  await sdkWorkflow.enableWorkflow(config.api_key, orgId, id);
   success(`Workflow ${id} enabled`);
 }
 
 export async function disable(id: string, flags: Record<string, string | boolean>) {
-  if (!id) error("Missing id");
   const config = requireConfig();
-  await sdkWorkflow.disableWorkflow(config.api_key, id);
-  success(`Workflow ${id} disabled`);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi workflow disable <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+
+  await sdkWorkflow.disableWorkflow(config.api_key, orgId, id);
+  success(`Disabled workflow ${id}`);
+}
+
+export async function del(id: string, flags: Record<string, string | boolean>) {
+  const config = requireConfig();
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi workflow delete <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+
+  await sdkWorkflow.deleteWorkflow(config.api_key, orgId, id);
+  success(`Deleted workflow ${id}`);
 }
 
 export async function runs(id: string, flags: Record<string, string | boolean>) {
-  if (!id) error("Missing id");
   const config = requireConfig();
-  const runs = await sdkWorkflow.listWorkflowRuns(config.api_key, id);
-  printTable(runs as unknown as Record<string, unknown>[]);
+  const orgId = (flags.org as string) || config.default_org;
+  if (!orgId || !id) error("Missing required arguments.\nUsage: myapi workflow runs <id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+  
+  const wRuns = await sdkWorkflow.listWorkflowRuns(config.api_key, orgId, id);
+  if (flags.json) printJson(wRuns);
+  else printTable(wRuns as unknown as Record<string, unknown>[]);
+}
+
+export async function run(subcommand: string | undefined, args: string[], flags: Record<string, string | boolean>) {
+  if (!subcommand || (flags.help && !subcommand)) {
+    info('Usage: myapi workflow <subcommand>\n\nSubcommands:\n  list       List all workflows\n  create     Create and enable a new workflow\n  enable     Enable a workflow\n  disable    Disable a workflow\n  delete     Delete a workflow\n  runs       List recent executions (runs) of a workflow\n\nNote: All workflow commands require the --org <id> flag.');
+    return;
+  }
+  
+  if (flags.help) {
+    if (subcommand === 'list') info('Usage: myapi workflow list --org <id> [--json]\n\nLists all workflows in your organization, showing their ID, name, status, and attached webhook endpoint.');
+    else if (subcommand === 'create') info('Usage: myapi workflow create --name <name> --endpoint-id <id> --steps <json_array> --org <id>\n\nCreates a new webhook-triggered workflow and immediately enables it.\n\nArguments:\n  --name          A friendly name for your workflow.\n  --endpoint-id   The UUID of the my-webhook-api endpoint that will trigger this workflow.\n  --steps         A raw JSON array defining the actions to take when triggered.\n\nExample Steps Payload:\n  \'[{"type": "send_email", "from": "hello@example.com", "to": "{{payload.user.email}}", "subject": "Welcome!", "template_id": "abc-123"}]\n  \'[{"type": "slack_message", "webhook_url": "https://hooks.slack.com/...", "text": "New lead: {{payload.name}}"}]\'');
+    else if (subcommand === 'enable') info('Usage: myapi workflow enable <id> --org <id>\n\nActivates a disabled workflow so it begins listening to its webhook trigger again.');
+    else if (subcommand === 'disable') info('Usage: myapi workflow disable <id> --org <id>\n\nPauses a workflow. The attached webhook will still accept data, but the workflow steps will not execute.');
+    else if (subcommand === 'delete') info('Usage: myapi workflow delete <id> --org <id>\n\nDeletes the workflow permanently.');
+    else if (subcommand === 'runs') info('Usage: myapi workflow runs <workflow_id> --org <id> [--json]\n\nLists the 100 most recent executions of the specified workflow, including completion status and any error messages.');
+    return;
+  }
+
+  if (subcommand === 'list') await list(flags);
+  else if (subcommand === 'create') await create(flags);
+  else if (subcommand === 'enable') await enable(args[0], flags);
+  else if (subcommand === 'disable') await disable(args[0], flags);
+  else if (subcommand === 'delete') await del(args[0], flags);
+  else if (subcommand === 'runs') await runs(args[0], flags);
+  else error(`Unknown subcommand: ${subcommand}. Run "myapi workflow --help" for a list of valid subcommands.`);
 }

package/src/config.ts

@@ -8,21 +8,33 @@ export interface Config {
   pin: string;
   default_org?: string;
   default_domain?: string;
+  autocomplete_setup?: boolean;
 }
 
 const CONFIG_DIR = path.join(os.homedir(), '.myapi');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
 export function loadConfig(): Config | null {
+  let fileConfig: Partial<Config> = {};
   try {
-    if (!fs.existsSync(CONFIG_FILE)) {
-      return null;
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      fileConfig = JSON.parse(data) as Partial<Config>;
     }
-    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
-    return JSON.parse(data) as Config;
   } catch (err) {
+    // Ignore read errors
+  }
+
+  const envKey = process.env.MYAPI_KEY;
+  if (envKey) {
+    fileConfig.api_key = envKey;
+  }
+
+  if (Object.keys(fileConfig).length === 0) {
     return null;
   }
+
+  return fileConfig as Config;
 }
 
 export function saveConfig(config: Config): void {
@@ -35,7 +47,7 @@ export function saveConfig(config: Config): void {
 export function requireConfig(): Config {
   const config = loadConfig();
   if (!config || !config.api_key) {
-    console.error("No API key found. Run: myapi account create");
+    console.error("No API key found. Provide MYAPI_KEY env var or run: myapi setup");
     process.exit(1);
   }
   return config;

package/src/index.ts

@@ -1,8 +1,16 @@
 #!/usr/bin/env node
 // AUTO-GENERATED by scripts/generate-indexes.js — do not edit manually
 import { parseArgs } from './utils.js';
-import { error, info } from './output.js';
+import { error, info, success } from './output.js';
+import { loadConfig, saveConfig } from './config.js';
 import { MyApiError } from '@myapihq/sdk';
+import updateNotifier from 'update-notifier';
+import omelette from 'omelette';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const pkgPath = new URL('../package.json', import.meta.url);
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 import * as keysCmd from './commands/keys.js';
 import * as billingCmd from './commands/billing.js';
 import * as orgCmd from './commands/org.js';
@@ -10,13 +18,42 @@ import * as setupCmd from './commands/setup.js';
 import * as configCmd from './commands/config.js';
 import * as domainCmd from './commands/domain.js';
 import * as funnelCmd from './commands/funnel.js';
+import * as imageCmd from './commands/image.js';
+import * as storageCmd from './commands/storage.js';
+import * as urlCmd from './commands/url.js';
+import * as webhookCmd from './commands/webhook.js';
+import * as workflowCmd from './commands/workflow.js';
 
 async function main() {
+  const completion = omelette('myapi');
+  completion.on('myapi', ({ reply }) => {
+    reply(['keys', 'billing', 'org', 'setup', 'config', 'domain', 'funnel', 'image', 'storage', 'url', 'webhook', 'workflow', 'autocomplete']);
+  });
+  completion.init();
+
+  const config = loadConfig();
+  if (config && !config.autocomplete_setup) {
+    try {
+      completion.setupShellInitFile();
+      config.autocomplete_setup = true;
+      saveConfig(config);
+      info('✨ Autocomplete has been auto-configured! Restart your terminal (or run: source ~/.bashrc) to use it.');
+    } catch (e) {
+      // Ignore if we can't write to shell profiles
+    }
+  }
+
+  updateNotifier({ pkg }).notify();
+
   const { args, flags } = parseArgs(process.argv.slice(2));
   if (args.length === 0) { printHelp(); process.exit(0); }
   const [command, subcommand, ...restArgs] = args;
   try {
     switch (command) {
+      case 'autocomplete':
+        completion.setupShellInitFile();
+        success('Autocomplete successfully configured! Please restart your terminal or run: source ~/.bashrc (or ~/.zshrc)');
+        break;
       case 'setup':
         if (flags.help) {
           info('Usage: myapi setup\n\nSetup CLI credentials and view integration instructions');
@@ -66,6 +103,21 @@ async function main() {
       case 'funnel':
         await funnelCmd.run(subcommand, restArgs, flags);
         break;
+      case 'image':
+        await imageCmd.run(subcommand, restArgs, flags);
+        break;
+      case 'storage':
+        await storageCmd.run(subcommand, restArgs, flags);
+        break;
+      case 'url':
+        await urlCmd.run(subcommand, restArgs, flags);
+        break;
+      case 'webhook':
+        await webhookCmd.run(subcommand, restArgs, flags);
+        break;
+      case 'workflow':
+        await workflowCmd.run(subcommand, restArgs, flags);
+        break;
       default:
         printHelp();
         process.exit(0);
@@ -85,6 +137,7 @@ function printHelp() {
 Usage: myapi <command> [subcommand] [args]
 
 Commands:
+  autocomplete Autocomplete setup for bash/zsh
   keys         Manage API keys
   billing      Check balance and manage billing
   org          Manage organizations
@@ -92,6 +145,11 @@ Commands:
   config       Manage CLI defaults like org_id and domain
   domain       Manage domain configurations
   funnel       Manage headless funnels and pages
+  image        Generate AI images
+  storage      Manage static assets
+  url          Shorten URLs and manage links
+  webhook      Manage inbound webhooks
+  workflow     Manage workflow automations
 
 Run "myapi <command> --help" for subcommand help.`);
 }