maka-agent 0.2.0-dev.62.20260928 → 0.2.0-dev.64.20260929

package/node_modules/@maka/eval/harbor/egress_filter.py

@@ -126,7 +126,7 @@ def public_trajectory_repository(host: str, path_query: str) -> bool:
 
 try:
     from mitmproxy import http
-except ImportError:
+except ImportError as missing_http_dependency:
     http = None
 
 try:
@@ -134,7 +134,7 @@ try:
     from mitmproxy.proxy.layer import Layer
     from mitmproxy.proxy.layers import ClientTLSLayer, ServerTLSLayer
     from mitmproxy.proxy.layers.tcp import TCPLayer
-except ImportError:
+except ImportError as missing_proxy_dependency:
     proxy_commands = None
     Layer = object
     ClientTLSLayer = None
@@ -177,52 +177,47 @@ def response(flow: object) -> None:
     reject_raw_transport(flow, close=False)
 
 
-def http_connect(flow: object) -> None:
+def http_connect(flow: object, /) -> None:
     request = getattr(flow, "request", None)
-    try:
-        target = parse_connect_target(
-            getattr(request, "host", None),
-            getattr(request, "port", None),
-        ).url
-    except (TypeError, ValueError):
-        target = ""
+    target = _safe_connect_url(
+        getattr(request, "host", None),
+        getattr(request, "port", None),
+    )
     enforce_url_policy(flow, target)
 
 
-def tcp_start(flow: object) -> None:
+def tcp_start(flow: object, /) -> None:
     # This is a last-resort hook for a raw layer admitted by an override.
     reject_raw_transport(flow)
 
 
-def tcp_message(flow: object) -> None:
-    messages = getattr(flow, "messages", None)
-    if messages and hasattr(messages[-1], "content"):
-        messages[-1].content = b""
+def tcp_message(flow: object, /) -> None:
+    _clear_latest_tcp_message(getattr(flow, "messages", None))
     close_flow(flow)
 
 
 def next_layer(nextlayer: object) -> None:
-    current = getattr(nextlayer, "layer", None)
-    context = getattr(nextlayer, "context", None)
-    if current is None:
+    active_layer = getattr(nextlayer, "layer", None)
+    layer_context = getattr(nextlayer, "context", None)
+    if active_layer is None:
         data_client = _next_layer_bytes(nextlayer, "data_client")
         if _is_fragmented_tls_record_prefix(data_client):
             if ClientTLSLayer is None or ServerTLSLayer is None:
                 return
-            server_tls = ServerTLSLayer(context)
-            server_tls.child_layer = ClientTLSLayer(context)
+            server_tls = ServerTLSLayer(layer_context)
+            server_tls.child_layer = ClientTLSLayer(layer_context)
             nextlayer.layer = server_tls
             return
         if not initial_stream_is_raw(nextlayer):
             return
-        reject_raw_transport(context, close=False)
-        nextlayer.layer = RejectRawTransport(context, proxy_commands)
+        reject_raw_transport(layer_context, close=False)
+        nextlayer.layer = RejectRawTransport(layer_context, proxy_commands)
         return
-    if TCPLayer is None or not isinstance(current, TCPLayer):
+    if TCPLayer is None or not isinstance(active_layer, TCPLayer):
         return
-    reject_raw_transport(context, close=False)
-    closer = RejectRawTransport(context, proxy_commands)
-    replace_layer(context, current, closer)
+    reject_raw_transport(layer_context, close=False)
+    closer = RejectRawTransport(layer_context, proxy_commands)
+    replace_layer(layer_context, active_layer, closer)
     nextlayer.layer = closer
 
 
@@ -230,10 +225,10 @@ def enforce_url_policy(flow: object, raw_url: str) -> None:
     if http is None:
         raise RuntimeError("mitmproxy is required to run the Eval egress filter")
     try:
-        matched = contamination_rule(raw_url)
-        if not matched:
+        match = contamination_rule(raw_url)
+        if not match:
             return
-        rule_id, host, normalized_path = matched
+        rule_id, host, normalized_path = match
         audit_event(rule_id, host, normalized_path)
         flow.response = blocked_response(rule_id)
     except Exception as error:
@@ -255,6 +250,21 @@ def connect_url(host: object, port: object) -> str:
     return parse_connect_target(host, port).url
 
 
+def _safe_connect_url(host: object, port: object) -> str:
+    try:
+        return connect_url(host, port)
+    except (TypeError, ValueError):
+        return ""
+
+
+def _clear_latest_tcp_message(messages: object) -> None:
+    if not isinstance(messages, list) or not messages:
+        return
+    latest = messages[-1]
+    if hasattr(latest, "content"):
+        latest.content = b""
+
+
 def parse_connect_target(host: object, port: object) -> ConnectTarget:
     normalized_host = _normalize_connect_host(host)
     normalized_port = _normalize_connect_port(port)
@@ -343,31 +353,37 @@ def _next_layer_bytes(nextlayer: object, name: str) -> bytes:
 
 def peer_label(owner: object) -> tuple[str, str]:
     server = getattr(owner, "server_conn", None) or getattr(owner, "server", None)
-    address = getattr(server, "address", None)
-    if isinstance(address, (tuple, list)) and address:
-        host = str(address[0])[:255]
-        port = address[1] if len(address) > 1 else ""
-        return host, f":{port}" if port != "" else ""
-    return "", ""
+    peer_address = getattr(server, "address", None)
+    return _format_peer_address(peer_address)
+
+
+def _format_peer_address(address: object) -> tuple[str, str]:
+    if not isinstance(address, (tuple, list)) or not address:
+        return "", ""
+    host = str(address[0])[:255]
+    port = address[1] if len(address) > 1 else ""
+    return host, f":{port}" if port != "" else ""
 
 
 def reject_raw_transport(owner: object, *, close: bool = True) -> None:
     host, port = peer_label(owner)
-    try:
-        audit_event("raw_tunnel", host, port)
-    except Exception:
-        pass
+    _audit_safely("raw_tunnel", host, port)
     if close:
         close_flow(owner)
 
 
+def _audit_safely(rule_id: str, host: str, normalized_path: str) -> None:
+    with suppress(Exception):
+        audit_event(rule_id, host, normalized_path)
+
+
 def close_flow(flow: object) -> None:
     terminate = getattr(flow, "kill", None)
     if callable(terminate) and getattr(flow, "killable", True):
         try:
             terminate()
-        except Exception:
-            pass
+        except Exception as close_error:
+            del close_error
 
 
 def replace_layer(context: object, current: object, closer: object) -> None:
@@ -400,11 +416,11 @@ class RejectRawTransport(Layer):
     def handle_event(self, event: object):
         if self._close_connection is None:
             return
-            yield
-        for name in ("client", "server"):
-            connection = getattr(self.context, name, None)
-            if connection is not None:
-                yield self._close_connection(connection)
+        yield from (
+            self._close_connection(connection)
+            for name in ("client", "server")
+            if (connection := getattr(self.context, name, None)) is not None
+        )
 
 
 def blocked_response(rule_id: str):
@@ -456,7 +472,8 @@ class AuditJournal:
             return None
         size = self.path.stat().st_size
         with self.path.open("rb") as stream:
-            stream.seek(max(0, size - 4096))
+            tail_offset = max(0, size - 4096)
+            stream.seek(tail_offset)
             lines = stream.read().decode("utf-8", errors="ignore").splitlines()
         for line in reversed(lines):
             if not line.strip():

package/node_modules/@maka/eval/harbor/eval_framework.py

@@ -17,7 +17,7 @@
 
 """Process-local framework authority shared by the trial runner and relay."""
 
-from __future__ import annotations
+from __future__ import annotations  # Keep framework metadata importable on Python 3.9.
 
 from typing import NamedTuple
 
@@ -39,7 +39,7 @@ def framework_spec(name: str) -> FrameworkSpec:
     try:
         return _FRAMEWORKS[name]
     except KeyError:
-        raise RuntimeError("framework must be harbor or pier")
+        raise RuntimeError("framework must be harbor or pier") from None
 
 
 def install(name: str) -> None:
@@ -51,7 +51,7 @@ def install(name: str) -> None:
 
 def current_framework() -> str:
     if _active is None:
-        raise RuntimeError("Eval framework selection is not installed")
+        raise RuntimeError("Eval framework selection is not installed") from None
     return _active.name
 
 

package/node_modules/@maka/eval/harbor/run_trial.py

@@ -117,9 +117,9 @@ def publish_ready_task(namespace: Path, target: Path) -> None:
 
 
 async def run_trial(framework: str, expected_version: str, config_file: Path) -> None:
-    from eval_framework import install
+    from eval_framework import install as select_framework
 
-    install(framework)
+    select_framework(framework)
     await _run_selected_trial(framework, expected_version, config_file)
 
 

package/node_modules/@maka/eval/node_modules/undici/README.md

@@ -378,7 +378,16 @@ The `body` mixins are the most common way to format the request/response body. M
 > The body returned from `undici.request` does not implement `.formData()`.
 
 > [!WARNING]
-> Calling `body.formData()` on a fetch response causes undici to buffer and parse the entire body. Since this is dictated by the spec, `body.formData()` must only be called on responses from trusted servers.
+> The body mixins `.arrayBuffer()`, `.blob()`, `.bytes()`, `.json()`, `.text()`,
+> and `.formData()` buffer the entire body in memory before returning. Where
+> applicable, they also decode or parse the payload and retain that
+> representation in memory. Calling these methods therefore means trusting that
+> the response body is small enough to fit in the available memory. Do not use
+> them for responses from untrusted or user-controlled sources. Instead, consume
+> the response body as a stream and enforce an application-specific size limit:
+> use `response.body` for fetch responses or the `body` returned by
+> `undici.request()`. For streaming decoded text, use `body.textStream()` on a
+> fetch `Request` or `Response`.
 
 Example usage:
 

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Agent.md

@@ -56,16 +56,16 @@ changes:
     `Infinity`, no limit is enforced. Must be a number greater than `0`.
     **Default:** `Infinity`.
 
-`Agent` inherits all {PoolOptions} (and therefore all {ClientOptions}). The
-per-origin {Pool} it creates uses the default unlimited `connections`, so
-concurrent requests to the same origin are spread across separate {Client}
-instances on separate sockets.
+`Agent` inherits all {PoolOptions} (and therefore all {ClientOptions}). Each
+origin gets a separate {Pool}, with `connections` acting as the maximum number
+of clients that pool may create.
 
 > [!NOTE]
-> Because each concurrent request to an origin may use a different {Client},
-> HTTP/2 multiplexing on a shared session does not apply unless `connections` is
-> set to a small value (for example `connections: 1`). See {PoolOptions} and
-> {ClientOptions} for the full set of inherited options such as `allowH2`
+> For an h2-capable HTTPS origin, the per-origin pool waits for the first TLS
+> connection to finish ALPN negotiation. If the server selects h2, concurrent
+> requests share that session up to `maxConcurrentStreams`. If it selects
+> HTTP/1.1, normal connection fan-out resumes up to `connections`. See
+> {PoolOptions} and {ClientOptions} for inherited options such as `allowH2`
 > (default `true`) and `maxConcurrentStreams` (default `100`).
 
 ### `agent.closed`

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/DiagnosticsChannel.md

@@ -120,7 +120,8 @@ diagnosticsChannel.channel('undici:request:bodySent').subscribe(({ request }) =>
 added: v6.3.0
 -->
 
-Published after the response headers have been received.
+Published after the response headers have been received. This includes a
+successful CONNECT or protocol upgrade response.
 
 * `message` {Object}
   * `request` {Object} The same object published by
@@ -128,8 +129,9 @@ Published after the response headers have been received.
   * `response` {Object} The response being received.
     * `statusCode` {number} The HTTP status code.
     * `statusText` {string} The HTTP status message.
-    * `headers` {Buffer[]} The raw response headers as an array of buffers,
-      alternating between header name and value.
+    * `headers` {Buffer[]|Object} HTTP/1.1 response headers are an array of
+      buffers alternating between header name and value. HTTP/2 response
+      headers are an object.
 
 ```mjs
 import diagnosticsChannel from 'node:diagnostics_channel'
@@ -137,7 +139,7 @@ import diagnosticsChannel from 'node:diagnostics_channel'
 diagnosticsChannel.channel('undici:request:headers').subscribe(({ request, response }) => {
   console.log('statusCode', response.statusCode)
   console.log(response.statusText)
-  console.log(response.headers.map((x) => x.toString()))
+  console.log(response.headers)
 })
 ```
 
@@ -168,8 +170,9 @@ diagnosticsChannel.channel('undici:request:bodyChunkReceived').subscribe(({ requ
 added: v6.3.0
 -->
 
-Published after the response body and trailers have been received, that is, once
-the response has fully completed.
+Published once the response has fully completed. After an upgraded socket has
+been passed to the request handler, this event is published with an empty
+`trailers` array.
 
 * `message` {Object}
   * `request` {Object} The same object published by

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Dispatcher.md

@@ -466,6 +466,15 @@ example, calling `text()` after `json()` throws a `TypeError`. The body also
 provides `dump({ limit })`, which discards up to `limit` bytes (default
 `131072`) without destroying the socket.
 
+> [!WARNING]
+> The `arrayBuffer()`, `blob()`, `bytes()`, `json()`, and `text()` methods buffer
+> the entire body in memory before returning. Where applicable, they also decode
+> or parse the payload and retain that representation in memory. Calling these
+> methods therefore means trusting that the body is small enough to fit in the
+> available memory. Do not use them for bodies received from untrusted or
+> user-controlled sources. Instead, process `body` as a `Readable` stream and
+> enforce an application-specific size limit.
+
 The body is always a `Readable`, even when empty. Deserializing an empty body
 with `json()` throws. To guard against this, verify the status code is not `204`
 and the `content-type` header starts with `application/json` before calling

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Errors.md

@@ -446,6 +446,31 @@ The response returned an error status code. This is raised, for example, when th
   * `headers` {Object|string[]|null} The response headers. (optional)
   * `body` {Object|string|null} The response body. (optional)
 
+## Class: `ProxyConnectionError`
+
+<!-- YAML
+added: v8.10.1
+changes:
+  - version: v8.10.1
+    pr-url: https://github.com/nodejs/undici/pull/5707
+    description: Added to fail the request instead of retrying forever when the proxy connection is torn down.
+-->
+
+* Extends: {UndiciError}
+
+A connection to the proxy failed in a way that cannot be recovered on the
+same connection, so the request fails instead of being retried.
+
+* `name` {string} Always `'ProxyConnectionError'`.
+* `code` {string} Always `'UND_ERR_PRX_CONN'`.
+* `cause` {Error} The underlying error that caused the proxy connection to fail.
+
+### `new ProxyConnectionError(cause[, message[, options]])`
+
+* `cause` {Error} The underlying error. (optional)
+* `message` {string} The error message. (optional)
+* `options` {Object} Additional `Error` options merged with `cause`. (optional)
+
 ## Class: `SecureProxyConnectionError`
 
 <!-- YAML

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Fetch.md

@@ -596,6 +596,16 @@ properties for reading a body. Each consuming method reads the body once; after
 the body has been consumed, [`bodyUsed`](#bodybodyused) becomes `true` and
 calling another consuming method throws a `TypeError`.
 
+> [!WARNING]
+> The `arrayBuffer()`, `blob()`, `bytes()`, `formData()`, `json()`, and `text()`
+> methods buffer the entire body in memory before returning. Where applicable,
+> they also decode or parse the payload and retain that representation in
+> memory. Calling these methods therefore means trusting that the body is small
+> enough to fit in the available memory. Do not use them for bodies received
+> from untrusted or user-controlled sources. Instead, process `body.body` or
+> `body.textStream()` incrementally and enforce an application-specific size
+> limit.
+
 ### `body.arrayBuffer()`
 
 <!-- YAML

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Interceptors.md

@@ -210,9 +210,10 @@ Automatically decompresses response bodies encoded with `gzip`, `x-gzip`,
     skipped. **Default:** `[204, 304]`.
   * `skipErrorResponses` {boolean} When `true`, responses with a status code
     >= 400 are not decompressed. **Default:** `true`.
-  * `maxSize` {number} Maximum decompressed response size in bytes. The request
-    fails with a `ResponseExceededMaxSizeError` if the decoded body exceeds
-    this limit. **Default:** `67108864` (64 MiB).
+  * `maxSize` {number} Maximum decompressed response size in bytes for each
+    decompression stage. The request fails with a
+    `ResponseExceededMaxSizeError` if a stage exceeds this limit. Set to `0` to
+    disable the limit. **Default:** `0`.
 
 **Returns:** {Dispatcher.DispatcherComposeInterceptor}
 

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Pool.md

@@ -73,12 +73,11 @@ connector shared by every pooled client.
 
 > [!NOTE]
 > `Pool` inherits all {ClientOptions}, including `allowH2` and
-> `maxConcurrentStreams`. With the default unlimited `connections`, the pool
-> opens a new client - and therefore a new TCP/TLS socket - per concurrent
-> dispatch, which defeats HTTP/2 multiplexing over a shared session. To benefit
-> from h2 multiplexing on a single session, cap `connections` (for example
-> `connections: 1`) so that concurrent requests share a session up to
-> `maxConcurrentStreams`.
+> `maxConcurrentStreams`. For an h2-capable HTTPS origin, the pool waits for
+> the first TLS connection to finish ALPN negotiation before opening more
+> clients. If the server selects h2, concurrent requests share that session up
+> to `maxConcurrentStreams`. If it selects HTTP/1.1, the pool resumes normal
+> connection fan-out up to `connections`.
 
 ```mjs
 import { Pool } from 'undici'

package/node_modules/@maka/eval/node_modules/undici/docs/docs/index.md

@@ -380,7 +380,16 @@ The `body` mixins are the most common way to format the request/response body. M
 > The body returned from `undici.request` does not implement `.formData()`.
 
 > [!WARNING]
-> Calling `body.formData()` on a fetch response causes undici to buffer and parse the entire body. Since this is dictated by the spec, `body.formData()` must only be called on responses from trusted servers.
+> The body mixins `.arrayBuffer()`, `.blob()`, `.bytes()`, `.json()`, `.text()`,
+> and `.formData()` buffer the entire body in memory before returning. Where
+> applicable, they also decode or parse the payload and retain that
+> representation in memory. Calling these methods therefore means trusting that
+> the response body is small enough to fit in the available memory. Do not use
+> them for responses from untrusted or user-controlled sources. Instead, consume
+> the response body as a stream and enforce an application-specific size limit:
+> use `response.body` for fetch responses or the `body` returned by
+> `undici.request()`. For streaming decoded text, use `body.textStream()` on a
+> fetch `Request` or `Response`.
 
 Example usage:
 

package/node_modules/@maka/eval/node_modules/undici/lib/api/readable.js

@@ -5,7 +5,6 @@ const { addAbortListener } = require('node:events')
 const { Readable } = require('node:stream')
 const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require('../core/errors')
 const util = require('../core/util')
-const { ReadableStreamFrom } = require('../core/util')
 
 const kConsume = Symbol('kConsume')
 const kReading = Symbol('kReading')
@@ -246,7 +245,7 @@ class BodyReadable extends Readable {
    */
   get body () {
     if (!this[kBody]) {
-      this[kBody] = ReadableStreamFrom(this)
+      this[kBody] = ReadableStream.from(this)
       if (this[kConsume]) {
         // TODO: Is this the best way to force a lock?
         this[kBody].getReader() // Ensure stream is locked.

package/node_modules/@maka/eval/node_modules/undici/lib/core/request.js

@@ -368,10 +368,22 @@ class Request {
     }
   }
 
-  onRequestUpgrade (statusCode, headers, socket) {
+  /**
+   * @param {number} statusCode
+   * @param {Buffer[]|string[]|import('../../types/header.d.ts').IncomingHttpHeaders} headers
+   * @param {import('node:stream').Duplex} socket
+   * @param {string} [statusText]
+   */
+  onRequestUpgrade (statusCode, headers, socket, statusText = '') {
+    this.onFinally()
+
     assert(!this.aborted)
     assert(!this.completed)
 
+    if (channels.headers.hasSubscribers) {
+      channels.headers.publish({ request: this, response: { statusCode, headers, statusText } })
+    }
+
     const controller = this[kController]
     if (controller) {
       controller.rawHeaders = headers
@@ -379,7 +391,16 @@ class Request {
 
     const parsedHeaders = Array.isArray(headers) ? parseHeaders(headers) : headers
 
-    return this[kHandler].onRequestUpgrade?.(controller, statusCode, parsedHeaders, socket)
+    const result = this[kHandler].onRequestUpgrade?.(controller, statusCode, parsedHeaders, socket)
+
+    if (!this.aborted) {
+      this.completed = true
+      if (channels.trailers.hasSubscribers) {
+        channels.trailers.publish({ request: this, trailers: [] })
+      }
+    }
+
+    return result
   }
 
   onResponseEnd (trailers) {

package/node_modules/@maka/eval/node_modules/undici/lib/core/util.js

@@ -644,44 +644,6 @@ function getSocketInfo (socket) {
   }
 }
 
-/**
- * @param {Iterable} iterable
- * @returns {ReadableStream}
- */
-function ReadableStreamFrom (iterable) {
-  // We cannot use ReadableStream.from here because it does not return a byte stream.
-
-  let iterator
-  return new ReadableStream(
-    {
-      start () {
-        iterator = iterable[Symbol.asyncIterator]()
-      },
-      pull (controller) {
-        return iterator.next().then(({ done, value }) => {
-          if (done) {
-            return queueMicrotask(() => {
-              controller.close()
-              controller.byobRequest?.respond(0)
-            })
-          } else {
-            const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
-            if (buf.byteLength) {
-              return controller.enqueue(new Uint8Array(buf))
-            } else {
-              return this.pull(controller)
-            }
-          }
-        })
-      },
-      cancel () {
-        return iterator.return()
-      },
-      type: 'bytes'
-    }
-  )
-}
-
 /**
  * The object should be a FormData instance and contains all the required
  * methods.
@@ -1026,7 +988,6 @@ module.exports = {
   destroy,
   bodyLength,
   deepClone,
-  ReadableStreamFrom,
   isBuffer,
   assertRequestHandler,
   getSocketInfo,

package/node_modules/@maka/eval/node_modules/undici/lib/dispatcher/client-h1.js

@@ -70,8 +70,14 @@ function lazyllhttp () {
 
   let mod
 
-  // We disable wasm SIMD on ppc64 as it seems to be broken on Power 9 architectures.
-  let useWasmSIMD = process.arch !== 'ppc64'
+  // We disable wasm SIMD on older versions of Node.js on ppc64 that are broken on Power >=9 architectures.
+  let useWasmSIMD = true
+  if (process.arch === 'ppc64') {
+    const [major, minor] = process.versions.node.split('.').map(n => parseInt(n, 10))
+    if (major < 24 || (major === 24 && minor < 12)) {
+      useWasmSIMD = false
+    }
+  }
   // The Env Variable UNDICI_NO_WASM_SIMD allows explicitly overriding the default behavior
   if (process.env.UNDICI_NO_WASM_SIMD === '1') {
     useWasmSIMD = false
@@ -561,7 +567,7 @@ class Parser {
    * @param {Buffer} head
    */
   onUpgrade (head) {
-    const { upgrade, client, socket, headers, statusCode } = this
+    const { upgrade, client, socket, headers, statusCode, statusText } = this
 
     assert(upgrade)
     assert(client[kSocket] === socket)
@@ -596,8 +602,9 @@ class Parser {
     client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade'))
 
     try {
-      request.onRequestUpgrade(statusCode, headers, socket)
+      request.onRequestUpgrade(statusCode, headers, socket, statusText)
     } catch (err) {
+      util.errorRequest(client, request, err)
       util.destroy(socket, err)
     }