api-emulator 0.5.0

package/dist/index.js

@@ -0,0 +1,887 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command } from "commander";
+
+// src/external-plugin-adapter.ts
+import { isAbsolute, resolve } from "path";
+async function loadExternalPluginModule(specifier) {
+  const modulePath = specifier.startsWith(".") || isAbsolute(specifier) ? resolve(specifier) : specifier;
+  const mod = await import(modulePath);
+  const plugin = mod.plugin ?? mod.default;
+  if (!plugin || typeof plugin.register !== "function" || typeof plugin.name !== "string") {
+    throw new Error(`Plugin "${specifier}" must export a ServicePlugin (as "plugin" or default export)`);
+  }
+  const name = plugin.name;
+  return {
+    name,
+    label: mod.label ?? `${name} (external plugin)`,
+    endpoints: mod.endpoints ?? "",
+    async load() {
+      return {
+        plugin,
+        seedFromConfig: mod.seedFromConfig
+      };
+    },
+    defaultFallback: mod.defaultFallback ?? (() => ({ login: "admin", id: 1, scopes: [] })),
+    initConfig: mod.initConfig ?? {}
+  };
+}
+
+// src/default-plugin-catalog.ts
+var DEFAULT_PLUGIN_NAME_LIST = [
+  "vercel",
+  "github",
+  "google",
+  "slack",
+  "apple",
+  "microsoft",
+  "okta",
+  "aws",
+  "resend",
+  "stripe",
+  "mongoatlas",
+  "clerk"
+];
+var DEFAULT_PLUGIN_NAMES = DEFAULT_PLUGIN_NAME_LIST;
+var DEFAULT_PLUGIN_REGISTRY = {
+  vercel: {
+    name: "vercel",
+    label: "Vercel REST API emulator",
+    endpoints: "projects, deployments, domains, env vars, users, teams, file uploads, protection bypass",
+    async load() {
+      const mod = await import("@emulators/vercel");
+      return { plugin: mod.vercelPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback(cfg) {
+      const firstLogin = cfg?.users?.[0]?.username ?? "admin";
+      return { login: firstLogin, id: 1, scopes: [] };
+    },
+    initConfig: {
+      vercel: {
+        users: [{ username: "developer", name: "Developer", email: "dev@example.com" }],
+        teams: [{ slug: "my-team", name: "My Team" }],
+        projects: [{ name: "my-app", team: "my-team", framework: "nextjs" }],
+        integrations: [
+          {
+            client_id: "oac_example_client_id",
+            client_secret: "example_client_secret",
+            name: "My Vercel App",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/vercel"]
+          }
+        ]
+      }
+    }
+  },
+  github: {
+    name: "github",
+    label: "GitHub REST API emulator",
+    endpoints: "users, repos, issues, PRs, comments, reviews, labels, milestones, branches, git data, orgs, teams, releases, webhooks, search, actions, checks, rate limit",
+    async load() {
+      const mod = await import("@emulators/github");
+      return {
+        plugin: mod.githubPlugin,
+        seedFromConfig: mod.seedFromConfig,
+        createAppKeyResolver(store) {
+          return (appId) => {
+            try {
+              const gh = mod.getGitHubStore(store);
+              const ghApp = gh.apps.all().find((a) => a.app_id === appId);
+              if (!ghApp) return null;
+              return { privateKey: ghApp.private_key, slug: ghApp.slug, name: ghApp.name };
+            } catch {
+              return null;
+            }
+          };
+        }
+      };
+    },
+    defaultFallback(cfg) {
+      const firstLogin = cfg?.users?.[0]?.login ?? "admin";
+      return { login: firstLogin, id: 1, scopes: ["repo", "user", "admin:org", "admin:repo_hook"] };
+    },
+    initConfig: {
+      github: {
+        users: [
+          {
+            login: "octocat",
+            name: "The Octocat",
+            email: "octocat@github.com",
+            bio: "I am the Octocat",
+            company: "GitHub",
+            location: "San Francisco"
+          }
+        ],
+        orgs: [{ login: "my-org", name: "My Organization", description: "A test organization" }],
+        repos: [
+          {
+            owner: "octocat",
+            name: "hello-world",
+            description: "My first repository",
+            language: "JavaScript",
+            topics: ["hello", "world"],
+            auto_init: true
+          },
+          {
+            owner: "my-org",
+            name: "org-repo",
+            description: "An organization repository",
+            language: "TypeScript",
+            auto_init: true
+          }
+        ],
+        oauth_apps: [
+          {
+            client_id: "Iv1.example_client_id",
+            client_secret: "example_client_secret",
+            name: "My App",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/github"]
+          }
+        ]
+      }
+    }
+  },
+  google: {
+    name: "google",
+    label: "Google OAuth 2.0 / OpenID Connect + Gmail, Calendar, and Drive emulator",
+    endpoints: "OAuth authorize, token exchange, userinfo, OIDC discovery, token revocation, Gmail messages/drafts/threads/labels/history/settings, Calendar lists/events/freebusy, Drive files/uploads",
+    async load() {
+      const mod = await import("@emulators/google");
+      return { plugin: mod.googlePlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback(cfg) {
+      const firstEmail = cfg?.users?.[0]?.email ?? "testuser@gmail.com";
+      return { login: firstEmail, id: 1, scopes: ["openid", "email", "profile"] };
+    },
+    initConfig: {
+      google: {
+        users: [
+          {
+            email: "testuser@example.com",
+            name: "Test User",
+            picture: "https://lh3.googleusercontent.com/a/default-user",
+            email_verified: true
+          }
+        ],
+        oauth_clients: [
+          {
+            client_id: "example-client-id.apps.googleusercontent.com",
+            client_secret: "GOCSPX-example_secret",
+            name: "Code App (Google)",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/google"]
+          }
+        ],
+        labels: [
+          {
+            id: "Label_ops",
+            user_email: "testuser@example.com",
+            name: "Ops/Review",
+            color_background: "#DDEEFF",
+            color_text: "#111111"
+          }
+        ],
+        messages: [
+          {
+            id: "msg_welcome",
+            user_email: "testuser@example.com",
+            from: "welcome@example.com",
+            to: "testuser@example.com",
+            subject: "Welcome to the Gmail emulator",
+            body_text: "You can now test Gmail, Calendar, and Drive flows locally.",
+            label_ids: ["INBOX", "UNREAD", "CATEGORY_UPDATES"],
+            date: "2025-01-04T10:00:00.000Z"
+          }
+        ],
+        calendars: [
+          {
+            id: "primary",
+            user_email: "testuser@example.com",
+            summary: "testuser@example.com",
+            primary: true,
+            selected: true,
+            time_zone: "UTC"
+          }
+        ],
+        calendar_events: [
+          {
+            id: "evt_kickoff",
+            user_email: "testuser@example.com",
+            calendar_id: "primary",
+            summary: "Project Kickoff",
+            start_date_time: "2025-01-10T09:00:00.000Z",
+            end_date_time: "2025-01-10T09:30:00.000Z"
+          }
+        ],
+        drive_items: [
+          {
+            id: "drv_docs",
+            user_email: "testuser@example.com",
+            name: "Docs",
+            mime_type: "application/vnd.google-apps.folder",
+            parent_ids: ["root"]
+          }
+        ]
+      }
+    }
+  },
+  slack: {
+    name: "slack",
+    label: "Slack API emulator",
+    endpoints: "auth, chat, conversations, users, reactions, team, OAuth, incoming webhooks",
+    async load() {
+      const mod = await import("@emulators/slack");
+      return { plugin: mod.slackPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback() {
+      return { login: "U000000001", id: 1, scopes: ["chat:write", "channels:read", "users:read", "reactions:write"] };
+    },
+    initConfig: {
+      slack: {
+        team: { name: "My Workspace", domain: "my-workspace" },
+        users: [{ name: "developer", real_name: "Developer", email: "dev@example.com" }],
+        channels: [
+          { name: "general", topic: "General discussion" },
+          { name: "random", topic: "Random stuff" }
+        ],
+        bots: [{ name: "my-bot" }],
+        oauth_apps: [
+          {
+            client_id: "12345.67890",
+            client_secret: "example_client_secret",
+            name: "My Slack App",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/slack"]
+          }
+        ]
+      }
+    }
+  },
+  apple: {
+    name: "apple",
+    label: "Apple Sign In / OAuth emulator",
+    endpoints: "OAuth authorize, token exchange, JWKS",
+    async load() {
+      const mod = await import("@emulators/apple");
+      return { plugin: mod.applePlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback(cfg) {
+      const firstEmail = cfg?.users?.[0]?.email ?? "testuser@icloud.com";
+      return { login: firstEmail, id: 1, scopes: ["openid", "email", "name"] };
+    },
+    initConfig: {
+      apple: {
+        users: [{ email: "testuser@icloud.com", name: "Test User" }],
+        oauth_clients: [
+          {
+            client_id: "com.example.app",
+            team_id: "TEAM001",
+            name: "My Apple App",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/apple"]
+          }
+        ]
+      }
+    }
+  },
+  microsoft: {
+    name: "microsoft",
+    label: "Microsoft Entra ID OAuth 2.0 / OpenID Connect emulator",
+    endpoints: "OAuth authorize, token exchange, userinfo, OIDC discovery, Graph /me, logout, token revocation",
+    async load() {
+      const mod = await import("@emulators/microsoft");
+      return { plugin: mod.microsoftPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback(cfg) {
+      const firstEmail = cfg?.users?.[0]?.email ?? "testuser@outlook.com";
+      return { login: firstEmail, id: 1, scopes: ["openid", "email", "profile", "User.Read"] };
+    },
+    initConfig: {
+      microsoft: {
+        users: [{ email: "testuser@outlook.com", name: "Test User" }],
+        oauth_clients: [
+          {
+            client_id: "example-client-id",
+            client_secret: "example-client-secret",
+            name: "My Microsoft App",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/microsoft-entra-id"]
+          }
+        ]
+      }
+    }
+  },
+  okta: {
+    name: "okta",
+    label: "Okta OAuth 2.0 / OpenID Connect + management API emulator",
+    endpoints: "OIDC discovery, JWKS, OAuth authorize/token/userinfo/introspect/revoke/logout, users, groups, apps, authorization servers",
+    async load() {
+      const mod = await import("@emulators/okta");
+      return { plugin: mod.oktaPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback(cfg) {
+      const firstLogin = cfg?.users?.[0]?.login ?? cfg?.users?.[0]?.email ?? "testuser@okta.local";
+      return { login: firstLogin, id: 1, scopes: ["openid", "profile", "email", "groups"] };
+    },
+    initConfig: {
+      okta: {
+        users: [{ login: "testuser@okta.local", email: "testuser@okta.local", first_name: "Test", last_name: "User" }],
+        groups: [{ name: "Everyone", description: "All users", type: "BUILT_IN", okta_id: "00g_everyone" }],
+        authorization_servers: [{ id: "default", name: "default", audiences: ["api://default"] }],
+        oauth_clients: [
+          {
+            client_id: "okta-test-client",
+            client_secret: "okta-test-secret",
+            name: "Sample OIDC Client",
+            redirect_uris: ["http://localhost:3000/callback"],
+            auth_server_id: "default"
+          }
+        ]
+      }
+    }
+  },
+  aws: {
+    name: "aws",
+    label: "AWS cloud service emulator",
+    endpoints: "S3 (buckets, objects), SQS (queues, messages), IAM (users, roles, access keys), STS (assume role, caller identity)",
+    async load() {
+      const mod = await import("@emulators/aws");
+      return { plugin: mod.awsPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback() {
+      return { login: "admin", id: 1, scopes: ["s3:*", "sqs:*", "iam:*", "sts:*"] };
+    },
+    initConfig: {
+      aws: {
+        region: "us-east-1",
+        s3: { buckets: [{ name: "my-app-bucket" }, { name: "my-app-uploads" }] },
+        sqs: { queues: [{ name: "my-app-events" }, { name: "my-app-dlq" }] },
+        iam: {
+          users: [{ user_name: "developer", create_access_key: true }],
+          roles: [{ role_name: "lambda-execution-role", description: "Role for Lambda function execution" }]
+        }
+      }
+    }
+  },
+  resend: {
+    name: "resend",
+    label: "Resend email API emulator",
+    endpoints: "emails, domains, contacts, API keys, inbox UI",
+    async load() {
+      const mod = await import("@emulators/resend");
+      return { plugin: mod.resendPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback() {
+      return { login: "re_test_admin", id: 1, scopes: [] };
+    },
+    initConfig: {
+      resend: {
+        domains: [{ name: "example.com", region: "us-east-1" }],
+        contacts: [{ email: "test@example.com", first_name: "Test", last_name: "User" }]
+      }
+    }
+  },
+  stripe: {
+    name: "stripe",
+    label: "Stripe payments emulator",
+    endpoints: "customers, payment methods, customer sessions, payment intents, charges, products, prices, checkout sessions, webhooks",
+    async load() {
+      const mod = await import("@emulators/stripe");
+      return { plugin: mod.stripePlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback() {
+      return { login: "sk_test_admin", id: 1, scopes: [] };
+    },
+    initConfig: {
+      stripe: {
+        customers: [{ email: "test@example.com", name: "Test Customer" }],
+        products: [{ name: "Pro Plan", description: "Monthly pro subscription" }],
+        prices: [{ product_name: "Pro Plan", currency: "usd", unit_amount: 2e3 }]
+      }
+    }
+  },
+  mongoatlas: {
+    name: "mongoatlas",
+    label: "MongoDB Atlas service emulator",
+    endpoints: "Atlas Admin API v2 (projects, clusters, database users, databases, collections), Atlas Data API v1 (findOne, find, insertOne, insertMany, updateOne, updateMany, deleteOne, deleteMany, aggregate)",
+    async load() {
+      const mod = await import("@emulators/mongoatlas");
+      return { plugin: mod.mongoatlasPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback() {
+      return { login: "admin", id: 1, scopes: [] };
+    },
+    initConfig: {
+      mongoatlas: {
+        projects: [{ name: "Project0" }],
+        clusters: [{ name: "Cluster0", project: "Project0" }],
+        database_users: [{ username: "admin", project: "Project0" }],
+        databases: [{ cluster: "Cluster0", name: "test", collections: ["items"] }]
+      }
+    }
+  },
+  clerk: {
+    name: "clerk",
+    label: "Clerk authentication and user management emulator",
+    endpoints: "OIDC discovery, JWKS, OAuth authorize/token/userinfo, users, email addresses, organizations, memberships, invitations, sessions",
+    async load() {
+      const mod = await import("@emulators/clerk");
+      return { plugin: mod.clerkPlugin, seedFromConfig: mod.seedFromConfig };
+    },
+    defaultFallback(cfg) {
+      const firstEmail = cfg?.users?.[0]?.email_addresses?.[0] ?? "test@example.com";
+      return { login: firstEmail, id: 1, scopes: [] };
+    },
+    initConfig: {
+      clerk: {
+        users: [
+          {
+            first_name: "Test",
+            last_name: "User",
+            email_addresses: ["test@example.com"],
+            password: "clerk_test_password"
+          }
+        ],
+        organizations: [
+          {
+            name: "My Company",
+            slug: "my-company",
+            members: [{ email: "test@example.com", role: "admin" }]
+          }
+        ],
+        oauth_applications: [
+          {
+            client_id: "clerk_emulate_client",
+            client_secret: "clerk_emulate_secret",
+            name: "api-emulator App",
+            redirect_uris: ["http://localhost:3000/api/auth/callback/clerk"]
+          }
+        ]
+      }
+    }
+  }
+};
+
+// src/registry.ts
+var DEFAULT_TOKENS = {
+  tokens: {
+    test_token_admin: {
+      login: "admin",
+      scopes: ["repo", "user", "admin:org", "admin:repo_hook"]
+    },
+    test_token_user1: {
+      login: "octocat",
+      scopes: ["repo", "user"]
+    }
+  }
+};
+async function resolvePluginModules(pluginSpecifiers = []) {
+  const results = await Promise.all(pluginSpecifiers.map(loadExternalPluginModule));
+  const externalEntries = {};
+  for (const pluginModule of results) {
+    if (pluginModule.name in DEFAULT_PLUGIN_REGISTRY) {
+      throw new Error(`Plugin "${pluginModule.name}" conflicts with default plugin "${pluginModule.name}"`);
+    }
+    if (pluginModule.name in externalEntries) {
+      throw new Error(`Duplicate plugin name "${pluginModule.name}"`);
+    }
+    externalEntries[pluginModule.name] = pluginModule;
+  }
+  return { ...DEFAULT_PLUGIN_REGISTRY, ...externalEntries };
+}
+function getDefaultPluginNames() {
+  return [...DEFAULT_PLUGIN_NAMES];
+}
+
+// src/commands/start.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { parse as parseYaml } from "yaml";
+import pc from "picocolors";
+
+// src/portless.ts
+import { execSync, spawnSync } from "child_process";
+import { createInterface } from "readline";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+function hasPortless() {
+  const result = spawnSync("portless", ["--version"], { stdio: "ignore" });
+  return result.status === 0;
+}
+function promptYesNo(question) {
+  return new Promise((resolve4) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve4(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+function isProxyRunning() {
+  const result = spawnSync("portless", ["list"], { stdio: "ignore" });
+  return result.status === 0;
+}
+async function ensurePortless() {
+  if (!hasPortless()) {
+    if (!isInteractive()) {
+      console.error("portless is required but not installed. Run: npm i -g portless");
+      process.exit(1);
+    }
+    const yes = await promptYesNo("portless is not installed. Install it now? (npm i -g portless) [Y/n] ");
+    if (!yes) {
+      console.error("Cannot continue without portless.");
+      process.exit(1);
+    }
+    try {
+      execSync("npm i -g portless", { stdio: "inherit" });
+    } catch {
+      console.error("Failed to install portless.");
+      process.exit(1);
+    }
+    if (!hasPortless()) {
+      console.error("portless was installed but could not be found on PATH.");
+      process.exit(1);
+    }
+  }
+  if (!isProxyRunning()) {
+    console.error("portless proxy is not running. Start it with: portless proxy start");
+    process.exit(1);
+  }
+}
+function registerAliases(aliases) {
+  const registered = [];
+  for (const { name, port } of aliases) {
+    const result = spawnSync("portless", ["alias", name, String(port), "--force"], {
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      if (registered.length > 0) {
+        removeAliases(registered);
+      }
+      throw new Error(`Failed to register portless alias: ${name} -> ${port}`);
+    }
+    registered.push({ name, port });
+  }
+}
+function removeAliases(aliases) {
+  for (const { name } of aliases) {
+    const result = spawnSync("portless", ["alias", "--remove", name], { stdio: "ignore" });
+    if (result.status !== 0) {
+      console.error(`Warning: failed to remove portless alias: ${name}`);
+    }
+  }
+}
+function portlessBaseUrl(serviceName) {
+  return `https://${serviceName}.api-emulator.localhost`;
+}
+
+// src/base-url.ts
+function resolveBaseUrl(opts) {
+  if (opts.seedBaseUrl) {
+    return opts.seedBaseUrl.replace(/\{service\}/g, opts.service);
+  }
+  if (opts.baseUrl) {
+    return opts.baseUrl.replace(/\{service\}/g, opts.service);
+  }
+  const envBaseUrl = process.env.API_EMULATOR_BASE_URL ?? process.env.EMULATE_BASE_URL;
+  if (envBaseUrl) {
+    return envBaseUrl.replace(/\{service\}/g, opts.service);
+  }
+  const portlessUrl = process.env.PORTLESS_URL;
+  if (portlessUrl) {
+    return portlessUrl.replace(/\{service\}/g, opts.service);
+  }
+  return `http://localhost:${opts.port}`;
+}
+
+// src/service-runtime.ts
+import { createServer } from "@emulators/core";
+import { serve } from "@hono/node-server";
+function createAuthTokens(seedConfig) {
+  const tokens = {};
+  if (seedConfig?.tokens) {
+    let tokenId = 100;
+    for (const [token, user] of Object.entries(seedConfig.tokens)) {
+      tokens[token] = { login: user.login, id: tokenId++, scopes: user.scopes };
+    }
+  } else {
+    tokens["test_token_admin"] = { login: "admin", id: 2, scopes: ["repo", "user", "admin:org", "admin:repo_hook"] };
+  }
+  return tokens;
+}
+function createServiceRuntime(options) {
+  const { service, pluginModule, loadedPlugin, port, baseUrl, tokens, seedConfig } = options;
+  const resolverRef = {};
+  const appKeyResolver = loadedPlugin.createAppKeyResolver ? (appId) => resolverRef.current(appId) : void 0;
+  const fallbackUser = pluginModule.defaultFallback(seedConfig);
+  const { app, store, webhooks } = createServer(loadedPlugin.plugin, {
+    port,
+    baseUrl,
+    tokens,
+    appKeyResolver,
+    fallbackUser
+  });
+  resolverRef.current = loadedPlugin.createAppKeyResolver?.(store);
+  const seed = () => {
+    loadedPlugin.plugin.seed?.(store, baseUrl);
+    if (seedConfig && loadedPlugin.seedFromConfig) {
+      loadedPlugin.seedFromConfig(store, baseUrl, seedConfig, webhooks);
+    }
+  };
+  seed();
+  const httpServer = serve({ fetch: app.fetch, port });
+  return {
+    service,
+    url: baseUrl,
+    store,
+    reset() {
+      store.reset();
+      seed();
+    },
+    close() {
+      return new Promise((resolve4, reject) => {
+        httpServer.close((err) => {
+          if (err) reject(err);
+          else resolve4();
+        });
+      });
+    }
+  };
+}
+
+// src/commands/start.ts
+var pkg = { version: "0.5.0" };
+function loadSeedConfig(seedPath) {
+  if (seedPath) {
+    const fullPath = resolve2(seedPath);
+    if (!existsSync(fullPath)) {
+      console.error(`Seed file not found: ${fullPath}`);
+      process.exit(1);
+    }
+    const content = readFileSync(fullPath, "utf-8");
+    try {
+      const config = fullPath.endsWith(".json") ? JSON.parse(content) : parseYaml(content);
+      return { config, source: seedPath };
+    } catch (err) {
+      console.error(`Failed to parse ${seedPath}: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  }
+  const autoFiles = [
+    "api-emulator.config.yaml",
+    "api-emulator.config.yml",
+    "api-emulator.config.json",
+    "emulate.config.yaml",
+    "emulate.config.yml",
+    "emulate.config.json",
+    "service-emulator.config.yaml",
+    "service-emulator.config.yml",
+    "service-emulator.config.json"
+  ];
+  for (const file of autoFiles) {
+    const fullPath = resolve2(file);
+    if (existsSync(fullPath)) {
+      const content = readFileSync(fullPath, "utf-8");
+      try {
+        const config = fullPath.endsWith(".json") ? JSON.parse(content) : parseYaml(content);
+        return { config, source: file };
+      } catch (err) {
+        console.error(`Failed to parse ${file}: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+    }
+  }
+  return null;
+}
+function inferServicesFromConfig(config, availableServices) {
+  const found = availableServices.filter((k) => k in config);
+  return found.length > 0 ? [...found] : null;
+}
+async function startCommand(options) {
+  const { port: basePort } = options;
+  if (options.portless && options.baseUrl) {
+    console.error("--portless and --base-url are mutually exclusive.");
+    process.exit(1);
+  }
+  const loaded = loadSeedConfig(options.seed);
+  const seedConfig = loaded?.config ?? null;
+  const configSource = loaded?.source ?? null;
+  const pluginSpecifiers = options.plugin?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
+  let allPluginModules;
+  try {
+    allPluginModules = await resolvePluginModules(pluginSpecifiers);
+  } catch (err) {
+    console.error(`Failed to load plugins: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+  const defaultPlugins = getDefaultPluginNames();
+  const externalServices = Object.keys(allPluginModules).filter((name) => !defaultPlugins.includes(name));
+  let services;
+  if (options.service) {
+    services = options.service.split(",").map((s) => s.trim());
+  } else if (seedConfig) {
+    services = inferServicesFromConfig(seedConfig, Object.keys(allPluginModules)) ?? [
+      ...defaultPlugins,
+      ...externalServices
+    ];
+  } else {
+    services = [...defaultPlugins, ...externalServices];
+  }
+  for (const svc of services) {
+    if (!allPluginModules[svc]) {
+      console.error(`Unknown service: ${svc}`);
+      process.exit(1);
+    }
+  }
+  const tokens = createAuthTokens(seedConfig);
+  if (options.portless) {
+    await ensurePortless();
+  }
+  const portlessAliases = [];
+  const prepared = [];
+  for (let i = 0; i < services.length; i++) {
+    const svc = services[i];
+    const pluginModule = allPluginModules[svc];
+    const loadedPlugin = await pluginModule.load();
+    const svcSeedConfig = seedConfig?.[svc];
+    const port = svcSeedConfig?.port ?? basePort + i;
+    if (options.portless) {
+      portlessAliases.push({ name: `${svc}.api-emulator`, port });
+    }
+    const seedBaseUrl = typeof svcSeedConfig?.baseUrl === "string" && svcSeedConfig.baseUrl.length > 0 ? svcSeedConfig.baseUrl : void 0;
+    const effectiveBaseUrl = options.portless ? portlessBaseUrl(svc) : options.baseUrl;
+    const baseUrl = resolveBaseUrl({ service: svc, port, baseUrl: effectiveBaseUrl, seedBaseUrl });
+    prepared.push({ svc, pluginModule, loadedPlugin, svcSeedConfig, port, baseUrl });
+  }
+  if (portlessAliases.length > 0) {
+    registerAliases(portlessAliases);
+  }
+  const serviceUrls = [];
+  const runningServices = [];
+  for (const { svc, pluginModule, loadedPlugin, svcSeedConfig, port, baseUrl } of prepared) {
+    serviceUrls.push({ name: svc, url: baseUrl });
+    const running = createServiceRuntime({
+      service: svc,
+      pluginModule,
+      loadedPlugin,
+      port,
+      baseUrl,
+      tokens,
+      seedConfig: svcSeedConfig
+    });
+    runningServices.push(running);
+  }
+  printBanner(serviceUrls, tokens, configSource);
+  const shutdown = () => {
+    console.log(`
+${pc.dim("Shutting down...")}`);
+    if (portlessAliases.length > 0) {
+      removeAliases(portlessAliases);
+    }
+    for (const running of runningServices) {
+      void running.close();
+    }
+    process.exit(0);
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+function printBanner(services, tokens, configSource) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${pc.bold("api-emulator")} ${pc.dim(`v${pkg.version}`)}`);
+  lines.push("");
+  const maxNameLen = Math.max(...services.map((s) => s.name.length));
+  for (const { name, url } of services) {
+    lines.push(`  ${pc.cyan(name.padEnd(maxNameLen + 2))}${pc.bold(url)}`);
+  }
+  lines.push("");
+  const tokenEntries = Object.entries(tokens);
+  if (tokenEntries.length > 0) {
+    lines.push(`  ${pc.dim("Tokens")}`);
+    for (const [token, user] of tokenEntries) {
+      lines.push(`  ${pc.dim(token)} ${pc.dim("->")} ${user.login}`);
+    }
+    lines.push("");
+  }
+  if (configSource) {
+    lines.push(`  ${pc.dim("Config:")} ${configSource}`);
+  } else {
+    lines.push(`  ${pc.dim("Config:")} defaults ${pc.dim("(run")} npx api-emulator init ${pc.dim("to customize)")}`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/init.ts
+import { writeFileSync, existsSync as existsSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import { stringify as yamlStringify } from "yaml";
+async function initCommand(options) {
+  const filename = "api-emulator.config.yaml";
+  const fullPath = resolve3(filename);
+  if (existsSync2(fullPath)) {
+    console.error(`Config file already exists: ${filename}`);
+    process.exit(1);
+  }
+  const pluginSpecifiers = options.plugin?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
+  const pluginModules = await resolvePluginModules(pluginSpecifiers);
+  const availableServices = Object.keys(pluginModules);
+  let config;
+  if (options.service === "all") {
+    config = { ...DEFAULT_TOKENS };
+    for (const name of availableServices) {
+      Object.assign(config, pluginModules[name].initConfig);
+    }
+  } else {
+    const pluginModule = pluginModules[options.service];
+    if (!pluginModule) {
+      console.error(`Unknown service: ${options.service}. Available: ${availableServices.join(", ")}, all`);
+      process.exit(1);
+    }
+    config = { ...DEFAULT_TOKENS, ...pluginModule.initConfig };
+  }
+  const content = yamlStringify(config);
+  writeFileSync(fullPath, content, "utf-8");
+  console.log(`Created ${filename}`);
+  console.log(`
+Run 'npx api-emulator' to start the emulator.`);
+}
+
+// src/commands/list.ts
+async function listCommand(options = {}) {
+  const pluginSpecifiers = options.plugin?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
+  const pluginModules = await resolvePluginModules(pluginSpecifiers);
+  console.log("\nAvailable services:\n");
+  for (const pluginModule of Object.values(pluginModules)) {
+    console.log(`  ${pluginModule.name.padEnd(10)}${pluginModule.label}`);
+    console.log(`            Endpoints: ${pluginModule.endpoints}`);
+    console.log();
+  }
+}
+
+// src/index.ts
+var pkg2 = { version: "0.5.0" };
+var defaultPort = process.env.API_EMULATOR_PORT ?? process.env.EMULATE_PORT ?? process.env.PORT ?? "4000";
+var program = new Command();
+program.name("api-emulator").description("Local API emulators you can run, share, and extend with plugins").version(pkg2.version);
+program.command("start", { isDefault: true }).description("Start the emulator server").option("-p, --port <port>", "Base port", defaultPort).option("-s, --service <services>", "Comma-separated services to enable").option("--seed <file>", "Path to seed config file").option("--base-url <url>", "Override advertised base URL (supports {service} template)").option("--portless", "Serve over HTTPS via portless (auto-registers aliases)").option("--plugin <plugins>", "Comma-separated external plugin paths or package names").action(async (opts) => {
+  const port = parseInt(opts.port, 10);
+  if (Number.isNaN(port) || port < 1 || port > 65535) {
+    console.error(`Invalid port: ${opts.port}`);
+    process.exit(1);
+  }
+  await startCommand({
+    port,
+    service: opts.service,
+    seed: opts.seed,
+    baseUrl: opts.baseUrl,
+    portless: opts.portless,
+    plugin: opts.plugin
+  });
+});
+program.command("init").description("Generate a starter config file").option("-s, --service <service>", "Service to generate config for", "all").option("--plugin <plugins>", "Comma-separated external plugin paths or package names").action(async (opts) => {
+  await initCommand({ service: opts.service, plugin: opts.plugin });
+});
+program.command("list").alias("list-services").description("List available services").option("--plugin <plugins>", "Comma-separated external plugin paths or package names").action(async (opts) => {
+  await listCommand({ plugin: opts.plugin });
+});
+program.parse();
+//# sourceMappingURL=index.js.map