emulate 0.5.0 → 0.6.0

package/dist/api.js

@@ -2,12 +2,9 @@ import {
   importPKCS8,
   jwtVerify
 } from "./chunk-D6EKRYGP.js";
-import {
-  Hono,
-  cors
-} from "./chunk-AQ2CLRU3.js";
 
 // ../@emulators/core/dist/index.js
+import { createServer as createNodeServer } from "http";
 import { createHmac } from "crypto";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
@@ -231,6 +228,397 @@ var Store = class {
     }
   }
 };
+var HonoRequest = class {
+  constructor(request, params) {
+    this.params = params;
+    this.raw = request;
+    this.url = request.url;
+    this.method = request.method;
+    this.path = new URL(request.url).pathname;
+  }
+  raw;
+  url;
+  method;
+  path;
+  header(name) {
+    if (name) return this.raw.headers.get(name) ?? void 0;
+    const headers = {};
+    this.raw.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return headers;
+  }
+  query(name) {
+    return new URL(this.url).searchParams.get(name) ?? void 0;
+  }
+  queries(name) {
+    const values = new URL(this.url).searchParams.getAll(name);
+    return values.length > 0 ? values : void 0;
+  }
+  param(name) {
+    if (!name) return { ...this.params };
+    return this.params[name] ?? "";
+  }
+  json() {
+    return this.raw.json();
+  }
+  text() {
+    return this.raw.text();
+  }
+  arrayBuffer() {
+    return this.raw.arrayBuffer();
+  }
+  async parseBody() {
+    const contentType = this.header("Content-Type") ?? "";
+    if (contentType.includes("multipart/form-data")) {
+      return formDataToObject(await this.raw.formData());
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const params = new URLSearchParams(await this.raw.text());
+      const out = {};
+      for (const [key, value] of params) {
+        appendBodyValue(out, key, value);
+      }
+      return out;
+    }
+    if (contentType.includes("application/json")) {
+      const body = await this.raw.json().catch(() => ({}));
+      return body && typeof body === "object" && !Array.isArray(body) ? body : {};
+    }
+    return {};
+  }
+};
+var Context = class {
+  constructor(request, params, notFoundHandler) {
+    this.notFoundHandler = notFoundHandler;
+    this.req = new HonoRequest(request, params);
+  }
+  req;
+  vars = /* @__PURE__ */ new Map();
+  responseHeaders = new Headers();
+  responseStatus = 200;
+  get(key) {
+    return this.vars.get(key);
+  }
+  set(key, value) {
+    this.vars.set(key, value);
+  }
+  header(name, value) {
+    this.responseHeaders.set(name, value);
+  }
+  status(status) {
+    this.responseStatus = status;
+  }
+  json(data, status, headers) {
+    return this.response(JSON.stringify(data), status, defaultContentType(headers, "application/json; charset=UTF-8"));
+  }
+  text(text, status, headers) {
+    return this.response(text, status, defaultContentType(headers, "text/plain; charset=UTF-8"));
+  }
+  html(html, status, headers) {
+    return this.response(html, status, defaultContentType(headers, "text/html; charset=UTF-8"));
+  }
+  body(body, status, headers) {
+    return this.response(body, status, headers);
+  }
+  redirect(location, status = 302) {
+    return this.response(null, status, { Location: location });
+  }
+  notFound() {
+    return this.notFoundHandler(this);
+  }
+  finalize(response) {
+    if (!hasHeaders(this.responseHeaders)) return response;
+    const headers = new Headers(response.headers);
+    this.responseHeaders.forEach((value, key) => {
+      headers.set(key, value);
+    });
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  response(body, status, headers) {
+    const merged = new Headers(headers);
+    this.responseHeaders.forEach((value, key) => {
+      merged.set(key, value);
+    });
+    return new Response(body, {
+      status: status ?? this.responseStatus,
+      headers: merged
+    });
+  }
+};
+var Hono = class {
+  middleware = [];
+  routes = [];
+  errorHandler = (err) => {
+    const message = err instanceof Error ? err.message : "Internal Server Error";
+    return new Response(message, { status: 500 });
+  };
+  notFoundHandler = () => new Response("404 Not Found", { status: 404 });
+  use(pathOrHandler, ...handlers) {
+    if (typeof pathOrHandler === "string") {
+      this.middleware.push({ method: "ALL", compiled: compilePath(pathOrHandler), handlers });
+    } else {
+      this.middleware.push({ method: "ALL", compiled: compilePath("*"), handlers: [pathOrHandler, ...handlers] });
+    }
+    return this;
+  }
+  on(method, path, ...handlers) {
+    this.routes.push({ method: method.toUpperCase(), compiled: compilePath(path), handlers });
+    return this;
+  }
+  get(path, ...handlers) {
+    return this.on("GET", path, ...handlers);
+  }
+  post(path, ...handlers) {
+    return this.on("POST", path, ...handlers);
+  }
+  put(path, ...handlers) {
+    return this.on("PUT", path, ...handlers);
+  }
+  patch(path, ...handlers) {
+    return this.on("PATCH", path, ...handlers);
+  }
+  delete(path, ...handlers) {
+    return this.on("DELETE", path, ...handlers);
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  notFound(handler) {
+    this.notFoundHandler = handler;
+    return this;
+  }
+  async request(input, init) {
+    if (input instanceof Request) return this.fetch(input);
+    const url = input.startsWith("/") ? `http://localhost${input}` : input;
+    return this.fetch(new Request(url, init));
+  }
+  fetch = async (request) => {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const method = request.method.toUpperCase();
+    const matched = this.match(method, path);
+    const context = new Context(request, matched.params, this.notFoundHandler);
+    try {
+      const response = await this.dispatch(context, matched.handlers);
+      return context.finalize(response ?? await this.notFoundHandler(context));
+    } catch (err) {
+      return context.finalize(await this.errorHandler(err, context));
+    }
+  };
+  match(method, path) {
+    const handlers = [];
+    const params = {};
+    for (const route2 of this.middleware) {
+      const match = matchPath(route2.compiled, path);
+      if (!match) continue;
+      Object.assign(params, match);
+      for (const handler of route2.handlers) {
+        handlers.push({ handler, params: match });
+      }
+    }
+    const route = this.routes.find((candidate) => candidate.method === method && matchPath(candidate.compiled, path) != null) ?? (method === "HEAD" ? this.routes.find((candidate) => candidate.method === "GET" && matchPath(candidate.compiled, path) != null) : void 0);
+    if (route) {
+      const match = matchPath(route.compiled, path) ?? {};
+      Object.assign(params, match);
+      for (const handler of route.handlers) {
+        handlers.push({ handler, params: match });
+      }
+    }
+    return { handlers, params };
+  }
+  async dispatch(context, handlers) {
+    let index = -1;
+    const run = async (nextIndex) => {
+      if (nextIndex <= index) throw new Error("next() called multiple times");
+      index = nextIndex;
+      const matched = handlers[nextIndex];
+      if (!matched) return void 0;
+      const originalParams = context.req.param();
+      Object.assign(originalParams, matched.params);
+      let nextResponse = void 0;
+      let nextCalled = false;
+      const next = async () => {
+        nextCalled = true;
+        nextResponse = await run(nextIndex + 1);
+      };
+      const response = await matched.handler(context, next);
+      if (response instanceof Response) return response;
+      if (nextCalled) return nextResponse;
+      return response;
+    };
+    return run(0);
+  }
+};
+function cors(options = {}) {
+  const origin = options.origin ?? "*";
+  const allowMethods = options.allowMethods ?? ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "OPTIONS"];
+  return async (c, next) => {
+    c.header("Access-Control-Allow-Origin", origin);
+    if (options.credentials) c.header("Access-Control-Allow-Credentials", "true");
+    if (c.req.method.toUpperCase() === "OPTIONS") {
+      c.header("Access-Control-Allow-Methods", allowMethods.join(","));
+      const allowHeaders = options.allowHeaders?.join(",") ?? c.req.header("Access-Control-Request-Headers");
+      if (allowHeaders) c.header("Access-Control-Allow-Headers", allowHeaders);
+      if (options.maxAge != null) c.header("Access-Control-Max-Age", String(options.maxAge));
+      return c.body(null, 204);
+    }
+    await next();
+  };
+}
+function serve(options) {
+  const port = options.port ?? 3e3;
+  const server = createNodeServer(async (req, res) => {
+    try {
+      const request = nodeRequestToFetchRequest(req);
+      const response = await options.fetch(request);
+      await writeFetchResponse(res, response, req.method?.toUpperCase() === "HEAD");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal Server Error";
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/plain; charset=UTF-8");
+      res.end(message);
+    }
+  });
+  server.listen(port, options.hostname);
+  return server;
+}
+function compilePath(pattern) {
+  if (pattern === "*" || pattern === "/*") {
+    return { pattern, regex: /^.*$/, paramNames: [] };
+  }
+  const paramNames = [];
+  let source = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char !== ":") {
+      source += escapeRegex(char);
+      continue;
+    }
+    let name = "";
+    i++;
+    while (i < pattern.length && /[A-Za-z0-9_]/.test(pattern[i])) {
+      name += pattern[i];
+      i++;
+    }
+    i--;
+    paramNames.push(name);
+    if (pattern[i + 1] === "{") {
+      const close = pattern.indexOf("}", i + 2);
+      if (close < 0) throw new Error(`Invalid route pattern: ${pattern}`);
+      const expr = pattern.slice(i + 2, close);
+      source += `(${expr})`;
+      i = close;
+    } else {
+      source += "([^/]+)";
+    }
+  }
+  source += "$";
+  return { pattern, regex: new RegExp(source), paramNames };
+}
+function matchPath(compiled, path) {
+  const match = compiled.regex.exec(path);
+  if (!match) return null;
+  const params = {};
+  for (let i = 0; i < compiled.paramNames.length; i++) {
+    params[compiled.paramNames[i]] = decodePathParam(match[i + 1] ?? "");
+  }
+  return params;
+}
+function decodePathParam(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+}
+function hasHeaders(headers) {
+  for (const _ of headers) return true;
+  return false;
+}
+function defaultContentType(headers, contentType) {
+  const out = new Headers(headers);
+  if (!out.has("Content-Type")) {
+    out.set("Content-Type", contentType);
+  }
+  return out;
+}
+function formDataToObject(formData) {
+  const out = {};
+  for (const [key, value] of formData) {
+    appendBodyValue(out, key, value);
+  }
+  return out;
+}
+function appendBodyValue(target, key, value) {
+  const existing = target[key];
+  if (existing === void 0) {
+    target[key] = value;
+  } else if (Array.isArray(existing)) {
+    existing.push(value);
+  } else {
+    target[key] = [existing, value];
+  }
+}
+function nodeRequestToFetchRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.url ?? "/", `http://${host}`);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) headers.append(key, item);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const method = req.method ?? "GET";
+  const hasBody = method !== "GET" && method !== "HEAD";
+  return new Request(url.toString(), {
+    method,
+    headers,
+    body: hasBody ? req : void 0,
+    duplex: "half"
+  });
+}
+async function writeFetchResponse(res, response, headOnly) {
+  res.statusCode = response.status;
+  res.statusMessage = response.statusText;
+  const headersWithCookies = response.headers;
+  const cookies = headersWithCookies.getSetCookie?.();
+  response.headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie" && cookies && cookies.length > 0) return;
+    res.setHeader(key, value);
+  });
+  if (cookies && cookies.length > 0) {
+    res.setHeader("Set-Cookie", cookies);
+  }
+  if (headOnly || !response.body) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!res.write(value)) {
+        await new Promise((resolve) => res.once("drain", resolve));
+      }
+    }
+    res.end();
+  } catch (err) {
+    res.destroy(err instanceof Error ? err : void 0);
+  }
+}
 var MAX_DELIVERIES = 1e3;
 var WebhookDispatcher = class {
   subscriptions = [];
@@ -520,7 +908,7 @@ var SERVICE_REGISTRY = {
     label: "Vercel REST API emulator",
     endpoints: "projects, deployments, domains, env vars, users, teams, file uploads, protection bypass",
     async load() {
-      const mod = await import("./dist-4X2KPMAJ.js");
+      const mod = await import("./dist-CXRPM6BK.js");
       return { plugin: mod.vercelPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback(cfg) {
@@ -547,7 +935,7 @@ var SERVICE_REGISTRY = {
     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-REDHDZ3V.js");
+      const mod = await import("./dist-PO4CL5SJ.js");
       return {
         plugin: mod.githubPlugin,
         seedFromConfig: mod.seedFromConfig,
@@ -614,7 +1002,7 @@ var SERVICE_REGISTRY = {
     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-KKTYBE5S.js");
+      const mod = await import("./dist-ZY5SZSJ2.js");
       return { plugin: mod.googlePlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback(cfg) {
@@ -694,18 +1082,34 @@ var SERVICE_REGISTRY = {
   },
   slack: {
     label: "Slack API emulator",
-    endpoints: "auth, chat, conversations, users, reactions, team, OAuth, incoming webhooks",
+    endpoints: "auth, chat, conversations, users, profiles, presence, files, pins, bookmarks, views, reactions, team, OAuth, incoming webhooks, inspector",
     async load() {
-      const mod = await import("./dist-CE6BUCWQ.js");
+      const mod = await import("./dist-OGSAVJ25.js");
       return { plugin: mod.slackPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback() {
-      return { login: "U000000001", id: 1, scopes: ["chat:write", "channels:read", "users:read", "reactions:write"] };
+      return {
+        login: "U000000001",
+        id: 1,
+        scopes: []
+      };
     },
     initConfig: {
       slack: {
         team: { name: "My Workspace", domain: "my-workspace" },
-        users: [{ name: "developer", real_name: "Developer", email: "dev@example.com" }],
+        users: [
+          {
+            name: "developer",
+            real_name: "Developer",
+            email: "dev@example.com",
+            profile: {
+              title: "Local Developer",
+              status_text: "Testing locally",
+              status_emoji: ":computer:"
+            },
+            presence: "active"
+          }
+        ],
         channels: [
           { name: "general", topic: "General discussion" },
           { name: "random", topic: "Random stuff" }
@@ -715,10 +1119,45 @@ var SERVICE_REGISTRY = {
           {
             client_id: "12345.67890",
             client_secret: "example_client_secret",
+            app_id: "A000000001",
             name: "My Slack App",
-            redirect_uris: ["http://localhost:3000/api/auth/callback/slack"]
+            redirect_uris: ["http://localhost:3000/api/auth/callback/slack"],
+            scopes: [
+              "chat:write",
+              "channels:read",
+              "channels:history",
+              "channels:join",
+              "channels:manage",
+              "channels:write",
+              "groups:read",
+              "groups:history",
+              "groups:write",
+              "im:read",
+              "im:history",
+              "im:write",
+              "mpim:read",
+              "mpim:history",
+              "mpim:write",
+              "users:read",
+              "users:read.email",
+              "users.profile:read",
+              "users.profile:write",
+              "users:write",
+              "files:read",
+              "files:write",
+              "pins:read",
+              "pins:write",
+              "bookmarks:read",
+              "bookmarks:write",
+              "reactions:read",
+              "reactions:write",
+              "team:read"
+            ],
+            user_scopes: ["users:read", "users.profile:read"],
+            bot_name: "my-bot"
           }
-        ]
+        ],
+        strict_scopes: false
       }
     }
   },
@@ -726,7 +1165,7 @@ var SERVICE_REGISTRY = {
     label: "Apple Sign In / OAuth emulator",
     endpoints: "OAuth authorize, token exchange, JWKS",
     async load() {
-      const mod = await import("./dist-CFST4X4K.js");
+      const mod = await import("./dist-WACHAAVU.js");
       return { plugin: mod.applePlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback(cfg) {
@@ -751,7 +1190,7 @@ var SERVICE_REGISTRY = {
     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-ETHHYBGF.js");
+      const mod = await import("./dist-IFULY5LE.js");
       return { plugin: mod.microsoftPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback(cfg) {
@@ -776,7 +1215,7 @@ var SERVICE_REGISTRY = {
     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("./dist-5JVGPOL3.js");
+      const mod = await import("./dist-XWWZVLQQ.js");
       return { plugin: mod.oktaPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback(cfg) {
@@ -804,7 +1243,7 @@ var SERVICE_REGISTRY = {
     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-LDUHEJAN.js");
+      const mod = await import("./dist-DSJSF3GY.js");
       return { plugin: mod.awsPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback() {
@@ -826,7 +1265,7 @@ var SERVICE_REGISTRY = {
     label: "Resend email API emulator",
     endpoints: "emails, domains, contacts, API keys, inbox UI",
     async load() {
-      const mod = await import("./dist-IBXD3O6A.js");
+      const mod = await import("./dist-R3TNKUIE.js");
       return { plugin: mod.resendPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback() {
@@ -843,7 +1282,7 @@ var SERVICE_REGISTRY = {
     label: "Stripe payments emulator",
     endpoints: "customers, payment methods, customer sessions, payment intents, charges, products, prices, checkout sessions, webhooks",
     async load() {
-      const mod = await import("./dist-ENKE2S7V.js");
+      const mod = await import("./dist-NJJLJT2N.js");
       return { plugin: mod.stripePlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback() {
@@ -861,7 +1300,7 @@ var SERVICE_REGISTRY = {
     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("./dist-PWGOAQC6.js");
+      const mod = await import("./dist-2ZZGNPJI.js");
       return { plugin: mod.mongoatlasPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback() {
@@ -880,7 +1319,7 @@ var SERVICE_REGISTRY = {
     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("./dist-J6LHUR52.js");
+      const mod = await import("./dist-IRUBHCZU.js");
       return { plugin: mod.clerkPlugin, seedFromConfig: mod.seedFromConfig };
     },
     defaultFallback(cfg) {
@@ -917,9 +1356,6 @@ var SERVICE_REGISTRY = {
   }
 };
 
-// src/api.ts
-import { serve } from "@hono/node-server";
-
 // src/base-url.ts
 function resolveBaseUrl(opts) {
   if (opts.seedBaseUrl) {