opnsense_diag_log_resolver

Instructions

Implementation Reference

• src/tools/diagnostics.ts:427-431 (handler)

  Handler for opnsense_diag_log_resolver: parses args with LogQuerySchema, calls fetchLogWithFallback(client, 'resolver', limit), returns JSON result.

  case "opnsense_diag_log_resolver": {
    const parsed = LogQuerySchema.parse(args);
    const result = await fetchLogWithFallback(client, "resolver", parsed.limit);
    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
  }

• src/tools/diagnostics.ts:33-35 (schema)

  LogQuerySchema defines the input schema for log-resolver: optional limit (1-5000, default 500) coerced from string.

  const LogQuerySchema = z.object({
    limit: z.coerce.number().int().min(1).max(5000).optional().default(500),
  });

• src/tools/diagnostics.ts:174-183 (registration)

  Tool definition registration in diagnosticsToolDefinitions array with name 'opnsense_diag_log_resolver', description, and input schema.

  {
    name: "opnsense_diag_log_resolver",
    description: "Retrieve recent Unbound DNS resolver log entries.",
    inputSchema: {
      type: "object" as const,
      properties: {
        limit: { type: "number", description: "Number of log entries (1-5000, default 500)" },
      },
    },
  },

• src/tools/diagnostics.ts:207-251 (helper)

  fetchLogWithFallback helper function that tries multiple API endpoint variants (get, post search, get core/) to retrieve log entries, used by the resolver handler.

  async function fetchLogWithFallback(
    client: OPNsenseClient,
    category: string,
    limit: number,
  ): Promise<unknown> {
    type Variant = { method: "get" | "post"; path: string; body?: unknown };
    const variants: Variant[] = [
      { method: "get", path: `/diagnostics/log/${category}?limit=${limit}` },
      {
        method: "post",
        path: `/diagnostics/log/${category}/search`,
        body: { current: 1, rowCount: limit, sort: {}, searchPhrase: "" },
      },
      { method: "get", path: `/diagnostics/log/core/${category}?limit=${limit}` },
    ];
  
    let lastResult: unknown = null;
    let lastError: unknown = null;
  
    for (const variant of variants) {
      try {
        const result =
          variant.method === "get"
            ? await client.get<unknown>(variant.path)
            : await client.post<unknown>(variant.path, variant.body);
  
        // A non-empty payload wins. Treat the result as non-empty if:
        //   - array with length > 0
        //   - object with rows[].length > 0
        //   - object with any other non-empty data field
        if (isNonEmptyLogPayload(result)) {
          return result;
        }
        lastResult = result;
      } catch (error) {
        lastError = error;
        // Endpoint not present (404) → keep trying. Other errors propagate
        // only if every variant fails.
      }
    }
  
    if (lastResult !== null) return lastResult;
    if (lastError) throw lastError;
    return [];
  }

• src/tools/diagnostics.ts:253-261 (helper)

  isNonEmptyLogPayload helper function that checks if a log payload contains data (array length > 0, or object with rows/total).

  function isNonEmptyLogPayload(payload: unknown): boolean {
    if (Array.isArray(payload)) return payload.length > 0;
    if (payload && typeof payload === "object") {
      const obj = payload as Record<string, unknown>;
      if (Array.isArray(obj["rows"]) && (obj["rows"] as unknown[]).length > 0) return true;
      if (typeof obj["total"] === "number" && obj["total"] > 0) return true;
    }
    return false;
  }