@myapihq/cli 1.0.25 → 1.0.28

package/src/commands/setup.ts

@@ -3,7 +3,7 @@ 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';
@@ -54,30 +54,29 @@ export async function installSkills(): Promise<void> {
     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}`);
@@ -96,6 +95,7 @@ async function registeredFlow(rl: readline.Interface): Promise<{
   account_id: string;
   default_org: string;
   default_funnel: string;
+  email: string;
 }> {
   const email = (await ask(rl, '› Email? ')).trim();
 
@@ -110,7 +110,7 @@ async function registeredFlow(rl: readline.Interface): Promise<{
     default_funnel: string;
   };
 
-  return data;
+  return { ...data, email };
 }
 
 // ---------------------------------------------------------------------------
@@ -143,28 +143,33 @@ export async function setup() {
 
   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();
       }
-    } catch { /* fall through to full setup */ }
+      return;
+    }
+    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 });
@@ -175,6 +180,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) ');
@@ -185,6 +191,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');
       const data = await anonymousFlow();
@@ -199,10 +206,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,
@@ -215,6 +223,51 @@ export async function setup() {
       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() as any)?.data ?? [];
+          if (orgs.length > 0) {
+            const latest = orgs[orgs.length - 1];
+            if (!resolvedOrg || !orgs.find((o: any) => 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() as any)?.data ?? [];
+              if (funnels.length > 0 && (!resolvedFunnel || !funnels.find((f: any) => 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) info(`› Your funnel: ${subdomainUrl}`);

package/src/commands/update.ts

@@ -22,8 +22,10 @@ export async function checkForUpdate(currentVersion: string): Promise<void> {
     const data = await res.json() as { version?: string };
     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)) {

package/src/config.ts

@@ -2,56 +2,126 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 
-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;
+}
+
+// Flat interface used by all command files — represents the active account.
+export interface Config extends AccountEntry {
   last_update_check?: number;
   autocomplete_setup?: boolean;
 }
 
-const CONFIG_DIR = path.join(os.homedir(), '.myapi');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export interface FullConfig {
+  active: number;
+  accounts: AccountEntry[];
+  last_update_check?: number;
+  autocomplete_setup?: boolean;
+}
 
-export function loadConfig(): Config | null {
-  let fileConfig: Partial<Config> = {};
+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(): any {
   try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
-      fileConfig = JSON.parse(data) as Partial<Config>;
-    }
-  } 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: any): raw is FullConfig {
+  return raw && Array.isArray(raw.accounts);
+}
+
+// Migrate a flat (legacy) config to the new multi-account shape.
+function migrate(raw: any): FullConfig {
+  const { last_update_check, autocomplete_setup, ...account } = raw;
+  return { active: 0, accounts: [account as AccountEntry], last_update_check, autocomplete_setup };
+}
+
+export function loadFullConfig(): FullConfig | null {
+  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(): Config | null {
   const envKey = process.env.MYAPI_KEY;
-  if (envKey) {
-    fileConfig.api_key = envKey;
-  }
+  const full = loadFullConfig();
 
-  if (Object.keys(fileConfig).length === 0) {
-    return null;
-  }
+  if (!full && envKey) return { api_key: envKey, account_id: '', pin: '' };
+  if (!full) return null;
+
+  const active = full.accounts[full.active] ?? full.accounts[0];
+  if (!active) return null;
 
-  return fileConfig as Config;
+  const config: 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: Config): void {
-  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 as AccountEntry);
+  else full.accounts[full.active] = account as AccountEntry;
+  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: AccountEntry): number {
+  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: number): boolean {
+  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(): Array<AccountEntry & { index: number; active: boolean }> {
+  const full = loadFullConfig();
+  if (!full) return [];
+  return full.accounts.map((a, i) => ({ ...a, index: i, active: i === full.active }));
 }
 
 export function requireConfig(): Config {
   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;

package/src/index.ts

@@ -4,7 +4,6 @@ import { parseArgs } from './utils.js';
 import { error, info, success } from './output.js';
 import { loadConfig } from './config.js';
 import { MyApiError } from '@myapihq/sdk';
-import updateNotifier from 'update-notifier';
 import * as fs from 'fs';
 
 const pkgPath = new URL('../package.json', import.meta.url);
@@ -13,26 +12,62 @@ import * as keysCmd from './commands/keys.js';
 import * as billingCmd from './commands/billing.js';
 import * as orgCmd from './commands/org.js';
 import * as setupCmd from './commands/setup.js';
-import * as configCmd from './commands/config.js';
+import * as updateCmd from './commands/update.js';
 import * as domainCmd from './commands/domain.js';
 import * as funnelCmd from './commands/funnel.js';
+import * as authCmd from './commands/auth.js';
+import * as configCmd from './commands/config.js';
 
 async function main() {
-  try {
-    updateNotifier({ pkg }).notify();
-  } catch(e) {}
+  // Fire-and-forget auto-update check — never blocks the command.
+  updateCmd.checkForUpdate(pkg.version).catch(() => {});
 
   const { args, flags } = parseArgs(process.argv.slice(2));
-  if (args.length === 0) { printHelp(); process.exit(0); }
+
+  if (flags.version || flags.v) {
+    const latest = await updateCmd.latestVersion();
+    const updateNote = latest && updateCmd.isNewer(latest, pkg.version)
+      ? ` (update available: ${latest})`
+      : '';
+    info(`myapi ${pkg.version}${updateNote}`);
+    process.exit(0);
+  }
+
+  if (args.length === 0) {
+    const config = loadConfig();
+    if (!config?.api_key) {
+      info('No account found. Run: myapi auth setup');
+      info('');
+    }
+    printHelp();
+    process.exit(0);
+  }
+
   const [command, subcommand, ...restArgs] = args;
   try {
     switch (command) {
-      case 'setup':
-        if (flags.help) {
-          info('Usage: myapi setup\n\nSetup CLI credentials and view integration instructions');
+      case 'auth':
+        if (!subcommand || flags.help) {
+          info('Usage: myapi auth <subcommand>\n\nSubcommands:\n  setup           Configure your account\n  whoami          Show current account\n  signup          Upgrade anonymous account to registered\n  switch          Switch between accounts\n  config          Manage CLI defaults (org_id, domain…)\n  install-skills  Install the MyAPI skills pack\n  api-keys        Manage API keys');
           break;
         }
-        await setupCmd.setup();
+        if (subcommand === 'setup') await setupCmd.setup();
+        else if (subcommand === 'whoami') await authCmd.whoami();
+        else if (subcommand === 'signup') await authCmd.signup();
+        else if (subcommand === 'switch') await authCmd.switchCmd();
+        else if (subcommand === 'install-skills') {
+          await setupCmd.installSkills();
+          success('› Skills installed.');
+        } else if (subcommand === 'config') await configCmd.run(restArgs[0], restArgs.slice(1), flags);
+        else if (subcommand === 'api-keys') {
+          if (!restArgs[0]) { info('Usage: myapi auth api-keys <list|create|revoke>'); break; }
+          if (restArgs[0] === 'create') await keysCmd.createNew(flags);
+          else if (restArgs[0] === 'list') await keysCmd.list(flags);
+          else if (restArgs[0] === 'revoke') await keysCmd.revoke(restArgs[1], flags);
+        } else info('Unknown subcommand. Run: myapi auth --help');
+        break;
+      case 'update':
+        await updateCmd.update();
         break;
       case 'keys':
         if (!subcommand || (flags.help && !subcommand)) {
@@ -67,9 +102,6 @@ async function main() {
         else if (subcommand === 'setup') await billingCmd.setup(flags);
         else printHelp();
         break;
-      case 'config':
-        await configCmd.run(subcommand, restArgs, flags);
-        break;
       case 'domain':
         await domainCmd.run(subcommand, restArgs, flags);
         break;
@@ -90,27 +122,30 @@ async function main() {
 }
 
 function printHelp() {
+  const config = loadConfig();
+  const quickStart = config?.api_key
+    ? `Quick start:
+  myapi funnel create
+  echo '<h1>Hello!</h1>' | myapi funnel push <funnel_id> /`
+    : `Quick start:
+  myapi setup`;
   info(`myapi - MyAPI command-line interface
 
 Usage: myapi <command> [subcommand] [args]
+       myapi --version
 
 Commands:
   keys         Manage API keys
   billing      Check balance and manage billing
   org          Manage organizations
-  setup        Setup CLI credentials and view integration instructions
-  config       Manage CLI defaults like org_id and domain
+  setup        Configure account · whoami · signup · config · install-skills
+  update       Update CLI and skills to the latest version
   domain       Manage domain configurations
   funnel       Manage headless funnels and pages
 
 Run "myapi <command> --help" for subcommand help.
 
-Quick start:
-  myapi org create --name "Acme Inc"
-  myapi domain register acme.com --org <org_id>
-  myapi domain assign acme.com --org <org_id> --target <org_id>
-  myapi funnel create --org <org_id>
-  echo '<h1>Hello!</h1>' | myapi funnel push <funnel_id> / --org <org_id>`);
+${quickStart}`);
 }
 
 main().catch(err => { error(err.message || (typeof err === 'object' ? JSON.stringify(err) : String(err))); });

package/src/skills/my-funnel-api.md

@@ -11,7 +11,7 @@ These endpoints manage the database records and structural configuration of funn
 
 - `GET /funnel/orgs/{org_id}/funnels`
   Lists all funnels for the specified organization.
-- `POST /funnel/orgs/{org_id}/funnels/create-raw`
+- `POST /funnel/orgs/{org_id}/funnels`
   Creates a new funnel entry. Expects basic configuration metadata (name, domain, etc.). Body: `{ "domain": "example.com" }`
 - `GET /funnel/orgs/{org_id}/funnels/{id}`
   Retrieves the metadata and configuration details of a specific funnel.