@crvouga/mockingbird-service-slack 1.7.1 → 2.0.0

package/dist/{chunk-LOAZPGDT.js → chunk-PVVAIER7.js}

@@ -1,16 +1,26 @@
 import {
   bindSocketTransport,
   claimSocketTicket,
+  createClock,
   createRuntime,
   markSocketClosed,
   openSocketCount,
+  parseDuration,
+  resolveAdminPrefix,
   unbindSocketTransport
-} from "./chunk-73BP3FZK.js";
+} from "./chunk-56E5SPJ7.js";
 
 // ../../adapters/node/dist/cli.js
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
 
+// ../../adapters/node/dist/fleet.js
+import { randomUUID } from "node:crypto";
+import { chmod, readFile, rename, rm, writeFile } from "node:fs/promises";
+
 // ../../adapters/node/dist/serve.js
 import { createServer } from "node:http";
 var serve = async (api, options = {}) => {
@@ -72,7 +82,7 @@ var serve = async (api, options = {}) => {
         if (done)
           break;
         if (!res.write(value))
-          await new Promise((resolve) => res.once("drain", resolve));
+          await new Promise((resolve2) => res.once("drain", resolve2));
       }
       res.end();
     } catch {
@@ -81,9 +91,9 @@ var serve = async (api, options = {}) => {
       reader.releaseLock();
     }
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.once("error", reject);
-    server.listen(options.port ?? 0, options.host, resolve);
+    server.listen(options.port ?? 0, options.host, resolve2);
   });
   return server;
 };
@@ -100,18 +110,454 @@ var listen = async (api, options = {}) => {
     port,
     host,
     server,
-    close: () => new Promise((resolve, reject) => {
+    close: () => new Promise((resolve2, reject) => {
       server.close((error) => {
         if (error && error.code !== "ERR_SERVER_NOT_RUNNING")
           reject(error);
         else
-          resolve();
+          resolve2();
       });
       server.closeAllConnections?.();
     })
   };
 };
 
+// ../../adapters/node/dist/fleet.js
+var EMPTY = {
+  activeRequests: 0,
+  activeConnections: 0,
+  blockedCommands: 0,
+  pendingJobs: 0,
+  pendingWebhooks: 0,
+  unmatchedRequests: 0
+};
+var NS = /^[A-Za-z0-9_.-]{1,64}$/;
+var json = (status, value) => Response.json(value, { status });
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pending = (d) => d.activeRequests + d.blockedCommands + d.pendingJobs + d.pendingWebhooks;
+var publicUrl = (raw) => {
+  const url = new URL(raw);
+  url.password = "";
+  return url.href;
+};
+var atomicWrite = async (path, value) => {
+  const temp = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await chmod(temp, 384);
+    await rename(temp, path);
+  } finally {
+    await rm(temp, { force: true });
+  }
+};
+var removeOwned = async (path, id) => {
+  if (!path)
+    return;
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (isObject(value) && value.id === id)
+      await rm(path, { force: true });
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+};
+var httpChild = async (target, entry, options) => {
+  const runtime = await target.create(entry.options ?? {}, {
+    adminPrefix: resolveAdminPrefix(entry.adminPrefix),
+    adminKey: entry.adminKey,
+    seed: entry.seed,
+    onLog: options.onLog
+  });
+  const adminPrefix = resolveAdminPrefix(entry.adminPrefix);
+  runtime.isolateNamespaces();
+  const locked = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Map();
+  const api = {
+    async fetch(request) {
+      const namespace = runtime.namespaceOf(request);
+      if (locked.has(namespace))
+        return json(409, { error: "fleet control in progress", namespace });
+      active.set(namespace, (active.get(namespace) ?? 0) + 1);
+      try {
+        return await runtime.fetch(request);
+      } finally {
+        active.set(namespace, (active.get(namespace) ?? 1) - 1);
+      }
+    }
+  };
+  let server;
+  try {
+    server = await listen(api, {
+      port: entry.port ?? target.defaultPort,
+      host: entry.host ?? "127.0.0.1"
+    });
+    target.listening?.(server);
+  } catch (error) {
+    runtime.stop?.();
+    await server?.close();
+    runtime.webhooks?.clear();
+    await runtime.webhooks?.idle();
+    throw error;
+  }
+  return {
+    protocol: "http",
+    url: server.url,
+    healthUrl: `${server.url}${adminPrefix}/health`,
+    adminUrl: `${server.url}${adminPrefix}`,
+    namespaces: { header: "x-mockingbird-namespace", path: `${adminPrefix}/ns/{name}` },
+    ready: async () => {
+      try {
+        return (await fetch(`${server.url}${adminPrefix}/health`, { signal: AbortSignal.timeout(2e3) })).ok;
+      } catch {
+        return false;
+      }
+    },
+    async close() {
+      runtime.stop?.();
+      runtime.webhooks?.clear();
+      await server.close();
+      await runtime.webhooks?.idle();
+    },
+    lock(namespace) {
+      if (locked.has(namespace))
+        throw new Error("namespace already locked");
+      locked.add(namespace);
+      return () => locked.delete(namespace);
+    },
+    diagnostics(namespace) {
+      return {
+        ...EMPTY,
+        activeRequests: active.get(namespace) ?? 0,
+        pendingWebhooks: runtime.webhooks?.pending(namespace) ?? 0,
+        unmatchedRequests: runtime.metrics.report(namespace).unmatched.reduce((n, r) => n + r.count, 0)
+      };
+    },
+    async checkpoint(namespace) {
+      return runtime.fleetSnapshot(namespace);
+    },
+    async restore(namespace, checkpoint) {
+      runtime.fleetRestore(checkpoint, namespace);
+    },
+    reset: (namespace) => runtime.reset(namespace),
+    clock: (namespace) => runtime.namespaceClock(namespace),
+    async settle(namespace) {
+      const instance = runtime.instance(namespace);
+      instance.tick?.();
+      await runtime.webhooks?.idle();
+    }
+  };
+};
+async function startFleet(config, options) {
+  const id = randomUUID();
+  const startedAt2 = (/* @__PURE__ */ new Date()).toISOString();
+  const children = /* @__PURE__ */ new Map();
+  const clocks = /* @__PURE__ */ new Map();
+  const checkpoints = /* @__PURE__ */ new Map();
+  let supervisor;
+  let stopped = false;
+  let controlling = false;
+  const close = async () => {
+    if (stopped)
+      return;
+    stopped = true;
+    await Promise.allSettled([...children.values()].map((child) => child.close()));
+    await supervisor?.close();
+    await removeOwned(options.readyFile, id);
+    await removeOwned(options.connectionsFile, id);
+  };
+  if (options.readyFile)
+    await rm(options.readyFile, { force: true });
+  if (options.connectionsFile)
+    await rm(options.connectionsFile, { force: true });
+  const clock = (namespace) => {
+    let value = clocks.get(namespace);
+    if (!value) {
+      value = createClock();
+      clocks.set(namespace, value);
+    }
+    return value;
+  };
+  const select = (body) => {
+    if (body.services === void 0)
+      return children;
+    if (!Array.isArray(body.services) || body.services.length === 0)
+      throw new Error("services must be a nonempty list");
+    const selected = /* @__PURE__ */ new Map();
+    for (const name of body.services) {
+      if (typeof name !== "string" || !children.has(name))
+        throw new Error("unknown service in selection");
+      selected.set(name, children.get(name));
+    }
+    return selected;
+  };
+  const diagnostics = (namespace) => Object.fromEntries([...children].map(([name, child]) => [name, child.diagnostics(namespace)]));
+  const transaction = async (namespace, selected, run) => {
+    if (controlling)
+      return json(409, { error: "another fleet operation is in progress" });
+    controlling = true;
+    const release = [];
+    const before = /* @__PURE__ */ new Map();
+    const results = {};
+    let failure;
+    try {
+      for (const [name, child] of selected) {
+        failure = name;
+        release.push(child.lock(namespace));
+      }
+      const busy = Object.fromEntries([...selected].filter(([, child]) => {
+        const state = child.diagnostics(namespace);
+        return state.activeRequests + state.blockedCommands + state.pendingWebhooks + (state.activeJobs ?? 0) > 0;
+      }).map(([name, child]) => [name, child.diagnostics(namespace)]));
+      if (Object.keys(busy).length)
+        return json(409, { error: "namespace is not quiescent", services: busy });
+      for (const [name, child] of selected) {
+        failure = name;
+        before.set(name, await child.checkpoint(namespace));
+      }
+      for (const [name, child] of selected) {
+        failure = name;
+        results[name] = { status: "ok", result: await run(name, child) };
+      }
+      return json(200, { status: "ok", namespace, services: results });
+    } catch {
+      const rollback = {};
+      for (const [name, point] of before) {
+        try {
+          await selected.get(name)?.restore(namespace, point);
+          rollback[name] = "restored";
+        } catch {
+          rollback[name] = "failed";
+        }
+      }
+      return json(500, {
+        status: "failed",
+        namespace,
+        failedService: failure,
+        services: results,
+        rollback,
+        rolledBack: before.size > 0 && Object.values(rollback).every((value) => value === "restored")
+      });
+    } finally {
+      for (const unlock of release.reverse())
+        unlock();
+      controlling = false;
+    }
+  };
+  const api = {
+    async fetch(request) {
+      const url = new URL(request.url);
+      const adminPrefix = resolveAdminPrefix(config.adminPrefix);
+      const path = url.pathname.startsWith(`${adminPrefix}/`) ? url.pathname.slice(adminPrefix.length) : "";
+      if (path === "/health" && request.method === "GET") {
+        const states = await Promise.all([...children].map(async ([name, child]) => {
+          let protocolReady = false;
+          try {
+            protocolReady = await child.ready();
+          } catch {
+          }
+          return [
+            name,
+            {
+              processReady: !stopped,
+              protocolReady,
+              status: protocolReady ? "ready" : "failed",
+              url: publicUrl(child.url)
+            }
+          ];
+        }));
+        const ready = !stopped && states.every(([, state]) => state.protocolReady);
+        return json(ready ? 200 : 503, {
+          status: ready ? "ready" : "failed",
+          id,
+          services: Object.fromEntries(states)
+        });
+      }
+      if (!path.startsWith("/fleet/"))
+        return json(404, { error: "not found" });
+      const adminKey = config.adminKey ?? process.env.MOCKINGBIRD_ADMIN_KEY;
+      if (adminKey !== void 0 && request.headers.get("x-mockingbird-admin-key") !== adminKey)
+        return json(401, { error: "admin key required" });
+      const route = /^\/fleet\/namespaces\/([^/]+)\/(reset|snapshots)(?:\/([^/]+)\/restore)?$/.exec(path);
+      const namespace = route ? decodeURIComponent(route[1]) : url.searchParams.get("namespace") ?? request.headers.get("x-mockingbird-namespace") ?? config.namespace ?? "default";
+      if (!NS.test(namespace))
+        return json(400, { error: "invalid namespace" });
+      if (request.method === "GET" && path === "/fleet/metrics")
+        return json(200, { namespace, services: diagnostics(namespace) });
+      if (request.method === "GET" && path === "/fleet/clock")
+        return json(200, {
+          namespace,
+          ...clock(namespace).state(),
+          services: Object.fromEntries([...children].map(([name, child]) => [name, child.clock(namespace).state()]))
+        });
+      if (request.method !== "POST")
+        return json(405, { error: "method not allowed" });
+      let body;
+      try {
+        const text2 = await request.text();
+        const value = text2 ? JSON.parse(text2) : {};
+        if (!isObject(value))
+          throw new Error("expected object");
+        body = value;
+      } catch {
+        return json(400, { error: "expected JSON object" });
+      }
+      let selected;
+      try {
+        selected = select(body);
+      } catch (error) {
+        return json(400, { error: error instanceof Error ? error.message : "bad selection" });
+      }
+      if (path === "/fleet/wait-until-idle") {
+        const services = diagnostics(namespace);
+        const idle = Object.values(services).every((d) => pending(d) === 0);
+        return json(idle ? 200 : 409, { status: idle ? "idle" : "busy", namespace, services });
+      }
+      if (path === "/fleet/clock") {
+        const current = clock(namespace);
+        let target = current.now();
+        if (body.set !== void 0) {
+          target = typeof body.set === "number" ? body.set : typeof body.set === "string" ? Date.parse(body.set) : NaN;
+          if (!Number.isFinite(target))
+            return json(400, { error: "set must be epoch ms or ISO-8601" });
+        }
+        if (body.advance !== void 0) {
+          const delta = parseDuration(body.advance);
+          if (delta === void 0)
+            return json(400, { error: "invalid advance" });
+          target += delta;
+        }
+        const frozen = body.freeze === void 0 ? current.state().frozen : body.freeze;
+        if (typeof frozen !== "boolean")
+          return json(400, { error: "freeze must be boolean" });
+        const response2 = await transaction(namespace, selected, async (_name, child) => {
+          const childClock = child.clock(namespace);
+          childClock.freeze();
+          childClock.set(target);
+          if (!frozen)
+            childClock.unfreeze();
+          await child.settle?.(namespace);
+          return childClock.state();
+        });
+        if (response2.ok) {
+          current.freeze();
+          current.set(target);
+          if (!frozen)
+            current.unfreeze();
+        }
+        return response2;
+      }
+      if (!route)
+        return json(404, { error: "not found" });
+      if (route[2] === "reset") {
+        if (route[3])
+          return json(404, { error: "not found" });
+        const response2 = await transaction(namespace, selected, async (_name, child) => child.reset(namespace));
+        if (response2.ok && selected.size === children.size)
+          clock(namespace).reset();
+        return response2;
+      }
+      if (route[3]) {
+        const point = checkpoints.get(route[3]);
+        if (!point || point.namespace !== namespace)
+          return json(404, { error: "no snapshot in this namespace" });
+        const restored = new Map([...point.values].map(([name]) => [name, children.get(name)]));
+        const response2 = await transaction(namespace, restored, async (name, child) => child.restore(namespace, point.values.get(name)));
+        if (response2.ok) {
+          const current = clock(namespace);
+          current.freeze();
+          current.set(point.clock.now);
+          if (!point.clock.frozen)
+            current.unfreeze();
+        }
+        return response2;
+      }
+      const snapshotId = randomUUID();
+      const values = /* @__PURE__ */ new Map();
+      const response = await transaction(namespace, selected, async (name, child) => {
+        values.set(name, await child.checkpoint(namespace));
+        return { checkpoint: `${snapshotId}:${name}` };
+      });
+      if (!response.ok)
+        return response;
+      checkpoints.set(snapshotId, { namespace, values, clock: clock(namespace).state() });
+      return json(201, {
+        ...await response.json(),
+        id: snapshotId,
+        label: body.label
+      });
+    }
+  };
+  try {
+    const adminPrefix = resolveAdminPrefix(config.adminPrefix);
+    if (!isObject(config.services) || Object.keys(config.services).length === 0)
+      throw new Error("config must contain at least one service");
+    for (const [name, entry] of Object.entries(config.services)) {
+      if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
+        throw new Error("invalid service name");
+      try {
+        const target = await options.load(name);
+        if (entry.protocol && entry.protocol !== ("protocol" in target ? target.protocol : "http"))
+          throw new Error("configured protocol does not match target");
+        const adminKey = entry.adminKey ?? config.adminKey ?? process.env.MOCKINGBIRD_ADMIN_KEY;
+        const child = "start" in target ? await target.start(entry) : await httpChild(target, {
+          ...entry,
+          adminPrefix: resolveAdminPrefix(entry.adminPrefix ?? adminPrefix),
+          ...adminKey !== void 0 ? { adminKey } : {}
+        }, options);
+        children.set(name, child);
+        if (!await child.ready())
+          throw new Error("protocol readiness failed");
+      } catch {
+        throw new Error(`service ${name} failed to start; all started listeners were closed`);
+      }
+    }
+    supervisor = await listen(api, {
+      port: config.control?.port ?? 0,
+      host: config.control?.host ?? "127.0.0.1"
+    });
+    const manifest = {
+      version: 1,
+      state: "ready",
+      pid: process.pid,
+      id,
+      startedAt: startedAt2,
+      adminBase: `${supervisor.url}${adminPrefix}/fleet`,
+      healthUrl: `${supervisor.url}${adminPrefix}/health`,
+      services: Object.fromEntries([...children].map(([name, child]) => [
+        name,
+        {
+          protocol: child.protocol,
+          url: publicUrl(child.url),
+          healthUrl: child.healthUrl ?? `${supervisor?.url}${adminPrefix}/health`,
+          adminUrl: child.adminUrl ?? `${supervisor?.url}${adminPrefix}/fleet`,
+          namespaces: child.namespaces,
+          processReady: true,
+          protocolReady: true
+        }
+      ]))
+    };
+    if (options.connectionsFile)
+      await atomicWrite(options.connectionsFile, {
+        version: 1,
+        id,
+        pid: process.pid,
+        services: Object.fromEntries([...children].map(([name, child]) => [
+          name,
+          { url: child.connection ?? child.url, namespaces: child.connections }
+        ]))
+      });
+    if (options.readyFile)
+      await atomicWrite(options.readyFile, manifest);
+    options.onReady?.(manifest);
+    return { manifest, children, fetch: api.fetch, close };
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+
 // ../../adapters/node/dist/cli.js
 var optionHelp = (options) => Object.entries(options).map(([name, option]) => {
   const flag = `--${name}${option.type === "string" ? ` ${option.value ?? "<value>"}` : ""}`;
@@ -181,6 +627,11 @@ ${commandHelp(spec, name, command)}`);
 var COMMON_SERVE_OPTIONS = {
   port: { type: "string", value: "<port>", description: "Port to listen on" },
   host: { type: "string", value: "<host>", description: "Interface to bind", default: "127.0.0.1" },
+  "admin-prefix": {
+    type: "string",
+    value: "<path>",
+    description: "Internal API prefix (default /__admin; env MOCKINGBIRD_ADMIN_PREFIX)"
+  },
   "admin-key": {
     type: "string",
     value: "<key>",
@@ -201,6 +652,20 @@ var COMMON_SERVE_OPTIONS = {
     type: "string",
     value: "<file>",
     description: "Serve every service in a mockingbird.json config instead"
+  },
+  "ready-file": {
+    type: "string",
+    description: "Atomically publish fleet endpoint JSON",
+    value: "<file>"
+  },
+  "connections-file": {
+    type: "string",
+    description: "Write private connection URLs with mode 0600",
+    value: "<file>"
+  },
+  "ready-json": {
+    type: "boolean",
+    description: "Emit one public JSON record after fleet readiness"
   }
 };
 var formatLog = (format) => {
@@ -224,7 +689,13 @@ var loadTarget = async (name, own) => {
     return own;
   const specifier = `@crvouga/mockingbird-service-${name}/server`;
   try {
-    const mod = await import(specifier);
+    let mod;
+    try {
+      mod = await import(specifier);
+    } catch {
+      const fromProject = createRequire(resolve(process.cwd(), "package.json"));
+      mod = await import(pathToFileURL(fromProject.resolve(specifier)).href);
+    }
     if (!mod.serveTarget)
       throw new Error(`${specifier} exports no serveTarget`);
     return mod.serveTarget;
@@ -234,7 +705,9 @@ var loadTarget = async (name, own) => {
   }
 };
 var start = async (target, values, config) => {
+  const adminPrefix = resolveAdminPrefix(config.adminPrefix);
   const runtime = await target.create(values, {
+    adminPrefix,
     adminKey: config.adminKey,
     seed: config.seed,
     onLog: formatLog(config.log)
@@ -242,24 +715,27 @@ var start = async (target, values, config) => {
   const listening = await listen(runtime, { port: config.port, host: config.host });
   target.listening?.(listening);
   console.log(`${target.name} mock listening on ${listening.url}`);
-  console.log(`${target.name} health: GET ${listening.url}/health`);
-  console.log(`${target.name} admin: ${listening.url}/__admin (${config.adminKey ? "x-mockingbird-admin-key required" : "open \u2014 pass --admin-key to lock"})`);
-  console.log(`${target.name} admin ui: ${listening.url}/__admin/ui`);
+  console.log(`${target.name} health: GET ${listening.url}${adminPrefix}/health`);
+  console.log(`${target.name} admin: ${listening.url}${adminPrefix} (${config.adminKey ? "x-mockingbird-admin-key required" : "open \u2014 pass --admin-key to lock"})`);
+  console.log(`${target.name} admin ui: ${listening.url}${adminPrefix}/ui`);
   for (const line of target.banner?.(runtime) ?? [])
-    console.log(`${target.name} ${line}`);
+    console.log(`${target.name} ${line.replaceAll("/__admin", adminPrefix)}`);
   return listening;
 };
-var untilSignal = async (servers) => new Promise((resolve) => {
+var untilSignal = async (servers) => new Promise((resolve2) => {
   const stop = async () => {
+    ;
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
     await Promise.allSettled(servers.map((s) => s.close()));
-    resolve(0);
+    resolve2(0);
   };
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
 });
 var serveCommand = (target) => ({
-  summary: `Serve the ${target.name} mock over HTTP`,
-  options: { ...COMMON_SERVE_OPTIONS, ...target.options },
+  summary: `Serve the ${target.name} mock or a configured fleet`,
+  options: { ...COMMON_SERVE_OPTIONS, ..."options" in target ? target.options : {} },
   async run(values) {
     const log = values["log-requests"] === true ? "json" : asString(values.log) ?? "pretty";
     if (!["pretty", "json", "off"].includes(log)) {
@@ -268,25 +744,34 @@ var serveCommand = (target) => ({
     }
     const configPath = asString(values.config);
     if (configPath !== void 0) {
-      const config = JSON.parse(await readFile(configPath, "utf8"));
-      const servers = [];
       try {
-        for (const [name, entry] of Object.entries(config.services ?? {})) {
-          const each = await loadTarget(name, target);
-          servers.push(await start(each, entry.options ?? {}, {
-            port: entry.port ?? each.defaultPort,
-            host: entry.host ?? "127.0.0.1",
-            ...entry.adminKey !== void 0 ? { adminKey: entry.adminKey } : {},
-            ...entry.seed !== void 0 ? { seed: entry.seed } : {},
-            log: config.log ?? log
-          }));
-        }
+        const config = JSON.parse(await readFile2(configPath, "utf8"));
+        config.adminPrefix = resolveAdminPrefix(config.adminPrefix ?? asString(values["admin-prefix"]) ?? process.env.MOCKINGBIRD_ADMIN_PREFIX);
+        const adminKey2 = config.adminKey ?? asString(values["admin-key"]) ?? process.env.MOCKINGBIRD_ADMIN_KEY;
+        if (adminKey2 !== void 0)
+          config.adminKey = adminKey2;
+        const fleet = await startFleet(config, {
+          load: (name) => loadTarget(name, target),
+          onLog: formatLog(config.log ?? log),
+          ...asString(values["ready-file"]) ? { readyFile: asString(values["ready-file"]) } : {},
+          ...asString(values["connections-file"]) ? { connectionsFile: asString(values["connections-file"]) } : {},
+          onReady: (manifest) => {
+            if (values["ready-json"])
+              console.log(JSON.stringify(manifest));
+            else
+              for (const [name, endpoint] of Object.entries(manifest.services))
+                console.log(`${name} mock listening on ${endpoint.url}`);
+          }
+        });
+        return untilSignal([fleet]);
       } catch (error) {
-        await Promise.allSettled(servers.map((s) => s.close()));
         console.error(error instanceof Error ? error.message : String(error));
         return 1;
       }
-      return untilSignal(servers);
+    }
+    if ("start" in target) {
+      console.error("Use --config to supervise protocol services with this command");
+      return 2;
     }
     const port = asString(values.port);
     const adminKey = asString(values["admin-key"]) ?? process.env.MOCKINGBIRD_ADMIN_KEY;
@@ -294,6 +779,7 @@ var serveCommand = (target) => ({
     let listening;
     try {
       listening = await start(target, values, {
+        adminPrefix: resolveAdminPrefix(asString(values["admin-prefix"]) ?? process.env.MOCKINGBIRD_ADMIN_PREFIX),
         port: port === void 0 ? target.defaultPort : Number.parseInt(port, 10),
         host: asString(values.host) ?? "127.0.0.1",
         ...adminKey !== void 0 ? { adminKey } : {},
@@ -627,6 +1113,7 @@ var serveTarget = {
         ...token ? { tokens: [token] } : {},
         ...values["strict-channels"] === true ? { strictChannels: true } : {}
       },
+      ...common.adminPrefix !== void 0 ? { adminPrefix: common.adminPrefix } : {},
       ...common.adminKey !== void 0 ? { adminKey: common.adminKey } : {},
       ...common.seed !== void 0 ? { seed: common.seed } : {},
       ...common.onLog ? { onLog: common.onLog } : {}
@@ -650,4 +1137,4 @@ export {
   createServer2 as createServer,
   serveTarget
 };
-//# sourceMappingURL=chunk-LOAZPGDT.js.map
+//# sourceMappingURL=chunk-PVVAIER7.js.map