emulate 0.1.1 → 0.3.0

package/dist/api.js

@@ -0,0 +1,713 @@
+import {
+  importPKCS8,
+  jwtVerify
+} from "./chunk-D6EKRYGP.js";
+import {
+  Hono,
+  cors
+} from "./chunk-TEPNEZ63.js";
+
+// ../@emulators/core/dist/index.js
+import { createHmac } from "crypto";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var Collection = class {
+  constructor(indexFields = []) {
+    this.indexFields = indexFields;
+    this.fieldNames = indexFields.map(String).sort();
+    for (const field of indexFields) {
+      this.indexes.set(String(field), /* @__PURE__ */ new Map());
+    }
+  }
+  items = /* @__PURE__ */ new Map();
+  indexes = /* @__PURE__ */ new Map();
+  autoId = 1;
+  fieldNames;
+  addToIndex(item) {
+    for (const field of this.indexFields) {
+      const value = item[field];
+      if (value === void 0 || value === null) continue;
+      const indexMap = this.indexes.get(String(field));
+      const key = String(value);
+      if (!indexMap.has(key)) {
+        indexMap.set(key, /* @__PURE__ */ new Set());
+      }
+      indexMap.get(key).add(item.id);
+    }
+  }
+  removeFromIndex(item) {
+    for (const field of this.indexFields) {
+      const value = item[field];
+      if (value === void 0 || value === null) continue;
+      const indexMap = this.indexes.get(String(field));
+      const key = String(value);
+      indexMap.get(key)?.delete(item.id);
+    }
+  }
+  insert(data) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const explicitId = data.id != null && data.id > 0 ? data.id : void 0;
+    const id = explicitId ?? this.autoId++;
+    if (id >= this.autoId) {
+      this.autoId = id + 1;
+    }
+    const item = {
+      ...data,
+      id,
+      created_at: now,
+      updated_at: now
+    };
+    this.items.set(id, item);
+    this.addToIndex(item);
+    return item;
+  }
+  get(id) {
+    return this.items.get(id);
+  }
+  findBy(field, value) {
+    if (this.indexes.has(String(field))) {
+      const ids = this.indexes.get(String(field)).get(String(value));
+      if (!ids) return [];
+      return Array.from(ids).map((id) => this.items.get(id)).filter(Boolean);
+    }
+    return this.all().filter((item) => item[field] === value);
+  }
+  findOneBy(field, value) {
+    return this.findBy(field, value)[0];
+  }
+  update(id, data) {
+    const existing = this.items.get(id);
+    if (!existing) return void 0;
+    this.removeFromIndex(existing);
+    const updated = {
+      ...existing,
+      ...data,
+      id,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.items.set(id, updated);
+    this.addToIndex(updated);
+    return updated;
+  }
+  delete(id) {
+    const existing = this.items.get(id);
+    if (!existing) return false;
+    this.removeFromIndex(existing);
+    return this.items.delete(id);
+  }
+  all() {
+    return Array.from(this.items.values());
+  }
+  query(options = {}) {
+    let results = this.all();
+    if (options.filter) {
+      results = results.filter(options.filter);
+    }
+    const total_count = results.length;
+    if (options.sort) {
+      results.sort(options.sort);
+    }
+    const page = options.page ?? 1;
+    const per_page = Math.min(options.per_page ?? 30, 100);
+    const start = (page - 1) * per_page;
+    const paged = results.slice(start, start + per_page);
+    return {
+      items: paged,
+      total_count,
+      page,
+      per_page,
+      has_next: start + per_page < total_count,
+      has_prev: page > 1
+    };
+  }
+  count(filter) {
+    if (!filter) return this.items.size;
+    return this.all().filter(filter).length;
+  }
+  clear() {
+    this.items.clear();
+    for (const indexMap of this.indexes.values()) {
+      indexMap.clear();
+    }
+    this.autoId = 1;
+  }
+};
+var Store = class {
+  collections = /* @__PURE__ */ new Map();
+  _data = /* @__PURE__ */ new Map();
+  collection(name, indexFields = []) {
+    const existing = this.collections.get(name);
+    if (existing) {
+      if (indexFields.length > 0) {
+        const requested = indexFields.map(String).sort();
+        if (existing.fieldNames.length !== requested.length || existing.fieldNames.some((f, i) => f !== requested[i])) {
+          throw new Error(
+            `Collection "${name}" already exists with indexes [${existing.fieldNames}] but was requested with [${requested}]`
+          );
+        }
+      }
+      return existing;
+    }
+    const col = new Collection(indexFields);
+    this.collections.set(name, col);
+    return col;
+  }
+  getData(key) {
+    return this._data.get(key);
+  }
+  setData(key, value) {
+    this._data.set(key, value);
+  }
+  reset() {
+    for (const collection of this.collections.values()) {
+      collection.clear();
+    }
+    this._data.clear();
+  }
+};
+var MAX_DELIVERIES = 1e3;
+var WebhookDispatcher = class {
+  subscriptions = [];
+  deliveries = [];
+  subscriptionIdCounter = 1;
+  deliveryIdCounter = 1;
+  register(sub) {
+    const { id: explicitId, ...rest } = sub;
+    const id = explicitId !== void 0 ? explicitId : this.subscriptionIdCounter++;
+    if (id >= this.subscriptionIdCounter) {
+      this.subscriptionIdCounter = id + 1;
+    }
+    const subscription = { ...rest, id };
+    this.subscriptions.push(subscription);
+    return subscription;
+  }
+  unregister(id) {
+    const idx = this.subscriptions.findIndex((s) => s.id === id);
+    if (idx === -1) return false;
+    this.subscriptions.splice(idx, 1);
+    return true;
+  }
+  getSubscription(id) {
+    return this.subscriptions.find((s) => s.id === id);
+  }
+  getSubscriptions(owner, repo) {
+    return this.subscriptions.filter((s) => {
+      if (owner && s.owner !== owner) return false;
+      if (repo !== void 0 && s.repo !== repo) return false;
+      return true;
+    });
+  }
+  updateSubscription(id, data) {
+    const sub = this.subscriptions.find((s) => s.id === id);
+    if (!sub) return void 0;
+    Object.assign(sub, data);
+    return sub;
+  }
+  async dispatch(event, action, payload, owner, repo) {
+    const matchingSubs = this.subscriptions.filter((s) => {
+      if (!s.active) return false;
+      if (s.owner !== owner) return false;
+      if (repo !== void 0) {
+        if (s.repo !== repo) return false;
+      } else if (s.repo !== void 0) {
+        return false;
+      }
+      return event === "ping" || s.events.includes("*") || s.events.includes(event);
+    });
+    for (const sub of matchingSubs) {
+      const delivery = {
+        id: this.deliveryIdCounter++,
+        hook_id: sub.id,
+        event,
+        action,
+        payload,
+        status_code: null,
+        delivered_at: (/* @__PURE__ */ new Date()).toISOString(),
+        duration: null,
+        success: false
+      };
+      const body = JSON.stringify(payload);
+      const signatureHeaders = {};
+      if (sub.secret) {
+        const hmac = createHmac("sha256", sub.secret).update(body).digest("hex");
+        signatureHeaders["X-Hub-Signature-256"] = `sha256=${hmac}`;
+      }
+      try {
+        const start = Date.now();
+        const response = await fetch(sub.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-GitHub-Event": event,
+            "X-GitHub-Delivery": String(delivery.id),
+            ...signatureHeaders
+          },
+          body,
+          signal: AbortSignal.timeout(1e4)
+        });
+        delivery.duration = Date.now() - start;
+        delivery.status_code = response.status;
+        delivery.success = response.ok;
+      } catch {
+        delivery.duration = 0;
+        delivery.success = false;
+      }
+      this.deliveries.push(delivery);
+      if (this.deliveries.length > MAX_DELIVERIES) {
+        this.deliveries.splice(0, this.deliveries.length - MAX_DELIVERIES);
+      }
+    }
+  }
+  getDeliveries(hookId) {
+    if (hookId !== void 0) {
+      return this.deliveries.filter((d) => d.hook_id === hookId);
+    }
+    return [...this.deliveries];
+  }
+  clear() {
+    this.subscriptions.length = 0;
+    this.deliveries.length = 0;
+    this.subscriptionIdCounter = 1;
+    this.deliveryIdCounter = 1;
+  }
+};
+var DEFAULT_DOCS_URL = "https://emulate.dev";
+function getDocsUrl(c) {
+  return c.get("docsUrl") ?? DEFAULT_DOCS_URL;
+}
+function errorStatus(err) {
+  if (err && typeof err === "object" && "status" in err) {
+    const s = err.status;
+    if (typeof s === "number" && Number.isFinite(s)) return s;
+  }
+  return 500;
+}
+function createApiErrorHandler(documentationUrl) {
+  return (err, c) => {
+    if (documentationUrl) {
+      c.set("docsUrl", documentationUrl);
+    }
+    const status = errorStatus(err);
+    const message = err instanceof Error ? err.message : "Internal Server Error";
+    return c.json(
+      {
+        message,
+        documentation_url: getDocsUrl(c)
+      },
+      status
+    );
+  };
+}
+function createErrorHandler(documentationUrl) {
+  return async (c, next) => {
+    if (documentationUrl) {
+      c.set("docsUrl", documentationUrl);
+    }
+    await next();
+  };
+}
+var errorHandler = createErrorHandler();
+var isDebug = typeof process !== "undefined" && (process.env.DEBUG === "1" || process.env.DEBUG === "true" || process.env.EMULATE_DEBUG === "1");
+function debug(label, ...args) {
+  if (isDebug) {
+    console.log(`[${label}]`, ...args);
+  }
+}
+function authMiddleware(tokens, appKeyResolver, fallbackUser) {
+  return async (c, next) => {
+    const authHeader = c.req.header("Authorization");
+    if (authHeader) {
+      const token = authHeader.replace(/^(Bearer|token)\s+/i, "").trim();
+      if (token.startsWith("eyJ") && appKeyResolver) {
+        try {
+          const [, payloadB64] = token.split(".");
+          const payload = JSON.parse(
+            Buffer.from(payloadB64, "base64url").toString()
+          );
+          const appId = typeof payload.iss === "string" ? parseInt(payload.iss, 10) : payload.iss;
+          if (typeof appId === "number" && !isNaN(appId)) {
+            const appInfo = appKeyResolver(appId);
+            if (appInfo) {
+              const key = await importPKCS8(appInfo.privateKey, "RS256");
+              await jwtVerify(token, key, { algorithms: ["RS256"] });
+              c.set("authApp", {
+                appId,
+                slug: appInfo.slug,
+                name: appInfo.name
+              });
+            }
+          }
+        } catch {
+        }
+      } else {
+        let user = tokens.get(token);
+        if (!user && fallbackUser && token.length > 0) {
+          debug("auth", "fallback user for unknown token", { login: fallbackUser.login, id: fallbackUser.id });
+          user = { login: fallbackUser.login, id: fallbackUser.id, scopes: fallbackUser.scopes };
+        }
+        if (user) {
+          c.set("authUser", user);
+          c.set("authToken", token);
+          c.set("authScopes", user.scopes);
+        }
+      }
+    }
+    await next();
+  };
+}
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var FONTS = {
+  "geist-sans.woff2": readFileSync(join(__dirname, "fonts", "geist-sans.woff2")),
+  "GeistPixel-Square.woff2": readFileSync(join(__dirname, "fonts", "GeistPixel-Square.woff2"))
+};
+function registerFontRoutes(app) {
+  app.get("/_emulate/fonts/:name", (c) => {
+    const name = c.req.param("name");
+    const buf = FONTS[name];
+    if (!buf) return c.notFound();
+    return new Response(buf, {
+      headers: {
+        "Content-Type": "font/woff2",
+        "Cache-Control": "public, max-age=31536000, immutable",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  });
+}
+function createServer(plugin, options = {}) {
+  const port = options.port ?? 4e3;
+  const baseUrl = options.baseUrl ?? `http://localhost:${port}`;
+  const app = new Hono();
+  const store = new Store();
+  const webhooks = new WebhookDispatcher();
+  const tokenMap = /* @__PURE__ */ new Map();
+  if (options.tokens) {
+    for (const [token, user] of Object.entries(options.tokens)) {
+      tokenMap.set(token, {
+        login: user.login,
+        id: user.id,
+        scopes: user.scopes ?? ["repo", "user", "admin:org", "admin:repo_hook"]
+      });
+    }
+  }
+  const docsUrl = options.docsUrl ?? `https://emulate.dev/${plugin.name}`;
+  registerFontRoutes(app);
+  app.onError(createApiErrorHandler(docsUrl));
+  app.use("*", cors());
+  app.use("*", createErrorHandler(docsUrl));
+  app.use("*", authMiddleware(tokenMap, options.appKeyResolver, options.fallbackUser));
+  const rateLimitCounters = /* @__PURE__ */ new Map();
+  let lastPruneAt = Math.floor(Date.now() / 1e3);
+  app.use("*", async (c, next) => {
+    const token = c.get("authToken") ?? "__anonymous__";
+    const now = Math.floor(Date.now() / 1e3);
+    if (now - lastPruneAt > 3600) {
+      for (const [key, val] of rateLimitCounters) {
+        if (val.resetAt <= now) rateLimitCounters.delete(key);
+      }
+      lastPruneAt = now;
+    }
+    let counter = rateLimitCounters.get(token);
+    if (!counter || counter.resetAt <= now) {
+      counter = { remaining: 5e3, resetAt: now + 3600 };
+      rateLimitCounters.set(token, counter);
+    }
+    counter.remaining = Math.max(0, counter.remaining - 1);
+    c.header("X-RateLimit-Limit", "5000");
+    c.header("X-RateLimit-Remaining", String(counter.remaining));
+    c.header("X-RateLimit-Reset", String(counter.resetAt));
+    c.header("X-RateLimit-Resource", "core");
+    if (counter.remaining === 0) {
+      return c.json(
+        {
+          message: "API rate limit exceeded",
+          documentation_url: docsUrl
+        },
+        403
+      );
+    }
+    await next();
+  });
+  plugin.register(app, store, webhooks, baseUrl, tokenMap);
+  app.notFound(
+    (c) => c.json(
+      {
+        message: "Not Found",
+        documentation_url: docsUrl
+      },
+      404
+    )
+  );
+  return { app, store, webhooks, port, baseUrl, tokenMap };
+}
+
+// src/registry.ts
+var SERVICE_REGISTRY = {
+  vercel: {
+    label: "Vercel REST API emulator",
+    endpoints: "projects, deployments, domains, env vars, users, teams, file uploads, protection bypass",
+    async load() {
+      const mod = await import("./dist-JYDZIVC6.js");
+      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: {
+    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("./dist-OCDKIMRJ.js");
+      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: {
+    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("./dist-BKXG6HVH.js");
+      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: {
+    label: "Slack API emulator",
+    endpoints: "auth, chat, conversations, users, reactions, team, OAuth, incoming webhooks",
+    async load() {
+      const mod = await import("./dist-UZSUUE3Y.js");
+      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: {
+    label: "Apple Sign In / OAuth emulator",
+    endpoints: "OAuth authorize, token exchange, JWKS",
+    async load() {
+      const mod = await import("./dist-O4KFIBVU.js");
+      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: {
+    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("./dist-DSSB3LYT.js");
+      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"]
+        }]
+      }
+    }
+  },
+  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("./dist-VVXVP5EZ.js");
+      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" }]
+        }
+      }
+    }
+  }
+};
+
+// src/api.ts
+import { serve } from "@hono/node-server";
+async function createEmulator(options) {
+  const { service, port = 4e3, seed: seedConfig } = options;
+  const entry = SERVICE_REGISTRY[service];
+  if (!entry) {
+    throw new Error(`Unknown service: ${service}`);
+  }
+  const loaded = await entry.load();
+  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"] };
+  }
+  const baseUrl = `http://localhost:${port}`;
+  let cachedResolver;
+  const appKeyResolver = loaded.createAppKeyResolver ? (appId) => cachedResolver(appId) : void 0;
+  const svcSeedConfig = seedConfig?.[service];
+  const fallbackUser = entry.defaultFallback(svcSeedConfig);
+  const { app, store } = createServer(loaded.plugin, { port, baseUrl, tokens, appKeyResolver, fallbackUser });
+  cachedResolver = loaded.createAppKeyResolver?.(store);
+  const seed = () => {
+    loaded.plugin.seed?.(store, baseUrl);
+    if (svcSeedConfig && loaded.seedFromConfig) {
+      loaded.seedFromConfig(store, baseUrl, svcSeedConfig);
+    }
+  };
+  seed();
+  const httpServer = serve({ fetch: app.fetch, port });
+  return {
+    url: baseUrl,
+    reset() {
+      store.reset();
+      seed();
+    },
+    close() {
+      return new Promise((resolve, reject) => {
+        httpServer.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  };
+}
+export {
+  createEmulator
+};
+//# sourceMappingURL=api.js.map