contract-drift-detection 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## 0.1.2 - 2026-03-16
+
+### Added
+
+- Root command now accepts serve options directly for faster first-run usage.
+- New runtime diagnostics endpoint: `GET /__routes`.
+- Proxy robustness test coverage for auth header forwarding and diagnostics route.
+
+### Improved
+
+- Startup output now prints a clear banner with mode/spec/db/routes information.
+- Drift alerts are more prominent and actionable in terminal output.
+- Drift validation now skips non-2xx proxy responses to reduce false/noisy alerts.
+- Proxy forwarding now preserves incoming request headers more faithfully.
+
+## 0.1.1 - 2026-03-16
+
+### Added
+
+- New `serve` onboarding modes:
+  - `--spec-url <url>` to fetch remote OpenAPI specs
+  - `--discover <backend-url>` to auto-discover OpenAPI endpoints
+- New `quickstart` command to generate starter contract and run instantly.
+- `init --template rest-crud|none` for template-driven setup.
+- Local cache for remote/discovered specs under `.cdd/`.
+- New onboarding tests covering local, remote, and discovery-based spec resolution.
+
+### Improved
+
+- README now includes no-friction first-run flows for users without an existing local spec file.
+
+## 0.1.0 - 2026-03-16
+
+### Added
+
+- Initial public release with stateful OpenAPI mock server.
+- CRUD route generation from OpenAPI 3.x documents.
+- `x-mock-state` workflow action support.
+- Proxy mode with contract drift detection.
+- Browser CORS support and frontend/backend demo harness.

package/README.md

@@ -39,9 +39,11 @@ This project combines both and adds a third layer: drift detection against a liv
 ### Use directly with `npx` (no install)
 
 ```bash
-npx contract-drift-detection@latest serve --spec ./openapi.yaml --port 4010
+npx contract-drift-detection@latest --spec ./openapi.yaml --port 4010
 ```
 
+(`serve` subcommand is optional; root command accepts serve options.)
+
 ### Install globally
 
 ```bash
@@ -64,23 +66,41 @@ npm run dev
 
 ## 30-second quick start
 
-Run the included example API:
+No spec file yet? Start instantly:
+
+```bash
+npx contract-drift-detection@latest quickstart
+```
+
+Already have an OpenAPI file? Start with local spec:
 
 ```bash
-npx tsx src/cli.ts serve --spec ./examples/helpdesk.openapi.yaml --port 4010
+npx contract-drift-detection@latest serve --spec ./openapi.yaml --port 4010
 ```
 
-Create a starter config file in any project:
+Create a starter config + starter OpenAPI file in current directory:
 
 ```bash
-npx tsx src/cli.ts init
+npx contract-drift-detection@latest init
+```
+
+If your backend already exposes OpenAPI, avoid writing spec manually:
+
+```bash
+npx contract-drift-detection@latest serve --discover http://localhost:8080 --port 4010
+```
+
+Or use direct remote spec URL:
+
+```bash
+npx contract-drift-detection@latest serve --spec-url http://localhost:8080/openapi.json --port 4010
 ```
 
 Start in drift detection mode against a real backend:
 
 ```bash
-npx tsx src/cli.ts serve \
-  --spec ./examples/helpdesk.openapi.yaml \
+npx contract-drift-detection@latest serve \
+  --discover http://localhost:8080 \
   --port 4010 \
   --drift-check http://localhost:8080
 ```
@@ -92,12 +112,24 @@ Point your frontend API base URL to `http://localhost:4010`.
 ## CLI
 
 ```text
-contract-drift-detection serve --spec <path> [--port 4010] [--host 0.0.0.0] [--db .mock-db.json] [--cors-origin *] [--drift-check <url>] [--fallback-to-mock] [--verbose]
-contract-drift-detection init [--spec openapi.yaml] [--db .mock-db.json] [--port 4010] [--host 0.0.0.0]
+contract-drift-detection serve [--spec <path> | --spec-url <url> | --discover <backend-url>] [--port 4010] [--host 0.0.0.0] [--db .mock-db.json] [--cors-origin *] [--drift-check <url>] [--fallback-to-mock] [--verbose]
+contract-drift-detection init [--spec openapi.yaml] [--template rest-crud|none] [--db .mock-db.json] [--port 4010] [--host 0.0.0.0]
+contract-drift-detection quickstart [--spec openapi.yaml] [--port 4010] [--host 0.0.0.0] [--db .mock-db.json] [--cors-origin *] [--verbose]
+
+# Root command (equivalent to serve)
+contract-drift-detection [--spec <path> | --spec-url <url> | --discover <backend-url>] [--port 4010] ...
 ```
 
 `--cors-origin` defaults to `*` for frictionless browser testing.
 
+Spec resolution priority in `serve` is:
+
+1. `--spec`
+2. `--spec-url`
+3. `--discover`
+
+Remote/discovered specs are cached locally under `.cdd/`.
+
 ## Recommended workflows
 
 ### A) Frontend-first (mock only)
@@ -149,6 +181,7 @@ Values inside `assign` and `set` can reference request input with `{{body.field}
 
 - `GET /__health` returns a simple health payload.
 - `GET /__spec` returns the dereferenced OpenAPI document currently in memory.
+- `GET /__routes` returns generated route diagnostics (method/path/operation).
 
 ## Browser/CORS notes
 

package/dist/cli.js

@@ -4,22 +4,257 @@
 import process from "process";
 
 // src/config.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+import { Command } from "commander";
+
+// src/onboarding.ts
 import { mkdir, writeFile } from "fs/promises";
 import path from "path";
-import { Command } from "commander";
+var DISCOVERY_PATHS = [
+  "/openapi.json",
+  "/openapi.yaml",
+  "/swagger.json",
+  "/v3/api-docs",
+  "/api-docs-json"
+];
+var STARTER_SPEC = `openapi: 3.0.3
+info:
+  title: Contract Drift Detection Starter API
+  version: 1.0.0
+paths:
+  /users:
+    get:
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/User'
+    post:
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/UserCreateInput'
+      responses:
+        '201':
+          description: created
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+  /users/{id}:
+    get:
+      parameters:
+        - $ref: '#/components/parameters/UserId'
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+    patch:
+      parameters:
+        - $ref: '#/components/parameters/UserId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/UserPatchInput'
+      responses:
+        '200':
+          description: updated
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+    delete:
+      parameters:
+        - $ref: '#/components/parameters/UserId'
+      responses:
+        '204':
+          description: deleted
+  /tickets:
+    get:
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Ticket'
+  /tickets/{id}/resolve:
+    post:
+      parameters:
+        - $ref: '#/components/parameters/TicketId'
+      x-mock-state:
+        action: update
+        target: tickets
+        find_by: id
+        set:
+          status: resolved
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Ticket'
+components:
+  parameters:
+    UserId:
+      name: id
+      in: path
+      required: true
+      schema:
+        type: integer
+    TicketId:
+      name: id
+      in: path
+      required: true
+      schema:
+        type: integer
+  schemas:
+    User:
+      type: object
+      required: [id, name, email]
+      properties:
+        id:
+          type: integer
+        name:
+          type: string
+        email:
+          type: string
+          format: email
+    UserCreateInput:
+      type: object
+      required: [name, email]
+      properties:
+        name:
+          type: string
+        email:
+          type: string
+          format: email
+    UserPatchInput:
+      type: object
+      properties:
+        name:
+          type: string
+        email:
+          type: string
+          format: email
+    Ticket:
+      type: object
+      required: [id, title, status]
+      properties:
+        id:
+          type: integer
+        title:
+          type: string
+        status:
+          type: string
+          enum: [open, resolved]
+`;
+function normalizeBaseUrl(value) {
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function inferSpecExtension(contentType, content) {
+  const normalized = contentType.toLowerCase();
+  if (normalized.includes("json")) {
+    return "json";
+  }
+  const trimmed = content.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[") ? "json" : "yaml";
+}
+async function cacheSpecContent(cwd, specContent, extension, filePrefix) {
+  const cacheDir = path.join(cwd, ".cdd");
+  await mkdir(cacheDir, { recursive: true });
+  const filePath = path.join(cacheDir, `${filePrefix}.${extension}`);
+  await writeFile(filePath, specContent, "utf8");
+  return filePath;
+}
+async function cacheSpecFromUrl(cwd, specUrl) {
+  const response = await fetch(specUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to download OpenAPI spec from ${specUrl}: ${response.status} ${response.statusText}`);
+  }
+  const content = await response.text();
+  const extension = inferSpecExtension(response.headers.get("content-type") ?? "", content);
+  return cacheSpecContent(cwd, content, extension, "openapi.cached");
+}
+async function discoverSpecUrl(backendBaseUrl) {
+  const baseUrl = normalizeBaseUrl(backendBaseUrl);
+  for (const candidatePath of DISCOVERY_PATHS) {
+    const candidateUrl = `${baseUrl}${candidatePath}`;
+    try {
+      const response = await fetch(candidateUrl, { method: "GET" });
+      if (!response.ok) {
+        continue;
+      }
+      const body = await response.text();
+      const maybeSpec = body.includes("openapi") || body.includes("swagger");
+      if (!maybeSpec) {
+        continue;
+      }
+      return candidateUrl;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    `Could not discover an OpenAPI spec under ${baseUrl}. Tried: ${DISCOVERY_PATHS.join(", ")}`
+  );
+}
+async function writeStarterSpec(cwd, specPath) {
+  const resolvedPath = path.isAbsolute(specPath) ? specPath : path.join(cwd, specPath);
+  await mkdir(path.dirname(resolvedPath), { recursive: true });
+  await writeFile(resolvedPath, STARTER_SPEC, "utf8");
+  return resolvedPath;
+}
+
+// src/config.ts
+function resolvePathFromCwd(cwd, value) {
+  return path2.isAbsolute(value) ? value : path2.join(cwd, value);
+}
+function applyServeOptions(command) {
+  return command.option("--spec <path>", "Path to an OpenAPI 3.x file").option("--spec-url <url>", "Remote URL to an OpenAPI 3.x file").option("--discover <backend-url>", "Discover OpenAPI from a backend URL and cache it locally").option("--port <port>", "Port to bind the server", "4010").option("--host <host>", "Host to bind the server", "0.0.0.0").option("--db <path>", "JSON database path", ".mock-db.json").option("--cors-origin <origin>", "CORS origin (default is *)", "*").option("--drift-check <url>", "Forward traffic to a real backend and validate responses").option("--fallback-to-mock", "Fallback to mock responses when proxying fails", false).option("--verbose", "Enable verbose logging", false);
+}
 function createCli() {
   const program = new Command();
   program.name("contract-drift-detection").description("Stateful OpenAPI mock server with contract drift detection").version("0.1.0");
-  program.command("serve").description("Start the mock engine").requiredOption("--spec <path>", "Path to an OpenAPI 3.x file").option("--port <port>", "Port to bind the server", "4010").option("--host <host>", "Host to bind the server", "0.0.0.0").option("--db <path>", "JSON database path", ".mock-db.json").option("--cors-origin <origin>", "CORS origin (default is *)", "*").option("--drift-check <url>", "Forward traffic to a real backend and validate responses").option("--fallback-to-mock", "Fallback to mock responses when proxying fails", false).option("--verbose", "Enable verbose logging", false);
-  program.command("init").description("Create a starter config for the current workspace").option("--spec <path>", "Default OpenAPI path", "openapi.yaml").option("--db <path>", "Default JSON database path", ".mock-db.json").option("--port <port>", "Default port", "4010").option("--host <host>", "Default host", "0.0.0.0");
+  applyServeOptions(program);
+  applyServeOptions(program.command("serve").description("Start the mock engine"));
+  program.command("init").description("Create a starter config for the current workspace").option("--spec <path>", "Default OpenAPI path", "openapi.yaml").option("--template <name>", "Template to generate (rest-crud | none)", "rest-crud").option("--db <path>", "Default JSON database path", ".mock-db.json").option("--port <port>", "Default port", "4010").option("--host <host>", "Default host", "0.0.0.0");
+  program.command("quickstart").description("Generate a starter OpenAPI file and start the server immediately").option("--spec <path>", "Starter OpenAPI path", "openapi.yaml").option("--port <port>", "Port to bind the server", "4010").option("--host <host>", "Host to bind the server", "0.0.0.0").option("--db <path>", "JSON database path", ".mock-db.json").option("--cors-origin <origin>", "CORS origin (default is *)", "*").option("--verbose", "Enable verbose logging", false);
   return program;
 }
-function toServeConfig(options) {
+async function resolveServeConfig(cwd, options) {
+  let resolvedSpecPath;
+  if (options.spec) {
+    resolvedSpecPath = resolvePathFromCwd(cwd, String(options.spec));
+  } else if (options.specUrl) {
+    resolvedSpecPath = await cacheSpecFromUrl(cwd, String(options.specUrl));
+  } else if (options.discover) {
+    const discoveredSpecUrl = await discoverSpecUrl(String(options.discover));
+    resolvedSpecPath = await cacheSpecFromUrl(cwd, discoveredSpecUrl);
+  }
+  if (!resolvedSpecPath) {
+    throw new Error("Provide one of --spec, --spec-url, or --discover");
+  }
   return {
-    specPath: String(options.spec),
+    specPath: resolvedSpecPath,
     port: Number(options.port ?? 4010),
     host: String(options.host ?? "0.0.0.0"),
-    dbPath: String(options.db ?? ".mock-db.json"),
+    dbPath: resolvePathFromCwd(cwd, String(options.db ?? ".mock-db.json")),
     corsOrigin: String(options.corsOrigin ?? "*"),
     driftCheckTarget: options.driftCheck ? String(options.driftCheck) : void 0,
     fallbackToMockOnProxyError: Boolean(options.fallbackToMock),
@@ -27,9 +262,12 @@ function toServeConfig(options) {
   };
 }
 async function writeStarterConfig(cwd, initConfig) {
-  const targetPath = path.join(cwd, "contract-drift.config.json");
-  await mkdir(cwd, { recursive: true });
-  await writeFile(
+  if (initConfig.template === "rest-crud") {
+    await writeStarterSpec(cwd, initConfig.spec);
+  }
+  const targetPath = path2.join(cwd, "contract-drift.config.json");
+  await mkdir2(cwd, { recursive: true });
+  await writeFile2(
     targetPath,
     `${JSON.stringify(
       {
@@ -48,12 +286,12 @@ async function writeStarterConfig(cwd, initConfig) {
 }
 
 // src/server.ts
-import path4 from "path";
+import path5 from "path";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 
 // src/utils.ts
-import path2 from "path";
+import path3 from "path";
 function isSchemaObject(schema) {
   return Boolean(schema) && !("$ref" in schema);
 }
@@ -73,7 +311,7 @@ function singularize(value) {
   return value;
 }
 function resolveFile(baseDir, filePath) {
-  return path2.isAbsolute(filePath) ? filePath : path2.join(baseDir, filePath);
+  return path3.isAbsolute(filePath) ? filePath : path3.join(baseDir, filePath);
 }
 function getOperationId(method, openApiPath, operation) {
   if (operation.operationId) {
@@ -215,7 +453,7 @@ var DriftDetector = class {
     addFormats(this.ajv);
   }
   ajv = new Ajv({ allErrors: true, strict: false });
-  validate(method, path5, statusCode, schema, body) {
+  validate(method, path6, statusCode, schema, body) {
     if (!schema || body === void 0 || body === null) {
       return null;
     }
@@ -226,14 +464,16 @@ var DriftDetector = class {
     }
     const issue = {
       method: method.toUpperCase(),
-      path: path5,
+      path: path6,
       statusCode,
-      message: `Drift detected for ${method.toUpperCase()} ${path5} (${statusCode})`,
+      message: `Drift detected for ${method.toUpperCase()} ${path6} (${statusCode})`,
       errors: formatErrors(validate.errors)
     };
-    this.logger.error(
-      `${pc.red("DRIFT DETECTED")} ${issue.method} ${issue.path} -> ${issue.errors.join("; ")}`
-    );
+    const errorLines = issue.errors.map((entry) => `  \u2022 ${entry}`).join("\n");
+    this.logger.error([
+      `${pc.bgRed(pc.black(" \u{1F6A8} DRIFT DETECTED "))} ${pc.bold(issue.method)} ${issue.path} (${statusCode})`,
+      errorLines
+    ].join("\n"));
     return issue;
   }
 };
@@ -383,8 +623,8 @@ async function loadOpenApiDocument(specPath) {
 }
 
 // src/state-store.ts
-import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
-import path3 from "path";
+import { mkdir as mkdir3, readFile, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
 function normalizeDatabase(input) {
   return {
     collections: input?.collections ?? {},
@@ -397,7 +637,7 @@ var JsonStateStore = class {
     this.filePath = filePath;
   }
   async initialize(seedCollections) {
-    await mkdir2(path3.dirname(this.filePath), { recursive: true });
+    await mkdir3(path4.dirname(this.filePath), { recursive: true });
     try {
       const existing = await this.read();
       let changed = false;
@@ -428,7 +668,7 @@ var JsonStateStore = class {
     return normalizeDatabase(JSON.parse(raw));
   }
   async write(database) {
-    await writeFile2(this.filePath, `${JSON.stringify(database, null, 2)}
+    await writeFile3(this.filePath, `${JSON.stringify(database, null, 2)}
 `, "utf8");
   }
   async withDatabase(updater) {
@@ -440,8 +680,8 @@ var JsonStateStore = class {
 };
 
 // src/proxy.ts
-async function proxyRequest(targetBaseUrl, path5, init) {
-  const response = await fetch(new URL(path5, targetBaseUrl), init);
+async function proxyRequest(targetBaseUrl, path6, init) {
+  const response = await fetch(new URL(path6, targetBaseUrl), init);
   const contentType = readContentType(response.headers);
   let body;
   let rawBody;
@@ -463,6 +703,32 @@ async function proxyRequest(targetBaseUrl, path5, init) {
 }
 
 // src/server.ts
+function toProxyHeaders(inputHeaders) {
+  const passthrough = ["host", "content-length", "connection"];
+  const headers = {};
+  for (const [key, value] of Object.entries(inputHeaders)) {
+    if (passthrough.includes(key)) {
+      continue;
+    }
+    if (value === void 0) {
+      continue;
+    }
+    headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return headers;
+}
+function toProxyBody(request) {
+  if (request.method === "GET" || request.method === "HEAD") {
+    return void 0;
+  }
+  if (request.body === void 0 || request.body === null) {
+    return void 0;
+  }
+  if (typeof request.body === "string" || request.body instanceof Uint8Array) {
+    return request.body;
+  }
+  return JSON.stringify(request.body);
+}
 function sendResponse(reply, statusCode, body) {
   if (statusCode === 204) {
     return reply.code(204).send();
@@ -609,25 +875,28 @@ async function handleMockRoute(store, route, request) {
   });
 }
 async function handleProxyRoute(config, route, detector, request) {
-  const rawBody = request.body ? JSON.stringify(request.body) : void 0;
   const targetBaseUrl = config.driftCheckTarget;
   if (!targetBaseUrl) {
     throw new Error("Proxy target is not configured");
   }
+  const headers = toProxyHeaders(request.headers);
+  if (!headers["content-type"] && request.body !== void 0) {
+    headers["content-type"] = "application/json";
+  }
   const result = await proxyRequest(targetBaseUrl, request.url, {
     method: request.method,
-    headers: {
-      "content-type": request.headers["content-type"] ?? "application/json"
-    },
-    body: rawBody
+    headers,
+    body: toProxyBody(request)
   });
-  detector.validate(
-    route.method,
-    route.path,
-    result.statusCode,
-    route.successResponse?.schema,
-    result.body
-  );
+  if (result.statusCode >= 200 && result.statusCode < 300) {
+    detector.validate(
+      route.method,
+      route.path,
+      result.statusCode,
+      route.successResponse?.schema,
+      result.body
+    );
+  }
   return {
     statusCode: result.statusCode,
     headers: Object.fromEntries(result.headers.entries()),
@@ -664,6 +933,16 @@ async function registerRoutes(app, document, config, store) {
       }
     });
   }
+  app.get(
+    "/__routes",
+    async () => routes.map((route) => ({
+      method: route.method.toUpperCase(),
+      path: route.fastifyPath,
+      operationId: route.operationId,
+      resource: route.resourceName,
+      hasDsl: Boolean(route.operation["x-mock-state"])
+    }))
+  );
 }
 async function createServer(config) {
   const app = Fastify({
@@ -679,7 +958,7 @@ async function createServer(config) {
   });
   const document = await loadOpenApiDocument(config.specPath);
   const seedCollections = inferSeedCollections(document);
-  const dbPath = resolveFile(path4.dirname(config.specPath), config.dbPath);
+  const dbPath = resolveFile(path5.dirname(config.specPath), config.dbPath);
   const store = new JsonStateStore(dbPath);
   await store.initialize(seedCollections);
   app.get("/__health", async () => ({ status: "ok" }));
@@ -689,16 +968,39 @@ async function createServer(config) {
 }
 
 // src/cli.ts
+function renderStartupBanner(config) {
+  const lines = [
+    `\u{1F680} Contract Drift Detection running at http://${config.host}:${config.port}`,
+    `- Spec: ${config.specPath}`,
+    `- DB: ${config.dbPath}`,
+    `- Mode: ${config.driftCheckTarget ? `proxy + drift-check (${config.driftCheckTarget})` : "stateful mock"}`,
+    "- Health: GET /__health",
+    "- Routes: GET /__routes"
+  ];
+  return `${lines.join("\n")}
+`;
+}
 async function main() {
   const cli = createCli();
   const serveCommand = cli.commands.find((command) => command.name() === "serve");
   const initCommand = cli.commands.find((command) => command.name() === "init");
-  serveCommand?.action(async function() {
-    const config = toServeConfig(this.opts());
+  const quickstartCommand = cli.commands.find((command) => command.name() === "quickstart");
+  const startServer = async (rawOptions) => {
+    const config = await resolveServeConfig(process.cwd(), rawOptions);
     const server = await createServer(config);
     await server.listen({ port: config.port, host: config.host });
-    process.stdout.write(`Mock engine listening on http://${config.host}:${config.port}
-`);
+    process.stdout.write(renderStartupBanner(config));
+  };
+  serveCommand?.action(async function() {
+    await startServer(this.opts());
+  });
+  cli.action(async () => {
+    const options = cli.opts();
+    if (!options.spec && !options.specUrl && !options.discover) {
+      cli.outputHelp();
+      return;
+    }
+    await startServer(options);
   });
   initCommand?.action(async function() {
     const options = this.opts();
@@ -706,11 +1008,35 @@ async function main() {
       spec: String(options.spec),
       db: String(options.db),
       host: String(options.host),
-      port: Number(options.port)
+      port: Number(options.port),
+      template: options.template === "none" ? "none" : "rest-crud"
     });
     process.stdout.write(`Created ${targetPath}
 `);
   });
+  quickstartCommand?.action(async function() {
+    const options = this.opts();
+    const cwd = process.cwd();
+    const specPath = String(options.spec ?? "openapi.yaml");
+    await writeStarterConfig(cwd, {
+      spec: specPath,
+      db: String(options.db ?? ".mock-db.json"),
+      host: String(options.host ?? "0.0.0.0"),
+      port: Number(options.port ?? 4010),
+      template: "rest-crud"
+    });
+    const config = await resolveServeConfig(cwd, {
+      spec: specPath,
+      db: String(options.db ?? ".mock-db.json"),
+      host: String(options.host ?? "0.0.0.0"),
+      port: String(options.port ?? 4010),
+      corsOrigin: String(options.corsOrigin ?? "*"),
+      verbose: Boolean(options.verbose)
+    });
+    const server = await createServer(config);
+    await server.listen({ port: config.port, host: config.host });
+    process.stdout.write(renderStartupBanner(config));
+  });
   await cli.parseAsync(process.argv);
 }
 await main().catch((error) => {