create-ailk 0.24.0 → 0.26.0

package/templates/apps/mcp/__tests__/rate-limit-write.test.ts

@@ -1,189 +0,0 @@
-/**
- * The write-tool per-minute rate limit (#9251).
- *
- * `MCP_RATE_LIMIT_WRITE_PER_MIN` (`config.rateLimits.writePerMin`) used to be
- * parsed and ignored: one app-wide @fastify/rate-limit bucket at `readPerMin`
- * counted every request, and the TODO in the write preHandler deferred the
- * tighter write bucket. These tests pin what the transport now enforces:
- *
- * - with `writePerMin: 2`, the third anonymous write-tool call from one IP
- *   inside a minute is refused with the limiter's 429 shape — the same body
- *   and headers the read ceiling emits — before the tool (and so the hub) is
- *   reached, while reads from that IP keep answering 200;
- * - the write bucket counts ONLY write-tool calls: reads spend none of it;
- * - a JSON-RPC batch of N write calls spends N units, not one.
- *
- * Same harness as http-transport.test.ts: a real Fastify server on an
- * ephemeral port, stateless mode, and the hub stubbed through
- * `apiClient.leads.submit` so an allowed `capture_lead` succeeds.
- */
-
-import type { AddressInfo } from "node:net";
-
-import type { FastifyInstance } from "fastify";
-import { apiClient } from "@working-theory/api-client";
-
-import { buildHttpTransportApp } from "../src/http-transport.js";
-
-type RateLimitErrorBody = {
-  statusCode?: number;
-  error?: string;
-  message?: string;
-};
-
-const WRITE_LIMITED_CONFIG = {
-  path: "/mcp",
-  stateless: true,
-  rateLimits: { readPerMin: 60, writePerMin: 2 },
-  cors: { writeAllowedOrigins: [] as string[] },
-  abuse: {
-    captureLeadDailyCapPerIp: 50,
-    blockedUserAgents: "",
-  },
-} as const;
-
-const TOOLS_LIST_PAYLOAD = {
-  jsonrpc: "2.0",
-  id: 1,
-  method: "tools/list",
-  params: {},
-};
-
-function captureLead(id: number) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    method: "tools/call",
-    params: {
-      name: "capture_lead",
-      arguments: {
-        source: "mcp",
-        email: `jane${id}@example.com`,
-        payload: { name: "Jane" },
-      },
-    },
-  };
-}
-
-async function mcpPost(port: number, payload: object): Promise<Response> {
-  return fetch(`http://127.0.0.1:${port}/mcp`, {
-    method: "POST",
-    body: JSON.stringify(payload),
-    headers: {
-      "content-type": "application/json",
-      accept: "application/json, text/event-stream",
-    },
-  });
-}
-
-async function listen(
-  config: Parameters<typeof buildHttpTransportApp>[0],
-): Promise<{ app: FastifyInstance; port: number }> {
-  const app = await buildHttpTransportApp(config);
-  await app.listen({ host: "127.0.0.1", port: 0 });
-  return { app, port: (app.server.address() as AddressInfo).port };
-}
-
-describe("MCP_RATE_LIMIT_WRITE_PER_MIN is enforced on the write tools (#9251)", () => {
-  let app: FastifyInstance;
-  let port: number;
-  let submitSpy: jest.SpiedFunction<typeof apiClient.leads.submit>;
-
-  beforeEach(async () => {
-    submitSpy = jest.spyOn(apiClient.leads, "submit").mockResolvedValue({
-      ok: true,
-      body: {
-        id: "lead_1",
-        persisted: "db",
-        email: { ok: true, messageId: "msg_1" },
-      },
-    });
-    ({ app, port } = await listen(WRITE_LIMITED_CONFIG));
-  });
-
-  afterEach(async () => {
-    await app.close();
-    submitSpy.mockRestore();
-  });
-
-  it("refuses the third write call from one IP within a minute with the limiter's 429, while reads continue", async () => {
-    expect((await mcpPost(port, captureLead(1))).status).toBe(200);
-    expect((await mcpPost(port, captureLead(2))).status).toBe(200);
-
-    const refused = await mcpPost(port, captureLead(3));
-
-    expect(refused.status).toBe(429);
-    const body = (await refused.json()) as RateLimitErrorBody;
-    expect(body).toEqual({
-      statusCode: 429,
-      error: "Too Many Requests",
-      message: expect.stringMatching(/^Rate limit exceeded, retry in /),
-    });
-    expect(refused.headers.get("x-ratelimit-limit")).toBe("2");
-    expect(refused.headers.get("x-ratelimit-remaining")).toBe("0");
-    expect(refused.headers.get("x-ratelimit-reset")).toMatch(/^\d+$/);
-    expect(refused.headers.get("retry-after")).toMatch(/^\d+$/);
-    // Refused in the preHandler: the tool never ran, so the hub saw two calls.
-    expect(submitSpy).toHaveBeenCalledTimes(2);
-
-    const read = await mcpPost(port, TOOLS_LIST_PAYLOAD);
-    expect(read.status).toBe(200);
-  });
-
-  it("counts only write-tool calls — reads spend none of the write bucket", async () => {
-    for (let i = 0; i < 10; i += 1) {
-      expect((await mcpPost(port, TOOLS_LIST_PAYLOAD)).status).toBe(200);
-    }
-
-    expect((await mcpPost(port, captureLead(11))).status).toBe(200);
-    expect((await mcpPost(port, captureLead(12))).status).toBe(200);
-    expect((await mcpPost(port, captureLead(13))).status).toBe(429);
-  });
-
-  it("a batch of N write calls spends N units, not one", async () => {
-    const res = await mcpPost(port, [
-      captureLead(21),
-      captureLead(22),
-      captureLead(23),
-    ]);
-
-    expect(res.status).toBe(429);
-    expect(submitSpy).not.toHaveBeenCalled();
-  });
-
-  it("emits the same 429 shape as the read ceiling", async () => {
-    const readLimited = await listen({
-      ...WRITE_LIMITED_CONFIG,
-      rateLimits: { readPerMin: 1, writePerMin: 2 },
-    });
-    try {
-      await mcpPost(readLimited.port, TOOLS_LIST_PAYLOAD);
-      const readRefusal = await mcpPost(readLimited.port, TOOLS_LIST_PAYLOAD);
-      expect(readRefusal.status).toBe(429);
-
-      await mcpPost(port, captureLead(31));
-      await mcpPost(port, captureLead(32));
-      const writeRefusal = await mcpPost(port, captureLead(33));
-      expect(writeRefusal.status).toBe(429);
-
-      const readBody = (await readRefusal.json()) as RateLimitErrorBody;
-      const writeBody = (await writeRefusal.json()) as RateLimitErrorBody;
-      expect(Object.keys(writeBody).sort()).toEqual(
-        Object.keys(readBody).sort(),
-      );
-      expect(writeBody.error).toBe(readBody.error);
-      expect(writeBody.message).toBe(readBody.message);
-      for (const header of [
-        "x-ratelimit-limit",
-        "x-ratelimit-remaining",
-        "x-ratelimit-reset",
-        "retry-after",
-      ]) {
-        expect(readRefusal.headers.has(header)).toBe(true);
-        expect(writeRefusal.headers.has(header)).toBe(true);
-      }
-    } finally {
-      await readLimited.app.close();
-    }
-  });
-});

package/templates/apps/mcp/__tests__/read_content.test.ts

@@ -1,511 +0,0 @@
-/**
- * Tests for the read_content MCP tool handler.
- *
- * Acceptance criteria verified here:
- * - contentPageParamsSchema validates correct inputs (type + slug)
- * - contentPageParamsSchema rejects unknown type values and malformed slugs,
- *   a leading or trailing hyphen included (the route's grammar)
- * - ailkReadContent returns the route's document — the page's JSON-LD at the
- *   root, `page`, and `body` only with `include: "body"` — for a known slug
- * - ailkReadContent returns the not-found body (not throws) for an unknown slug
- * - Output validates against contentPageResultSchema
- * - No console.* calls in handler (structural test)
- *
- * #7169 (the operator's decision of 2026-10-19): the tool adopted its route's
- * arguments (`include`) and result (the document, not
- * `{ slug, type, frontmatter, body } | null`), so the cases below read
- * `page`/`body` and expect the not-found body where they expected `null`.
- * - #6030 AC-1: BlogPosting and DocsDetail — the two types this issue admits —
- *   are readable through the adapter on both the MDX leg and the database
- *   leg, and both are asserted against the shared adapter seam
- *   (`ContentAdapter.getPageSource`) per the API↔MCP parity contract (D3).
- */
-
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { resolve, join } from "node:path";
-
-import {
-  createMdxAdapter,
-  resetResolvedContentAdapter,
-  type ArtifactPrismaClient,
-} from "@working-theory/content-adapters";
-
-import {
-  ailkReadContent,
-  contentPageParamsSchema,
-  contentPageResultSchema,
-  type ContentPageResult,
-} from "../src/tools/read_content.js";
-import { notFoundError } from "../src/lib/errors.js";
-import {
-  __setMcpPublicWorkspaceForTest,
-  resetMcpPublicWorkspace,
-} from "../src/lib/public-workspace.js";
-
-const REPO_ROOT = resolve(__dirname, "../../..");
-const CONTENT_ROOT = join(REPO_ROOT, "content");
-const WORKSPACE_ID = "wksp_00000000-0000-7000-8000-000000000001";
-
-/** The body a missing page answers — the route's 404 message, the MCP code. */
-const NOT_FOUND = notFoundError("Page not found");
-
-/** Narrows a tool answer to the document, failing on the not-found body. */
-function document(
-  result: Awaited<ReturnType<typeof ailkReadContent>>,
-): ContentPageResult {
-  if (!("page" in result)) {
-    throw new Error(`read_content answered ${JSON.stringify(result)}`);
-  }
-  return result;
-}
-
-/**
- * A structural `ArtifactPrismaClient` stub (#5876 spec D11) — `artifact` and
- * `artifactVersion` jest.fn()s, injected directly, no database.
- */
-function makeArtifactPrismaClientStub(overrides: {
-  artifact?: { publishedVersionId: string | null } | null;
-  version?: { content: unknown } | null;
-}): ArtifactPrismaClient {
-  const artifact =
-    overrides.artifact === undefined || overrides.artifact === null
-      ? null
-      : {
-          id: "artifact_1",
-          workspaceId: WORKSPACE_ID,
-          contentType: "text/page",
-          locale: "en",
-          slug: "home",
-          title: "Home",
-          publishedVersionId: overrides.artifact.publishedVersionId,
-        };
-  const version =
-    overrides.version === undefined || overrides.version === null
-      ? null
-      : {
-          id: "version_1",
-          artifactId: "artifact_1",
-          workspaceId: WORKSPACE_ID,
-          content: overrides.version.content,
-          isCurrent: false,
-        };
-  return {
-    artifact: {
-      findFirst: jest.fn().mockResolvedValue(artifact),
-      findMany: jest.fn().mockResolvedValue([]),
-      create: jest.fn(),
-      updateMany: jest.fn(),
-      deleteMany: jest.fn(),
-    },
-    artifactVersion: {
-      findFirst: jest.fn().mockResolvedValue(version),
-      findMany: jest.fn().mockResolvedValue([]),
-      create: jest.fn(),
-      updateMany: jest.fn(),
-    },
-    $transaction: jest.fn(),
-  };
-}
-
-describe("contentPageParamsSchema", () => {
-  it("accepts a valid type + slug", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "HomePage",
-      slug: "home",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts a HomePage slug", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "HomePage",
-      slug: "home",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects missing slug", () => {
-    const result = contentPageParamsSchema.safeParse({ type: "HomePage" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects missing type", () => {
-    const result = contentPageParamsSchema.safeParse({
-      slug: "launching-ailk",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects an unknown type", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "NotAType",
-      slug: "some-slug",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects empty slug", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "HomePage",
-      slug: "",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects slug with path traversal characters", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "HomePage",
-      slug: "../etc/passwd",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects slug with forward slashes", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "HomePage",
-      slug: "some/path",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  // The route's grammar (`SLUG_PATTERN`): no leading or trailing hyphen —
-  // refused here too since #7169 (the tool adopted the API's arguments).
-  it.each(["-a", "a-", "-"])("rejects slug %p (leading or trailing hyphen)", (slug) => {
-    const result = contentPageParamsSchema.safeParse({ type: "HomePage", slug });
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts an interior hyphen", () => {
-    const result = contentPageParamsSchema.safeParse({
-      type: "HomePage",
-      slug: "a-b",
-    });
-    expect(result.success).toBe(true);
-  });
-});
-
-describe("ailkReadContent handler", () => {
-  it("returns the HomePage document — the @graph envelope and page, no body without include", async () => {
-    const result = document(
-      await ailkReadContent({ type: "HomePage", slug: "home" }, CONTENT_ROOT),
-    );
-
-    expect(result["@context"]).toBe("https://schema.org");
-    expect(Array.isArray(result["@graph"])).toBe(true);
-    expect(result.page.slug).toBe("home");
-    expect(result.page.type).toBe("HomePage");
-    expect(result).not.toHaveProperty("body");
-  });
-
-  it("attaches the raw MDX body only with include: body (#5890)", async () => {
-    const result = document(
-      await ailkReadContent(
-        { type: "HomePage", slug: "home", include: "body" },
-        CONTENT_ROOT,
-      ),
-    );
-    expect(result.page.slug).toBe("home");
-    expect(typeof result.body).toBe("string");
-  });
-
-  it("returns the not-found body (not throws) for an unknown slug", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "does-not-exist" },
-      CONTENT_ROOT,
-    );
-    expect(result).toEqual(NOT_FOUND);
-  });
-
-  it("returns the not-found body for a slug that exists in a different type", async () => {
-    // home.mdx exists under HomePage, not AboutPage
-    const result = await ailkReadContent(
-      { type: "AboutPage", slug: "home" },
-      CONTENT_ROOT,
-    );
-    expect(result).toEqual(NOT_FOUND);
-  });
-
-  it("returns the not-found body for a valid type with no files when given an unknown slug", async () => {
-    const result = await ailkReadContent(
-      { type: "FAQPage", slug: "nonexistent" },
-      CONTENT_ROOT,
-    );
-    expect(result).toEqual(NOT_FOUND);
-  });
-
-  it("output shape validates against contentPageResultSchema", async () => {
-    const result = await ailkReadContent(
-      { type: "HomePage", slug: "home", include: "body" },
-      CONTENT_ROOT,
-    );
-    const parsed = contentPageResultSchema.safeParse(result);
-    expect(parsed.success).toBe(true);
-  });
-});
-
-describe("ailkReadContent — CONTENT_ADAPTER=database (#5876)", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-
-  beforeEach(() => {
-    process.env.CONTENT_ADAPTER = "database";
-    // resolveContentAdapter() memoises per (kind, workspaceId, contentRoot,
-    // defaultLocale, manifestPath) — NOT per prisma instance — so every case
-    // below (same workspaceId, same defaults) would otherwise reuse the FIRST
-    // test's adapter, bound to the FIRST test's stub.
-    resetResolvedContentAdapter();
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    resetMcpPublicWorkspace();
-    resetResolvedContentAdapter();
-  });
-
-  it("AC-1: returns the document with page and body for a published page", async () => {
-    const stub = makeArtifactPrismaClientStub({
-      artifact: { publishedVersionId: "version_1" },
-      version: {
-        content: {
-          type: "HomePage",
-          slug: "home",
-          title: "Home",
-          description: "The homepage.",
-          body: "# Hello",
-        },
-      },
-    });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = document(
-      await ailkReadContent({ type: "HomePage", slug: "home", include: "body" }),
-    );
-
-    expect(result.page.slug).toBe("home");
-    expect(result.page.type).toBe("HomePage");
-    expect(result.body).toBe("# Hello");
-    // The reach test (§5.2 AC-1) — the read is bound to the resolved workspace.
-    expect(stub.artifact.findFirst).toHaveBeenCalledWith(
-      expect.objectContaining({
-        where: expect.objectContaining({ workspaceId: WORKSPACE_ID }),
-      }),
-    );
-  });
-
-  it("AC-1: returns the not-found body for a draft-only artifact (no published version)", async () => {
-    const stub = makeArtifactPrismaClientStub({
-      artifact: { publishedVersionId: null },
-    });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
-
-    expect(result).toEqual(NOT_FOUND);
-  });
-
-  it("AC-1: returns the not-found body for an unknown slug", async () => {
-    const stub = makeArtifactPrismaClientStub({ artifact: null });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({
-      type: "HomePage",
-      slug: "does-not-exist",
-    });
-
-    expect(result).toEqual(NOT_FOUND);
-  });
-
-  it("AC-2: returns the not-found body when the workspace is unresolved, with no content lookup", async () => {
-    const stub = makeArtifactPrismaClientStub({});
-    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
-
-    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
-
-    expect(result).toEqual(NOT_FOUND);
-    expect(stub.artifact.findFirst).not.toHaveBeenCalled();
-  });
-});
-
-describe("ailkReadContent — BlogPosting and DocsDetail, MDX leg (#6030 AC-1)", () => {
-  let root = "";
-
-  beforeAll(() => {
-    root = mkdtempSync(join(tmpdir(), "ailk-mcp-6030-"));
-    for (const { type, slug, body } of [
-      { type: "BlogPosting", slug: "launch-post", body: "# Launch post\n\nBody." },
-      { type: "DocsDetail", slug: "getting-started", body: "# Getting started\n\nBody." },
-    ]) {
-      const dir = join(root, "en", type);
-      mkdirSync(dir, { recursive: true });
-      writeFileSync(
-        join(dir, `${slug}.mdx`),
-        [
-          "---",
-          `type: "${type}"`,
-          `slug: "${slug}"`,
-          `title: "${type} ${slug} title"`,
-          `description: "${type} ${slug} description"`,
-          "---",
-          "",
-          body,
-          "",
-        ].join("\n"),
-        "utf8",
-      );
-    }
-  });
-
-  afterAll(() => {
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns the page for %s, with page and body equal to what getPageSource returns (D3)",
-    async (type) => {
-      const slug = type === "BlogPosting" ? "launch-post" : "getting-started";
-      const result = document(
-        await ailkReadContent({ type, slug, locale: "en", include: "body" }, root),
-      );
-
-      // The shared seam D3 asserts from both ends: read_content's payload is
-      // derived from exactly what ContentAdapter.getPageSource(type, slug,
-      // locale) returns for the arguments the tool builds — not restated.
-      const adapter = createMdxAdapter({ contentRoot: root });
-      const source = await adapter.getPageSource(type, slug, "en");
-      expect(source).not.toBeNull();
-
-      expect(result.page).toEqual(source!.frontmatter);
-      expect(result.body).toBe(source!.body);
-      expect(result.page.slug).toBe(slug);
-      expect(result.page.type).toBe(type);
-    },
-  );
-
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns the not-found body for an absent slug of %s",
-    async (type) => {
-      const result = await ailkReadContent(
-        { type, slug: "does-not-exist", locale: "en" },
-        root,
-      );
-      expect(result).toEqual(NOT_FOUND);
-    },
-  );
-});
-
-describe("ailkReadContent — BlogPosting and DocsDetail, CONTENT_ADAPTER=database (#6030 AC-1)", () => {
-  const previous = process.env.CONTENT_ADAPTER;
-
-  beforeEach(() => {
-    process.env.CONTENT_ADAPTER = "database";
-    resetResolvedContentAdapter();
-  });
-
-  afterEach(() => {
-    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
-    else process.env.CONTENT_ADAPTER = previous;
-    resetMcpPublicWorkspace();
-    resetResolvedContentAdapter();
-  });
-
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns the document with page and body for a published %s",
-    async (type) => {
-      const slug = "probe";
-      const stub = makeArtifactPrismaClientStub({
-        artifact: { publishedVersionId: "version_1" },
-        version: {
-          content: {
-            type,
-            slug,
-            title: `${type} title`,
-            description: `${type} description`,
-            body: "# Published body",
-          },
-        },
-      });
-      __setMcpPublicWorkspaceForTest({
-        kind: "resolved",
-        workspaceId: WORKSPACE_ID,
-        prisma: stub,
-      });
-
-      const result = document(
-        await ailkReadContent({ type, slug, include: "body" }),
-      );
-
-      expect(result.page.slug).toBe(slug);
-      expect(result.page.type).toBe(type);
-      expect(result.body).toBe("# Published body");
-    },
-  );
-
-  // D4 — the publication guard must hold for every newly-admitted type, not
-  // only HomePage's existing case.
-  it.each(["BlogPosting", "DocsDetail"] as const)(
-    "returns the not-found body for a draft-only %s artifact (no published version)",
-    async (type) => {
-      const stub = makeArtifactPrismaClientStub({
-        artifact: { publishedVersionId: null },
-      });
-      __setMcpPublicWorkspaceForTest({
-        kind: "resolved",
-        workspaceId: WORKSPACE_ID,
-        prisma: stub,
-      });
-
-      const result = await ailkReadContent({ type, slug: "probe" });
-
-      expect(result).toEqual(NOT_FOUND);
-    },
-  );
-
-  // D4 — type-as-address: a page stored under a different frontmatter.type
-  // than requested reads as absent, never as a cross-type hit.
-  it("returns the not-found body when the requested type does not match the stored frontmatter.type", async () => {
-    const stub = makeArtifactPrismaClientStub({
-      artifact: { publishedVersionId: "version_1" },
-      version: {
-        content: {
-          type: "BlogPosting",
-          slug: "probe",
-          title: "A blog post",
-          description: "Stored as BlogPosting.",
-          body: "# Body",
-        },
-      },
-    });
-    __setMcpPublicWorkspaceForTest({
-      kind: "resolved",
-      workspaceId: WORKSPACE_ID,
-      prisma: stub,
-    });
-
-    const result = await ailkReadContent({ type: "DocsDetail", slug: "probe" });
-
-    expect(result).toEqual(NOT_FOUND);
-  });
-});
-
-describe("architectural guard — no console calls", () => {
-  it("apps/mcp/src/tools/read_content.ts does not call console.*", () => {
-    const src = readFileSync(
-      resolve(__dirname, "../src/tools/read_content.ts"),
-      "utf-8",
-    );
-    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
-  });
-});