@vellumai/vellum-gateway 0.7.3 → 0.8.1

package/src/http/routes/contact-prompt.ts

@@ -168,9 +168,10 @@ export async function handleContactPromptSubmit(req: Request): Promise<Response>
         { channelType, address: normalizedAddress, contactId, existingContactId: existingChannel[0].contactId },
         "contact-prompt-submit: channel already assigned to another contact",
       );
-      await ipcCallAssistant("resolve_contact_prompt", {
-        body: { requestId, error: "Channel already assigned to another contact" },
-      });
+      await notifyDaemonResolveError(
+        requestId,
+        "Channel already assigned to another contact",
+      );
       return Response.json(
         { accepted: false, error: "Channel already assigned to another contact" },
         { status: 409 },
@@ -223,9 +224,10 @@ export async function handleContactPromptSubmit(req: Request): Promise<Response>
         }
 
         // Notify daemon of failure so the CLI doesn't hang.
-        await ipcCallAssistant("resolve_contact_prompt", {
-          body: { requestId, error: "Failed to create contact channel" },
-        });
+        await notifyDaemonResolveError(
+          requestId,
+          "Failed to create contact channel",
+        );
         return Response.json(
           { accepted: false, error: "Failed to create contact channel" },
           { status: 500 },
@@ -239,22 +241,49 @@ export async function handleContactPromptSubmit(req: Request): Promise<Response>
     }
   } catch (err) {
     log.error({ err, requestId }, "contact-prompt-submit: DB error");
-    await ipcCallAssistant("resolve_contact_prompt", {
-      body: { requestId, error: "Database error" },
-    });
+    await notifyDaemonResolveError(requestId, "Database error");
     return Response.json({ accepted: false, error: "Database error" }, { status: 500 });
   }
 
   // Notify daemon to unblock the waiting contacts/prompt IPC call.
-  const ipcResult = await ipcCallAssistant("resolve_contact_prompt", {
-    body: { requestId, contactId, channelId, channelType, address: normalizedAddress },
-  });
-  if (!ipcResult || (ipcResult as { resolved?: boolean }).resolved === false) {
+  try {
+    const ipcResult = await ipcCallAssistant("resolve_contact_prompt", {
+      body: { requestId, contactId, channelId, channelType, address: normalizedAddress },
+    });
+    if ((ipcResult as { resolved?: boolean }).resolved === false) {
+      log.warn(
+        { requestId, contactId },
+        "contact-prompt-submit: resolve_contact_prompt IPC did not find a pending prompt — CLI may time out",
+      );
+    }
+  } catch (err) {
     log.warn(
-      { requestId, contactId },
-      "contact-prompt-submit: resolve_contact_prompt IPC did not find a pending prompt — CLI may time out",
+      { err, requestId, contactId },
+      "contact-prompt-submit: resolve_contact_prompt IPC failed — CLI may time out",
     );
   }
 
   return Response.json({ accepted: true });
 }
+
+/**
+ * Best-effort notification to the daemon that a pending contact prompt has
+ * resolved with an error. Failures here must not block the HTTP response —
+ * the caller has already decided the request failed; we just want to wake
+ * the CLI up.
+ */
+async function notifyDaemonResolveError(
+  requestId: string,
+  error: string,
+): Promise<void> {
+  try {
+    await ipcCallAssistant("resolve_contact_prompt", {
+      body: { requestId, error },
+    });
+  } catch (err) {
+    log.warn(
+      { err, requestId },
+      "contact-prompt-submit: resolve_contact_prompt error notification failed",
+    );
+  }
+}

package/src/http/routes/contacts-control-plane-proxy.ts

@@ -15,6 +15,7 @@ import {
   assistantDbRun,
 } from "../../db/assistant-db-proxy.js";
 import { getGatewayDb } from "../../db/connection.js";
+import { ContactStore } from "../../db/contact-store.js";
 import { contacts } from "../../db/schema.js";
 import { fetchImpl } from "../../fetch.js";
 import { ipcCallAssistant } from "../../ipc/assistant-client.js";
@@ -22,6 +23,61 @@ import { getLogger } from "../../logger.js";
 
 const log = getLogger("contacts-control-plane-proxy");
 
+// ---------------------------------------------------------------------------
+// Validation constants (mirrored from assistant/src/runtime/routes/contact-routes.ts)
+// ---------------------------------------------------------------------------
+
+const VALID_CONTACT_TYPES = ["human", "assistant"] as const;
+const VALID_ASSISTANT_SPECIES = ["vellum"] as const;
+const VALID_CHANNEL_STATUSES = [
+  "active",
+  "pending",
+  "revoked",
+  "blocked",
+  "unverified",
+] as const;
+const VALID_CHANNEL_POLICIES = ["allow", "deny", "escalate"] as const;
+
+type ContactType = (typeof VALID_CONTACT_TYPES)[number];
+type AssistantSpecies = (typeof VALID_ASSISTANT_SPECIES)[number];
+type ChannelStatus = (typeof VALID_CHANNEL_STATUSES)[number];
+type ChannelPolicy = (typeof VALID_CHANNEL_POLICIES)[number];
+
+function isContactType(v: unknown): v is ContactType {
+  return VALID_CONTACT_TYPES.includes(v as ContactType);
+}
+function isAssistantSpecies(v: unknown): v is AssistantSpecies {
+  return VALID_ASSISTANT_SPECIES.includes(v as AssistantSpecies);
+}
+function isChannelStatus(v: unknown): v is ChannelStatus {
+  return VALID_CHANNEL_STATUSES.includes(v as ChannelStatus);
+}
+function isChannelPolicy(v: unknown): v is ChannelPolicy {
+  return VALID_CHANNEL_POLICIES.includes(v as ChannelPolicy);
+}
+
+/**
+ * Validate that metadata matches the expected shape for the given species.
+ * Mirrors `validateSpeciesMetadata` in `assistant/src/contacts/contact-store.ts`.
+ */
+function validateSpeciesMetadata(
+  species: AssistantSpecies,
+  metadata: Record<string, unknown> | null | undefined,
+): string | null {
+  if (metadata == null) return null;
+
+  if (species === "vellum") {
+    if (typeof metadata.assistantId !== "string" || !metadata.assistantId) {
+      return 'Vellum assistant metadata requires a non-empty "assistantId" string';
+    }
+    if (typeof metadata.gatewayUrl !== "string" || !metadata.gatewayUrl) {
+      return 'Vellum assistant metadata requires a non-empty "gatewayUrl" string';
+    }
+  }
+
+  return null;
+}
+
 export function createContactsControlPlaneProxyHandler(config: GatewayConfig) {
   async function forward(
     req: Request,
@@ -72,8 +128,240 @@ export function createContactsControlPlaneProxyHandler(config: GatewayConfig) {
       return forward(req, "/v1/contacts", url.search);
     },
 
+    /**
+     * POST /v1/contacts — gateway-native contact upsert.
+     *
+     * Writes to BOTH the gateway DB (auth/authz fields: id, displayName, role,
+     * principalId + channels) and the assistant DB (all fields including notes,
+     * userFile, contactType) so the daemon stays in sync during the migration
+     * transition period.
+     *
+     * Resolution order mirrors the assistant's upsertContact:
+     *  1. Match by `body.id` if provided.
+     *  2. Match by (type, address) on any provided channel.
+     *  3. Create a new contact with a generated id.
+     */
     async handleUpsertContact(req: Request): Promise<Response> {
-      return forward(req, "/v1/contacts");
+      // ── Parse body ──────────────────────────────────────────────────
+      let body: Record<string, unknown>;
+      try {
+        body = (await req.json()) as Record<string, unknown>;
+      } catch {
+        return Response.json(
+          { error: { code: "BAD_REQUEST", message: "Invalid JSON body" } },
+          { status: 400 },
+        );
+      }
+
+      // ── Validate ────────────────────────────────────────────────────
+      if (
+        !body.displayName ||
+        typeof body.displayName !== "string" ||
+        !body.displayName.trim()
+      ) {
+        return Response.json(
+          {
+            error: {
+              code: "BAD_REQUEST",
+              message:
+                "displayName is required and must be a non-empty string",
+            },
+          },
+          { status: 400 },
+        );
+      }
+      const displayName = (body.displayName as string).trim();
+
+      if (body.contactType !== undefined && !isContactType(body.contactType)) {
+        return Response.json(
+          {
+            error: {
+              code: "BAD_REQUEST",
+              message: `Invalid contactType "${body.contactType}". Must be one of: ${VALID_CONTACT_TYPES.join(", ")}`,
+            },
+          },
+          { status: 400 },
+        );
+      }
+
+      const assistantMeta = body.assistantMetadata as
+        | { species?: unknown; metadata?: unknown }
+        | undefined;
+
+      if (body.contactType === "assistant") {
+        if (!assistantMeta) {
+          return Response.json(
+            {
+              error: {
+                code: "BAD_REQUEST",
+                message:
+                  'assistantMetadata is required when contactType is "assistant"',
+              },
+            },
+            { status: 400 },
+          );
+        }
+        if (!isAssistantSpecies(assistantMeta.species)) {
+          return Response.json(
+            {
+              error: {
+                code: "BAD_REQUEST",
+                message: `Invalid species "${assistantMeta.species}". Must be one of: ${VALID_ASSISTANT_SPECIES.join(", ")}`,
+              },
+            },
+            { status: 400 },
+          );
+        }
+        const speciesError = validateSpeciesMetadata(
+          assistantMeta.species,
+          assistantMeta.metadata as
+            | Record<string, unknown>
+            | null
+            | undefined,
+        );
+        if (speciesError) {
+          return Response.json(
+            { error: { code: "BAD_REQUEST", message: speciesError } },
+            { status: 400 },
+          );
+        }
+      }
+      if (body.contactType === "human" && assistantMeta) {
+        return Response.json(
+          {
+            error: {
+              code: "BAD_REQUEST",
+              message:
+                'assistantMetadata must not be provided when contactType is "human"',
+            },
+          },
+          { status: 400 },
+        );
+      }
+      if (assistantMeta && !body.contactType) {
+        return Response.json(
+          {
+            error: {
+              code: "BAD_REQUEST",
+              message:
+                'contactType must be "assistant" when assistantMetadata is provided',
+            },
+          },
+          { status: 400 },
+        );
+      }
+
+      type ChannelInput = {
+        type: string;
+        address: string;
+        isPrimary?: boolean;
+        externalUserId?: string | null;
+        externalChatId?: string | null;
+        status?: string;
+        policy?: string;
+      };
+
+      const channelInputs = body.channels as ChannelInput[] | undefined;
+      if (channelInputs !== undefined) {
+        if (!Array.isArray(channelInputs)) {
+          return Response.json(
+            {
+              error: {
+                code: "BAD_REQUEST",
+                message: "channels must be an array",
+              },
+            },
+            { status: 400 },
+          );
+        }
+        for (const ch of channelInputs) {
+          if (typeof ch?.type !== "string" || !ch.type.trim()) {
+            return Response.json(
+              {
+                error: {
+                  code: "BAD_REQUEST",
+                  message:
+                    "channel.type is required and must be a non-empty string",
+                },
+              },
+              { status: 400 },
+            );
+          }
+          if (typeof ch?.address !== "string" || !ch.address.trim()) {
+            return Response.json(
+              {
+                error: {
+                  code: "BAD_REQUEST",
+                  message:
+                    "channel.address is required and must be a non-empty string",
+                },
+              },
+              { status: 400 },
+            );
+          }
+          if (ch.status !== undefined && !isChannelStatus(ch.status)) {
+            return Response.json(
+              {
+                error: {
+                  code: "BAD_REQUEST",
+                  message: `Invalid channel status "${ch.status}". Must be one of: ${VALID_CHANNEL_STATUSES.join(", ")}`,
+                },
+              },
+              { status: 400 },
+            );
+          }
+          if (ch.policy !== undefined && !isChannelPolicy(ch.policy)) {
+            return Response.json(
+              {
+                error: {
+                  code: "BAD_REQUEST",
+                  message: `Invalid channel policy "${ch.policy}". Must be one of: ${VALID_CHANNEL_POLICIES.join(", ")}`,
+                },
+              },
+              { status: 400 },
+            );
+          }
+        }
+      }
+
+      // ── Service-layer write (gateway DB + assistant DB dual-write) ───
+      const store = new ContactStore();
+      const { contact, created } = await store.upsertContact({
+        id: body.id as string | undefined,
+        displayName,
+        role: body.role as string | undefined,
+        principalId: body.principalId as string | null | undefined,
+        notes: body.notes as string | null | undefined,
+        contactType: body.contactType as string | undefined,
+        assistantMetadata:
+          body.contactType === "assistant" && assistantMeta
+            ? {
+                species: assistantMeta.species as string,
+                metadata:
+                  (assistantMeta.metadata as
+                    | Record<string, unknown>
+                    | null
+                    | undefined) ?? null,
+              }
+            : undefined,
+        channels: channelInputs?.map((ch) => ({
+          type: ch.type,
+          address: ch.address,
+          isPrimary: ch.isPrimary,
+          externalUserId: ch.externalUserId ?? null,
+          externalChatId: ch.externalChatId ?? null,
+          status: ch.status,
+          policy: ch.policy,
+        })),
+      });
+
+      // ── Emit contacts_changed ────────────────────────────────────────
+      void ipcCallAssistant("emit_event", {
+        body: { kind: "contacts_changed" },
+      } as unknown as Record<string, unknown>).catch(() => {});
+
+      log.info({ contactId: contact.id, created }, "upsert_contact: handled natively");
+      return Response.json({ ok: true, contact });
     },
 
     async handleGetContact(req: Request, contactId: string): Promise<Response> {
@@ -103,7 +391,7 @@ export function createContactsControlPlaneProxyHandler(config: GatewayConfig) {
       getGatewayDb().delete(contacts).where(eq(contacts.id, contactId)).run();
       void ipcCallAssistant("emit_event", {
         body: { kind: "contacts_changed" },
-      } as unknown as Record<string, unknown>);
+      } as unknown as Record<string, unknown>).catch(() => {});
       log.info({ contactId }, "delete_contact: deleted");
       return new Response(null, { status: 204 });
     },
@@ -119,6 +407,45 @@ export function createContactsControlPlaneProxyHandler(config: GatewayConfig) {
       return forward(req, `/v1/contact-channels/${contactChannelId}`);
     },
 
+    /**
+     * POST /v1/contact-channels/:id/verify — guardian-only manual verify.
+     *
+     * Gateway-native + dual-write: the channel mutation happens in the
+     * gateway DB first (source of truth); a best-effort mirror is written
+     * to the assistant DB so the daemon stays in sync during the
+     * gateway-security-migration transition period.
+     *
+     * Idempotent: a row that's already active+verifiedVia=manual returns
+     * the same shape (200 with channel) but no second write occurs.
+     */
+    async handleVerifyContactChannel(
+      _req: Request,
+      contactChannelId: string,
+    ): Promise<Response> {
+      const result =
+        await new ContactStore().markChannelVerified(contactChannelId);
+      if (!result) {
+        return Response.json(
+          {
+            error: {
+              code: "NOT_FOUND",
+              message: `Channel "${contactChannelId}" not found`,
+            },
+          },
+          { status: 404 },
+        );
+      }
+      log.info(
+        {
+          contactChannelId,
+          didWrite: result.didWrite,
+          status: result.channel.status,
+        },
+        "manual_verify: channel attested verified by guardian",
+      );
+      return Response.json({ ok: true, channel: result.channel });
+    },
+
     // ── Invite routes ──
     async handleListInvites(req: Request): Promise<Response> {
       const url = new URL(req.url);

package/src/http/routes/contacts-control-plane-route-match.ts

@@ -5,6 +5,7 @@ export type ContactsControlPlaneRoute =
   | { kind: "deleteContact"; contactId: string }
   | { kind: "mergeContacts" }
   | { kind: "updateContactChannel"; contactChannelId: string }
+  | { kind: "verifyContactChannel"; contactChannelId: string }
   | { kind: "listInvites" }
   | { kind: "createInvite" }
   | { kind: "redeemInvite" }
@@ -26,6 +27,17 @@ export function matchContactsControlPlaneRoute(
     return { kind: "mergeContacts" };
   }
 
+  // Channel verify (must come before the bare channel match)
+  const channelVerifyMatch = pathname.match(
+    /^\/v1\/contact-channels\/([^/]+)\/verify$/,
+  );
+  if (channelVerifyMatch && method === "POST") {
+    return {
+      kind: "verifyContactChannel",
+      contactChannelId: channelVerifyMatch[1],
+    };
+  }
+
   // Channel status/policy updates
   const channelMatch = pathname.match(/^\/v1\/contact-channels\/([^/]+)$/);
   if (channelMatch && method === "PATCH") {

package/src/http/routes/ipc-runtime-proxy.test.ts

@@ -31,39 +31,38 @@ class MockIpcTransportError extends Error {
   }
 }
 
-// ipcCallAssistant — used by refreshRouteSchema to prime the cache
-const ipcCallAssistantMock = mock(() =>
-  Promise.resolve([
-    { operationId: "health", endpoint: "health", method: "GET" },
-    { operationId: "acp_steer", endpoint: "acp/:id/steer", method: "POST" },
-    {
-      operationId: "acp_list_sessions",
-      endpoint: "acp/sessions",
-      method: "GET",
-    },
-    {
-      operationId: "apps_dist_file",
-      endpoint: "apps/:appId/dist/:filename",
-      method: "GET",
-    },
-    // Policy-enforced routes (policies resolved gateway-side)
-    { operationId: "settings_get", endpoint: "settings", method: "GET" },
-    { operationId: "calls_start", endpoint: "calls/start", method: "POST" },
-  ]),
-);
+// Single mock for `ipcCallAssistant` — used by both `refreshRouteSchema`
+// (to prime the cache) and `tryIpcProxy` (per-request IPC calls).
+const ROUTE_SCHEMA = [
+  { operationId: "health", endpoint: "health", method: "GET" },
+  { operationId: "acp_steer", endpoint: "acp/:id/steer", method: "POST" },
+  {
+    operationId: "acp_list_sessions",
+    endpoint: "acp/sessions",
+    method: "GET",
+  },
+  {
+    operationId: "apps_dist_file",
+    endpoint: "apps/:appId/dist/:filename",
+    method: "GET",
+  },
+  // Policy-enforced routes (policies resolved gateway-side)
+  { operationId: "settings_get", endpoint: "settings", method: "GET" },
+  { operationId: "calls_start", endpoint: "calls/start", method: "POST" },
+];
+
+const defaultIpcImpl = (
+  method: string,
+  _params?: Record<string, unknown>,
+): Promise<unknown> => {
+  if (method === "get_route_schema") return Promise.resolve(ROUTE_SCHEMA);
+  return Promise.resolve({ ok: true });
+};
 
-// ipcCallAssistantStrict — used by tryIpcProxy for actual IPC calls
-const ipcCallAssistantStrictMock = mock(
-  (_method: string, _params?: Record<string, unknown>) =>
-    Promise.resolve({ ok: true }),
-);
+const ipcCallAssistantMock = mock(defaultIpcImpl);
 
-// Single mock.module for assistant-client — must include ALL exports
-// that any transitive import needs (route-schema-cache uses ipcCallAssistant,
-// ipc-runtime-proxy uses ipcCallAssistantStrict + error classes).
 mock.module("../../ipc/assistant-client.js", () => ({
   ipcCallAssistant: ipcCallAssistantMock,
-  ipcCallAssistantStrict: ipcCallAssistantStrictMock,
   IpcHandlerError: MockIpcHandlerError,
   IpcTransportError: MockIpcTransportError,
 }));
@@ -196,10 +195,8 @@ describe("matchRoute", () => {
 
 describe("tryIpcProxy", () => {
   beforeEach(() => {
-    ipcCallAssistantStrictMock.mockReset();
-    ipcCallAssistantStrictMock.mockImplementation(() =>
-      Promise.resolve({ ok: true }),
-    );
+    ipcCallAssistantMock.mockReset();
+    ipcCallAssistantMock.mockImplementation(defaultIpcImpl);
     validateEdgeTokenMock.mockReset();
     validateEdgeTokenMock.mockImplementation(() => ({
       ok: true,
@@ -241,8 +238,8 @@ describe("tryIpcProxy", () => {
     expect(result).not.toBeNull();
     expect(result!.status).toBe(200);
 
-    expect(ipcCallAssistantStrictMock).toHaveBeenCalledTimes(1);
-    const [opId, params] = ipcCallAssistantStrictMock.mock.calls[0] as [
+    expect(ipcCallAssistantMock).toHaveBeenCalledTimes(1);
+    const [opId, params] = ipcCallAssistantMock.mock.calls[0] as [
       string,
       Record<string, unknown>,
     ];
@@ -263,7 +260,7 @@ describe("tryIpcProxy", () => {
 
     await tryIpcProxy(req, makeConfig());
 
-    const [, params] = ipcCallAssistantStrictMock.mock.calls[0] as [
+    const [, params] = ipcCallAssistantMock.mock.calls[0] as [
       string,
       Record<string, unknown>,
     ];
@@ -306,7 +303,7 @@ describe("tryIpcProxy", () => {
   });
 
   test("returns handler error status code from IpcHandlerError", async () => {
-    ipcCallAssistantStrictMock.mockImplementation(() => {
+    ipcCallAssistantMock.mockImplementation(() => {
       throw new MockIpcHandlerError("Not found", 404, "NOT_FOUND");
     });
 
@@ -320,7 +317,7 @@ describe("tryIpcProxy", () => {
   });
 
   test("returns 502 on transport error", async () => {
-    ipcCallAssistantStrictMock.mockImplementation(() => {
+    ipcCallAssistantMock.mockImplementation(() => {
       throw new MockIpcTransportError("Socket closed");
     });
 
@@ -333,7 +330,7 @@ describe("tryIpcProxy", () => {
     const req = makeRequest("/v1/acp/sessions?limit=10&offset=5");
     await tryIpcProxy(req, makeConfig());
 
-    const [, params] = ipcCallAssistantStrictMock.mock.calls[0] as [
+    const [, params] = ipcCallAssistantMock.mock.calls[0] as [
       string,
       Record<string, unknown>,
     ];
@@ -347,10 +344,8 @@ describe("tryIpcProxy", () => {
 
 describe("policy enforcement", () => {
   beforeEach(() => {
-    ipcCallAssistantStrictMock.mockReset();
-    ipcCallAssistantStrictMock.mockImplementation(() =>
-      Promise.resolve({ ok: true }),
-    );
+    ipcCallAssistantMock.mockReset();
+    ipcCallAssistantMock.mockImplementation(defaultIpcImpl);
     validateEdgeTokenMock.mockReset();
   });
 

package/src/http/routes/ipc-runtime-proxy.ts

@@ -22,9 +22,9 @@ import { validateEdgeToken } from "../../auth/token-exchange.js";
 import type { TokenClaims } from "../../auth/types.js";
 import type { GatewayConfig } from "../../config.js";
 import {
-  ipcCallAssistantStrict,
   IpcHandlerError,
   IpcTransportError,
+  ipcCallAssistant,
 } from "../../ipc/assistant-client.js";
 import { matchRoute } from "../../ipc/route-schema-cache.js";
 import { getLogger } from "../../logger.js";
@@ -160,7 +160,7 @@ export async function tryIpcProxy(
 
   // --- Call daemon via IPC ------------------------------------------------
   try {
-    const result = await ipcCallAssistantStrict(match.operationId, params);
+    const result = await ipcCallAssistant(match.operationId, params);
 
     const duration = Math.round(performance.now() - start);
     log.info(

package/src/http/routes/log-export.test.ts

@@ -63,6 +63,7 @@ mock.module("../../logger.js", () => {
     getLogger: () => noopLogger,
     initLogger: noop,
     LOG_FILE_PATTERN: /^gateway-(\d{4}-\d{2}-\d{2})\.log$/,
+    LOG_FILE_JSON_PATTERN: /^gateway-(\d{4}-\d{2}-\d{2})\.jsonl$/,
   };
 });
 

package/src/http/routes/log-export.ts

@@ -30,7 +30,11 @@ import { fetchCesLogExport } from "@vellumai/ces-client/http-log-export";
 import { mintServiceToken } from "../../auth/token-exchange.js";
 import type { GatewayConfig } from "../../config.js";
 import { fetchImpl } from "../../fetch.js";
-import { getLogger, LOG_FILE_PATTERN } from "../../logger.js";
+import {
+  getLogger,
+  LOG_FILE_JSON_PATTERN,
+  LOG_FILE_PATTERN,
+} from "../../logger.js";
 
 const log = getLogger("log-export");
 
@@ -257,7 +261,10 @@ async function collectGatewayLogs(
   let totalBytes = 0;
 
   for (const name of entries) {
-    const match = LOG_FILE_PATTERN.exec(name);
+    // Include both the pretty .log and the JSONL sidecar so support bundles
+    // give humans something readable and tooling something parseable.
+    const match =
+      LOG_FILE_PATTERN.exec(name) ?? LOG_FILE_JSON_PATTERN.exec(name);
     if (!match) continue;
 
     const fileDateStr = match[1];