mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-21 07:30:53 +08:00
Compare commits
60
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
752d0cfab4 | ||
|
|
79119ae9bd | ||
|
|
b3b9334dc8 | ||
|
|
33e8d79426 | ||
|
|
42e8d3554d | ||
|
|
caa38f6ca8 | ||
|
|
0d85fc9b06 | ||
|
|
40a43580fe | ||
|
|
944c131e90 | ||
|
|
0dbb6de8d5 | ||
|
|
5def7bf57e | ||
|
|
268693066a | ||
|
|
0ffb0a68c4 | ||
|
|
892d1330f6 | ||
|
|
11adad32ce | ||
|
|
49c5e8fa8a | ||
|
|
f6f9575b19 | ||
|
|
280e99eace | ||
|
|
e2ca0118e7 | ||
|
|
1e9079267b | ||
|
|
3559be6482 | ||
|
|
aa8ba54efb | ||
|
|
3bbeb2c54e | ||
|
|
eecf8895aa | ||
|
|
5e1c55db4d | ||
|
|
dd5c371ead | ||
|
|
5679618ea7 | ||
|
|
9ab895f2b7 | ||
|
|
e10c2b76aa | ||
|
|
4841016892 | ||
|
|
8793f7b56c | ||
|
|
f758b4d964 | ||
|
|
c5cb1afad7 | ||
|
|
3feeb37a3a | ||
|
|
bbe95d085b | ||
|
|
9be6b76420 | ||
|
|
ef25384063 | ||
|
|
ada0092168 | ||
|
|
2d6d5c4e2b | ||
|
|
12f0ec0432 | ||
|
|
2ff2fc59ac | ||
|
|
9465dfa67a | ||
|
|
61d567a771 | ||
|
|
74b9843761 | ||
|
|
2db355389a | ||
|
|
6e906b4920 | ||
|
|
b7bc9f9517 | ||
|
|
594d1918fd | ||
|
|
ab40834567 | ||
|
|
84c77021c4 | ||
|
|
5e979f102a | ||
|
|
79c5daf076 | ||
|
|
cc465be782 | ||
|
|
64b90a746a | ||
|
|
dbbc287cd8 | ||
|
|
72fe3c3da1 | ||
|
|
15ed120758 | ||
|
|
221ad67549 | ||
|
|
dbf5cc3186 | ||
|
|
32ebb38e0f |
@@ -21,6 +21,8 @@ ARTEX_LLM_PROVIDER=
|
||||
ARTEX_LLM_MODEL=
|
||||
ARTEX_LLM_BASE_URL=
|
||||
ARTEX_LLM_PROXY=
|
||||
# Allow the UI model list to reach a local Ollama, e.g. host.docker.internal:11434
|
||||
ARTEX_LLM_PRIVATE_ENDPOINTS=
|
||||
|
||||
# Untrusted-output boundary. Frames every tool output between nonce-tagged markers so
|
||||
# the model treats it as data, not instructions. On by default (unset or empty = on);
|
||||
|
||||
@@ -39,8 +39,6 @@ jobs:
|
||||
# - TestGraphOverviewExpandsAssociatedCompanyScope,
|
||||
# TestCaptureApprovalLifecycle: fail on unmodified upstream code with a
|
||||
# fresh database.
|
||||
# - TestSideUsageRecordedOnceOnConsumerCancellation: concurrency/cancellation
|
||||
# test that passes locally but is timing-sensitive on 2-core CI runners.
|
||||
# They now skip themselves in code (t.Skip with a pointer to the issue).
|
||||
- name: go test
|
||||
# -p 1: package test suites share the single postgres service; running
|
||||
|
||||
+5
-1
@@ -23,8 +23,11 @@ All notable changes to this project are documented in this file. The format is b
|
||||
- **`ask_operator` target warning**: a request whose question names a host or URL outside the goal targets is tagged as containing target-derived text (#197).
|
||||
- **Opt-in update banner**: `ARTEX_UPDATE_CHECK` makes the backend check the latest GitHub release at most once per 24 hours and the UI show a banner; off by default (#202).
|
||||
- **Release provenance**: release archives carry GitHub build provenance attestations and a CycloneDX SBOM (`gh attestation verify <zip> --repo BaaRai/ARTEX`); release notes are the matching `CHANGELOG.md` section (#219, #201).
|
||||
- **Opt-in worker cache-prefix split (P3.5 Phase C)**: setting `ARTEX_CACHE_PREFIX=1` (off by default) splits the `worker` system prompt at `DynamicBoundary = 1` into a sibling-shareable static prefix (`body + untrustedContentTail + workerTrafficBlock`) and a per-intent dynamic suffix (`workerArtifactSpec(runDir)` through `<available-deferred-tools>`) without reordering sections or altering the visible joined prompt text. Planner, mainagent, chat, and goals are unchanged; custom worker prompts referencing `{{.Now}}` remain volatile in the static segment. See `docs/context-telemetry.md`.
|
||||
- **Opt-in LLM context size telemetry (P3.5 Phase A)**: setting `ARTEX_CONTEXT_TELEMETRY=1` (off by default) records per-call request section byte sizes (`system_static`/`system_dynamic` split at `DynamicBoundary`, serialized `tools`, `messages` by role, `tool_result` subset, and `last_message_bytes`), tool/message counts, and token/cache usage in the new `llm_context` table (migration `0009_llm_context.sql`), with zero prompt/behavior change and zero content stored, independent of `llm_record`. `GET /api/llm/context/summary` aggregates input percentiles (`p50`/`p90`/`p99`), pro-rata section shares over real `input_tokens`, `cache_read/input` ratios by `(worker, model)`, and top tasks. See `docs/context-telemetry.md`.
|
||||
- **HAR 1.2 traffic import and export**: `POST /api/traffic/import/har` imports raw HAR 1.2 JSON captures (up to 32 MiB / 2,000 entries / 32 MiB decoded bodies) with deterministic `har-<sha256>` IDs (and `_artexExchangeId` preservation for ARTEX exports so distinct same-second exchanges round-trip without collapsing), base64 decoding, `postData.params` and `cookies` array fallbacks, URL userinfo stripping, blob spilling above 256 KiB, and full-text indexing, without applying capture rewrite rules (`exchange_rewrites` stays empty); per-entry errors are reported alongside `imported`/`skipped`/`failed` counts. `GET /api/traffic/export/har` exports filtered traffic (reusing the `GET /api/traffic` filters) as a compliant HAR 1.2 document (with explicit unknown placeholders for unrecorded timings and header sizes) in stable `(ts, id)` order, encoding UTF-8 bodies as text and binary bodies as base64, capped at 1,000 entries / 20 MiB raw headers+bodies (31 MiB JSON backstop, guaranteed under the 32 MiB import limit) with explicit truncation reporting via `X-ARTEX-HAR-*` headers and `_truncated`/`_truncatedReason`/`_totalMatched` fields. The Traffic page adds **Import HAR** and **Export HAR** controls. See `docs/traffic-har.md`.
|
||||
- **Capture-proxy rewrite rules, storage and API**: `GET`, `POST`, `PUT` and `DELETE /api/traffic/rewrite-rules` and `POST /api/traffic/rewrite-rules/{id}/toggle` manage rules that match a request or a response (method, host, URL, headers, body, status) and describe a rewrite (method, path and query, headers, body, status). Rules are validated on save, limited to 100 of which 50 enabled, created disabled, and stored in the new table `traffic_rewrite_rules` (migration `0005_traffic_rewrite_rules.sql`) with `matchers` and `actions` encrypted at rest. The value of an action marked `sensitive` is never returned, and an update sent without it keeps the stored one. The server compiles the enabled rules at startup and after every change and hands the snapshot to the proxy. The proxy applies them from the next entry. See `docs/traffic-rewrite-rules.md`.
|
||||
- **Capture-proxy rewrite rules applied**: the capture proxy applies enabled rules to each HTTP request before it is sent to the target and to each response before it reaches the client. Each action that ran is recorded in the new table `exchange_rewrites` in the same transaction as the exchange, `traffic_get` shows a `REWRITTEN` line, and `traffic_search` never finds a value a rule wrote. SSE status and headers are rewritten at the start of the stream. **WebSocket handshakes are not rewritten**: the capture library runs its hook after the upgrade, so the status and headers cannot be changed, and frames pass unchanged. **Responses of 5 MiB or more** are forwarded unchanged and not recorded in full, because the library does not call the response hook for them. Snapshots of original requests are capped at 1024 entries and 64 MiB. Replays go through the proxy, so the rules apply to them. Archives, a per-replay rule toggle, the web UI and the proof flag come later.
|
||||
- **Capture-proxy rewrite rules applied**: the capture proxy applies enabled rules to each HTTP request before it is sent to the target and to each response before it reaches the client. Each action that ran is recorded in the new table `exchange_rewrites` in the same transaction as the exchange, `traffic_get` shows a `REWRITTEN` line, and `traffic_search` never finds a value a rule wrote. SSE status and headers are rewritten at the start of the stream. **WebSocket handshakes are not rewritten**: the capture library runs its hook after the upgrade, so the status and headers cannot be changed, and frames pass unchanged. **Responses of 5 MiB or more** are forwarded unchanged and not recorded in full, because the library does not call the response hook for them. Snapshots of original requests are capped at 1024 entries and 64 MiB. Replays (`POST /api/traffic/replay`) bypass capture rewrite rules by default via an internal `X-ARTEX-Replay-Nonce` header stripped unconditionally by the proxy, and apply the rules when opted in with `apply_rules: true` (the **Apply capture rewrite rules** checkbox in the Replay panel). `GET /api/traffic` exposes the proxy's `rewrite` counters (`large_responses`, `capacity_refusals`, `tombstone_drops`, `conversions`, `sweeps`), flags each exchange row with `rewritten`, and filters with `rewritten=all|rewritten|original` (also accepting `true`/`false`), surfaced with a filter control and row badge on the Traffic page. Traffic archives export version 2 with per-exchange `rewritten` and sorted distinct applied `rewrite_rule_ids` while remaining deterministic and backward-compatible with version 1 archives. The rule-management web UI comes later.
|
||||
- **Bulk finding status** (#298): select findings in the findings table and apply one disposition to all of them, up to 500 per call, in one transaction; each row still goes through the single-decision notification semantics and the change is mirrored onto its exploration node (#289).
|
||||
- **Stream message direction filter** (#379): `GET /api/traffic/stream` and the `traffic_messages` agent tool take an optional `direction` (`c2s` or `s2c`) that lists only one side of a WebSocket or SSE conversation. `total` and `offset` apply to the filtered list, each row keeps its `seq` in the whole stream, and the `meta` row (messages dropped past the recorder limits) stays in a filtered page. Any other value is a 400 (API) or a tool error.
|
||||
- **Traffic replay** (#266): replay a recorded request from the traffic detail with its method, URL, headers and stored body; replay is disabled when only the body preview is loaded.
|
||||
@@ -50,6 +53,7 @@ All notable changes to this project are documented in this file. The format is b
|
||||
|
||||
### Fixed
|
||||
|
||||
- **LLM usage status on early stream exit**: when a consumer stops reading a stream before `message_stop`, the recorder now stores the `llm_usage` row as `error` at that point, whether or not the context was cancelled, instead of inferring the status from `ctx.Err()` in a deferred call. `TestSideUsageRecordedOnceOnConsumerCancellation` runs again (follow-up to #9).
|
||||
- **Workspace and skill symlink confinement**: workspace file operations, the skill file APIs and the skill loader resolve symlinks in every path component and refuse a target outside their root, so a link planted in the workspace or a skill directory cannot expose another file.
|
||||
- **Target gate behind proxies**: a target approval is name-only whenever a proxy is in the path, including the recording proxy, the global egress proxy and a custom tool's own proxy, so the gate never claims an IP binding the proxy does not enforce.
|
||||
- **Remote MCP response bound**: Streamable HTTP JSON-RPC bodies and SSE data payloads are refused above 8 MiB, so a remote MCP server cannot force an unbounded decode.
|
||||
|
||||
@@ -1,5 +1,12 @@
|
||||
# Contributing
|
||||
|
||||
## First contribution
|
||||
|
||||
- **Share feedback.** Check [open issues](https://github.com/BaaRai/ARTEX/issues) for the same problem or proposal and add any new details there. For a new idea, explain what you were trying to do and what would make it easier.
|
||||
- **Report a problem.** Include a short reproduction and the relevant environment. For a UI issue, a sanitized screenshot and the browser version can help. Remove credentials, private URLs, and sensitive task data before posting.
|
||||
- **Report a security issue.** Do not open a public issue for a vulnerability; follow [SECURITY.md](SECURITY.md) to report it privately.
|
||||
- **Send a small change.** A documentation correction or a focused UI improvement is a good place to start. Check [open pull requests](https://github.com/BaaRai/ARTEX/pulls) for overlapping work and refer to the relevant issue in your PR so readers can find the discussion.
|
||||
|
||||
## Pull requests
|
||||
|
||||
- **At most 7 open pull requests per contributor.** The repository enforces this with GitHub's pull request creation limit, drafts included: when you reach it, close or merge one before opening another. Review is manual, one change at a time, so a larger batch makes the queue unmanageable and slows everyone down, including you. If you have more changes queued, open one issue that lists them and wait for the current ones to be reviewed.
|
||||
|
||||
+57
-26
@@ -14,6 +14,7 @@
|
||||
# Pinned to the Node 22 line the CI/release workflows use. On the build platform
|
||||
# only; the frontend static export is architecture-independent.
|
||||
FROM --platform=$BUILDPLATFORM node:22-bookworm-slim AS web
|
||||
ENV NEXT_TELEMETRY_DISABLED=1
|
||||
WORKDIR /src/web
|
||||
COPY web/package.json web/package-lock.json ./
|
||||
RUN npm ci --ignore-scripts
|
||||
@@ -47,19 +48,44 @@ RUN ARTEX_SKIP_FRONTEND=1 \
|
||||
# Web-recon toolbox (drost-community take 1, #100): pinned release binaries, staged
|
||||
# on the build platform and copied into /usr/local/bin of the runtime image so hunt
|
||||
# workers can run them directly through their Bash tool. Versions pinned per tool;
|
||||
# upgrade deliberately. Each archive is verified against the checksums file of its
|
||||
# own GitHub release (exact asset name, sha256). That file comes from the same
|
||||
# release channel as the archive, so it catches corrupted or swapped downloads and
|
||||
# moved tags, not a compromised publisher. sqlmap has no release binaries: it is a
|
||||
# shallow clone of a pinned tag, checked against the expected commit.
|
||||
# upgrade deliberately.
|
||||
#
|
||||
# Every archive is verified against a SHA-256 written down here, per asset and per
|
||||
# architecture, not against the *_checksums.txt of its own GitHub release. Checking
|
||||
# against that file catches a corrupted or swapped download and a moved tag, but the
|
||||
# digest and the artifact it describes come from the same publisher and the same
|
||||
# release: a replacement asset and a replacement checksums file agree with each
|
||||
# other and the build passes. Pinning the digest here moves that decision out of the
|
||||
# build, so a swapped asset fails unless the diff that swaps it also changes the
|
||||
# digest a reviewer reads.
|
||||
#
|
||||
# Cost: a version bump is now three edits (the version ARG and the two digests), and
|
||||
# a publisher re-uploading an asset under the same tag breaks the build until the
|
||||
# digest is bumped on purpose. That is the trade: the build stops trusting the
|
||||
# channel it downloads from.
|
||||
#
|
||||
# sqlmap has no release binaries: it is a shallow clone of a pinned tag, checked
|
||||
# against the expected commit, which is the same idea.
|
||||
FROM --platform=$BUILDPLATFORM debian:bookworm-slim AS tools
|
||||
ARG TARGETARCH
|
||||
ARG NUCLEI_VERSION=v3.11.1
|
||||
ARG NUCLEI_SHA256_AMD64=ea63d4ae232808cd7c6bc00d0142428e231fab59dae01042246097d195835ab6
|
||||
ARG NUCLEI_SHA256_ARM64=8044e3d9768ba0a744b2872c1a87e813006f013da97ca9f50f7661a4203bec07
|
||||
ARG HTTPX_VERSION=v1.12.0
|
||||
ARG HTTPX_SHA256_AMD64=9d8439e8b6c9aa7d1e2314817a392e00d5178da3af5652f7475f88868f418f76
|
||||
ARG HTTPX_SHA256_ARM64=fd7b123c1dfbc3d69f19f524e4eebcd6ec06b9a6cbd56813c76f11645197331e
|
||||
ARG SUBFINDER_VERSION=v2.17.0
|
||||
ARG SUBFINDER_SHA256_AMD64=a39c3e5c7a26ef3c430915c4d6cbf7716a00f26769a75e9405aba796142eba37
|
||||
ARG SUBFINDER_SHA256_ARM64=24913d49dddc1d3a5e99a4a7580da5be980959b9415b96f52c4f7f4124392190
|
||||
ARG KATANA_VERSION=v1.8.0
|
||||
ARG KATANA_SHA256_AMD64=cb027ae99d0757061b70c07a15c7a80f62c5a535ab52c4a329f80c4b0a7309d2
|
||||
ARG KATANA_SHA256_ARM64=80e269210727a855511ffac8dfb01297b2344742acec71a35e8ba4a67a90f0f2
|
||||
ARG FFUF_VERSION=v2.3.0
|
||||
ARG FFUF_SHA256_AMD64=b2a3c725fcb9da175159682f54d6e9149f2905b00d84d155e7efc5d599975ceb
|
||||
ARG FFUF_SHA256_ARM64=e2d712615d53da797ee929006e41f2df5a7960a5353133db9c150ddaa22ae4e8
|
||||
ARG DALFOX_VERSION=v3.2.4
|
||||
ARG DALFOX_SHA256_AMD64=c11cfd2f8261973f0a2a2a1eba5a147ce77712a29acfa6343f9847fb8bb7eca2
|
||||
ARG DALFOX_SHA256_ARM64=fd56b0b7da2d06868cd73b504f41d21314629feffcd5bdc97718db1c9dd2fa70
|
||||
ARG SQLMAP_VERSION=1.9.9
|
||||
ARG SQLMAP_COMMIT=cceda39208b5aad478de2c3f731df4239d9881f6
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
@@ -67,17 +93,21 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
RUN set -eux; \
|
||||
case "${TARGETARCH:-amd64}" in \
|
||||
amd64) PD_ARCH=amd64; FFUF_ARCH=amd64; DALFOX_ARCH=x86_64 ;; \
|
||||
arm64) PD_ARCH=arm64; FFUF_ARCH=arm64; DALFOX_ARCH=aarch64 ;; \
|
||||
amd64) PD_ARCH=amd64; FFUF_ARCH=amd64; DALFOX_ARCH=x86_64; \
|
||||
NUCLEI_SUM="$NUCLEI_SHA256_AMD64"; HTTPX_SUM="$HTTPX_SHA256_AMD64"; \
|
||||
SUBFINDER_SUM="$SUBFINDER_SHA256_AMD64"; KATANA_SUM="$KATANA_SHA256_AMD64"; \
|
||||
FFUF_SUM="$FFUF_SHA256_AMD64"; DALFOX_SUM="$DALFOX_SHA256_AMD64" ;; \
|
||||
arm64) PD_ARCH=arm64; FFUF_ARCH=arm64; DALFOX_ARCH=aarch64; \
|
||||
NUCLEI_SUM="$NUCLEI_SHA256_ARM64"; HTTPX_SUM="$HTTPX_SHA256_ARM64"; \
|
||||
SUBFINDER_SUM="$SUBFINDER_SHA256_ARM64"; KATANA_SUM="$KATANA_SHA256_ARM64"; \
|
||||
FFUF_SUM="$FFUF_SHA256_ARM64"; DALFOX_SUM="$DALFOX_SHA256_ARM64" ;; \
|
||||
*) echo "unsupported architecture: ${TARGETARCH}" >&2; exit 1 ;; \
|
||||
esac; \
|
||||
mkdir -p /out; \
|
||||
fetch() { base="$1"; asset="$2"; sums="$3"; name="$4"; \
|
||||
fetch() { base="$1"; asset="$2"; want="$3"; name="$4"; \
|
||||
rm -rf /tmp/t; mkdir -p /tmp/t/x; \
|
||||
curl -fsSL "$base/$asset" -o "/tmp/t/$asset"; \
|
||||
curl -fsSL "$base/$sums" -o /tmp/t/sums.txt; \
|
||||
want="$(awk -v a="$asset" '$2 == a || $2 == "*" a { print $1 }' /tmp/t/sums.txt)"; \
|
||||
if [ -z "$want" ]; then echo "no checksum entry for $asset" >&2; exit 1; fi; \
|
||||
if [ -z "$want" ]; then echo "no pinned digest for $asset" >&2; exit 1; fi; \
|
||||
got="$(sha256sum "/tmp/t/$asset" | cut -d' ' -f1)"; \
|
||||
if [ "$want" != "$got" ]; then echo "checksum mismatch for $asset: want $want got $got" >&2; exit 1; fi; \
|
||||
case "$asset" in *.zip) unzip -q "/tmp/t/$asset" -d /tmp/t/x ;; *) tar -xzf "/tmp/t/$asset" -C /tmp/t/x ;; esac; \
|
||||
@@ -86,17 +116,17 @@ RUN set -eux; \
|
||||
rm -rf /tmp/t; }; \
|
||||
gh="https://github.com"; \
|
||||
fetch "$gh/projectdiscovery/nuclei/releases/download/$NUCLEI_VERSION" \
|
||||
"nuclei_${NUCLEI_VERSION#v}_linux_${PD_ARCH}.zip" "nuclei_${NUCLEI_VERSION#v}_checksums.txt" nuclei; \
|
||||
"nuclei_${NUCLEI_VERSION#v}_linux_${PD_ARCH}.zip" "$NUCLEI_SUM" nuclei; \
|
||||
fetch "$gh/projectdiscovery/httpx/releases/download/$HTTPX_VERSION" \
|
||||
"httpx_${HTTPX_VERSION#v}_linux_${PD_ARCH}.zip" "httpx_${HTTPX_VERSION#v}_checksums.txt" httpx; \
|
||||
"httpx_${HTTPX_VERSION#v}_linux_${PD_ARCH}.zip" "$HTTPX_SUM" httpx; \
|
||||
fetch "$gh/projectdiscovery/subfinder/releases/download/$SUBFINDER_VERSION" \
|
||||
"subfinder_${SUBFINDER_VERSION#v}_linux_${PD_ARCH}.zip" "subfinder_${SUBFINDER_VERSION#v}_checksums.txt" subfinder; \
|
||||
"subfinder_${SUBFINDER_VERSION#v}_linux_${PD_ARCH}.zip" "$SUBFINDER_SUM" subfinder; \
|
||||
fetch "$gh/projectdiscovery/katana/releases/download/$KATANA_VERSION" \
|
||||
"katana_${KATANA_VERSION#v}_linux_${PD_ARCH}.zip" "katana-${KATANA_VERSION#v}-checksums.txt" katana; \
|
||||
"katana_${KATANA_VERSION#v}_linux_${PD_ARCH}.zip" "$KATANA_SUM" katana; \
|
||||
fetch "$gh/ffuf/ffuf/releases/download/$FFUF_VERSION" \
|
||||
"ffuf_${FFUF_VERSION#v}_linux_${FFUF_ARCH}.tar.gz" "ffuf_${FFUF_VERSION#v}_checksums.txt" ffuf; \
|
||||
"ffuf_${FFUF_VERSION#v}_linux_${FFUF_ARCH}.tar.gz" "$FFUF_SUM" ffuf; \
|
||||
fetch "$gh/hahwul/dalfox/releases/download/$DALFOX_VERSION" \
|
||||
"dalfox-${DALFOX_VERSION}-linux-${DALFOX_ARCH}-musl.tar.gz" "dalfox-${DALFOX_VERSION}-linux-${DALFOX_ARCH}-musl.tar.gz.sha256" dalfox; \
|
||||
"dalfox-${DALFOX_VERSION}-linux-${DALFOX_ARCH}-musl.tar.gz" "$DALFOX_SUM" dalfox; \
|
||||
git clone --quiet --depth 1 --branch "$SQLMAP_VERSION" https://github.com/sqlmapproject/sqlmap /opt/sqlmap; \
|
||||
commit="$(git -C /opt/sqlmap rev-parse HEAD)"; \
|
||||
if [ "$commit" != "$SQLMAP_COMMIT" ]; then echo "sqlmap commit mismatch: want $SQLMAP_COMMIT got $commit" >&2; exit 1; fi; \
|
||||
@@ -110,26 +140,27 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
ca-certificates ripgrep curl wget vim git jq unzip xz-utils \
|
||||
dnsutils iputils-ping netcat-openbsd inetutils-telnet whois nmap \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
# Node 22 from the official nodejs.org tarball, verified against its SHASUMS256.txt:
|
||||
# bookworm's apt nodejs is 18, Playwright requires >=20, and 20 is end-of-life.
|
||||
# 22 matches the CI and release workflows.
|
||||
# Node 22 from the official nodejs.org tarball: bookworm's apt nodejs is 18,
|
||||
# Playwright requires >=20, and 20 is end-of-life. 22 matches the CI and release
|
||||
# workflows. Verified against a digest pinned here rather than against the fetched
|
||||
# SHASUMS256.txt, for the reason given at the tools stage.
|
||||
ARG NODE_VERSION=22.23.4
|
||||
ARG NODE_SHA256_AMD64=1805bcd35e6815559bd2eb97db438d3fdb0eb3a5e6a977b7c1badca76337e9ce
|
||||
ARG NODE_SHA256_ARM64=6287aa46b6c375d816e63ae66d024fbbfd70404825aabdfdf898a970871d2f4b
|
||||
RUN set -eux; \
|
||||
case "${TARGETARCH:-amd64}" in \
|
||||
amd64) NODE_ARCH=x64 ;; \
|
||||
arm64) NODE_ARCH=arm64 ;; \
|
||||
amd64) NODE_ARCH=x64; want="$NODE_SHA256_AMD64" ;; \
|
||||
arm64) NODE_ARCH=arm64; want="$NODE_SHA256_ARM64" ;; \
|
||||
*) echo "unsupported architecture: ${TARGETARCH}" >&2; exit 1 ;; \
|
||||
esac; \
|
||||
base="https://nodejs.org/dist/v${NODE_VERSION}"; \
|
||||
asset="node-v${NODE_VERSION}-linux-${NODE_ARCH}.tar.xz"; \
|
||||
curl -fsSL "$base/$asset" -o "/tmp/$asset"; \
|
||||
curl -fsSL "$base/SHASUMS256.txt" -o /tmp/SHASUMS256.txt; \
|
||||
want="$(awk -v a="$asset" '$2 == a { print $1 }' /tmp/SHASUMS256.txt)"; \
|
||||
if [ -z "$want" ]; then echo "no checksum entry for $asset" >&2; exit 1; fi; \
|
||||
[ -n "$want" ] || { echo "no pinned digest for $asset" >&2; exit 1; }; \
|
||||
got="$(sha256sum "/tmp/$asset" | cut -d' ' -f1)"; \
|
||||
if [ "$want" != "$got" ]; then echo "checksum mismatch for $asset: want $want got $got" >&2; exit 1; fi; \
|
||||
tar -xJf "/tmp/$asset" -C /usr/local --strip-components=1 --no-same-owner; \
|
||||
rm -f "/tmp/$asset" /tmp/SHASUMS256.txt; \
|
||||
rm -f "/tmp/$asset"; \
|
||||
node --version; npm --version
|
||||
# Pinned, checksum-verified recon binaries and the sqlmap checkout from the tools stage.
|
||||
COPY --from=tools /out/ /usr/local/bin/
|
||||
|
||||
@@ -545,6 +545,25 @@ a trusted peer can claim any client address.
|
||||
|
||||
## Operations
|
||||
|
||||
### Troubleshooting an empty tool call
|
||||
|
||||
In the task's session transcript, expand the affected tool call and compare **Command** and
|
||||
**Output**. The `UNTRUSTED_OUTPUT` markers identify the boundary around tool output. They are
|
||||
expected and should stay enabled while troubleshooting.
|
||||
|
||||
- **Command shows `{}`.** The recorded tool input is an empty JSON object. For a tool that
|
||||
requires a command, this means its command argument was missing. Check which model and version
|
||||
produced the call.
|
||||
- **Command shows `(empty)` or `(failed to load)`.** The transcript has no input detail to display
|
||||
or could not fetch it. If the session record contains a command, include that discrepancy in a
|
||||
report.
|
||||
- **Output shows `[]`.** This is the recorded result body. Check the row's success or failure
|
||||
indicator and its input separately before drawing conclusions about what ran.
|
||||
|
||||
For a recurring problem, share the ARTEX version or commit, the model and version, and a sanitized
|
||||
excerpt of the affected input and result. Remove credentials, target data, and other sensitive
|
||||
content before sharing.
|
||||
|
||||
### Backups
|
||||
|
||||
`scripts/backup.sh` dumps the Postgres database (and optionally the data directory) with
|
||||
|
||||
@@ -101,6 +101,14 @@ func guardPanic(t actool.CoreTool) actool.CoreTool { return &guardedTool{CoreToo
|
||||
|
||||
type guardedTool struct{ actool.CoreTool }
|
||||
|
||||
// AcceptsRawInput forwards the wrapped tool's opt-out of the harness schema
|
||||
// check, as overriddenTool does: this wrapper is the one the harness sees, and
|
||||
// the embedded interface alone would hide the opt-out from its type assertion.
|
||||
func (g *guardedTool) AcceptsRawInput() bool {
|
||||
r, ok := g.CoreTool.(interface{ AcceptsRawInput() bool })
|
||||
return ok && r.AcceptsRawInput()
|
||||
}
|
||||
|
||||
func (g *guardedTool) Call(ctx context.Context, in json.RawMessage, tc *actool.ToolContext) (res actool.Result, err error) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
|
||||
@@ -33,7 +33,7 @@ func TestTaskScopeLabelIsHonest(t *testing.T) {
|
||||
// denominator and list_untested_assets.
|
||||
func TestAutoScopeOutsideDeclaredRootExcluded(t *testing.T) {
|
||||
d := testDB(t)
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
|
||||
stamp := time.Now().UnixNano()
|
||||
declared := fmt.Sprintf("app.f8-%d.invalid", stamp)
|
||||
|
||||
@@ -194,7 +194,7 @@ func companiesName(t *testing.T, companies *db.CompanyStore, companyID int64) st
|
||||
|
||||
func TestBlackboardToolsReadDirectSources(t *testing.T) {
|
||||
d := testDB(t)
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
|
||||
grand, err := d.CreateTask("grand", "grand goal", nil, 0, 0)
|
||||
if err != nil {
|
||||
@@ -378,7 +378,7 @@ func TestBlackboardToolsReadDirectSources(t *testing.T) {
|
||||
// model which ids it deferred, after de-duplicating and dropping invalid ids.
|
||||
func TestGetWorkerTraceStepIDsDegradeGracefully(t *testing.T) {
|
||||
d := testDB(t)
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
|
||||
task, err := d.CreateTask("trace-cap", "goal", nil, 0, 0)
|
||||
if err != nil {
|
||||
|
||||
@@ -16,7 +16,7 @@ import (
|
||||
// write happens even when the stored flag is off, which is the outage behaviour.
|
||||
func TestCoverageReadFailureKeepsToolsAndWritesAutoScope(t *testing.T) {
|
||||
d := testDB(t)
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
off := false
|
||||
task, err := d.CreateTaskWithOptions("coverage outage", "goal", db.TaskCreateOptions{CoverageEnabled: &off})
|
||||
if err != nil {
|
||||
|
||||
@@ -115,10 +115,9 @@ func TestRecordFactAssetAliases(t *testing.T) {
|
||||
func TestRecordFactAssetAliasSchema(t *testing.T) {
|
||||
schema := NewToolSet(nil, "").recordFact().InputSchema()
|
||||
props := schema["properties"].(map[string]any)
|
||||
for _, name := range []string{"asset_ids", "tested_asset_ids"} {
|
||||
if props[name] == nil {
|
||||
t.Fatalf("single schema missing %s", name)
|
||||
}
|
||||
// Facts-only contract: the alias lives on the items.
|
||||
if len(props) != 1 || props["facts"] == nil {
|
||||
t.Fatalf("top level must hold facts only: %v", props)
|
||||
}
|
||||
item := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
itemProps, _ := item["properties"].(map[string]any)
|
||||
|
||||
+88
-58
@@ -4,10 +4,12 @@ import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Match strings.TrimSpace, including Unicode whitespace, in the published schema.
|
||||
const factWhitespace = "\t\n\v\f\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000"
|
||||
const factWhitespace = "\t\n\v\f\r \u0085 -
"
|
||||
|
||||
func factAssetIDSchema() map[string]any {
|
||||
return map[string]any{
|
||||
@@ -16,10 +18,13 @@ func factAssetIDSchema() map[string]any {
|
||||
}
|
||||
}
|
||||
|
||||
// factItemSchema is one fact: the shape of every facts[] item. It is also the
|
||||
// shape of the legacy single-fact call (fields at the top level, no facts),
|
||||
// which the handler still accepts but the published schema no longer shows.
|
||||
func factItemSchema() map[string]any {
|
||||
schema := obj(map[string]any{
|
||||
"summary": str("Required on every fact: a non-empty one-sentence summary of this conclusion. Batch items do not inherit summary from the top level."),
|
||||
"intent_id": idp("The intent that produced this fact; only this field inherits from the top level in a batch."),
|
||||
"summary": str("Required: a non-empty one-sentence summary of this conclusion."),
|
||||
"intent_id": idp("The intent that produced this fact. Omit it to link the fact to the intent this worker is running; a batch may name a different intent per item."),
|
||||
"detail": str("Details of this fact, including all related observations."),
|
||||
"evidence": str("One line of key evidence: the command and the most proving output lines. Put longer output in detail."),
|
||||
"confidence": str("observed (seen directly in output) | inferred (inferred from phenomena). Label negative conclusions honestly."),
|
||||
@@ -34,68 +39,67 @@ func factItemSchema() map[string]any {
|
||||
return schema
|
||||
}
|
||||
|
||||
// recordFactFactsDescription documents the only top-level property of
|
||||
// record_fact. The wording tells a model that tends to fill every declared
|
||||
// property that there is nothing else to fill.
|
||||
const recordFactFactsDescription = "The facts to record, usually exactly one. Every item is a complete fact with its own summary. This is the only top-level property: never send summary, detail, evidence, confidence, source, intent_id or asset ids beside facts. Returned ids match item order; retry only failed indices."
|
||||
|
||||
// recordFactContractNote is appended to the record_fact description: the one
|
||||
// call shape the model is given.
|
||||
const recordFactContractNote = "\n★Call shape: exactly {\"facts\":[{...}]} with one item per distinct conclusion (usually one item). Each item carries its own summary, detail, evidence, confidence, source, asset_ids and, when it differs from the intent you are running, intent_id. Nothing else at the top level; a top-level fact field beside facts is refused and nothing is written."
|
||||
|
||||
// RecordFactContractNote exposes the text to the server's one-time refresh.
|
||||
func RecordFactContractNote() string { return recordFactContractNote }
|
||||
|
||||
// recordFactSchema is the published input contract: facts[] and nothing else.
|
||||
// Providers reject root-level anyOf, and the earlier contract (fact fields at
|
||||
// the top level beside facts[]) made models fill both; the handler alone keeps
|
||||
// the legacy shapes alive.
|
||||
func recordFactSchema() map[string]any {
|
||||
props := factItemSchema()["properties"].(map[string]any)
|
||||
props["facts"] = map[string]any{
|
||||
"type": "array", "minItems": 1, "items": factItemSchema(),
|
||||
"description": "A non-empty batch of complete facts. Every item needs its own summary. Only intent_id inherits from the top level. Returned ids match item order; retry only failed indices.",
|
||||
}
|
||||
schema := obj(props)
|
||||
// Providers reject root-level anyOf. The handler enforces single/batch mode.
|
||||
schema := obj(map[string]any{
|
||||
"facts": map[string]any{
|
||||
"type": "array", "minItems": 1, "items": factItemSchema(),
|
||||
"description": recordFactFactsDescription,
|
||||
},
|
||||
}, "facts")
|
||||
schema["additionalProperties"] = false
|
||||
return schema
|
||||
}
|
||||
|
||||
// RepairRecordFactSchema restores the single/batch input contract in stored or
|
||||
// cached schemas, preserving annotations only on fields the handler accepts.
|
||||
// RepairRecordFactSchema brings a stored or cached record_fact schema to the
|
||||
// facts-only contract. The structure always comes from the code; of the stored
|
||||
// schema only the annotations (description, default) of facts and of its known
|
||||
// item fields survive. Top-level fact fields of the earlier contract are
|
||||
// dropped: the handler still accepts them, but the model must not see them.
|
||||
func RepairRecordFactSchema(stored map[string]any) map[string]any {
|
||||
raw, _ := json.Marshal(stored)
|
||||
var out map[string]any
|
||||
_ = json.Unmarshal(raw, &out)
|
||||
if out == nil {
|
||||
out = map[string]any{}
|
||||
out := recordFactSchema()
|
||||
facts := out["properties"].(map[string]any)["facts"].(map[string]any)
|
||||
storedProps, _ := stored["properties"].(map[string]any)
|
||||
storedFacts, _ := storedProps["facts"].(map[string]any)
|
||||
if storedFacts == nil {
|
||||
return out
|
||||
}
|
||||
mergeFactContract(out, recordFactSchema())
|
||||
// A batch requires summaries on its items, never a redundant top-level one.
|
||||
delete(out, "required")
|
||||
delete(out, "anyOf")
|
||||
canonical := recordFactSchema()["properties"].(map[string]any)
|
||||
props := out["properties"].(map[string]any)
|
||||
for name := range props {
|
||||
if _, known := canonical[name]; !known {
|
||||
delete(props, name)
|
||||
if d, ok := storedFacts["description"].(string); ok && strings.TrimSpace(d) != "" {
|
||||
facts["description"] = d
|
||||
}
|
||||
storedItems, _ := storedFacts["items"].(map[string]any)
|
||||
storedItemProps, _ := storedItems["properties"].(map[string]any)
|
||||
itemProps := facts["items"].(map[string]any)["properties"].(map[string]any)
|
||||
for name, p := range itemProps {
|
||||
sp, _ := storedItemProps[name].(map[string]any)
|
||||
if sp == nil {
|
||||
continue
|
||||
}
|
||||
}
|
||||
items := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
itemProps := items["properties"].(map[string]any)
|
||||
for name := range itemProps {
|
||||
if _, known := canonical[name]; !known || name == "facts" {
|
||||
delete(itemProps, name)
|
||||
prop := p.(map[string]any)
|
||||
for _, key := range []string{"description", "default"} {
|
||||
if v, ok := sp[key]; ok && v != nil {
|
||||
prop[key] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func mergeFactContract(dst, src map[string]any) {
|
||||
for key, value := range src {
|
||||
if key == "description" || key == "default" {
|
||||
if _, ok := dst[key]; ok {
|
||||
continue
|
||||
}
|
||||
}
|
||||
if child, ok := value.(map[string]any); ok {
|
||||
target, _ := dst[key].(map[string]any)
|
||||
if target == nil {
|
||||
target = map[string]any{}
|
||||
dst[key] = target
|
||||
}
|
||||
mergeFactContract(target, child)
|
||||
} else {
|
||||
dst[key] = value
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type recordFactInput struct {
|
||||
Facts []factItem `json:"facts"`
|
||||
factItem
|
||||
@@ -103,6 +107,9 @@ type recordFactInput struct {
|
||||
|
||||
// Validate exact field names before decoding: encoding/json otherwise treats
|
||||
// Summary, SUMMARY, etc. as aliases even with DisallowUnknownFields enabled.
|
||||
// Three input shapes reach the handler: the published one ({facts:[...]}), the
|
||||
// legacy single fact (fields at the top level, no facts) and the legacy batch
|
||||
// with a top-level intent_id as the default of its items.
|
||||
func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
|
||||
var out recordFactInput
|
||||
fields, err := exactFactFields(in, true)
|
||||
@@ -111,11 +118,6 @@ func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
|
||||
}
|
||||
_, batch := fields["facts"]
|
||||
if batch {
|
||||
for name := range fields {
|
||||
if name != "intent_id" && name != "facts" {
|
||||
return out, true, fmt.Errorf("field %q is not allowed at the top level in batch mode; only intent_id and facts are accepted", name)
|
||||
}
|
||||
}
|
||||
var items []json.RawMessage
|
||||
if err := json.Unmarshal(fields["facts"], &items); err != nil {
|
||||
return out, true, fmt.Errorf("facts must be an array: %w", err)
|
||||
@@ -123,10 +125,16 @@ func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
|
||||
if len(items) == 0 {
|
||||
return out, true, fmt.Errorf("facts must be a non-empty array of complete facts, each with its own summary")
|
||||
}
|
||||
itemFields := make([]map[string]json.RawMessage, len(items))
|
||||
for i, item := range items {
|
||||
if _, err := exactFactFields(item, false); err != nil {
|
||||
f, err := exactFactFields(item, false)
|
||||
if err != nil {
|
||||
return out, true, fmt.Errorf("facts[%d]: %w", i, err)
|
||||
}
|
||||
itemFields[i] = f
|
||||
}
|
||||
if err := checkBatchTopLevel(fields, itemFields); err != nil {
|
||||
return out, true, err
|
||||
}
|
||||
}
|
||||
decoder := json.NewDecoder(bytes.NewReader(in))
|
||||
@@ -137,6 +145,28 @@ func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
|
||||
return out, batch, nil
|
||||
}
|
||||
|
||||
// checkBatchTopLevel enforces the contract at the top level of a facts[] call,
|
||||
// where only facts and (legacy) intent_id carry meaning. Any other top-level
|
||||
// field is refused by name before anything is written, including empty
|
||||
// placeholders and copies of a fact's fields: a value there is at best
|
||||
// redundant and at worst a second, conflicting claim. The message names the
|
||||
// one accepted shape, so a model that filled every declared property of an
|
||||
// older schema learns where the fields belong.
|
||||
func checkBatchTopLevel(fields map[string]json.RawMessage, items []map[string]json.RawMessage) error {
|
||||
var extra []string
|
||||
for name := range fields {
|
||||
if name == "intent_id" || name == "facts" {
|
||||
continue
|
||||
}
|
||||
extra = append(extra, fmt.Sprintf("%q", name))
|
||||
}
|
||||
if len(extra) == 0 {
|
||||
return nil
|
||||
}
|
||||
sort.Strings(extra)
|
||||
return fmt.Errorf("top-level field(s) %s are not allowed beside facts (%d item(s)): record_fact takes only {\"facts\":[...]}; put every field of a fact inside its facts item and send nothing else at the top level", strings.Join(extra, ", "), len(items))
|
||||
}
|
||||
|
||||
func exactFactFields(in json.RawMessage, topLevel bool) (map[string]json.RawMessage, error) {
|
||||
var fields map[string]json.RawMessage
|
||||
if err := json.Unmarshal(in, &fields); err != nil {
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
package agent
|
||||
|
||||
// Texts of the earlier record_fact contract (fact fields at the top level
|
||||
// beside facts[]), kept verbatim so the server's one-time refresh
|
||||
// (server/fact_input_schema.go) can tell a stored default from an operator
|
||||
// edit. Nothing here is published to a model.
|
||||
|
||||
// recordFactLegacyDescription is the record_fact description seeded up to the
|
||||
// facts-only contract.
|
||||
const recordFactLegacyDescription = "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n" +
|
||||
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n" +
|
||||
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n" +
|
||||
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n" +
|
||||
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n" +
|
||||
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n" +
|
||||
" · source = where the content came from: target_response (content the target itself returned: page bodies, headers, error messages, banners, even when a tool fetched it) | tool_output (a tool's own result about the target: port states, scanner verdicts, status codes, timings) | third_party_intel (OSINT, CVE databases, public reports) | operator_input (given by the human operator) | inference (your own reasoning; the default when omitted). Any other value is refused.\n" +
|
||||
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."
|
||||
|
||||
// recordFactReleasedDescription is the record_fact description seeded by the
|
||||
// releases v0.4.0 to v0.6.0 (agent/tools.go at those tags): the text above
|
||||
// without the source bullet.
|
||||
const recordFactReleasedDescription = "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n" +
|
||||
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n" +
|
||||
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n" +
|
||||
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n" +
|
||||
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n" +
|
||||
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n" +
|
||||
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."
|
||||
|
||||
// recordFactLegacyItemDescriptions are the facts[] item descriptions of the
|
||||
// earlier contract whose wording referred to the top level; the refresh
|
||||
// replaces exactly these texts with the current ones.
|
||||
var recordFactLegacyItemDescriptions = map[string]string{
|
||||
"summary": "Required on every fact: a non-empty one-sentence summary of this conclusion. Batch items do not inherit summary from the top level.",
|
||||
"intent_id": "The intent that produced this fact; only this field inherits from the top level in a batch.",
|
||||
}
|
||||
|
||||
// recordFactLegacyFactsDescription is the facts property description of the
|
||||
// earlier contract.
|
||||
const recordFactLegacyFactsDescription = "A non-empty batch of complete facts. Every item needs its own summary. Only intent_id inherits from the top level. Returned ids match item order; retry only failed indices."
|
||||
|
||||
// recordFactReleasedFactsDescription is the facts property description seeded
|
||||
// by the releases v0.4.0 to v0.6.0. RepairRecordFactSchema keeps a stored facts
|
||||
// description, so the refresh has to know this text to replace it.
|
||||
const recordFactReleasedFactsDescription = "[use when there are several distinct conclusions] array of facts; element fields same as the top-level fields below (summary/detail/evidence/confidence/intent_id/asset_ids); omitting intent_id falls back to the top-level intent_id. The returned ids match this array in length and order."
|
||||
|
||||
// RecordFactLegacyDescriptions returns the description texts of the earlier
|
||||
// contract that the refresh may replace: the tool descriptions, the facts
|
||||
// property descriptions and the item descriptions.
|
||||
func RecordFactLegacyDescriptions() (tool, facts []string, items map[string]string) {
|
||||
return []string{recordFactLegacyDescription, recordFactReleasedDescription},
|
||||
[]string{recordFactLegacyFactsDescription, recordFactReleasedFactsDescription},
|
||||
recordFactLegacyItemDescriptions
|
||||
}
|
||||
+244
-16
@@ -3,9 +3,11 @@ package agent
|
||||
import (
|
||||
"encoding/json"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
actool "github.com/Autumn-27/norma/tool"
|
||||
)
|
||||
|
||||
@@ -47,6 +49,10 @@ func TestRecordFactSummaryContract(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// A stored schema of the earlier contract (fact fields at the top level beside
|
||||
// facts[], operator annotations, a stray property) is republished as the
|
||||
// facts-only contract; annotations of facts and of its items survive, the top
|
||||
// level loses every fact field, and the result is idempotent.
|
||||
func TestRecordFactStoredContractRepair(t *testing.T) {
|
||||
old := map[string]any{
|
||||
"type": "object", "required": []any{"summary"},
|
||||
@@ -55,32 +61,40 @@ func TestRecordFactStoredContractRepair(t *testing.T) {
|
||||
"summary": map[string]any{"type": "string", "description": "operator summary"},
|
||||
"confidence": map[string]any{"type": "string", "default": "inferred"},
|
||||
"custom_field": map[string]any{"type": "string"},
|
||||
"facts": map[string]any{"type": "array", "items": map[string]any{"type": "object"}},
|
||||
"facts": map[string]any{"type": "array", "description": "operator facts", "items": map[string]any{"type": "object", "properties": map[string]any{
|
||||
"summary": map[string]any{"type": "string", "description": "operator item summary"},
|
||||
"confidence": map[string]any{"type": "string", "default": "observed"},
|
||||
"custom": map[string]any{"type": "string"},
|
||||
}}},
|
||||
},
|
||||
}
|
||||
base := NewToolSet(nil, "").recordFact()
|
||||
repaired := DecorateTool(base, "operator tool", old)
|
||||
schema := repaired.InputSchema()
|
||||
if _, required := schema["required"]; required {
|
||||
t.Fatal("batch still requires a top-level summary")
|
||||
if req, _ := schema["required"].([]string); len(req) != 1 || req[0] != "facts" {
|
||||
t.Fatalf("facts must be the only required property: %v", schema["required"])
|
||||
}
|
||||
if _, exists := schema["anyOf"]; exists {
|
||||
t.Fatal("root anyOf reaches the provider")
|
||||
}
|
||||
props := schema["properties"].(map[string]any)
|
||||
item := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
if len(props) != 1 || props["facts"] == nil || schema["additionalProperties"] != false {
|
||||
t.Fatalf("top level must hold facts only: %v", props)
|
||||
}
|
||||
facts := props["facts"].(map[string]any)
|
||||
item := facts["items"].(map[string]any)
|
||||
required := item["required"].([]string)
|
||||
if len(required) != 1 || required[0] != "summary" || props["facts"].(map[string]any)["minItems"] != 1 {
|
||||
if len(required) != 1 || required[0] != "summary" || facts["minItems"] != 1 {
|
||||
t.Fatal("batch must require a nonempty list with a summary per item")
|
||||
}
|
||||
if props["summary"].(map[string]any)["minLength"] != 1 ||
|
||||
item["properties"].(map[string]any)["summary"].(map[string]any)["minLength"] != 1 {
|
||||
itemProps := item["properties"].(map[string]any)
|
||||
if itemProps["summary"].(map[string]any)["minLength"] != 1 {
|
||||
t.Fatal("empty summaries permitted by schema")
|
||||
}
|
||||
if repaired.Description() != "operator tool" ||
|
||||
props["summary"].(map[string]any)["description"] != "operator summary" ||
|
||||
props["confidence"].(map[string]any)["default"] != "inferred" || props["custom_field"] != nil {
|
||||
t.Fatal("operator annotations lost")
|
||||
if repaired.Description() != "operator tool" || facts["description"] != "operator facts" ||
|
||||
itemProps["summary"].(map[string]any)["description"] != "operator item summary" ||
|
||||
itemProps["confidence"].(map[string]any)["default"] != "observed" || itemProps["custom"] != nil {
|
||||
t.Fatalf("item annotations lost or stray property kept: %v", itemProps)
|
||||
}
|
||||
if _, ok := old["properties"].(map[string]any)["tested_asset_ids"]; ok {
|
||||
t.Fatal("shared old schema mutated")
|
||||
@@ -94,9 +108,18 @@ func TestRecordFactStoredContractRepair(t *testing.T) {
|
||||
if err := json.Unmarshal(first, &roundTrip); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, input := range []string{`{"summary":"single"}`, `{"facts":[{"summary":"batch"}]}`} {
|
||||
if err := actool.ValidateInput(roundTrip, json.RawMessage(input)); err != nil {
|
||||
t.Fatalf("SDK rejects valid %s after catalog round trip: %v", input, err)
|
||||
if err := actool.ValidateInput(roundTrip, json.RawMessage(`{"facts":[{"summary":"batch"}]}`)); err != nil {
|
||||
t.Fatalf("SDK rejects the published shape after catalog round trip: %v", err)
|
||||
}
|
||||
// The legacy single shape no longer passes the published schema; the
|
||||
// handler validates its own input instead, also behind the catalog wrapper.
|
||||
if err := actool.ValidateInput(roundTrip, json.RawMessage(`{"summary":"single"}`)); err == nil {
|
||||
t.Fatal("published schema must require facts")
|
||||
}
|
||||
for _, tool := range []actool.CoreTool{base, repaired} {
|
||||
r, ok := tool.(interface{ AcceptsRawInput() bool })
|
||||
if !ok || !r.AcceptsRawInput() {
|
||||
t.Fatalf("%T must opt out of the harness schema check", tool)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -140,7 +163,7 @@ func TestRecordFactStrictFields(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestRecordFactSchemaMatchesStrings(t *testing.T) {
|
||||
props := recordFactSchema()["properties"].(map[string]any)
|
||||
props := factItemSchema()["properties"].(map[string]any)
|
||||
summary := regexp.MustCompile(props["summary"].(map[string]any)["pattern"].(string))
|
||||
for _, value := range []string{"", " ", "\t\r\n", "\u00a0\u0085", "\u2003\u3000", "conclusion", " observed "} {
|
||||
if got, want := summary.MatchString(value), strings.TrimSpace(value) != ""; got != want {
|
||||
@@ -155,7 +178,7 @@ func TestRecordFactSchemaMatchesStrings(t *testing.T) {
|
||||
}
|
||||
}
|
||||
for _, input := range []string{
|
||||
`{"summary":"single","asset_ids":["1",2]}`,
|
||||
`{"facts":[{"summary":"batch","asset_ids":["1",2]}]}`,
|
||||
`{"facts":[{"summary":"batch","tested_asset_ids":["1",2]}]}`,
|
||||
} {
|
||||
if err := actool.ValidateInput(recordFactSchema(), json.RawMessage(input)); err != nil {
|
||||
@@ -163,3 +186,208 @@ func TestRecordFactSchemaMatchesStrings(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A model that fills every declared property of the earlier schema sends the
|
||||
// single fact inside facts[] and a copy (or a placeholder) of every fact field
|
||||
// beside it. Such a call is refused by name before any write, whether the
|
||||
// copies are identical, empty or dummies, and the message names the one shape
|
||||
// that is accepted. The published schema no longer declares those fields.
|
||||
func TestRecordFactRefusesTopLevelCopiesBesideFacts(t *testing.T) {
|
||||
store := guardTaskStore(t)
|
||||
intentID := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "fingerprint the service"}, "running")
|
||||
tools := NewToolSet(store, "worker")
|
||||
before, err := store.ListByKind(db.KindFact, 100)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
id := strconv.FormatInt(intentID, 10)
|
||||
fact := `{"summary":"TLS 1.0 is offered on port 8443","detail":"the handshake succeeded with TLSv1.0","evidence":"openssl s_client -tls1 → Protocol: TLSv1","confidence":"observed","source":"tool_output","intent_id":` + id + `,"asset_ids":[]}`
|
||||
for _, tc := range []struct{ call, want string }{
|
||||
// an exact copy of every field beside facts[]
|
||||
{`{"summary":"TLS 1.0 is offered on port 8443","detail":"the handshake succeeded with TLSv1.0","evidence":"openssl s_client -tls1 → Protocol: TLSv1","confidence":"observed","source":"tool_output","intent_id":` + id + `,"asset_ids":[],"facts":[` + fact + `]}`, `"asset_ids", "confidence", "detail", "evidence", "source", "summary"`},
|
||||
// empty placeholders only
|
||||
{`{"summary":"","detail":"","evidence":"","confidence":"","source":"","asset_ids":[],"tested_asset_ids":[],"intent_id":` + id + `,"facts":[` + fact + `]}`, `"asset_ids", "confidence", "detail", "evidence", "source", "summary", "tested_asset_ids"`},
|
||||
// dummy values
|
||||
{`{"summary":"x","facts":[` + fact + `]}`, `"summary"`},
|
||||
{`{"summary":null,"facts":[` + fact + `]}`, `"summary"`},
|
||||
} {
|
||||
w := tools.Writes().Facts
|
||||
r := callGuardTool(t, tools.recordFact(), tc.call)
|
||||
if !r.IsError || !strings.Contains(r.Flatten(), tc.want) || !strings.Contains(r.Flatten(), `record_fact takes only {"facts":[...]}`) || tools.Writes().Facts != w {
|
||||
t.Errorf("%s: want refusal naming %s, got %s (writes %d→%d)", tc.call, tc.want, r.Flatten(), w, tools.Writes().Facts)
|
||||
}
|
||||
}
|
||||
if n, err := store.ListByKind(db.KindFact, 100); err != nil || len(n) != len(before) {
|
||||
t.Fatalf("refused calls wrote facts: %d → %d %v", len(before), len(n), err)
|
||||
}
|
||||
// The same fact in the published shape is written once and linked.
|
||||
res := callGuardTool(t, tools.recordFact(), `{"facts":[`+fact+`]}`)
|
||||
if res.IsError || tools.Writes().Facts != 1 {
|
||||
t.Fatalf("published shape refused: %s", res.Flatten())
|
||||
}
|
||||
var out struct {
|
||||
IDs []int64 `json:"ids"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(res.Flatten()), &out); err != nil || len(out.IDs) != 1 || out.IDs[0] <= 0 {
|
||||
t.Fatalf("batch result must carry exactly one id: %s", res.Flatten())
|
||||
}
|
||||
if yielded, err := store.FactsYielded(intentID); err != nil || len(yielded) != 1 || yielded[0] != out.IDs[0] {
|
||||
t.Fatalf("fact not linked to the intent: %v %v", yielded, err)
|
||||
}
|
||||
node, err := store.GetNode(out.IDs[0])
|
||||
if err != nil || node == nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var payload map[string]any
|
||||
_ = json.Unmarshal(node.Payload, &payload)
|
||||
if payload["summary"] != "TLS 1.0 is offered on port 8443" || payload["source"] != "tool_output" || payload["confidence"] != "observed" {
|
||||
t.Fatalf("fact payload: %s", node.Payload)
|
||||
}
|
||||
}
|
||||
|
||||
// Conflicting copies, placeholders, unknown fields, bad asset ids, missing
|
||||
// summaries and empty batches are refused, and nothing is written by a
|
||||
// refused call.
|
||||
func TestRecordFactBatchTopLevelConflicts(t *testing.T) {
|
||||
store := guardTaskStore(t)
|
||||
tools := NewToolSet(store, "worker")
|
||||
before, err := store.ListByKind(db.KindFact, 100) // the task's origin fact
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, tc := range []struct{ call, want string }{
|
||||
// dummy summaries a model may send after a refusal
|
||||
{`{"summary":"x","facts":[{"summary":"real conclusion"}]}`, `"summary"`},
|
||||
{`{"summary":"placeholder","detail":"test","evidence":"test","facts":[{"summary":"real","detail":"real detail","evidence":"real evidence"}]}`, `"detail", "evidence", "summary"`},
|
||||
{`{"summary":"contradictory","facts":[{"summary":"different"}]}`, `"summary"`},
|
||||
{`{"detail":"invented","facts":[{"summary":"legitimate"}]}`, `"detail"`},
|
||||
{`{"confidence":"observed","facts":[{"summary":"fact says inferred","confidence":"inferred"}]}`, `"confidence"`},
|
||||
{`{"source":"inference","facts":[{"summary":"fact says tool_output","source":"tool_output"}]}`, `"source"`},
|
||||
{`{"asset_ids":[1],"facts":[{"summary":"fact has other assets","asset_ids":[2]}]}`, `"asset_ids"`},
|
||||
{`{"summary":"first","facts":[{"summary":"first"},{"summary":"second"}]}`, `(2 item(s))`},
|
||||
{`{"summary":"x","typo":1,"facts":[{"summary":"unknown field"}]}`, `"typo"`},
|
||||
{`{"facts":[{"summary":"unknown nested","typo":1}]}`, `"typo"`},
|
||||
{`{"facts":[{"summary":"bad asset id","asset_ids":["abc"]}]}`, `asset`},
|
||||
{`{"summary":"must not inherit","facts":[{"detail":"missing summary"}]}`, `"summary"`},
|
||||
{`{"summary":"x","facts":[]}`, `non-empty`},
|
||||
{`{"facts":[]}`, `non-empty`},
|
||||
{`{"summary":"","facts":[]}`, `non-empty`},
|
||||
} {
|
||||
w := tools.Writes().Facts
|
||||
r := callGuardTool(t, tools.recordFact(), tc.call)
|
||||
if !r.IsError || !strings.Contains(r.Flatten(), tc.want) || tools.Writes().Facts != w {
|
||||
t.Errorf("%s: want refusal mentioning %s, got %s (writes %d→%d)", tc.call, tc.want, r.Flatten(), w, tools.Writes().Facts)
|
||||
}
|
||||
}
|
||||
if n, err := store.ListByKind(db.KindFact, 100); err != nil || len(n) != len(before) {
|
||||
t.Fatalf("refused calls wrote facts: %d → %d %v", len(before), len(n), err)
|
||||
}
|
||||
}
|
||||
|
||||
// The published schema holds facts[] and nothing else, and the description
|
||||
// names that one shape; the earlier "two shapes" wording is gone.
|
||||
func TestRecordFactSchemaIsFactsOnly(t *testing.T) {
|
||||
schema := recordFactSchema()
|
||||
props := schema["properties"].(map[string]any)
|
||||
if len(props) != 1 || props["facts"] == nil {
|
||||
t.Fatalf("top-level properties: %v", props)
|
||||
}
|
||||
if req, _ := schema["required"].([]string); len(req) != 1 || req[0] != "facts" || schema["additionalProperties"] != false {
|
||||
t.Fatalf("facts must be required and the only property: %v %v", schema["required"], schema["additionalProperties"])
|
||||
}
|
||||
facts := props["facts"].(map[string]any)
|
||||
if d, _ := facts["description"].(string); !strings.Contains(d, "never send summary") {
|
||||
t.Errorf("facts description must forbid top-level copies: %q", d)
|
||||
}
|
||||
item := facts["items"].(map[string]any)["properties"].(map[string]any)
|
||||
for _, name := range []string{"summary", "intent_id", "detail", "evidence", "confidence", "source", "asset_ids", "tested_asset_ids"} {
|
||||
if item[name] == nil {
|
||||
t.Errorf("facts[] item lacks %s", name)
|
||||
}
|
||||
}
|
||||
for name, d := range map[string]string{
|
||||
"summary": item["summary"].(map[string]any)["description"].(string),
|
||||
"intent_id": item["intent_id"].(map[string]any)["description"].(string),
|
||||
} {
|
||||
if strings.Contains(d, "top level") || strings.Contains(d, "top-level") {
|
||||
t.Errorf("facts[].%s still refers to a top level: %q", name, d)
|
||||
}
|
||||
}
|
||||
desc := NewToolSet(nil, "").recordFact().Description()
|
||||
if !strings.HasSuffix(desc, recordFactContractNote) || strings.Contains(desc, "top-level intent_id") {
|
||||
t.Fatalf("record_fact description must describe the facts-only contract: %q", desc)
|
||||
}
|
||||
// The seed the catalog stores is the same contract.
|
||||
for _, seed := range BuiltinToolSeeds() {
|
||||
if seed.Key != "record_fact" {
|
||||
continue
|
||||
}
|
||||
if seed.Desc != desc {
|
||||
t.Fatal("seed description differs from the tool")
|
||||
}
|
||||
if p := seed.Schema["properties"].(map[string]any); len(p) != 1 || p["facts"] == nil {
|
||||
t.Fatalf("seed schema is not facts-only: %v", p)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A facts[] item without intent_id is linked to the intent the worker runs
|
||||
// (SetOwnerNode); a legacy top-level intent_id still wins; a planner ToolSet
|
||||
// (owner = the task root, not an intent) writes an unlinked fact.
|
||||
func TestRecordFactDefaultsToRunningIntent(t *testing.T) {
|
||||
store := guardTaskStore(t)
|
||||
running := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "running intent"}, "running")
|
||||
other := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "other intent"}, "open")
|
||||
tools := NewToolSet(store, "worker")
|
||||
tools.SetOwnerNode(running)
|
||||
ids := func(res actool.Result) []int64 {
|
||||
t.Helper()
|
||||
var out struct {
|
||||
IDs []int64 `json:"ids"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(res.Flatten()), &out); err != nil || len(out.IDs) != 1 || out.IDs[0] <= 0 {
|
||||
t.Fatalf("batch result: %s", res.Flatten())
|
||||
}
|
||||
return out.IDs
|
||||
}
|
||||
res := callGuardTool(t, tools.recordFact(), `{"facts":[{"summary":"linked to the running intent","confidence":"observed","source":"tool_output"}]}`)
|
||||
if res.IsError {
|
||||
t.Fatal(res.Flatten())
|
||||
}
|
||||
first := ids(res)[0]
|
||||
if yielded, err := store.FactsYielded(running); err != nil || len(yielded) != 1 || yielded[0] != first {
|
||||
t.Fatalf("fact %d not linked to the running intent %d: %v %v", first, running, yielded, err)
|
||||
}
|
||||
res = callGuardTool(t, tools.recordFact(), `{"intent_id":`+strconv.FormatInt(other, 10)+`,"facts":[{"summary":"legacy top-level intent"}]}`)
|
||||
if res.IsError {
|
||||
t.Fatal(res.Flatten())
|
||||
}
|
||||
second := ids(res)[0]
|
||||
if yielded, err := store.FactsYielded(other); err != nil || len(yielded) != 1 || yielded[0] != second {
|
||||
t.Fatalf("legacy top-level intent_id must win: %v %v", yielded, err)
|
||||
}
|
||||
res = callGuardTool(t, tools.recordFact(), `{"facts":[{"summary":"item intent","intent_id":`+strconv.FormatInt(other, 10)+`}]}`)
|
||||
if res.IsError {
|
||||
t.Fatal(res.Flatten())
|
||||
}
|
||||
third := ids(res)[0]
|
||||
if yielded, _ := store.FactsYielded(other); len(yielded) != 2 || yielded[1] != third && yielded[0] != third {
|
||||
t.Fatalf("item intent_id must win: %v", yielded)
|
||||
}
|
||||
if yielded, _ := store.FactsYielded(running); len(yielded) != 1 {
|
||||
t.Fatalf("running intent gained facts it did not produce: %v", yielded)
|
||||
}
|
||||
planner := NewToolSet(store, "planner")
|
||||
origin, err := store.ListByKind(db.KindFact, 1)
|
||||
if err != nil || len(origin) == 0 {
|
||||
t.Fatalf("origin fact: %v", err)
|
||||
}
|
||||
planner.SetOwnerNode(origin[0].ID)
|
||||
res = callGuardTool(t, planner.recordFact(), `{"facts":[{"summary":"planner fact without intent"}]}`)
|
||||
if res.IsError || planner.Writes().Facts != 1 {
|
||||
t.Fatalf("planner write refused: %s", res.Flatten())
|
||||
}
|
||||
if yielded, _ := store.FactsYielded(running); len(yielded) != 1 {
|
||||
t.Fatalf("planner fact must not be linked to a worker intent: %v", yielded)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -44,7 +44,10 @@ func TestReportFindingStoresReasoningFields(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(task.ID)
|
||||
defer func() {
|
||||
_, _ = d.DeleteFindingsByTask(task.ID)
|
||||
_ = d.DeleteTask(task.ID)
|
||||
}()
|
||||
ts := NewToolSet(nil, "")
|
||||
ts.ts, ts.taskID = d.Exploration(task.ExplorationID), task.ID
|
||||
for _, tc := range []struct{ extra, counter, rationale string }{
|
||||
|
||||
@@ -25,7 +25,10 @@ func TestReportFindingOptionalTrafficWithoutCapture(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(task.ID)
|
||||
defer func() {
|
||||
_, _ = d.DeleteFindingsByTask(task.ID)
|
||||
_ = d.DeleteTask(task.ID)
|
||||
}()
|
||||
ts := NewToolSet(nil, "")
|
||||
ts.ts, ts.taskID = d.Exploration(task.ExplorationID), task.ID
|
||||
ts.SetFindingRecorder(evidence.New(d, nil, t.TempDir()))
|
||||
@@ -60,7 +63,10 @@ func TestReportFindingAtomicContract(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(task.ID)
|
||||
defer func() {
|
||||
_, _ = d.DeleteFindingsByTask(task.ID)
|
||||
_ = d.DeleteTask(task.ID)
|
||||
}()
|
||||
ts := NewToolSet(nil, "")
|
||||
ts.ts = d.Exploration(task.ExplorationID)
|
||||
ts.taskID = task.ID
|
||||
|
||||
@@ -0,0 +1,128 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
)
|
||||
|
||||
// Synthetic replay of the record_fact call shapes a model produces, replayed
|
||||
// against the handler in the package test database. The shapes mirror what
|
||||
// was observed in production before the facts-only contract (a model filling
|
||||
// every declared top-level property beside facts[]) without using recorded
|
||||
// data. Checked per call: the verdict, that an accepted call writes exactly one
|
||||
// node per facts item linked to the intent and anchored to the assets, and
|
||||
// that a refused call writes nothing and names the top-level fields.
|
||||
func TestRecordFactShapesReplay(t *testing.T) {
|
||||
d := testDB(t)
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
task, err := d.CreateTaskWithOptions("record_fact shapes", "replay synthetic record_fact call shapes", db.TaskCreateOptions{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = d.DeleteTask(task.ID) })
|
||||
store := d.Exploration(task.ExplorationID)
|
||||
intentID := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "enumerate the service"}, "running")
|
||||
var assets []int64
|
||||
for i := 1; i <= 2; i++ {
|
||||
id, err := d.Assets().UpsertIP(db.UpsertIPReq{IP: fmt.Sprintf("203.0.113.%d", i), TaskID: task.ID})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assets = append(assets, id)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = d.Assets().DeleteByIDs(assets) })
|
||||
tools := NewToolSet(store, "worker")
|
||||
tools.SetOwnerNode(intentID)
|
||||
tool := tools.recordFact()
|
||||
|
||||
iid := strconv.FormatInt(intentID, 10)
|
||||
a1, a2 := strconv.FormatInt(assets[0], 10), strconv.FormatInt(assets[1], 10)
|
||||
item := func(n int) string {
|
||||
return fmt.Sprintf(`{"summary":"conclusion %d","detail":"detail %d","evidence":"cmd %d → line","confidence":"observed","source":"tool_output","asset_ids":[%s]}`, n, n, n, a1)
|
||||
}
|
||||
type shape struct {
|
||||
name string
|
||||
call string
|
||||
accept bool
|
||||
items int
|
||||
fields string // named in the refusal
|
||||
}
|
||||
shapes := []shape{
|
||||
{"published: one item", `{"facts":[` + item(1) + `]}`, true, 1, ""},
|
||||
{"published: two items", `{"facts":[` + item(1) + `,` + item(2) + `]}`, true, 2, ""},
|
||||
{"published: item with its own intent_id and alias", `{"facts":[{"summary":"alias","tested_asset_ids":["` + a2 + `"],"intent_id":` + iid + `}]}`, true, 1, ""},
|
||||
{"legacy batch: top-level intent_id", `{"intent_id":` + iid + `,"facts":[` + item(3) + `]}`, true, 1, ""},
|
||||
{"legacy single", `{"summary":"single fact","confidence":"inferred","asset_ids":[` + a2 + `]}`, true, 1, ""},
|
||||
{"copies of every field beside facts", `{"summary":"conclusion 1","detail":"detail 1","evidence":"cmd 1 → line","confidence":"observed","source":"tool_output","asset_ids":[` + a1 + `],"facts":[` + item(1) + `]}`, false, 1, `"asset_ids", "confidence", "detail", "evidence", "source", "summary"`},
|
||||
{"empty placeholders beside facts", `{"summary":"","detail":"","asset_ids":[],"tested_asset_ids":[],"facts":[` + item(1) + `]}`, false, 1, `"asset_ids", "detail", "summary", "tested_asset_ids"`},
|
||||
{"dummy summary beside facts", `{"summary":"x","facts":[` + item(1) + `]}`, false, 1, `"summary"`},
|
||||
{"abbreviated copy beside facts", `{"summary":"short","detail":"short detail","facts":[` + item(1) + `]}`, false, 1, `"detail", "summary"`},
|
||||
{"conflicting source beside facts", `{"source":"inference","facts":[` + item(1) + `]}`, false, 1, `"source"`},
|
||||
{"top-level summary beside two items", `{"summary":"conclusion 1","facts":[` + item(1) + `,` + item(2) + `]}`, false, 2, `"summary"`},
|
||||
}
|
||||
for _, s := range shapes {
|
||||
before := tools.Writes().Facts
|
||||
linked, _ := store.FactsYielded(intentID)
|
||||
res := callGuardTool(t, tool, s.call)
|
||||
written := tools.Writes().Facts - before
|
||||
if !res.IsError != s.accept {
|
||||
t.Errorf("%s: accepted=%v want %v: %s", s.name, !res.IsError, s.accept, res.Flatten())
|
||||
continue
|
||||
}
|
||||
if !s.accept {
|
||||
if written != 0 || !strings.Contains(res.Flatten(), "top-level field(s) "+s.fields) || !strings.Contains(res.Flatten(), "no facts were written") {
|
||||
t.Errorf("%s: refusal must write nothing and name %s: %s (writes %d)", s.name, s.fields, res.Flatten(), written)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if written != s.items {
|
||||
t.Errorf("%s: wrote %d facts for %d items", s.name, written, s.items)
|
||||
}
|
||||
after, _ := store.FactsYielded(intentID)
|
||||
if len(after) != len(linked)+s.items {
|
||||
t.Errorf("%s: intent links %d → %d for %d items", s.name, len(linked), len(after), s.items)
|
||||
}
|
||||
ids := after[len(linked):]
|
||||
if strings.HasPrefix(s.call, `{"facts"`) || strings.HasPrefix(s.call, `{"intent_id"`) {
|
||||
var out struct {
|
||||
IDs []int64 `json:"ids"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(res.Flatten()), &out); err != nil || len(out.IDs) != s.items {
|
||||
t.Errorf("%s: ids: %s", s.name, res.Flatten())
|
||||
}
|
||||
}
|
||||
for _, id := range ids {
|
||||
node, err := store.GetNode(id)
|
||||
if err != nil || node == nil || node.Kind != db.KindFact {
|
||||
t.Fatalf("%s: fact %d: %v", s.name, id, err)
|
||||
}
|
||||
var payload map[string]any
|
||||
_ = json.Unmarshal(node.Payload, &payload)
|
||||
if sum, _ := payload["summary"].(string); sum == "" || sum == "x" {
|
||||
t.Errorf("%s: stored summary %q", s.name, sum)
|
||||
}
|
||||
if strings.Contains(s.call, "asset_ids") {
|
||||
anchored := false
|
||||
for _, asset := range assets {
|
||||
refs, err := store.AssetRefs(asset)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, r := range refs {
|
||||
if r.ID == id {
|
||||
anchored = true
|
||||
}
|
||||
}
|
||||
}
|
||||
if !anchored {
|
||||
t.Errorf("%s: fact %d not anchored to an asset", s.name, id)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -22,7 +22,7 @@ func TestIngestScanOutputPG(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%198.51.100.77%' OR url LIKE '%2001:db8::77%'`
|
||||
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain IN ('198.51.100.77','2001:db8::77','example.com') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%198.51.100.77%' OR url LIKE '%2001:db8::77%'`
|
||||
t.Cleanup(func() {
|
||||
_ = d.DeleteTask(task.ID)
|
||||
_, _ = d.Exec(`DELETE FROM assets WHERE ` + assetsWhere)
|
||||
@@ -127,7 +127,7 @@ func TestIngestScanOutputJSONPG(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const assetsWhere = `domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
|
||||
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain IN ('198.51.100.77','2001:db8::77','example.com') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
|
||||
t.Cleanup(func() {
|
||||
_ = d.DeleteTask(task.ID)
|
||||
_, _ = d.Exec(`DELETE FROM assets WHERE ` + assetsWhere)
|
||||
@@ -210,7 +210,7 @@ func TestIngestScanOutputUserinfoPG(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const assetsWhere = `domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
|
||||
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain IN ('198.51.100.77','2001:db8::77','example.com') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
|
||||
t.Cleanup(func() {
|
||||
_ = d.DeleteTask(task.ID)
|
||||
_, _ = d.Exec(`DELETE FROM assets WHERE ` + assetsWhere)
|
||||
|
||||
@@ -180,6 +180,14 @@ type overriddenTool struct {
|
||||
func (o *overriddenTool) Description() string { return o.desc }
|
||||
func (o *overriddenTool) InputSchema() map[string]any { return o.schema }
|
||||
|
||||
// AcceptsRawInput forwards the wrapped tool's opt-out of the harness schema
|
||||
// check (record_fact validates its own input); the embedded interface alone
|
||||
// would hide it from the harness's type assertion.
|
||||
func (o *overriddenTool) AcceptsRawInput() bool {
|
||||
r, ok := o.CoreTool.(interface{ AcceptsRawInput() bool })
|
||||
return ok && r.AcceptsRawInput()
|
||||
}
|
||||
|
||||
func (o *overriddenTool) Call(ctx context.Context, in json.RawMessage, tc *actool.ToolContext) (actool.Result, error) {
|
||||
return o.CoreTool.Call(ctx, injectDefaults(in, o.schema), tc)
|
||||
}
|
||||
|
||||
+44
-5
@@ -394,8 +394,21 @@ func readTool(name, desc string, schema map[string]any, run func(context.Context
|
||||
}
|
||||
|
||||
func writeTool(name, desc string, schema map[string]any, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
|
||||
return buildWriteTool(name, desc, schema, false, run)
|
||||
}
|
||||
|
||||
// writeRawTool is writeTool for a handler that validates its own input: the
|
||||
// harness skips its schema check (Spec.RawInput), so the published schema can
|
||||
// be stricter (required properties) than the legacy shapes the handler still
|
||||
// accepts, and refusals carry the handler's own message instead of the
|
||||
// SDK's generic one.
|
||||
func writeRawTool(name, desc string, schema map[string]any, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
|
||||
return buildWriteTool(name, desc, schema, true, run)
|
||||
}
|
||||
|
||||
func buildWriteTool(name, desc string, schema map[string]any, raw bool, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
|
||||
return actool.Build(actool.Spec{
|
||||
Name: name, Description: desc, Schema: schema,
|
||||
Name: name, Description: desc, Schema: schema, RawInput: raw,
|
||||
Permissions: func(context.Context, json.RawMessage, acperm.Context) acperm.Decision { return acperm.Allowed() },
|
||||
Run: func(ctx context.Context, in json.RawMessage, _ *actool.ToolContext) (actool.Result, error) {
|
||||
return run(ctx, in)
|
||||
@@ -419,6 +432,12 @@ func (t *ToolSet) writeExpTool(name, desc string, schema map[string]any, run fun
|
||||
return writeTool(name, desc, schema, t.needExploration(name, run))
|
||||
}
|
||||
|
||||
// writeExpToolRaw is writeExpTool with the harness schema check skipped (see
|
||||
// writeRawTool); the handler validates the input itself.
|
||||
func (t *ToolSet) writeExpToolRaw(name, desc string, schema map[string]any, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
|
||||
return writeRawTool(name, desc, schema, t.needExploration(name, run))
|
||||
}
|
||||
|
||||
// needExploration wraps a handler so it only runs with an exploration store.
|
||||
// Tools that degrade more usefully than "unavailable" (report_finding points at
|
||||
// add_task_hint, set_goals/set_constraints at the task itself) keep their own
|
||||
@@ -1588,15 +1607,30 @@ func (t *ToolSet) recordOneFact(it factItem, defaultIntent int64) (int64, error)
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// runningIntent is the intent this ToolSet works for (the worker's claimed
|
||||
// intent, set by SetOwnerNode), or 0 when the owner node is not an intent
|
||||
// (planner: the task root) or unknown.
|
||||
func (t *ToolSet) runningIntent() int64 {
|
||||
if t.ts == nil || t.ownerNode <= 0 {
|
||||
return 0
|
||||
}
|
||||
node, err := t.ts.GetNode(t.ownerNode)
|
||||
if err != nil || node == nil || node.Kind != db.KindIntent {
|
||||
return 0
|
||||
}
|
||||
return node.ID
|
||||
}
|
||||
|
||||
func (t *ToolSet) recordFact() actool.CoreTool {
|
||||
return t.writeExpTool("record_fact", "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n"+
|
||||
return t.writeExpToolRaw("record_fact", "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n"+
|
||||
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n"+
|
||||
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n"+
|
||||
"★facts is the only parameter: facts:[{...}] with one item per [mutually distinct] conclusion, usually exactly one item. Returns an ids array, same length and order as facts. An item without intent_id is linked to the intent you are running.\n"+
|
||||
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n"+
|
||||
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n"+
|
||||
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n"+
|
||||
" · source = where the content came from: target_response (content the target itself returned: page bodies, headers, error messages, banners, even when a tool fetched it) | tool_output (a tool's own result about the target: port states, scanner verdicts, status codes, timings) | third_party_intel (OSINT, CVE databases, public reports) | operator_input (given by the human operator) | inference (your own reasoning; the default when omitted). Any other value is refused.\n"+
|
||||
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen.",
|
||||
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."+
|
||||
recordFactContractNote,
|
||||
recordFactSchema(),
|
||||
func(_ context.Context, in json.RawMessage) (actool.Result, error) {
|
||||
a, batch, err := decodeRecordFactInput(in)
|
||||
@@ -1607,7 +1641,12 @@ func (t *ToolSet) recordFact() actool.CoreTool {
|
||||
if !batch {
|
||||
items = []factItem{a.factItem}
|
||||
}
|
||||
defaultIntent := pid(a.factItem.IntentID) // top-level intent_id = batch default
|
||||
// Default intent of the items: a legacy top-level intent_id, else the
|
||||
// intent this worker is running (the published schema has no top level).
|
||||
defaultIntent := pid(a.factItem.IntentID)
|
||||
if defaultIntent <= 0 {
|
||||
defaultIntent = t.runningIntent()
|
||||
}
|
||||
|
||||
ids := make([]int64, len(items))
|
||||
errs := map[string]string{}
|
||||
|
||||
+54
-8
@@ -387,12 +387,57 @@ func IsRunDirName(name string) bool {
|
||||
return true
|
||||
}
|
||||
|
||||
func workerSystem(proxyAddr, caCert, dataDir, runDir string) string {
|
||||
// CachePrefixEnv is the opt-in environment flag enabling the worker system
|
||||
// prompt cache-prefix split (P3.5 phase C). Off by default: when unset/false,
|
||||
// worker system segments and DynamicBoundary are byte-identical to the legacy
|
||||
// layout. Planner, mainagent, chat, and goals are unaffected.
|
||||
const CachePrefixEnv = "ARTEX_CACHE_PREFIX"
|
||||
|
||||
func cachePrefixEnabled() bool {
|
||||
switch strings.ToLower(strings.TrimSpace(os.Getenv(CachePrefixEnv))) {
|
||||
case "1", "true", "on", "yes":
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// workerSystemParts splits workerSystem at the first per-intent volatile
|
||||
// segment (workerArtifactSpec(runDir)) without reordering any text:
|
||||
// - staticPart = body + untrustedContentTail + workerTrafficBlock
|
||||
// - dynamicHead = workerArtifactSpec(runDir) + noiseProfileBlock
|
||||
//
|
||||
// Custom DB prompts that reference {{.Now}} remain volatile inside staticPart.
|
||||
func workerSystemParts(proxyAddr, caCert, dataDir, runDir string) (staticPart, dynamicHead string) {
|
||||
body := renderSystem("worker", workerDefaultTmpl, WorkerVars{ProxyAddr: proxyAddr, DataDir: dataDir, Now: nowStr()})
|
||||
// caCert is present only when the recording MITM is on, which is exactly when
|
||||
// the traffic_* tools are registered — so it gates the traffic-tool note.
|
||||
// Optional finding guidance is added for every role after tool resolution.
|
||||
return body + untrustedContentTail(body) + workerTrafficBlock(caCert != "") + workerArtifactSpec(runDir) + noiseProfileBlock()
|
||||
staticPart = body + untrustedContentTail(body) + workerTrafficBlock(caCert != "")
|
||||
dynamicHead = workerArtifactSpec(runDir) + noiseProfileBlock()
|
||||
return staticPart, dynamicHead
|
||||
}
|
||||
|
||||
func workerSystem(proxyAddr, caCert, dataDir, runDir string) string {
|
||||
staticPart, dynamicHead := workerSystemParts(proxyAddr, caCert, dataDir, runDir)
|
||||
return staticPart + dynamicHead
|
||||
}
|
||||
|
||||
// assembleWorkerSystem builds the worker's SystemPrompt segments and
|
||||
// DynamicBoundary. When split is false (default), it delegates directly to
|
||||
// deferredSystem(staticPart+dynamicTail, def). When split is true
|
||||
// (ARTEX_CACHE_PREFIX=1), it emits two segments [staticPart, dynamic] with
|
||||
// DynamicBoundary=1 so sibling workers in the same task share the cached static
|
||||
// prefix, absorbing the leading "\n\n" separator from workerArtifactSpec so
|
||||
// strings.Join(system, "\n\n") is byte-identical to the unsplit prompt.
|
||||
func assembleWorkerSystem(staticPart, dynamicTail string, def DeferredInfo, split bool) (system []string, boundary int) {
|
||||
if !split {
|
||||
return deferredSystem(staticPart+dynamicTail, def)
|
||||
}
|
||||
dyn := strings.TrimPrefix(dynamicTail+def.FindingGuidance, "\n\n")
|
||||
if block := actool.RenderDeferredToolsBlock(def.GlobalNames); block != "" {
|
||||
dyn += "\n\n" + block
|
||||
}
|
||||
return []string{staticPart, dyn}, 1
|
||||
}
|
||||
|
||||
// renderIntentTask formats the claimed intent for the worker's launch USER message:
|
||||
@@ -524,18 +569,19 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db.
|
||||
// inherit a parent run's background into the action reviewer.
|
||||
ctx = intercept.WithReviewContext(ctx, runDir, intercept.ReviewBackground{})
|
||||
overview := renderWorkerGraphOverview(tsx.graphOverviewData(), newDataEnvelope())
|
||||
sysBody := workerSystem(w.proxyAddr, w.proxyCACert, w.workDir, runDir) + frameLessonsBlock(w.lessonsBlock)
|
||||
staticPart, dynamicTail := workerSystemParts(w.proxyAddr, w.proxyCACert, w.workDir, runDir)
|
||||
dynamicTail += frameLessonsBlock(w.lessonsBlock)
|
||||
if w.wantConstraints() {
|
||||
sysBody += constraintBlock(ts) // inject the operation constraints (if any) into the system prompt; the worker strictly obeys them during execution
|
||||
dynamicTail += constraintBlock(ts) // inject the operation constraints (if any) into the system prompt; the worker strictly obeys them during execution
|
||||
}
|
||||
// intent block → intent-anchored assets block → launch instruction, appended to
|
||||
// the system tail in that order (same append pattern as constraintBlock).
|
||||
sysBody += renderIntentTask(intent)
|
||||
dynamicTail += renderIntentTask(intent)
|
||||
if as != nil {
|
||||
if ids := intentAssetIDs(intent); len(ids) > 0 {
|
||||
if assets, err := as.GetByIDs(ids); err == nil && len(assets) > 0 {
|
||||
if b, err := json.Marshal(assets); err == nil {
|
||||
sysBody += "\n\nThe target assets corresponding to this intent's asset_ids:\n" + string(b)
|
||||
dynamicTail += "\n\nThe target assets corresponding to this intent's asset_ids:\n" + string(b)
|
||||
}
|
||||
// The assets this intent explicitly targets → automatically join the task's
|
||||
// test scope (same conservative granularity as insertAssets). upsertTaskScope's
|
||||
@@ -551,8 +597,8 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db.
|
||||
}
|
||||
}
|
||||
}
|
||||
sysBody += "\n\nStart executing the intent above: do only it, produce only facts, assets, findings, stop when done."
|
||||
system, boundary := deferredSystem(sysBody, def)
|
||||
dynamicTail += "\n\nStart executing the intent above: do only it, produce only facts, assets, findings, stop when done."
|
||||
system, boundary := assembleWorkerSystem(staticPart, dynamicTail, def, cachePrefixEnabled())
|
||||
// The task-level deadline (injected via ctx) clamps this run's wall-clock budget +
|
||||
// decides the wrap-up prompt (see taskclock.go).
|
||||
tc := taskClockFrom(ctx)
|
||||
|
||||
@@ -0,0 +1,326 @@
|
||||
package agent
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"iter"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/artex/llmrec"
|
||||
"github.com/Autumn-27/norma/llm"
|
||||
actool "github.com/Autumn-27/norma/tool"
|
||||
)
|
||||
|
||||
type captureReqProvider struct {
|
||||
mu sync.Mutex
|
||||
reqs []llm.CompletionRequest
|
||||
}
|
||||
|
||||
func (p *captureReqProvider) Stream(_ context.Context, req llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
|
||||
p.mu.Lock()
|
||||
p.reqs = append(p.reqs, req)
|
||||
p.mu.Unlock()
|
||||
return func(yield func(llm.StreamEvent, error) bool) {
|
||||
if !yield(llm.StreamEvent{Type: llm.SEMessageStart, Usage: llm.Usage{InputTokens: 100}}, nil) {
|
||||
return
|
||||
}
|
||||
if !yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "done"}, nil) {
|
||||
return
|
||||
}
|
||||
yield(llm.StreamEvent{Type: llm.SEMessageDelta, StopReason: "end_turn", Usage: llm.Usage{OutputTokens: 4}}, nil)
|
||||
}
|
||||
}
|
||||
|
||||
func (p *captureReqProvider) Complete(_ context.Context, req llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
|
||||
p.mu.Lock()
|
||||
p.reqs = append(p.reqs, req)
|
||||
p.mu.Unlock()
|
||||
return llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{llm.TextBlock("done")}}, "end_turn", llm.Usage{InputTokens: 100, OutputTokens: 4}, nil
|
||||
}
|
||||
|
||||
func (p *captureReqProvider) last() llm.CompletionRequest {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
if len(p.reqs) == 0 {
|
||||
return llm.CompletionRequest{}
|
||||
}
|
||||
return p.reqs[len(p.reqs)-1]
|
||||
}
|
||||
|
||||
func TestAssembleWorkerSystemFlagOffAndOnByteExact(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
caCert string
|
||||
globalNames []string
|
||||
guidance string
|
||||
}{
|
||||
{name: "no_deferred_no_traffic", caCert: "", globalNames: nil, guidance: ""},
|
||||
{name: "with_deferred_and_traffic", caCert: "/ca.pem", globalNames: []string{"mcp__zap__scan", "mcp__burp__send"}, guidance: "\n\n[Finding guidance]"},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
def := DeferredInfo{
|
||||
GlobalNames: tc.globalNames,
|
||||
FindingGuidance: tc.guidance,
|
||||
}
|
||||
buildTail := func(runDir, intentSummary, assetDomain string) (string, string) {
|
||||
staticPart, dynamicTail := workerSystemParts("127.0.0.1:8788", tc.caCert, "/data", runDir)
|
||||
dynamicTail += "\n\n## Prior evidence\n- lesson A"
|
||||
dynamicTail += "\n\n[Constraints]\n- do not touch prod"
|
||||
dynamicTail += renderIntentTask(&db.Node{ID: 7, Payload: json.RawMessage(`{"summary":"` + intentSummary + `"}`)})
|
||||
dynamicTail += "\n\nThe target assets corresponding to this intent's asset_ids:\n[{\"domain\":\"" + assetDomain + "\"}]"
|
||||
dynamicTail += "\n\nStart executing the intent above: do only it, produce only facts, assets, findings, stop when done."
|
||||
return staticPart, dynamicTail
|
||||
}
|
||||
|
||||
s1, d1 := buildTail("/data/tasks/1/i10", "probe auth", "alpha.example")
|
||||
s2, d2 := buildTail("/data/tasks/1/i20", "probe billing", "beta.example")
|
||||
|
||||
// Legacy baseline (equivalent to flag off).
|
||||
legacySys1, legacyBound1 := deferredSystem(workerSystem("127.0.0.1:8788", tc.caCert, "/data", "/data/tasks/1/i10")+strings.TrimPrefix(d1, workerArtifactSpec("/data/tasks/1/i10")+noiseProfileBlock()), def)
|
||||
offSys1, offBound1 := assembleWorkerSystem(s1, d1, def, false)
|
||||
if offBound1 != legacyBound1 || !slices.Equal(offSys1, legacySys1) {
|
||||
t.Fatalf("flag off diverged from legacy: got (%d, len=%d) want (%d, len=%d)", offBound1, len(offSys1), legacyBound1, len(legacySys1))
|
||||
}
|
||||
|
||||
// Flag ON: split into [static, dynamic] with DynamicBoundary=1.
|
||||
onSys1, onBound1 := assembleWorkerSystem(s1, d1, def, true)
|
||||
onSys2, onBound2 := assembleWorkerSystem(s2, d2, def, true)
|
||||
|
||||
if onBound1 != 1 || onBound2 != 1 || len(onSys1) != 2 || len(onSys2) != 2 {
|
||||
t.Fatalf("flag on shape = (%d, %d) / (%d, %d), want boundary=1 len=2", onBound1, len(onSys1), onBound2, len(onSys2))
|
||||
}
|
||||
// Static segment identical across sibling workers.
|
||||
if onSys1[0] != onSys2[0] {
|
||||
t.Fatalf("static prefix differs between sibling workers")
|
||||
}
|
||||
// Dynamic segment differs and carries per-intent data + deferred block.
|
||||
if onSys1[1] == onSys2[1] {
|
||||
t.Fatalf("dynamic segment unexpectedly identical")
|
||||
}
|
||||
for _, want := range []string{"/data/tasks/1/i10", "probe auth", "alpha.example", "Start executing the intent above:"} {
|
||||
if !strings.Contains(onSys1[1], want) {
|
||||
t.Errorf("dynamic[1] missing %q", want)
|
||||
}
|
||||
if strings.Contains(onSys1[0], want) {
|
||||
t.Errorf("static[0] unexpectedly contains volatile %q", want)
|
||||
}
|
||||
}
|
||||
if len(tc.globalNames) > 0 {
|
||||
if !strings.Contains(onSys1[1], "<available-deferred-tools>") || !strings.Contains(onSys1[1], "mcp__zap__scan") {
|
||||
t.Errorf("deferred tools block missing from dynamic segment")
|
||||
}
|
||||
if strings.Contains(onSys1[0], "<available-deferred-tools>") {
|
||||
t.Errorf("deferred tools block unexpectedly in static segment")
|
||||
}
|
||||
}
|
||||
|
||||
// Byte-exact visible text: Join(onSys, "\n\n") == Join(offSys, "\n\n").
|
||||
wantVisible1 := strings.Join(offSys1, "\n\n")
|
||||
gotVisible1 := strings.Join(onSys1, "\n\n")
|
||||
if gotVisible1 != wantVisible1 {
|
||||
t.Fatalf("visible text mismatch (len got=%d want=%d)", len(gotVisible1), len(wantVisible1))
|
||||
}
|
||||
offSys2, _ := assembleWorkerSystem(s2, d2, def, false)
|
||||
if strings.Join(onSys2, "\n\n") != strings.Join(offSys2, "\n\n") {
|
||||
t.Fatalf("worker 2 visible text mismatch")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWorkerExecuteCachePrefixEndToEnd(t *testing.T) {
|
||||
d := testDB(t)
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
|
||||
stamp := time.Now().UnixNano()
|
||||
task, err := d.CreateTask(fmt.Sprintf("cache-prefix-%d", stamp), "verify worker cache prefix", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = d.DeleteTask(task.ID) })
|
||||
|
||||
ts := d.Exploration(task.ExplorationID)
|
||||
as := d.Assets()
|
||||
var asset1ID, asset2ID int64
|
||||
dom1 := fmt.Sprintf("alpha-%d.cache.test", stamp)
|
||||
dom2 := fmt.Sprintf("beta-%d.cache.test", stamp)
|
||||
if err := d.QueryRow(`INSERT INTO assets(type,domain,root_domain,task_ids) VALUES('subdomain',$1,$1,ARRAY[$2]::bigint[]) RETURNING id`, dom1, task.ID).Scan(&asset1ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := d.QueryRow(`INSERT INTO assets(type,domain,root_domain,task_ids) VALUES('subdomain',$1,$1,ARRAY[$2]::bigint[]) RETURNING id`, dom2, task.ID).Scan(&asset2ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
_, _ = d.Exec(`DELETE FROM assets WHERE id IN ($1,$2)`, asset1ID, asset2ID)
|
||||
})
|
||||
|
||||
if _, err := ts.AddConstraint("deny", "stay within test scope", "human"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
p1Map := map[string]any{"summary": "inspect alpha auth", "asset_ids": []int64{asset1ID}}
|
||||
p2Map := map[string]any{"summary": "inspect beta checkout", "asset_ids": []int64{asset2ID}}
|
||||
i1ID, err := ts.AddNode("intent", p1Map, 0, "running", "planner", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
i2ID, err := ts.AddNode("intent", p2Map, 0, "running", "planner", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
raw1, _ := json.Marshal(p1Map)
|
||||
raw2, _ := json.Marshal(p2Map)
|
||||
intent1 := &db.Node{ID: i1ID, Payload: raw1}
|
||||
intent2 := &db.Node{ID: i2ID, Payload: raw2}
|
||||
|
||||
// Inject a global deferred MCP name so the deferred block is exercised end-to-end.
|
||||
prevAugment := ToolAugment()
|
||||
SetToolAugment(func(_ context.Context, _ string) ([]actool.CoreTool, DeferredInfo, func()) {
|
||||
return nil, DeferredInfo{
|
||||
GlobalNames: []string{"mcp__demo__scanner"},
|
||||
}, func() {}
|
||||
})
|
||||
t.Cleanup(func() { SetToolAugment(prevAugment) })
|
||||
|
||||
workDir := t.TempDir()
|
||||
runWorker := func(intent *db.Node, lessons string) llm.CompletionRequest {
|
||||
t.Helper()
|
||||
prov := &captureReqProvider{}
|
||||
w := NewWorker(prov, "test-model", workDir, nil, 0, 2)
|
||||
w.SetProxy("127.0.0.1:8788", "/ca.pem")
|
||||
w.SetLessonsBlock(lessons)
|
||||
if _, _, err := w.Execute(t.Context(), "work#1", task.ID, as, ts, intent, passHooks{}, nil, nil, nil); err != nil {
|
||||
t.Fatalf("Worker.Execute(intent=%d): %v", intent.ID, err)
|
||||
}
|
||||
return prov.last()
|
||||
}
|
||||
|
||||
// 1. Flag OFF (default): legacy segments and boundary. With a global deferred
|
||||
// tool block, deferredSystem emits [sysText, deferredBlock] with boundary=2,
|
||||
// and norma's UntrustedOutputBoundary (on by default) appends its fixed note as
|
||||
// System[2], giving len=3 and boundary=2.
|
||||
t.Setenv(CachePrefixEnv, "")
|
||||
req1Off := runWorker(intent1, "")
|
||||
req2Off := runWorker(intent2, "")
|
||||
if req1Off.DynamicBoundary != 2 || len(req1Off.System) != 3 {
|
||||
t.Fatalf("flag off worker 1: boundary=%d len=%d, want 2/3", req1Off.DynamicBoundary, len(req1Off.System))
|
||||
}
|
||||
if req1Off.System[0] == req2Off.System[0] {
|
||||
t.Fatalf("expected flag-off worker system[0] to differ because runDir/intent are inside it")
|
||||
}
|
||||
|
||||
// 2. Flag ON: static prefix identical across sibling workers, dynamic differs,
|
||||
// visible text byte-identical, tools unchanged, deferred block inside dynamic,
|
||||
// norma's appended untrusted-output note preserved as System[2].
|
||||
t.Setenv(CachePrefixEnv, "1")
|
||||
req1On := runWorker(intent1, "")
|
||||
req2On := runWorker(intent2, "")
|
||||
|
||||
if req1On.DynamicBoundary != 1 || req2On.DynamicBoundary != 1 || len(req1On.System) != 3 || len(req2On.System) != 3 {
|
||||
t.Fatalf("flag on shape: w1=(%d,%d) w2=(%d,%d), want (1,3)",
|
||||
req1On.DynamicBoundary, len(req1On.System), req2On.DynamicBoundary, len(req2On.System))
|
||||
}
|
||||
if req1On.System[2] != req1Off.System[2] || req2On.System[2] != req2Off.System[2] {
|
||||
t.Fatalf("norma untrusted-output note segment changed under ARTEX_CACHE_PREFIX=1")
|
||||
}
|
||||
if req1On.System[0] != req2On.System[0] {
|
||||
t.Fatalf("flag on static prefix differs between sibling workers")
|
||||
}
|
||||
if req1On.System[1] == req2On.System[1] {
|
||||
t.Fatalf("flag on dynamic suffix should differ between sibling workers")
|
||||
}
|
||||
|
||||
runDir1 := filepath.Join(workDir, "tasks", fmt.Sprint(task.ID), fmt.Sprintf("i%d", intent1.ID))
|
||||
runDir2 := filepath.Join(workDir, "tasks", fmt.Sprint(task.ID), fmt.Sprintf("i%d", intent2.ID))
|
||||
for _, pair := range []struct {
|
||||
name string
|
||||
req llm.CompletionRequest
|
||||
runDir string
|
||||
intent string
|
||||
domain string
|
||||
}{
|
||||
{"worker1", req1On, runDir1, "inspect alpha auth", dom1},
|
||||
{"worker2", req2On, runDir2, "inspect beta checkout", dom2},
|
||||
} {
|
||||
for _, needle := range []string{pair.runDir, pair.intent, pair.domain, "stay within test scope", "Start executing the intent above:", "<available-deferred-tools>", "mcp__demo__scanner"} {
|
||||
if !strings.Contains(pair.req.System[1], needle) {
|
||||
t.Errorf("%s dynamic segment missing %q", pair.name, needle)
|
||||
}
|
||||
if strings.Contains(pair.req.System[0], needle) {
|
||||
t.Errorf("%s static segment unexpectedly contains %q", pair.name, needle)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if strings.Join(req1On.System, "\n\n") != strings.Join(req1Off.System, "\n\n") {
|
||||
t.Fatalf("worker 1 visible prompt changed under ARTEX_CACHE_PREFIX=1")
|
||||
}
|
||||
if strings.Join(req2On.System, "\n\n") != strings.Join(req2Off.System, "\n\n") {
|
||||
t.Fatalf("worker 2 visible prompt changed under ARTEX_CACHE_PREFIX=1")
|
||||
}
|
||||
|
||||
// With RSI lessons enabled (framed with a per-run random nonce), lessons stay in
|
||||
// System[1] so System[0] remains byte-identical across sibling workers.
|
||||
const sampleLessons = "- [positive, 1 evidence] sqli: verified"
|
||||
req1Lessons := runWorker(intent1, sampleLessons)
|
||||
req2Lessons := runWorker(intent2, sampleLessons)
|
||||
if req1Lessons.System[0] != req1On.System[0] || req2Lessons.System[0] != req1On.System[0] {
|
||||
t.Fatalf("lessons block leaked into static prefix")
|
||||
}
|
||||
if !strings.Contains(req1Lessons.System[1], sampleLessons) || !strings.Contains(req2Lessons.System[1], sampleLessons) {
|
||||
t.Fatalf("lessons block missing from dynamic segment")
|
||||
}
|
||||
|
||||
toolsOffJSON, _ := json.Marshal(req1Off.Tools)
|
||||
toolsOnJSON, _ := json.Marshal(req1On.Tools)
|
||||
if string(toolsOnJSON) != string(toolsOffJSON) {
|
||||
t.Fatalf("tools changed under ARTEX_CACHE_PREFIX=1")
|
||||
}
|
||||
|
||||
// Telemetry observes non-zero static & dynamic split with identical static bytes.
|
||||
m1 := llmrec.MeasureContext(req1On)
|
||||
m2 := llmrec.MeasureContext(req2On)
|
||||
if m1.SystemStaticBytes <= 0 || m1.SystemDynamicBytes <= 0 || m1.SystemStaticBytes != m2.SystemStaticBytes {
|
||||
t.Fatalf("MeasureContext mismatch: m1=(%d,%d) m2=(%d,%d)",
|
||||
m1.SystemStaticBytes, m1.SystemDynamicBytes, m2.SystemStaticBytes, m2.SystemDynamicBytes)
|
||||
}
|
||||
|
||||
// 3. Planner and mainagent are completely unchanged by ARTEX_CACHE_PREFIX=1.
|
||||
runPlanner := func() llm.CompletionRequest {
|
||||
prov := &captureReqProvider{}
|
||||
if _, _, err := NewPlanner(prov, "test-model", workDir, nil, 0, 2).Plan(t.Context(), task.ID, as, ts, "goal", nil, passHooks{}, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return prov.last()
|
||||
}
|
||||
runMain := func() llm.CompletionRequest {
|
||||
prov := &captureReqProvider{}
|
||||
if _, err := NewMainAgent(prov, "test-model", workDir, nil, 0, 2).Chat(t.Context(), task.ID, 0, as, ts, "goal", "status?", passHooks{}, nil, nil, nil, nil, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return prov.last()
|
||||
}
|
||||
|
||||
t.Setenv(CachePrefixEnv, "")
|
||||
planOff := runPlanner()
|
||||
mainOff := runMain()
|
||||
t.Setenv(CachePrefixEnv, "1")
|
||||
planOn := runPlanner()
|
||||
mainOn := runMain()
|
||||
|
||||
if planOn.DynamicBoundary != planOff.DynamicBoundary || !slices.Equal(planOn.System, planOff.System) {
|
||||
t.Fatalf("planner changed under ARTEX_CACHE_PREFIX=1: off=(%d,len=%d) on=(%d,len=%d)",
|
||||
planOff.DynamicBoundary, len(planOff.System), planOn.DynamicBoundary, len(planOn.System))
|
||||
}
|
||||
if mainOn.DynamicBoundary != mainOff.DynamicBoundary || !slices.Equal(mainOn.System, mainOff.System) {
|
||||
t.Fatalf("mainagent changed under ARTEX_CACHE_PREFIX=1: off=(%d,len=%d) on=(%d,len=%d)",
|
||||
mainOff.DynamicBoundary, len(mainOff.System), mainOn.DynamicBoundary, len(mainOn.System))
|
||||
}
|
||||
}
|
||||
@@ -118,7 +118,7 @@ else
|
||||
command -v rsync >/dev/null 2>&1 || die "rsync not detected"
|
||||
info "Building frontend static assets"
|
||||
if [ "${ARTEX_SKIP_NPM_CI:-0}" != "1" ]; then
|
||||
(cd web && npm ci)
|
||||
(cd web && npm ci --ignore-scripts)
|
||||
fi
|
||||
(cd web && npm run build:static)
|
||||
info "Syncing frontend assets to server/webui/dist"
|
||||
|
||||
@@ -22,7 +22,7 @@ func TestFlushActivityOutboxReplaysOnce(t *testing.T) {
|
||||
if err != nil {
|
||||
SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
expID, err := d.CreateExploration("outbox", "replay")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -65,7 +65,7 @@ func TestFlushActivityOutboxDropsStuckRow(t *testing.T) {
|
||||
if err != nil {
|
||||
SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
const missing = int64(9_000_000_000_001)
|
||||
t.Cleanup(func() { _, _ = d.Exec(`DELETE FROM activity_outbox WHERE exploration_id=$1`, missing) })
|
||||
es := d.Exploration(missing)
|
||||
|
||||
@@ -1143,6 +1143,7 @@ func TestAssetIPRejectsHostname(t *testing.T) {
|
||||
t.Fatalf("empty ip rejected: %v", err)
|
||||
}
|
||||
deleteAsset(d, id)
|
||||
_, _ = d.Exec(`DELETE FROM assets WHERE domain IN ('ip-guard.example.com','example.com')`)
|
||||
id, err = av2.UpsertIP(UpsertIPReq{IP: "203.0.113.7"})
|
||||
if err != nil {
|
||||
t.Fatalf("valid ip rejected: %v", err)
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestDashboardUsageIndexesMigration0010(t *testing.T) {
|
||||
d, err := Open(testDSN(t))
|
||||
if err != nil {
|
||||
SkipPGUnavailable(t, err)
|
||||
}
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
|
||||
wantIndexes := []struct {
|
||||
name string
|
||||
table string
|
||||
pred string
|
||||
}{
|
||||
{"idx_act_result_created", "activity", "kind = 'result'"},
|
||||
{"idx_conv_act_result", "conversation_activities", "kind = 'result'"},
|
||||
{"idx_llm_usage_judge_ts", "llm_usage", "worker = 'judge'"},
|
||||
}
|
||||
|
||||
for _, want := range wantIndexes {
|
||||
var valid, ready bool
|
||||
var def string
|
||||
err := d.QueryRow(`
|
||||
SELECT i.indisvalid, i.indisready, pg_get_indexdef(i.indexrelid)
|
||||
FROM pg_index i
|
||||
JOIN pg_class c ON c.oid = i.indexrelid
|
||||
JOIN pg_namespace n ON n.oid = c.relnamespace
|
||||
WHERE n.nspname = 'public' AND c.relname = $1`, want.name).Scan(&valid, &ready, &def)
|
||||
if err != nil {
|
||||
t.Fatalf("index public.%s missing after Open: %v", want.name, err)
|
||||
}
|
||||
if !valid || !ready {
|
||||
t.Fatalf("index %s indisvalid=%v indisready=%v, want both true (%s)", want.name, valid, ready, def)
|
||||
}
|
||||
if !strings.Contains(def, want.table) || !strings.Contains(def, want.pred) {
|
||||
t.Fatalf("index %s definition %q missing table %q or predicate %q", want.name, def, want.table, want.pred)
|
||||
}
|
||||
}
|
||||
|
||||
// Verify sargable TokenByModel matches both specific task_id and empty task_id.
|
||||
taskID := fmt.Sprintf("idx-test-%d", time.Now().UnixNano())
|
||||
t.Cleanup(func() {
|
||||
_, _ = d.Exec(`DELETE FROM llm_usage WHERE task_id = $1 OR profile_name = $2`, taskID, taskID)
|
||||
})
|
||||
if err := d.InsertLLMUsage(&LLMUsage{
|
||||
TaskID: taskID,
|
||||
Worker: "worker",
|
||||
Model: "claude-sonnet-4",
|
||||
ProfileName: taskID,
|
||||
InputTokens: 1000,
|
||||
OutputTokens: 200,
|
||||
Status: "ok",
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := d.InsertLLMUsage(&LLMUsage{
|
||||
TaskID: "",
|
||||
Worker: "chat",
|
||||
Model: "gpt-5",
|
||||
ProfileName: taskID,
|
||||
InputTokens: 500,
|
||||
OutputTokens: 100,
|
||||
Status: "ok",
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
got, err := d.TokenByModel(taskID)
|
||||
if err != nil {
|
||||
t.Fatalf("TokenByModel(%q): %v", taskID, err)
|
||||
}
|
||||
if len(got) != 1 || got[0].Model != "claude-sonnet-4" || got[0].InputTokens != 1000 || got[0].OutputTokens != 200 {
|
||||
t.Fatalf("TokenByModel(%q) = %+v, want 1 claude-sonnet-4 row", taskID, got)
|
||||
}
|
||||
|
||||
emptyGot, err := d.TokenByModel("")
|
||||
if err != nil {
|
||||
t.Fatalf("TokenByModel(\"\"): %v", err)
|
||||
}
|
||||
foundChat := false
|
||||
for _, m := range emptyGot {
|
||||
if m.Model == "gpt-5" && m.InputTokens >= 500 {
|
||||
foundChat = true
|
||||
}
|
||||
}
|
||||
if !foundChat {
|
||||
t.Fatalf("TokenByModel(\"\") did not include NULL/empty task_id row: %+v", emptyGot)
|
||||
}
|
||||
}
|
||||
@@ -100,7 +100,7 @@ func TestEvidenceRewriteFlagMigrationAndRoundTrip(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || strings.HasPrefix(e.Name(), "0008_") {
|
||||
if e.IsDir() || e.Name() >= "0008_" {
|
||||
continue
|
||||
}
|
||||
data, err := fs.ReadFile(migrationsFS(), e.Name())
|
||||
|
||||
@@ -28,6 +28,7 @@ func TestFindingQualityByNodeID(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteFinding(rec.FindingID)
|
||||
if err := d.SetFindingVerification(rec.FindingID, VerificationVerified, 3, "reproduced twice on staging"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
@@ -24,10 +24,12 @@ func TestFindingReasoningFieldsRoundTrip(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteFinding(with.FindingID)
|
||||
without, err := es.RecordFinding(t.Context(), RecordFindingInput{TaskID: tk.ID, VulnClass: "IDOR", Severity: "low", Summary: "without reasoning", Worker: "test"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteFinding(without.FindingID)
|
||||
want := map[int64][2]string{
|
||||
with.FindingID: {"UUID guessing returned 404", "two accounts, same response body"},
|
||||
without.FindingID: {"", ""},
|
||||
|
||||
@@ -32,7 +32,11 @@ func TestFindingTrafficLegacyArchiveDefaults(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer func() { d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID); d.DeleteTask(task.ID) }()
|
||||
defer func() {
|
||||
_, _ = d.DeleteFindingsByTask(task.ID)
|
||||
_, _ = d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID)
|
||||
_ = d.DeleteTask(task.ID)
|
||||
}()
|
||||
f, err := d.Exploration(task.ExplorationID).RecordFinding(t.Context(), RecordFindingInput{TaskID: task.ID, ExplorationID: task.ExplorationID, Summary: "legacy", Severity: "low"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
|
||||
+9
-3
@@ -100,6 +100,7 @@ func TestSetFindingStatusMirrorsNodePayload(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteFinding(fid)
|
||||
|
||||
n, err := d.SetFindingStatus(fid, FindingFalsePositive)
|
||||
if err != nil || n != 1 {
|
||||
@@ -146,13 +147,13 @@ func TestFindingReportState(t *testing.T) {
|
||||
if err != nil {
|
||||
SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { d.Close() })
|
||||
|
||||
tk, err := d.CreateTask("finding report state", "goal", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(tk.ID)
|
||||
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
|
||||
|
||||
es := d.Exploration(tk.ExplorationID)
|
||||
nodeID, err := es.AddNode(KindFinding, map[string]any{"summary": "x", "severity": "high"}, 5, "confirmed", "worker", nil)
|
||||
@@ -167,7 +168,11 @@ func TestFindingReportState(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id IN ($1,$2)`, fid, second) })
|
||||
t.Cleanup(func() {
|
||||
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id IN ($1,$2)`, fid, second)
|
||||
_, _ = d.DeleteFinding(fid)
|
||||
_, _ = d.DeleteFinding(second)
|
||||
})
|
||||
|
||||
one, err := d.GetFinding(fid)
|
||||
if err != nil || one == nil || one.ReportState != FindingReportNone {
|
||||
@@ -633,6 +638,7 @@ func TestAddFindingFollowUpIntent(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteFinding(findingID)
|
||||
|
||||
auditInput := Activity{Worker: "system", Kind: "text", Summary: "Manually submitted vulnerability deep-exploitation intent", Detail: "Verify exploitability and build an evidence chain"}
|
||||
intentID, audit, err := store.AddFindingFollowUpIntent(findingID, findingNodeID, "Verify exploitability and build an evidence chain", auditInput)
|
||||
|
||||
+12
-2
@@ -191,11 +191,14 @@ func TestExtractLessonsScopesSingleCompanyFromTaskScope(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupErr(t, "extract task", d.DeleteTask(task.ID)) })
|
||||
if _, err := d.Exec(`
|
||||
var extractedFID int64
|
||||
if err := d.QueryRow(`
|
||||
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
|
||||
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')`, task.ID); err != nil {
|
||||
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')
|
||||
RETURNING id`, task.ID).Scan(&extractedFID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, extractedFID) })
|
||||
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -477,6 +480,7 @@ func TestExtractLessonsRetractsReversedDisposition(t *testing.T) {
|
||||
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
|
||||
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
|
||||
if err != nil {
|
||||
@@ -589,12 +593,14 @@ func TestExtractLessonsRetireOnlyWhenLastEvidence(t *testing.T) {
|
||||
RETURNING id`, task.ID, cue, label).Scan(&aID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, aID) })
|
||||
if err := d.QueryRow(`
|
||||
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
|
||||
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
|
||||
RETURNING id`, task.ID, cue, label).Scan(&bID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, bID) })
|
||||
|
||||
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -681,6 +687,7 @@ func TestExtractLessonsRetractsAllRetests(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
|
||||
r1 := insertLessonRetest(t, d, fid, "reproduced")
|
||||
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
|
||||
@@ -752,6 +759,7 @@ func TestExtractLessonsDoesNotUnretireWithEvidence(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
|
||||
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -798,6 +806,7 @@ func TestExtractLessonsLeavesAdopted(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
|
||||
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -841,6 +850,7 @@ func TestExtractLessonsReopenRetractsNothing(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
|
||||
|
||||
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
|
||||
@@ -0,0 +1,316 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// LLMContext is one opt-in context-size telemetry row written when
|
||||
// ARTEX_CONTEXT_TELEMETRY=1. It records only byte sizes, counts, token usage,
|
||||
// and call metadata — never any prompt, tool, or message content.
|
||||
type LLMContext struct {
|
||||
TaskID string `json:"task_id"`
|
||||
Worker string `json:"worker"`
|
||||
Model string `json:"model"`
|
||||
Profile string `json:"profile"`
|
||||
ToolCount int `json:"tool_count"`
|
||||
MessageCount int `json:"message_count"`
|
||||
SystemStaticBytes int64 `json:"system_static_bytes"`
|
||||
SystemDynamicBytes int64 `json:"system_dynamic_bytes"`
|
||||
ToolsBytes int64 `json:"tools_bytes"`
|
||||
MessagesUserBytes int64 `json:"messages_user_bytes"`
|
||||
MessagesAssistantBytes int64 `json:"messages_assistant_bytes"`
|
||||
MessagesOtherBytes int64 `json:"messages_other_bytes"`
|
||||
ToolResultBytes int64 `json:"tool_result_bytes"`
|
||||
LastMessageBytes int64 `json:"last_message_bytes"`
|
||||
InputTokens int `json:"input_tokens"`
|
||||
OutputTokens int `json:"output_tokens"`
|
||||
CacheRead int `json:"cache_read"`
|
||||
CacheWrite int `json:"cache_write"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
// TotalMeasuredBytes returns the partition sum of request section bytes
|
||||
// (excluding ToolResultBytes, which is a subset of MessagesUserBytes).
|
||||
func (c LLMContext) TotalMeasuredBytes() int64 {
|
||||
return c.SystemStaticBytes + c.SystemDynamicBytes + c.ToolsBytes +
|
||||
c.MessagesUserBytes + c.MessagesAssistantBytes + c.MessagesOtherBytes
|
||||
}
|
||||
|
||||
// LLMContextSectionShares holds the pro-rata share (0..1) of real input_tokens
|
||||
// attributed to each request section by byte proportion. The six partition
|
||||
// fields (SystemStatic through MessagesOther) sum to 1.0 whenever at least one
|
||||
// call has both measured bytes > 0 and input_tokens > 0. ToolResultSubset is an
|
||||
// informational sub-share of MessagesUser (not added to the sum).
|
||||
type LLMContextSectionShares struct {
|
||||
SystemStatic float64 `json:"system_static"`
|
||||
SystemDynamic float64 `json:"system_dynamic"`
|
||||
Tools float64 `json:"tools"`
|
||||
MessagesUser float64 `json:"messages_user"`
|
||||
MessagesAsst float64 `json:"messages_assistant"`
|
||||
MessagesOther float64 `json:"messages_other"`
|
||||
ToolResultSubset float64 `json:"tool_result_subset"`
|
||||
}
|
||||
|
||||
// ComputeLLMContextShares deterministically allocates each call's real
|
||||
// input_tokens across sections proportionally to measured bytes, then divides
|
||||
// each section's attributed tokens by the total attributed input tokens.
|
||||
// Rows with zero measured bytes or zero input tokens are ignored so they never
|
||||
// produce NaN or distort the proportions.
|
||||
func ComputeLLMContextShares(rows []LLMContext) LLMContextSectionShares {
|
||||
var (
|
||||
totInput float64
|
||||
sysStat float64
|
||||
sysDyn float64
|
||||
tools float64
|
||||
msgUser float64
|
||||
msgAsst float64
|
||||
msgOther float64
|
||||
toolRes float64
|
||||
)
|
||||
for _, r := range rows {
|
||||
totalBytes := r.TotalMeasuredBytes()
|
||||
if totalBytes <= 0 || r.InputTokens <= 0 {
|
||||
continue
|
||||
}
|
||||
in := float64(r.InputTokens)
|
||||
tb := float64(totalBytes)
|
||||
totInput += in
|
||||
sysStat += in * (float64(r.SystemStaticBytes) / tb)
|
||||
sysDyn += in * (float64(r.SystemDynamicBytes) / tb)
|
||||
tools += in * (float64(r.ToolsBytes) / tb)
|
||||
msgUser += in * (float64(r.MessagesUserBytes) / tb)
|
||||
msgAsst += in * (float64(r.MessagesAssistantBytes) / tb)
|
||||
msgOther += in * (float64(r.MessagesOtherBytes) / tb)
|
||||
toolRes += in * (float64(r.ToolResultBytes) / tb)
|
||||
}
|
||||
if totInput <= 0 {
|
||||
return LLMContextSectionShares{}
|
||||
}
|
||||
return LLMContextSectionShares{
|
||||
SystemStatic: sysStat / totInput,
|
||||
SystemDynamic: sysDyn / totInput,
|
||||
Tools: tools / totInput,
|
||||
MessagesUser: msgUser / totInput,
|
||||
MessagesAsst: msgAsst / totInput,
|
||||
MessagesOther: msgOther / totInput,
|
||||
ToolResultSubset: toolRes / totInput,
|
||||
}
|
||||
}
|
||||
|
||||
// LLMContextGroupStat aggregates llm_context rows for one (worker, model) pair.
|
||||
type LLMContextGroupStat struct {
|
||||
Worker string `json:"worker"`
|
||||
Model string `json:"model"`
|
||||
Calls int `json:"calls"`
|
||||
InputTokensTotal int64 `json:"input_tokens_total"`
|
||||
OutputTokensTotal int64 `json:"output_tokens_total"`
|
||||
CacheReadTotal int64 `json:"cache_read_total"`
|
||||
CacheWriteTotal int64 `json:"cache_write_total"`
|
||||
CacheReadRatio float64 `json:"cache_read_ratio"`
|
||||
InputP50 float64 `json:"input_p50"`
|
||||
InputP90 float64 `json:"input_p90"`
|
||||
InputP99 float64 `json:"input_p99"`
|
||||
InputMax int `json:"input_max"`
|
||||
AvgToolCount float64 `json:"avg_tool_count"`
|
||||
AvgMessageCount float64 `json:"avg_message_count"`
|
||||
AvgLastMessageBytes float64 `json:"avg_last_message_bytes"`
|
||||
Shares LLMContextSectionShares `json:"shares"`
|
||||
}
|
||||
|
||||
// LLMContextTaskStat summarizes context consumption for one task_id.
|
||||
type LLMContextTaskStat struct {
|
||||
TaskID string `json:"task_id"`
|
||||
Calls int `json:"calls"`
|
||||
InputTokensTotal int64 `json:"input_tokens_total"`
|
||||
CacheReadTotal int64 `json:"cache_read_total"`
|
||||
CacheReadRatio float64 `json:"cache_read_ratio"`
|
||||
InputP90 float64 `json:"input_p90"`
|
||||
InputMax int `json:"input_max"`
|
||||
Shares LLMContextSectionShares `json:"shares"`
|
||||
}
|
||||
|
||||
// LLMContextSummary is the aggregation output for Phase A context measurement.
|
||||
type LLMContextSummary struct {
|
||||
ByWorkerModel []LLMContextGroupStat `json:"by_worker_model"`
|
||||
TopTasks []LLMContextTaskStat `json:"top_tasks"`
|
||||
}
|
||||
|
||||
// LLMContextQuery scopes LLMContextSummary.
|
||||
type LLMContextQuery struct {
|
||||
Days int // > 0 restricts to ts >= now() - Days; <= 0 = all time
|
||||
TaskID string // optional exact task_id filter
|
||||
TopTasks int // max rows in TopTasks (default 20, clamped 1..100)
|
||||
}
|
||||
|
||||
// InsertLLMContext appends one context-telemetry row. Best-effort: callers log
|
||||
// and continue on error so telemetry never breaks an LLM call.
|
||||
func (d *DB) InsertLLMContext(c *LLMContext) error {
|
||||
status := strings.TrimSpace(c.Status)
|
||||
if status == "" {
|
||||
status = "ok"
|
||||
}
|
||||
_, err := d.Exec(`
|
||||
INSERT INTO llm_context(
|
||||
task_id, worker, model, profile,
|
||||
tool_count, message_count,
|
||||
system_static_bytes, system_dynamic_bytes, tools_bytes,
|
||||
messages_user_bytes, messages_assistant_bytes, messages_other_bytes,
|
||||
tool_result_bytes, last_message_bytes,
|
||||
input_tokens, output_tokens, cache_read, cache_write, status
|
||||
) VALUES (
|
||||
NULLIF($1,''), NULLIF($2,''), NULLIF($3,''), NULLIF($4,''),
|
||||
$5, $6,
|
||||
$7, $8, $9,
|
||||
$10, $11, $12,
|
||||
$13, $14,
|
||||
$15, $16, $17, $18, $19
|
||||
)`,
|
||||
c.TaskID, c.Worker, c.Model, c.Profile,
|
||||
c.ToolCount, c.MessageCount,
|
||||
c.SystemStaticBytes, c.SystemDynamicBytes, c.ToolsBytes,
|
||||
c.MessagesUserBytes, c.MessagesAssistantBytes, c.MessagesOtherBytes,
|
||||
c.ToolResultBytes, c.LastMessageBytes,
|
||||
c.InputTokens, c.OutputTokens, c.CacheRead, c.CacheWrite, status)
|
||||
return err
|
||||
}
|
||||
|
||||
const llmContextTotalBytesExpr = `(system_static_bytes + system_dynamic_bytes + tools_bytes + messages_user_bytes + messages_assistant_bytes + messages_other_bytes)`
|
||||
|
||||
// llmContextSharesSelect produces the 7 pro-rata section-share SQL expressions
|
||||
// matching ComputeLLMContextShares.
|
||||
const llmContextSharesSelect = `
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (system_static_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0),
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (system_dynamic_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0),
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (tools_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0),
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (messages_user_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0),
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (messages_assistant_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0),
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (messages_other_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0),
|
||||
COALESCE(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens * (tool_result_bytes::double precision / ` + llmContextTotalBytesExpr + `::double precision) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN ` + llmContextTotalBytesExpr + ` > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0), 0)`
|
||||
|
||||
// LLMContextSummary aggregates llm_context by (worker, model) and returns the
|
||||
// top tasks by total input_tokens, with input percentiles (p50/p90/p99),
|
||||
// pro-rata section shares over real input_tokens, and cache_read/input ratio.
|
||||
func (d *DB) LLMContextSummary(q LLMContextQuery) (*LLMContextSummary, error) {
|
||||
topLimit := q.TopTasks
|
||||
if topLimit <= 0 {
|
||||
topLimit = 20
|
||||
}
|
||||
if topLimit > 100 {
|
||||
topLimit = 100
|
||||
}
|
||||
|
||||
var conds []string
|
||||
var args []any
|
||||
addCond := func(expr string, val any) {
|
||||
args = append(args, val)
|
||||
conds = append(conds, fmt.Sprintf(expr, len(args)))
|
||||
}
|
||||
if q.Days > 0 {
|
||||
addCond("ts >= now() - make_interval(days => $%d)", q.Days)
|
||||
}
|
||||
if tid := strings.TrimSpace(q.TaskID); tid != "" {
|
||||
addCond("COALESCE(task_id,'') = $%d", tid)
|
||||
}
|
||||
where := ""
|
||||
if len(conds) > 0 {
|
||||
where = " WHERE " + strings.Join(conds, " AND ")
|
||||
}
|
||||
|
||||
out := &LLMContextSummary{
|
||||
ByWorkerModel: []LLMContextGroupStat{},
|
||||
TopTasks: []LLMContextTaskStat{},
|
||||
}
|
||||
|
||||
groupSQL := `
|
||||
SELECT COALESCE(NULLIF(worker,''),'(unknown)') AS w,
|
||||
COALESCE(NULLIF(model,''),'(unknown)') AS m,
|
||||
COUNT(*),
|
||||
COALESCE(SUM(input_tokens), 0),
|
||||
COALESCE(SUM(output_tokens), 0),
|
||||
COALESCE(SUM(cache_read), 0),
|
||||
COALESCE(SUM(cache_write), 0),
|
||||
COALESCE(SUM(cache_read)::double precision / NULLIF(SUM(input_tokens)::double precision, 0), 0),
|
||||
COALESCE(PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY input_tokens), 0),
|
||||
COALESCE(PERCENTILE_CONT(0.90) WITHIN GROUP (ORDER BY input_tokens), 0),
|
||||
COALESCE(PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY input_tokens), 0),
|
||||
COALESCE(MAX(input_tokens), 0),
|
||||
COALESCE(AVG(tool_count)::double precision, 0),
|
||||
COALESCE(AVG(message_count)::double precision, 0),
|
||||
COALESCE(AVG(last_message_bytes)::double precision, 0),` + llmContextSharesSelect + `
|
||||
FROM llm_context` + where + `
|
||||
GROUP BY w, m
|
||||
ORDER BY SUM(input_tokens) DESC, w ASC, m ASC`
|
||||
|
||||
rows, err := d.Query(groupSQL, args...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var g LLMContextGroupStat
|
||||
if err := rows.Scan(
|
||||
&g.Worker, &g.Model, &g.Calls,
|
||||
&g.InputTokensTotal, &g.OutputTokensTotal, &g.CacheReadTotal, &g.CacheWriteTotal,
|
||||
&g.CacheReadRatio,
|
||||
&g.InputP50, &g.InputP90, &g.InputP99, &g.InputMax,
|
||||
&g.AvgToolCount, &g.AvgMessageCount, &g.AvgLastMessageBytes,
|
||||
&g.Shares.SystemStatic, &g.Shares.SystemDynamic, &g.Shares.Tools,
|
||||
&g.Shares.MessagesUser, &g.Shares.MessagesAsst, &g.Shares.MessagesOther,
|
||||
&g.Shares.ToolResultSubset,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out.ByWorkerModel = append(out.ByWorkerModel, g)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
taskConds := append([]string{}, conds...)
|
||||
taskConds = append(taskConds, "COALESCE(task_id,'') <> ''")
|
||||
taskArgs := append([]any{}, args...)
|
||||
taskArgs = append(taskArgs, topLimit)
|
||||
limitPlaceholder := fmt.Sprintf("$%d", len(taskArgs))
|
||||
|
||||
taskSQL := `
|
||||
SELECT task_id,
|
||||
COUNT(*),
|
||||
COALESCE(SUM(input_tokens), 0),
|
||||
COALESCE(SUM(cache_read), 0),
|
||||
COALESCE(SUM(cache_read)::double precision / NULLIF(SUM(input_tokens)::double precision, 0), 0),
|
||||
COALESCE(PERCENTILE_CONT(0.90) WITHIN GROUP (ORDER BY input_tokens), 0),
|
||||
COALESCE(MAX(input_tokens), 0),` + llmContextSharesSelect + `
|
||||
FROM llm_context
|
||||
WHERE ` + strings.Join(taskConds, " AND ") + `
|
||||
GROUP BY task_id
|
||||
ORDER BY SUM(input_tokens) DESC, task_id ASC
|
||||
LIMIT ` + limitPlaceholder
|
||||
|
||||
trows, err := d.Query(taskSQL, taskArgs...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer trows.Close()
|
||||
for trows.Next() {
|
||||
var ts LLMContextTaskStat
|
||||
if err := trows.Scan(
|
||||
&ts.TaskID, &ts.Calls, &ts.InputTokensTotal, &ts.CacheReadTotal,
|
||||
&ts.CacheReadRatio, &ts.InputP90, &ts.InputMax,
|
||||
&ts.Shares.SystemStatic, &ts.Shares.SystemDynamic, &ts.Shares.Tools,
|
||||
&ts.Shares.MessagesUser, &ts.Shares.MessagesAsst, &ts.Shares.MessagesOther,
|
||||
&ts.Shares.ToolResultSubset,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out.TopTasks = append(out.TopTasks, ts)
|
||||
}
|
||||
return out, trows.Err()
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"math"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestComputeLLMContextSharesDeterministic(t *testing.T) {
|
||||
// Call 1: 1000 bytes (400 sys_static, 100 sys_dyn, 200 tools, 200 user [150 tool_result], 100 asst), 1000 input tokens.
|
||||
// Call 2: 2000 bytes (200 sys_static, 0 sys_dyn, 200 tools, 1400 user [1200 tool_result], 200 asst), 3000 input tokens.
|
||||
// Call 3: zero tokens / zero bytes -> ignored safely (no NaN).
|
||||
rows := []LLMContext{
|
||||
{
|
||||
SystemStaticBytes: 400, SystemDynamicBytes: 100, ToolsBytes: 200,
|
||||
MessagesUserBytes: 200, MessagesAssistantBytes: 100, ToolResultBytes: 150,
|
||||
InputTokens: 1000,
|
||||
},
|
||||
{
|
||||
SystemStaticBytes: 200, SystemDynamicBytes: 0, ToolsBytes: 200,
|
||||
MessagesUserBytes: 1400, MessagesAssistantBytes: 200, ToolResultBytes: 1200,
|
||||
InputTokens: 3000,
|
||||
},
|
||||
{InputTokens: 0, SystemStaticBytes: 0},
|
||||
}
|
||||
|
||||
got := ComputeLLMContextShares(rows)
|
||||
// Exact hand-computed attributed tokens (total = 4000):
|
||||
// sys_static: 400 + 300 = 700 -> 0.175
|
||||
// sys_dynamic: 100 + 0 = 100 -> 0.025
|
||||
// tools: 200 + 300 = 500 -> 0.125
|
||||
// msg_user: 200 + 2100 = 2300 -> 0.575
|
||||
// msg_asst: 100 + 300 = 400 -> 0.100
|
||||
// msg_other: 0 = 0 -> 0.000
|
||||
// tool_result: 150 + 1800 = 1950 -> 0.4875
|
||||
assertNear := func(name string, v, want float64) {
|
||||
t.Helper()
|
||||
if math.IsNaN(v) || math.IsInf(v, 0) || math.Abs(v-want) > 1e-9 {
|
||||
t.Errorf("%s = %.12f, want %.12f", name, v, want)
|
||||
}
|
||||
}
|
||||
assertNear("SystemStatic", got.SystemStatic, 0.175)
|
||||
assertNear("SystemDynamic", got.SystemDynamic, 0.025)
|
||||
assertNear("Tools", got.Tools, 0.125)
|
||||
assertNear("MessagesUser", got.MessagesUser, 0.575)
|
||||
assertNear("MessagesAsst", got.MessagesAsst, 0.100)
|
||||
assertNear("MessagesOther", got.MessagesOther, 0.0)
|
||||
assertNear("ToolResultSubset", got.ToolResultSubset, 0.4875)
|
||||
|
||||
sum := got.SystemStatic + got.SystemDynamic + got.Tools + got.MessagesUser + got.MessagesAsst + got.MessagesOther
|
||||
assertNear("partition sum", sum, 1.0)
|
||||
|
||||
// Empty input produces zero struct without NaN.
|
||||
zero := ComputeLLMContextShares(nil)
|
||||
if zero != (LLMContextSectionShares{}) {
|
||||
t.Fatalf("empty shares = %+v, want zero", zero)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLLMContextMigration0009AndSummaryAggregation(t *testing.T) {
|
||||
dsn := scratchDSN(t, "ctx_mig_0009")
|
||||
|
||||
// 1. Open database with migrations 0001..0008 only (pre-0009 database).
|
||||
pre0009 := fstest.MapFS{}
|
||||
entries, err := fs.ReadDir(migrationsFS(), ".")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || e.Name() >= "0009_" {
|
||||
continue
|
||||
}
|
||||
data, err := fs.ReadFile(migrationsFS(), e.Name())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
pre0009[e.Name()] = &fstest.MapFile{Data: data}
|
||||
}
|
||||
d0, err := openWithMigrations(dsn, pre0009)
|
||||
if err != nil {
|
||||
t.Fatalf("open pre-0009: %v", err)
|
||||
}
|
||||
var existsBefore bool
|
||||
if err := d0.QueryRow(`SELECT to_regclass('llm_context') IS NOT NULL`).Scan(&existsBefore); err != nil || existsBefore {
|
||||
d0.Close()
|
||||
t.Fatalf("llm_context should not exist before 0009: exists=%v err=%v", existsBefore, err)
|
||||
}
|
||||
d0.Close()
|
||||
|
||||
// 2. Re-open with full embedded migrations: 0009 must apply cleanly.
|
||||
d, err := Open(dsn)
|
||||
if err != nil {
|
||||
t.Fatalf("Open with 0009: %v", err)
|
||||
}
|
||||
defer d.Close()
|
||||
|
||||
// 3. Seed deterministic rows across two workers and two tasks.
|
||||
seed := []LLMContext{
|
||||
{
|
||||
TaskID: "t-heavy", Worker: "worker", Model: "claude-sonnet", Profile: "main",
|
||||
ToolCount: 15, MessageCount: 4,
|
||||
SystemStaticBytes: 400, SystemDynamicBytes: 100, ToolsBytes: 200,
|
||||
MessagesUserBytes: 200, MessagesAssistantBytes: 100, ToolResultBytes: 150,
|
||||
LastMessageBytes: 120,
|
||||
InputTokens: 1000, OutputTokens: 200, CacheRead: 600, CacheWrite: 100, Status: "ok",
|
||||
},
|
||||
{
|
||||
TaskID: "t-heavy", Worker: "worker", Model: "claude-sonnet", Profile: "main",
|
||||
ToolCount: 15, MessageCount: 12,
|
||||
SystemStaticBytes: 200, SystemDynamicBytes: 0, ToolsBytes: 200,
|
||||
MessagesUserBytes: 1400, MessagesAssistantBytes: 200, ToolResultBytes: 1200,
|
||||
LastMessageBytes: 800,
|
||||
InputTokens: 3000, OutputTokens: 300, CacheRead: 1800, CacheWrite: 200, Status: "ok",
|
||||
},
|
||||
{
|
||||
TaskID: "t-light", Worker: "planner", Model: "claude-sonnet", Profile: "main",
|
||||
ToolCount: 10, MessageCount: 2,
|
||||
SystemStaticBytes: 600, SystemDynamicBytes: 0, ToolsBytes: 200,
|
||||
MessagesUserBytes: 200, MessagesAssistantBytes: 0, ToolResultBytes: 0,
|
||||
LastMessageBytes: 200,
|
||||
InputTokens: 500, OutputTokens: 100, CacheRead: 250, CacheWrite: 50, Status: "ok",
|
||||
},
|
||||
}
|
||||
for i := range seed {
|
||||
if err := d.InsertLLMContext(&seed[i]); err != nil {
|
||||
t.Fatalf("InsertLLMContext[%d]: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
summary, err := d.LLMContextSummary(LLMContextQuery{Days: 7, TopTasks: 10})
|
||||
if err != nil {
|
||||
t.Fatalf("LLMContextSummary: %v", err)
|
||||
}
|
||||
if len(summary.ByWorkerModel) != 2 {
|
||||
t.Fatalf("ByWorkerModel = %d, want 2: %+v", len(summary.ByWorkerModel), summary.ByWorkerModel)
|
||||
}
|
||||
|
||||
// First group is worker/claude-sonnet (total input = 4000).
|
||||
w := summary.ByWorkerModel[0]
|
||||
wantShares := ComputeLLMContextShares(seed[:2])
|
||||
near := func(name string, got, want float64) {
|
||||
t.Helper()
|
||||
if math.Abs(got-want) > 1e-9 {
|
||||
t.Errorf("%s = %.12f, want %.12f", name, got, want)
|
||||
}
|
||||
}
|
||||
if w.Worker != "worker" || w.Model != "claude-sonnet" || w.Calls != 2 ||
|
||||
w.InputTokensTotal != 4000 || w.OutputTokensTotal != 500 ||
|
||||
w.CacheReadTotal != 2400 || w.CacheWriteTotal != 300 || w.InputMax != 3000 {
|
||||
t.Fatalf("worker group = %+v", w)
|
||||
}
|
||||
near("CacheReadRatio", w.CacheReadRatio, 2400.0/4000.0)
|
||||
near("InputP50", w.InputP50, 2000.0)
|
||||
near("InputP90", w.InputP90, 2800.0)
|
||||
near("InputP99", w.InputP99, 2980.0)
|
||||
near("Shares.SystemStatic", w.Shares.SystemStatic, wantShares.SystemStatic)
|
||||
near("Shares.SystemDynamic", w.Shares.SystemDynamic, wantShares.SystemDynamic)
|
||||
near("Shares.Tools", w.Shares.Tools, wantShares.Tools)
|
||||
near("Shares.MessagesUser", w.Shares.MessagesUser, wantShares.MessagesUser)
|
||||
near("Shares.MessagesAsst", w.Shares.MessagesAsst, wantShares.MessagesAsst)
|
||||
near("Shares.ToolResultSubset", w.Shares.ToolResultSubset, wantShares.ToolResultSubset)
|
||||
|
||||
// TopTasks ordered by InputTokensTotal DESC: t-heavy (4000) then t-light (500).
|
||||
if len(summary.TopTasks) != 2 || summary.TopTasks[0].TaskID != "t-heavy" || summary.TopTasks[1].TaskID != "t-light" {
|
||||
t.Fatalf("TopTasks = %+v", summary.TopTasks)
|
||||
}
|
||||
|
||||
// Task filter narrows to t-light only.
|
||||
filtered, err := d.LLMContextSummary(LLMContextQuery{Days: 7, TaskID: "t-light", TopTasks: 5})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(filtered.ByWorkerModel) != 1 || filtered.ByWorkerModel[0].Worker != "planner" || len(filtered.TopTasks) != 1 {
|
||||
t.Fatalf("filtered summary = %+v", filtered)
|
||||
}
|
||||
}
|
||||
|
||||
// TestLLMContextRepresentativeFixtureReport runs a realistic multi-turn ARTEX
|
||||
// task fixture (planner rounds + deep worker intent execution + main-agent
|
||||
// follow-up) through InsertLLMContext and LLMContextSummary, verifying the
|
||||
// aggregation pipeline end-to-end and logging reproducible Phase A numbers.
|
||||
func TestLLMContextRepresentativeFixtureReport(t *testing.T) {
|
||||
d, err := Open(testDSN(t))
|
||||
if err != nil {
|
||||
SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer d.Close()
|
||||
|
||||
taskID := fmt.Sprintf("fixture-p35a-%d", time.Now().UnixNano())
|
||||
t.Cleanup(func() { _, _ = d.Exec(`DELETE FROM llm_context WHERE task_id=$1`, taskID) })
|
||||
|
||||
// Representative byte sizes modeled from ARTEX's actual plannerSystem (~12 KiB),
|
||||
// workerSystem (~11 KiB), tool schemas (~8-10 KiB for 12-16 tools), and real
|
||||
// multi-turn exploration trajectories (token estimate ~3.8 bytes/token).
|
||||
var fixture []LLMContext
|
||||
|
||||
// 5 planner rounds: ~12.5 KiB static system (includes {{.Now}} so cross-round cache misses
|
||||
// on first turn of each round), ~9.2 KiB tools (14 tools), situational graph overview growing
|
||||
// from 4 KiB to 14 KiB across rounds, 2 turns per round.
|
||||
for round := range 5 {
|
||||
overviewBytes := int64(4000 + round*2500)
|
||||
// Turn 1 of round: fresh session, cache miss (cache_write ~system+tools, cache_read 0)
|
||||
sysBytes := int64(12500)
|
||||
toolsBytes := int64(9200)
|
||||
in1 := int((sysBytes + toolsBytes + overviewBytes) / 4)
|
||||
fixture = append(fixture, LLMContext{
|
||||
TaskID: taskID, Worker: "planner", Model: "claude-sonnet-4", Profile: "fixture",
|
||||
ToolCount: 14, MessageCount: 1,
|
||||
SystemStaticBytes: sysBytes, ToolsBytes: toolsBytes,
|
||||
MessagesUserBytes: overviewBytes, LastMessageBytes: overviewBytes,
|
||||
InputTokens: in1, OutputTokens: 450, CacheRead: 0, CacheWrite: int((sysBytes + toolsBytes) / 4), Status: "ok",
|
||||
})
|
||||
// Turn 2 of round: after add_intent tool_result, prefix hits cache
|
||||
asstBytes := int64(1400)
|
||||
toolResBytes := int64(450)
|
||||
in2 := int((sysBytes + toolsBytes + overviewBytes + asstBytes + toolResBytes) / 4)
|
||||
fixture = append(fixture, LLMContext{
|
||||
TaskID: taskID, Worker: "planner", Model: "claude-sonnet-4", Profile: "fixture",
|
||||
ToolCount: 14, MessageCount: 3,
|
||||
SystemStaticBytes: sysBytes, ToolsBytes: toolsBytes,
|
||||
MessagesUserBytes: overviewBytes + toolResBytes, MessagesAssistantBytes: asstBytes,
|
||||
ToolResultBytes: toolResBytes, LastMessageBytes: toolResBytes,
|
||||
InputTokens: in2, OutputTokens: 320, CacheRead: in1, CacheWrite: 0, Status: "ok",
|
||||
})
|
||||
}
|
||||
|
||||
// 2 worker intents x 10 turns each: ~11 KiB system (embeds per-intent runDir + {{.Now}}),
|
||||
// ~10.5 KiB tools (16 tools), growing Bash/WebFetch tool_result outputs (avg ~5 KiB/turn).
|
||||
for range 2 {
|
||||
sysBytes := int64(11000)
|
||||
toolsBytes := int64(10500)
|
||||
userBytes := int64(6500) // launch overview + claimed intent
|
||||
asstBytes := int64(0)
|
||||
toolResTotal := int64(0)
|
||||
prevInput := 0
|
||||
for turn := range 10 {
|
||||
lastBytes := int64(6500)
|
||||
if turn > 0 {
|
||||
trChunk := int64(3500 + (turn%3)*2500) // realistic nmap/curl/ffuf tool outputs
|
||||
asstChunk := int64(900)
|
||||
userBytes += trChunk
|
||||
toolResTotal += trChunk
|
||||
asstBytes += asstChunk
|
||||
lastBytes = trChunk
|
||||
}
|
||||
totalB := sysBytes + toolsBytes + userBytes + asstBytes
|
||||
inTok := int(totalB / 4)
|
||||
cacheRead := prevInput
|
||||
cacheWrite := 0
|
||||
if turn == 0 {
|
||||
cacheRead = 0
|
||||
cacheWrite = int((sysBytes + toolsBytes) / 4)
|
||||
}
|
||||
fixture = append(fixture, LLMContext{
|
||||
TaskID: taskID, Worker: "worker", Model: "claude-sonnet-4", Profile: "fixture",
|
||||
ToolCount: 16, MessageCount: 1 + turn*2,
|
||||
SystemStaticBytes: sysBytes, ToolsBytes: toolsBytes,
|
||||
MessagesUserBytes: userBytes, MessagesAssistantBytes: asstBytes,
|
||||
ToolResultBytes: toolResTotal, LastMessageBytes: lastBytes,
|
||||
InputTokens: inTok, OutputTokens: 380, CacheRead: cacheRead, CacheWrite: cacheWrite, Status: "ok",
|
||||
})
|
||||
prevInput = inTok
|
||||
}
|
||||
}
|
||||
|
||||
for i := range fixture {
|
||||
if err := d.InsertLLMContext(&fixture[i]); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
summary, err := d.LLMContextSummary(LLMContextQuery{Days: 1, TaskID: taskID, TopTasks: 5})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(summary.ByWorkerModel) != 2 || len(summary.TopTasks) != 1 {
|
||||
t.Fatalf("unexpected fixture summary shape: %+v", summary)
|
||||
}
|
||||
for _, g := range summary.ByWorkerModel {
|
||||
t.Logf("FIXTURE [%s/%s] calls=%d in_total=%d p50=%.0f p90=%.0f max=%d cache_read_ratio=%.3f | sys_static=%.1f%% sys_dyn=%.1f%% tools=%.1f%% user=%.1f%% (tool_result=%.1f%%) asst=%.1f%%",
|
||||
g.Worker, g.Model, g.Calls, g.InputTokensTotal, g.InputP50, g.InputP90, g.InputMax, g.CacheReadRatio,
|
||||
g.Shares.SystemStatic*100, g.Shares.SystemDynamic*100, g.Shares.Tools*100,
|
||||
g.Shares.MessagesUser*100, g.Shares.ToolResultSubset*100, g.Shares.MessagesAsst*100)
|
||||
}
|
||||
}
|
||||
+21
-2
@@ -1,6 +1,7 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"sort"
|
||||
"strconv"
|
||||
"time"
|
||||
@@ -71,14 +72,32 @@ VALUES (NULLIF($1,''),$2,NULLIF($3,''),NULLIF($4,''),NULLIF($5,''),$6,$7,$8,$9,$
|
||||
// Accurate even with per-agent model bindings, pool rotation/failover, and
|
||||
// interrupted runs, since every call (success or error) is metered.
|
||||
func (d *DB) TokenByModel(taskID string) ([]ModelTokenStat, error) {
|
||||
rows, err := d.Query(`
|
||||
// Keep the predicate sargable for non-empty task IDs so PostgreSQL can use
|
||||
// idx_llm_usage_model(task_id, model) instead of sequentially scanning the
|
||||
// table via COALESCE(task_id, '').
|
||||
var (
|
||||
rows *sql.Rows
|
||||
err error
|
||||
)
|
||||
if taskID == "" {
|
||||
rows, err = d.Query(`
|
||||
SELECT COALESCE(NULLIF(model,''),'(unknown)') AS model, COUNT(*) AS calls,
|
||||
COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
|
||||
COALESCE(SUM(cache_read),0), COALESCE(SUM(cache_write),0)
|
||||
FROM llm_usage
|
||||
WHERE COALESCE(task_id,'') = $1
|
||||
WHERE task_id IS NULL OR task_id = ''
|
||||
GROUP BY model
|
||||
ORDER BY SUM(input_tokens) + SUM(output_tokens) DESC, model`)
|
||||
} else {
|
||||
rows, err = d.Query(`
|
||||
SELECT COALESCE(NULLIF(model,''),'(unknown)') AS model, COUNT(*) AS calls,
|
||||
COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
|
||||
COALESCE(SUM(cache_read),0), COALESCE(SUM(cache_write),0)
|
||||
FROM llm_usage
|
||||
WHERE task_id = $1
|
||||
GROUP BY model
|
||||
ORDER BY SUM(input_tokens) + SUM(output_tokens) DESC, model`, taskID)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
@@ -44,7 +44,7 @@ func TestCostSeparatesFreshReadAndWriteBuckets(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { d.Close() })
|
||||
priced, unpriced := costProfiles(t, d)
|
||||
// Every case adds 100k output tokens: 0.1 × 4.00 = 0.40.
|
||||
for _, tc := range []struct {
|
||||
@@ -82,7 +82,7 @@ func TestUsageByProfileCostAggregatesRows(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { d.Close() })
|
||||
priced, unpriced := costProfiles(t, d)
|
||||
t.Cleanup(func() { d.Exec(`DELETE FROM llm_usage WHERE profile_name IN ($1,$2)`, priced, unpriced) })
|
||||
rows := []LLMUsage{
|
||||
|
||||
+3
-3
@@ -123,7 +123,7 @@ func readApplied(t *testing.T, d *DB) []appliedMigration {
|
||||
// embedded migration is recorded with the SHA-256 of its file.
|
||||
func assertEmbeddedApplied(t *testing.T, d *DB) []appliedMigration {
|
||||
t.Helper()
|
||||
for _, table := range []string{"llm_records", "llm_usage"} {
|
||||
for _, table := range []string{"llm_records", "llm_usage", "llm_context"} {
|
||||
var exists bool
|
||||
if err := d.QueryRow(`SELECT to_regclass($1) IS NOT NULL`, table).Scan(&exists); err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -138,9 +138,9 @@ func assertEmbeddedApplied(t *testing.T, d *DB) []appliedMigration {
|
||||
name string
|
||||
}{{1, llmRecordsMigration}, {2, llmUsageMigration}, {3, "0003_task_scope_icp_index.sql"}, {4, "0004_llm_usage_ts_index.sql"},
|
||||
{5, "0005_traffic_rewrite_rules.sql"}, {6, "0006_activity_outbox.sql"}, {7, "0007_finding_report_state.sql"},
|
||||
{8, "0008_traffic_evidence_rewrite_flag.sql"}}
|
||||
{8, "0008_traffic_evidence_rewrite_flag.sql"}, {9, "0009_llm_context.sql"}, {10, "0010_dashboard_usage_indexes.sql"}}
|
||||
if len(applied) != len(want) {
|
||||
t.Fatalf("schema_migrations = %+v, want versions 1 to 8", applied)
|
||||
t.Fatalf("schema_migrations = %+v, want versions 1 to 10", applied)
|
||||
}
|
||||
for i, w := range want {
|
||||
content, err := fs.ReadFile(migrationsFS(), w.name)
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
-- Opt-in per-call LLM context size telemetry (ARTEX_CONTEXT_TELEMETRY=1).
|
||||
-- Records only byte sizes, counts, token usage, and metadata — never any
|
||||
-- prompt, tool, or message content.
|
||||
CREATE TABLE IF NOT EXISTS llm_context (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
ts TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
task_id TEXT,
|
||||
worker TEXT,
|
||||
model TEXT,
|
||||
profile TEXT,
|
||||
tool_count INTEGER NOT NULL DEFAULT 0,
|
||||
message_count INTEGER NOT NULL DEFAULT 0,
|
||||
system_static_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
system_dynamic_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
tools_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
messages_user_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
messages_assistant_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
messages_other_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
tool_result_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
last_message_bytes BIGINT NOT NULL DEFAULT 0,
|
||||
input_tokens INTEGER NOT NULL DEFAULT 0,
|
||||
output_tokens INTEGER NOT NULL DEFAULT 0,
|
||||
cache_read INTEGER NOT NULL DEFAULT 0,
|
||||
cache_write INTEGER NOT NULL DEFAULT 0,
|
||||
status TEXT NOT NULL DEFAULT 'ok'
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_llm_context_ts ON llm_context(ts);
|
||||
CREATE INDEX IF NOT EXISTS idx_llm_context_task ON llm_context(task_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_llm_context_worker_model ON llm_context(worker, model);
|
||||
@@ -0,0 +1,36 @@
|
||||
-- Partial covering indexes proved via EXPLAIN (ANALYZE, BUFFERS) on seeded
|
||||
-- production-shaped tables (P3.6 dashboard & usage query hygiene):
|
||||
--
|
||||
-- 1. idx_act_result_created: TokenDailyAll (db/exploration.go) aggregates
|
||||
-- activity WHERE kind='result' AND created_at >= now() - interval. The
|
||||
-- existing idx_act_result_usage is keyed on exploration_id, so date-bounded
|
||||
-- global daily rollups previously fell back to a bitmap heap scan across all
|
||||
-- result rows (~100x fewer shared buffers with an index-only scan).
|
||||
-- 2. idx_conv_act_result: ConversationTokenSummaries (db/conversation.go,
|
||||
-- polled every 5s by the dashboard) left-joins conversation_activities on
|
||||
-- (conversation_id) WHERE kind='result'. Without a partial index on
|
||||
-- kind='result', every poll sequentially scans the entire
|
||||
-- conversation_activities table (~65x fewer shared buffers).
|
||||
-- 3. idx_llm_usage_judge_ts: JudgeUsageStats (db/llm_usage.go) filters
|
||||
-- llm_usage WHERE worker='judge' (all-time and recent window). Judge rows
|
||||
-- are a small fraction of the append-only ledger; a partial covering index
|
||||
-- turns both queries into index-only scans (~60-80x fewer shared buffers).
|
||||
--
|
||||
-- Plain CREATE INDEX (migrations run in a transaction at startup before the
|
||||
-- HTTP server listens). Very large installs can pre-build them online with
|
||||
-- CREATE INDEX CONCURRENTLY IF NOT EXISTS before upgrading.
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_act_result_created
|
||||
ON activity(created_at)
|
||||
INCLUDE (input_tokens, output_tokens, cache_read_tokens)
|
||||
WHERE kind = 'result';
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_conv_act_result
|
||||
ON conversation_activities(conversation_id)
|
||||
INCLUDE (input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)
|
||||
WHERE kind = 'result';
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_llm_usage_judge_ts
|
||||
ON llm_usage(ts)
|
||||
INCLUDE (input_tokens, output_tokens, cache_read, cache_write)
|
||||
WHERE worker = 'judge';
|
||||
+17
-6
@@ -534,7 +534,7 @@ func TestSetFindingStatusWithNotifyOnlyEmitsOnRealChange(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(tk.ID)
|
||||
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
|
||||
es := d.Exploration(tk.ExplorationID)
|
||||
f, err := es.RecordFinding(ctx, RecordFindingInput{
|
||||
TaskID: tk.ID, Worker: "test", VulnClass: "SQL injection", Name: "status change case",
|
||||
@@ -543,7 +543,10 @@ func TestSetFindingStatusWithNotifyOnlyEmitsOnRealChange(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID) })
|
||||
t.Cleanup(func() {
|
||||
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID)
|
||||
_, _ = d.DeleteFinding(f.FindingID)
|
||||
})
|
||||
|
||||
// Writing the finding already registered one finding_created event; count it as the baseline.
|
||||
var base int
|
||||
@@ -617,7 +620,7 @@ func TestSetFindingStatusesWithNotify(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(tk.ID)
|
||||
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
|
||||
es := d.Exploration(tk.ExplorationID)
|
||||
record := func(name string) int64 {
|
||||
fi, err := es.RecordFinding(ctx, RecordFindingInput{
|
||||
@@ -627,7 +630,10 @@ func TestSetFindingStatusesWithNotify(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, fi.FindingID) })
|
||||
t.Cleanup(func() {
|
||||
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, fi.FindingID)
|
||||
_, _ = d.DeleteFinding(fi.FindingID)
|
||||
})
|
||||
return fi.FindingID
|
||||
}
|
||||
first, second := record("bulk one"), record("bulk two")
|
||||
@@ -891,7 +897,7 @@ func TestFinishFindingRetestEmitsStatusChange(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer d.DeleteTask(tk.ID)
|
||||
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
|
||||
es := d.Exploration(tk.ExplorationID)
|
||||
f, err := es.RecordFinding(ctx, RecordFindingInput{
|
||||
TaskID: tk.ID, Worker: "test", VulnClass: "SQL injection", Name: "retest target",
|
||||
@@ -900,7 +906,10 @@ func TestFinishFindingRetestEmitsStatusChange(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID) })
|
||||
t.Cleanup(func() {
|
||||
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID)
|
||||
_, _ = d.DeleteFinding(f.FindingID)
|
||||
})
|
||||
|
||||
// Create a retest record and drive it straight to completion.
|
||||
rt, _, _, err := d.CreateFindingRetest(ctx, f.FindingID, "review")
|
||||
@@ -910,6 +919,8 @@ func TestFinishFindingRetestEmitsStatusChange(t *testing.T) {
|
||||
if rt.ConversationID == nil {
|
||||
t.Fatal("a retest should be associated with a session")
|
||||
}
|
||||
retestConvID := *rt.ConversationID
|
||||
t.Cleanup(func() { _ = d.DeleteConversation(retestConvID) })
|
||||
// A retest must enter running before a verdict can land (consistent with the real flow).
|
||||
if ok, err := d.StartFindingRetest(ctx, rt.ID); err != nil || !ok {
|
||||
t.Fatalf("failed to start retest: ok=%v err=%v", ok, err)
|
||||
|
||||
@@ -154,19 +154,28 @@ func TestTaskArchiveDatabaseRoundTrip(t *testing.T) {
|
||||
VALUES($1,$2,0,'quota_exhausted','balance exhausted',$3,$4,$3)`, task.ID, llmProfileID, exhaustedAt, chainCreatedAt); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var assetID, findingID int64
|
||||
defer func() {
|
||||
_, _ = d.Exec(`DELETE FROM llm_usage WHERE task_id=$1 OR exploration_id=$2`, fmt.Sprint(task.ID), task.ExplorationID)
|
||||
_, _ = d.Exec(`DELETE FROM llm_records WHERE task_id=$1`, fmt.Sprint(task.ID))
|
||||
_, _ = d.Exec(`DELETE FROM skill_usage WHERE task_id=$1 OR exploration_id=$2`, task.ID, task.ExplorationID)
|
||||
_, _ = d.Exec(`DELETE FROM tool_usage WHERE task_id=$1 OR exploration_id=$2`, task.ID, task.ExplorationID)
|
||||
_, _ = d.DeleteFindingsByTask(task.ID)
|
||||
if findingID != 0 {
|
||||
_, _ = d.DeleteFinding(findingID)
|
||||
}
|
||||
_, _ = d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID)
|
||||
_ = d.DeleteTask(task.ID)
|
||||
if assetID != 0 {
|
||||
_, _ = d.Exec(`DELETE FROM assets WHERE id=$1`, assetID)
|
||||
}
|
||||
_, _ = d.Exec(`DELETE FROM llm_profiles WHERE id=$1`, llmProfileID)
|
||||
_, _ = d.Exec(`DELETE FROM companies WHERE id=$1`, companyID)
|
||||
}()
|
||||
if err := d.SetPaused(task.ID, true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assetID, err := d.Assets().UpsertRootDomain(UpsertRootDomainReq{Domain: fmt.Sprintf("archive-%d.example", task.ID), TaskID: task.ID})
|
||||
assetID, err = d.Assets().UpsertRootDomain(UpsertRootDomainReq{Domain: fmt.Sprintf("archive-%d.example", task.ID), TaskID: task.ID})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -197,7 +206,7 @@ VALUES($1,$2,0,'quota_exhausted','balance exhausted',$3,$4,$3)`, task.ID, llmPro
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := d.AddFinding(task.ID, nodeID, vulnclass, "archive finding", SeverityCritical, "summary", "evidence", "worker", []int64{assetID}); err != nil {
|
||||
if findingID, err = d.AddFinding(task.ID, nodeID, vulnclass, "archive finding", SeverityCritical, "summary", "evidence", "worker", []int64{assetID}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
archive, err := d.QueueTaskArchive(task.ID)
|
||||
|
||||
@@ -168,8 +168,9 @@ func TestIntentAssetsIncludesDirectSourceProvenance(t *testing.T) {
|
||||
cleanupErr(t, "source task", d.DeleteTask(source.ID))
|
||||
})
|
||||
|
||||
intentHost := fmt.Sprintf("intent-%d.example.test", time.Now().UnixNano())
|
||||
assetID, err := d.Assets().UpsertHTTPService(UpsertHTTPServiceReq{
|
||||
URL: fmt.Sprintf("https://intent-%d.example.test", time.Now().UnixNano()), TaskID: source.ID,
|
||||
URL: "https://" + intentHost, TaskID: source.ID,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
@@ -177,6 +178,9 @@ func TestIntentAssetsIncludesDirectSourceProvenance(t *testing.T) {
|
||||
t.Cleanup(func() {
|
||||
_, err := d.Assets().DeleteByIDs([]int64{assetID})
|
||||
cleanupErr(t, "asset", err)
|
||||
// UpsertHTTPService also creates the parent subdomain and root_domain rows.
|
||||
_, err = d.Exec(`DELETE FROM assets WHERE domain IN ($1, 'example.test')`, intentHost)
|
||||
cleanupErr(t, "parent assets", err)
|
||||
})
|
||||
intentID, err := d.Exploration(source.ExplorationID).AddIntent(map[string]any{"summary": "source worker"}, 5, []int64{assetID}, "planner")
|
||||
if err != nil {
|
||||
|
||||
@@ -13,7 +13,7 @@ func TestTaskLLMSpendCountsJudgeNotChat(t *testing.T) {
|
||||
if err != nil {
|
||||
SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer d.Close()
|
||||
t.Cleanup(func() { _ = d.Close() })
|
||||
|
||||
taskID := fmt.Sprintf("spend-%d", time.Now().UnixNano())
|
||||
t.Cleanup(func() {
|
||||
|
||||
@@ -38,6 +38,8 @@ services:
|
||||
ARTEX_LLM_MODEL: ${ARTEX_LLM_MODEL:-}
|
||||
ARTEX_LLM_BASE_URL: ${ARTEX_LLM_BASE_URL:-}
|
||||
ARTEX_LLM_PROXY: ${ARTEX_LLM_PROXY:-}
|
||||
# Exact host:port list the model-list fetch may reach on private addresses (e.g. host.docker.internal:11434 for Ollama).
|
||||
ARTEX_LLM_PRIVATE_ENDPOINTS: ${ARTEX_LLM_PRIVATE_ENDPOINTS:-}
|
||||
ARTEX_JWT_KEY_DIR: /app/keys
|
||||
# Optional: key for secrets at rest; empty = keys/secret.key (generated at first start).
|
||||
ARTEX_SECRET_KEY: ${ARTEX_SECRET_KEY:-}
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
# LLM Context Size Telemetry (P3.5 Phase A)
|
||||
|
||||
`ARTEX_CONTEXT_TELEMETRY=1` enables opt-in, size-only per-call telemetry for every `llmrec` `Stream` and `Complete` call. It is **disabled by default**: when off, no request sizing runs and no rows are written to PostgreSQL.
|
||||
|
||||
This phase measures context composition without changing any prompt, compaction policy, or model behavior, so Phases B (`ARTEX_BOUNDED_CONTEXT`) and C (`ARTEX_CACHE_PREFIX` / `ARTEX_COMPACTION_MEMO`) can be evaluated against real numbers first.
|
||||
|
||||
---
|
||||
|
||||
## Configuration
|
||||
|
||||
| Environment variable | Values | Default |
|
||||
|---|---|---|
|
||||
| `ARTEX_CONTEXT_TELEMETRY` | `1`, `true`, `on`, `yes` (case-insensitive) | off |
|
||||
|
||||
Telemetry runs independently of `llm_record` (`recordBodies`): enabling `ARTEX_CONTEXT_TELEMETRY=1` works even when full request/response body recording is disabled, and stores **no prompt, tool, or message content** — only byte lengths, counts, token usage, and metadata.
|
||||
|
||||
### Stopping, retention, and write cost
|
||||
|
||||
When `ARTEX_CONTEXT_TELEMETRY=1` is active, each LLM call incurs one lightweight `INSERT` into `llm_context` (~200 bytes/row plus index entries, no bodies), so the table grows by one row per completion call. Unset `ARTEX_CONTEXT_TELEMETRY` (and restart) once the measurement campaign is finished to stop all writes and sizing work, or purge old rows periodically:
|
||||
|
||||
```sql
|
||||
DELETE FROM llm_context WHERE ts < now() - interval '30 days';
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Measurement Semantics (`llmrec.MeasureContext`)
|
||||
|
||||
Every enabled `Stream` and `Complete` call measures the assembled `llm.CompletionRequest` right before it is handed to the inner provider, and persists one row to `llm_context` (migration `0009_llm_context.sql`) on completion or error:
|
||||
|
||||
- **`system_static_bytes` & `system_dynamic_bytes`**:
|
||||
- `norma`'s `CompletionRequest.System` is a slice of segments that `llm.joinSystem` trims (`strings.TrimSpace`), drops when empty, and joins with blank lines (`"\n\n"`). `MeasureContext` applies the exact same trim, drop-empty, and `"\n\n"` join rules per slice.
|
||||
- When `DynamicBoundary > 0`, `System` is split at `b = min(DynamicBoundary, len(System))`: `System[:b]` is measured into `system_static_bytes` and `System[b:]` into `system_dynamic_bytes`.
|
||||
- When `DynamicBoundary <= 0`, there is no provider-visible cache split, so the entire `System` slice is measured as one block in `system_static_bytes` and `system_dynamic_bytes` is `0`.
|
||||
- **Why this choice**: `agent/deferred.go` returns `boundary = 0` when no global deferred-MCP block exists and `boundary = len(system)` when one does. Placing the single unsplit block in `system_static_bytes` ensures `system_static_bytes + system_dynamic_bytes` always equals total system bytes and `system_dynamic_bytes > 0` strictly signals a dynamic suffix placed after a cache breakpoint.
|
||||
- **`tool_count` & `tools_bytes`**: `len(req.Tools)` and `len(json.Marshal(req.Tools))` (`0` when no tools). Go's `encoding/json` sorts map keys deterministically.
|
||||
- **`message_count`, `messages_user_bytes`, `messages_assistant_bytes`, `messages_other_bytes`, `last_message_bytes`**: each `llm.Message` is measured by `len(json.Marshal(msg))` and accumulated by role (`user`, `assistant`, or other); `last_message_bytes` is the serialized byte size of the final message.
|
||||
- **`tool_result_bytes`**: serialized byte length of `tool_result` content blocks inside messages. Reported as an **informational subset** of `messages_user_bytes` (not added to the partition denominator, avoiding double counting).
|
||||
|
||||
### Pro-rata token attribution
|
||||
|
||||
Rather than shipping per-provider tokenizers, each section's share of real `input_tokens` is computed per call by byte proportion:
|
||||
|
||||
```text
|
||||
total_bytes(call) = system_static_bytes + system_dynamic_bytes + tools_bytes
|
||||
+ messages_user_bytes + messages_assistant_bytes + messages_other_bytes
|
||||
|
||||
share(section) = SUM(input_tokens * (section_bytes / total_bytes))
|
||||
/ SUM(input_tokens) -- over calls with total_bytes > 0 and input_tokens > 0
|
||||
```
|
||||
|
||||
The six partition shares sum to `1.0`. `cache_read_ratio = SUM(cache_read) / NULLIF(SUM(input_tokens), 0)` (in ARTEX/Norma, `input_tokens` already includes cached tokens).
|
||||
|
||||
---
|
||||
|
||||
## Querying & Aggregation
|
||||
|
||||
### HTTP endpoint (admin JWT required, no UI in Phase A)
|
||||
|
||||
```text
|
||||
GET /api/llm/context/summary?days=30&top=20&task=<optional-task-id>
|
||||
```
|
||||
|
||||
Returns `enabled`, `by_worker_model` (calls, totals, `cache_read_ratio`, `input_p50`/`p90`/`p99`/`max`, avg tool/message/last-message size, and pro-rata `shares`), and `top_tasks` ordered by total `input_tokens`.
|
||||
|
||||
### Standalone SQL query (`psql`)
|
||||
|
||||
```sql
|
||||
WITH base AS (
|
||||
SELECT *,
|
||||
(system_static_bytes + system_dynamic_bytes + tools_bytes
|
||||
+ messages_user_bytes + messages_assistant_bytes + messages_other_bytes) AS total_bytes
|
||||
FROM llm_context
|
||||
WHERE ts >= now() - interval '30 days'
|
||||
)
|
||||
SELECT COALESCE(NULLIF(worker,''), '(unknown)') AS worker,
|
||||
COALESCE(NULLIF(model,''), '(unknown)') AS model,
|
||||
COUNT(*) AS calls,
|
||||
SUM(input_tokens) AS input_tokens,
|
||||
ROUND((SUM(cache_read)::numeric / NULLIF(SUM(input_tokens), 0))::numeric, 3) AS cache_read_ratio,
|
||||
PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY input_tokens) AS p50_input,
|
||||
PERCENTILE_CONT(0.90) WITHIN GROUP (ORDER BY input_tokens) AS p90_input,
|
||||
PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY input_tokens) AS p99_input,
|
||||
ROUND((SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens * (system_static_bytes::double precision / total_bytes) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0))::numeric, 3) AS share_sys_static,
|
||||
ROUND((SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens * (system_dynamic_bytes::double precision / total_bytes) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0))::numeric, 3) AS share_sys_dynamic,
|
||||
ROUND((SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens * (tools_bytes::double precision / total_bytes) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0))::numeric, 3) AS share_tools,
|
||||
ROUND((SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens * (messages_user_bytes::double precision / total_bytes) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0))::numeric, 3) AS share_user,
|
||||
ROUND((SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens * (tool_result_bytes::double precision / total_bytes) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0))::numeric, 3) AS share_tool_result_subset,
|
||||
ROUND((SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens * (messages_assistant_bytes::double precision / total_bytes) ELSE 0 END)
|
||||
/ NULLIF(SUM(CASE WHEN total_bytes > 0 AND input_tokens > 0 THEN input_tokens::double precision ELSE 0 END), 0))::numeric, 3) AS share_assistant
|
||||
FROM base
|
||||
GROUP BY 1, 2
|
||||
ORDER BY input_tokens DESC;
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Phase A Baseline Report & Recommendation on Phases B and C
|
||||
|
||||
> **Measurement scope note**: No live production LLM run was executed in this local verification environment. The figures below come from the reproducible representative fixture in `db/llm_context_test.go` (`TestLLMContextRepresentativeFixtureReport`), parameterized from ARTEX's actual `plannerSystem` (~12.5 KiB), `workerSystem` (~11 KiB), tool schema sets (14–16 tools, ~9–10.5 KiB), 5 planner rounds (2 turns each), and 2 worker intents (10 turns each with 3.5–8.5 KiB Bash/tool outputs), combined with a static audit of `agent/planner.go`, `agent/worker.go`, `agent/prompt.go`, and `agent/deferred.go`. Operators should capture 3–5 real tasks with `ARTEX_CONTEXT_TELEMETRY=1` before flipping Phases B or C on by default.
|
||||
|
||||
### Representative Fixture Breakdown
|
||||
|
||||
| Lane / Model | Calls | Total Input | p50 / p90 / Max | Cache Read Ratio | `sys_static` | `sys_dynamic` | `tools` | `user` (`tool_result` subset) | `assistant` |
|
||||
|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
|
||||
| `worker` / `claude-sonnet-4` | 20 | 299,000 | 15,075 / 21,535 / 22,525 | 84.9% | 18.4% | 0.0% | 17.6% | 57.3% (`46.4%`) | 6.8% |
|
||||
| `planner` / `claude-sonnet-4` | 10 | 79,060 | 7,906 / 8,971 / 9,387 | 48.5% | 39.5% | 0.0% | 29.1% | 29.2% (`0.7%`) | 2.2% |
|
||||
|
||||
### Explicit Recommendations
|
||||
|
||||
#### Phase B — Bounded Context (`ARTEX_BOUNDED_CONTEXT`)
|
||||
- **Recommendation: Proceed (opt-in first), highest ROI on deep `worker` runs.**
|
||||
- **Expected gain**: In the representative worker trajectory, `messages_user` accounts for **57.3%** of total input tokens, with **`tool_result` outputs alone representing 46.4%** (and growing quadratically across turns on long Bash/scanner sessions). Bounding/compacting old tool outputs on workers (keeping recent turns verbatim and summarizing/truncating stale `tool_result` payloads) targets the largest single token sink (realistic 25–45% input-token reduction on 10–30 turn workers, and lower p90/p99 latency).
|
||||
- **Risk**: Aggressive trimming of earlier tool outputs can drop credentials, endpoints, or exact error lines needed for exploit chaining or evidence binding, and mutating earlier messages inside a live multi-turn session **invalidates the prompt cache prefix** (turning cheap `cache_read` turns into uncached re-prefills if triggered too frequently). Bound only at explicit compaction boundaries or spill large `tool_result` bodies at insertion time before they enter the cached prefix.
|
||||
|
||||
#### Phase C — Cache Prefix Stabilization (`ARTEX_CACHE_PREFIX` / `ARTEX_COMPACTION_MEMO`)
|
||||
- **Recommendation: Proceed with a surgical `worker` prefix split (`ARTEX_CACHE_PREFIX`); verify `planner` cross-round cache behavior and `ARTEX_COMPACTION_MEMO` with live `ARTEX_CONTEXT_TELEMETRY=1` data before changing them.**
|
||||
- **Actual system-prompt volatility by lane (built-in prompts)**:
|
||||
|
||||
`system_dynamic` is **0.0%** across all lanes today because `agent/deferred.go` sets `DynamicBoundary = 0` (no global deferred MCP) or `len(system)` (everything before the boundary). Auditing the built-in templates and assembly in `agent/worker.go` and `agent/planner.go` shows what actually varies:
|
||||
|
||||
| Lane | Stable per task | Volatile per intent / round |
|
||||
|---|---|---|
|
||||
| `worker` | Base `workerDefaultTmpl` (`ProxyAddr`, `DataDir`), `untrustedContentTail`, `workerTrafficBlock`, `noiseProfileBlock`, `frameLessonsBlock` (task-level), `constraintBlock` (task-level, stable unless operator edits constraints), `def.FindingGuidance`, `<available-deferred-tools>` | `workerArtifactSpec(runDir)` (`tasks/<id>/i<intentID>`), `renderIntentTask(intent)`, intent target-assets JSON block, closing launch instruction |
|
||||
| `planner` | `plannerSystem` (`goal`, `dataDir`, `workDir`/`taskDir`, `untrustedDataRules`, `artifactSpec(taskDir)`, `noiseProfileBlock`), `frameLessonsBlock`, `def.FindingGuidance`, `<available-deferred-tools>` | `constraintBlock(ts)` is recomputed each round (stable unless operator changes constraints; situational graph overview already lives in the user turn) |
|
||||
| Custom prompts only | — | `{{.Now}}` (`agent/prompt.go:46`, 1-second resolution). Built-in templates do **not** reference `{{.Now}}` (Go's `text/template` ignores the unused `Now` field); it only affects operator-customized prompts that explicitly use `{{.Now}}`. |
|
||||
|
||||
- **Expected gain**:
|
||||
- **`worker` turn-1 cache reuse (real, code-backed)**: Today `workerArtifactSpec(runDir)` is concatenated into the single `sysBody` before `noiseProfileBlock`, lessons, constraints, `renderIntentTask(intent)`, and the target-assets block, so every sibling worker spawn busts the prompt cache from `runDir` onward. The minimal `ARTEX_CACHE_PREFIX=1` split shipped in Phase C places the prefix before `workerArtifactSpec(runDir)` (`body` + `untrustedContentTail` + `workerTrafficBlock`) **before** `DynamicBoundary = 1` (`system_static`) and leaves everything from `workerArtifactSpec(runDir)` onward (`workerArtifactSpec(runDir)` + `noiseProfileBlock` + lessons + constraints + `renderIntentTask(intent)` + target assets JSON + closing launch line + `def.FindingGuidance` + `<available-deferred-tools>`) **after** `DynamicBoundary = 1` (`system_dynamic`) in its exact original order. This keeps the visible joined prompt byte-identical and keeps the intent protected from compaction inside `System` while allowing sibling workers in the same task to share the cached `system_static + tools` prefix on turn 1 (in the fixture, `system + tools` is 36.0% of aggregate worker input and ~76.8% of turn-1 input, 21.5 KiB / 28.0 KiB, though the fixture does not isolate the per-intent suffix; measure the exact shareable prefix live). Moving the remaining task-stable blocks (`noiseProfileBlock`, lessons, constraints, `def.FindingGuidance`, `<available-deferred-tools>`) before the boundary would require reordering sections relative to `workerArtifactSpec(runDir)` and is left as a potential future optimization outside this PR.
|
||||
- **`planner` cross-round cache ratio (unverified hypothesis)**: The fixture above assumed a turn-1 cache miss on every planner round (yielding 48.5%), which is **not** demonstrated by the built-in code because `plannerSystem` is stable per task. Real cross-round misses could still happen from provider cache TTL expiry between rounds, constraint edits, or tool-RAG tool-list churn — treat any planner cache gain as a hypothesis to measure with `ARTEX_CONTEXT_TELEMETRY=1` on real tasks rather than a proven savings.
|
||||
- **Risk**: Low for the `worker` `ARTEX_CACHE_PREFIX` split (pure boundary split using `norma`'s existing `DynamicBoundary` contract, with zero text reordering; custom prompts using `{{.Now}}` stay an explicit edge case). Medium for `ARTEX_COMPACTION_MEMO` (injecting compaction memos alters model reasoning continuity and only pays off on tasks that repeatedly trigger compaction — verify with live `ARTEX_CONTEXT_TELEMETRY=1` data first).
|
||||
|
||||
---
|
||||
|
||||
## Phase C: Worker Cache Prefix Split (`ARTEX_CACHE_PREFIX=1`)
|
||||
|
||||
`ARTEX_CACHE_PREFIX=1` (accepts `1`, `true`, `on`, `yes`, case-insensitive; **off by default**) enables a minimal, zero-reordering system-prompt split for the **`worker`** lane only so sibling workers in the same task share a cacheable static prefix without changing the text visible to the model:
|
||||
|
||||
- **Static segment (`System[0]`, before `DynamicBoundary = 1`)**: `body + untrustedContentTail + workerTrafficBlock`.
|
||||
- **Dynamic segment (`System[1]`, after `DynamicBoundary = 1`)**: `workerArtifactSpec(runDir) + noiseProfileBlock + lessons + constraints + renderIntentTask(intent) + target assets + launch instruction + FindingGuidance + <available-deferred-tools>` (in exact original order). The leading `"\n\n"` from `workerArtifactSpec` is absorbed because providers join segments with `"\n\n"`, keeping `strings.Join(System, "\n\n")` byte-identical to the legacy unsplit prompt.
|
||||
- **Unchanged**: When `ARTEX_CACHE_PREFIX` is unset/false, worker segments and `DynamicBoundary` are byte-identical to the legacy layout. `planner`, `mainagent`, `chat`, and `goals` are completely unchanged regardless of the flag.
|
||||
- **Custom prompts caveat**: The split covers only the built-in suffix starting at `workerArtifactSpec(runDir)`. If an operator customizes the `worker` prompt in the database to include `{{.Now}}` (1-second resolution), that timestamp remains inside `System[0]` and will keep the static prefix volatile across spawns.
|
||||
- **Measuring live impact**: Enable both `ARTEX_CONTEXT_TELEMETRY=1` and `ARTEX_CACHE_PREFIX=1` on real tasks and compare `system_static` / `system_dynamic` shares and `cache_read_ratio` via `GET /api/llm/context/summary`.
|
||||
@@ -0,0 +1,25 @@
|
||||
[Unit]
|
||||
Description=ARTEX application
|
||||
After=network.target
|
||||
StartLimitIntervalSec=60
|
||||
StartLimitBurst=5
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=artex
|
||||
Group=artex
|
||||
WorkingDirectory=/opt/artex
|
||||
Environment=ARTEX_JWT_KEY_DIR=/opt/artex/keys
|
||||
ExecStart=/opt/artex/artex -addr 127.0.0.1:8787 -proxy 127.0.0.1:8788
|
||||
Restart=on-failure
|
||||
RestartSec=5s
|
||||
TimeoutStopSec=30s
|
||||
KillSignal=SIGTERM
|
||||
KillMode=control-group
|
||||
UMask=0002
|
||||
StandardOutput=journal
|
||||
StandardError=journal
|
||||
SyslogIdentifier=artex
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -0,0 +1,178 @@
|
||||
# Local ARTEX systemd deployment
|
||||
|
||||
This guide describes how to deploy ARTEX locally under `systemd` using the example unit at `docs/examples/artex.service`.
|
||||
|
||||
## Placeholders and defaults
|
||||
|
||||
The example unit uses these defaults; replace them if your host uses different paths or names:
|
||||
|
||||
- Install directory (`<install-dir>`): `/opt/artex` (executable at `/opt/artex/artex`).
|
||||
- System user and group (`<artex-user>`): `artex` (non-root).
|
||||
- PostgreSQL service unit (`<pg-unit>`): distribution-specific — for example `postgresql.service` on RHEL/Fedora/Arch or `postgresql@<pg-version>-<pg-cluster>.service` on Debian/Ubuntu (where `<pg-version>/<pg-cluster>` comes from `pg_lsclusters`, such as `18/main`).
|
||||
- Configuration: `<install-dir>/config.json`, ignored by Git, owner-only mode `0600`.
|
||||
- Web UI: `http://127.0.0.1:8787`; recording proxy: `127.0.0.1:8788`.
|
||||
- Example unit file: `docs/examples/artex.service`; installed at `/etc/systemd/system/artex.service`.
|
||||
|
||||
## System user and directory permissions
|
||||
|
||||
Create a dedicated non-login system user and group before installing the binary:
|
||||
|
||||
```bash
|
||||
sudo useradd --system --user-group --home-dir /opt/artex --shell /usr/sbin/nologin artex
|
||||
```
|
||||
|
||||
Create the install, runtime data, and key directories with explicit ownership and modes:
|
||||
|
||||
```bash
|
||||
sudo install -d -o root -g artex -m 0755 /opt/artex
|
||||
sudo install -d -o artex -g artex -m 0770 /opt/artex/data
|
||||
sudo install -d -o artex -g artex -m 0700 /opt/artex/keys
|
||||
```
|
||||
|
||||
Directory ownership and modes:
|
||||
|
||||
- `<install-dir>` (`/opt/artex`): `root:<artex-user>`, mode `0755` (executable `/opt/artex/artex` mode `0755`).
|
||||
- `<install-dir>/data` (`/opt/artex/data`): `<artex-user>:<artex-user>`, mode `0770` so the service user (and, in a root-run deployment using an executor group, that group) can write task run directories while blocking world access.
|
||||
- `<install-dir>/keys` (`/opt/artex/keys`): `<artex-user>:<artex-user>`, mode `0700`. Holds `jwt.key` and `secret.key` (mode `0600`) outside the browsable `data/` directory. `docs/examples/artex.service` sets `Environment=ARTEX_JWT_KEY_DIR=/opt/artex/keys` so the non-root service writes key files here rather than into `root`-owned `/opt/artex` (if `ARTEX_JWT_KEY_DIR` were left unset, ARTEX would fall back to `<install-dir>` and fail to create `jwt.key` and `secret.key` when `<install-dir>` is `root:<artex-user>` `0755`).
|
||||
- `<install-dir>/config.json` (`/opt/artex/config.json`): `<artex-user>:<artex-user>`, mode `0600`.
|
||||
|
||||
## Database and credentials
|
||||
|
||||
Install PostgreSQL on the host (or use an existing reachable PostgreSQL instance) and create a dedicated non-superuser login role and database named `artex` with no role-creation or database-creation privileges.
|
||||
|
||||
On Debian/Ubuntu, confirm the cluster name (`<pg-version>/<pg-cluster>`) with `pg_lsclusters`, start `<pg-unit>`, and create the role and database if absent:
|
||||
|
||||
```bash
|
||||
sudo systemctl start <pg-unit>
|
||||
sudo -u postgres createuser --pwprompt artex
|
||||
sudo -u postgres createdb --owner=artex artex
|
||||
```
|
||||
|
||||
Enter a unique password at the prompt. In `<install-dir>/config.json`, set `database.host` to `127.0.0.1`, `port` to `5432`, `user` and `dbname` to `artex`, `password` to that secret, and `sslmode` to `disable` (disabling TLS is appropriate only for loopback traffic). Preserve other settings and restrict access:
|
||||
|
||||
```bash
|
||||
sudo chown artex:artex /opt/artex/config.json
|
||||
sudo chmod 0600 /opt/artex/config.json
|
||||
```
|
||||
|
||||
`ARTEX_PG_DSN`, if set in a systemd drop-in override, takes precedence over `config.json`. Never commit configuration, credentials, encryption/signing keys, or startup logs.
|
||||
|
||||
## Build and install
|
||||
|
||||
The binary embeds the UI when built with `-tags embedui`. To rebuild the UI from a source checkout, run `npm ci` and `npm run build:static` in `web/`, create the parent directory with `mkdir -p server/webui`, and replace `server/webui/dist` with `web/out`. Build the binary with:
|
||||
|
||||
```bash
|
||||
CGO_ENABLED=0 go build -tags embedui -trimpath -o artex ./cmd/artex
|
||||
```
|
||||
|
||||
Install the binary into `<install-dir>`:
|
||||
|
||||
```bash
|
||||
sudo install -o root -g artex -m 0755 artex /opt/artex/artex
|
||||
```
|
||||
|
||||
For a running deployment, build into a separate staging path and stop the service before replacing `/opt/artex/artex` or generated assets. Avoid rerunning `install.sh` without reviewing its prompts: it regenerates `config.json` and starts a separate process.
|
||||
|
||||
Review `User`, `Group`, `WorkingDirectory`, `Environment=ARTEX_JWT_KEY_DIR=...`, and `ExecStart` in `docs/examples/artex.service` before installing it on your host:
|
||||
|
||||
```bash
|
||||
systemd-analyze verify docs/examples/artex.service
|
||||
sudo install -o root -g root -m 0644 docs/examples/artex.service /etc/systemd/system/artex.service
|
||||
sudo systemctl daemon-reload
|
||||
```
|
||||
|
||||
### Database dependency and environment overrides
|
||||
|
||||
`docs/examples/artex.service` intentionally declares only `After=network.target` and does not hardcode a distribution-specific PostgreSQL unit (such as Debian's `postgresql@<pg-version>-<pg-cluster>.service`), so it works across Linux distributions and with remote PostgreSQL servers.
|
||||
|
||||
When PostgreSQL runs locally on the same host, add a systemd drop-in (`sudo systemctl edit artex.service`) so ARTEX starts after and depends on your local PostgreSQL unit:
|
||||
|
||||
```ini
|
||||
[Unit]
|
||||
Requires=<pg-unit>
|
||||
After=<pg-unit>
|
||||
```
|
||||
|
||||
For example, set `<pg-unit>` to `postgresql.service` on RHEL/Fedora/Arch, or to `postgresql@<pg-version>-<pg-cluster>.service` on Debian/Ubuntu (and verify `/etc/postgresql/<pg-version>/<pg-cluster>/start.conf` is `auto`, not `disabled`). `ARTEX_JWT_KEY_DIR=/opt/artex/keys` is already set in `docs/examples/artex.service`; override it in the drop-in only if you install ARTEX under a different `<install-dir>`. Run `sudo systemctl daemon-reload` after editing the drop-in.
|
||||
|
||||
### Enable and start
|
||||
|
||||
If ARTEX is running outside `systemd`, identify its PID/executable and send that verified process `SIGTERM`. Wait for shutdown and release of ports `8787` and `8788` before enabling the service:
|
||||
|
||||
```bash
|
||||
ss -ltnp '( sport = :8787 or sport = :8788 )'
|
||||
sudo systemctl enable --now artex.service
|
||||
systemctl status artex.service --no-pager
|
||||
curl --fail --silent --show-error http://127.0.0.1:8787/api/health
|
||||
```
|
||||
|
||||
The unit runs `/opt/artex/artex` directly without an extra supervisor script. It starts after `network.target`, restarts on failure after five seconds, allows 30 seconds for graceful shutdown, logs to the journal, and uses `UMask=0002` (rather than `0077`, which would block group writes in a root-run deployment where executor privilege drop sets umask `002` for the executor group; sensitive files such as `config.json`, `keys/jwt.key`, and `keys/secret.key` are protected explicitly with `0600`/`0700` permissions). Five starts within 60 seconds trigger the start limit.
|
||||
|
||||
### Agent isolation
|
||||
|
||||
Because `docs/examples/artex.service` runs the server as the non-root `<artex-user>` (`User=artex`), the `-exec-uid`/`-exec-gid` privilege drop cannot be applied: `ResolveExecPrivilege` disables the drop when the server is not root (and errors if those flags are passed explicitly). The example unit deliberately omits `-exec-uid`/`-exec-gid`, so agents and spawned tools run under the `<artex-user>` service identity rather than a separate executor account. The root-owned run-directory layout and executor-group containment exist only when the server runs as root with explicit `-exec-uid`/`-exec-gid`; if you require unprivileged-executor containment, use the Docker deployment, which is the supported path for that isolation model.
|
||||
|
||||
## Web setup
|
||||
|
||||
On a new database, visit `http://127.0.0.1:8787/setup`, provide the one-time setup token from the private startup log or journal (`journalctl -u artex.service`), and choose a unique password of at least 12 characters. The username is `ARTEX`. Store the password in your password manager rather than in a plaintext file on disk.
|
||||
|
||||
## Reboot persistence verification (example)
|
||||
|
||||
Pre-reboot checks confirm persistent ARTEX enablement, active PostgreSQL and ARTEX services, HTTP 200 health, and initialized authentication, but do not by themselves prove survival across a reboot.
|
||||
|
||||
To verify reboot persistence on a host, record the current boot ID and timestamp in an ignored runtime file such as `<install-dir>/data/reboot-verification-baseline.json` before rebooting, and do not overwrite that baseline until the test is complete:
|
||||
|
||||
```bash
|
||||
sudo -u artex python3 -c 'import json, time; from pathlib import Path; Path("/opt/artex/data/reboot-verification-baseline.json").write_text(json.dumps({"boot_id": Path("/proc/sys/kernel/random/boot_id").read_text().strip(), "ts": time.time()}))'
|
||||
```
|
||||
|
||||
Save other work before rebooting; this disconnects local and remote sessions:
|
||||
|
||||
```bash
|
||||
sudo systemctl reboot
|
||||
```
|
||||
|
||||
After reconnecting, do not manually start ARTEX before checking automatic startup. Compare the current boot ID with the saved baseline and check the services:
|
||||
|
||||
```bash
|
||||
cd /opt/artex
|
||||
python3 -c 'import json; from pathlib import Path; old=json.loads(Path("data/reboot-verification-baseline.json").read_text())["boot_id"]; new=Path("/proc/sys/kernel/random/boot_id").read_text().strip(); print("PASS: a reboot occurred" if old != new else "FAIL: no reboot occurred"); raise SystemExit(0 if old != new else 1)'
|
||||
systemctl is-enabled artex.service
|
||||
systemctl is-active <pg-unit> artex.service
|
||||
curl --fail --silent --show-error http://127.0.0.1:8787/api/health
|
||||
python3 -c 'import json, urllib.request; r=json.load(urllib.request.urlopen("http://127.0.0.1:8787/api/auth/status", timeout=5)); print("Authentication initialized:", r.get("initialized")); raise SystemExit(0 if r.get("initialized") else 1)'
|
||||
systemctl show artex.service --no-pager -p ActiveState -p SubState -p MainPID -p ActiveEnterTimestamp
|
||||
```
|
||||
|
||||
Success requires a changed boot ID, enabled ARTEX, both services active without manual startup, HTTP 200, and authentication still initialized. A new PID alone is not proof of reboot. If the system has just booted, allow startup time and repeat health checks. Refresh the baseline before running a future independent reboot test.
|
||||
|
||||
### Example reboot verification record
|
||||
|
||||
Example of a completed post-reboot verification (recorded from the original Debian/PostgreSQL 18 reference deployment on 2026-11-17, without manually starting or restarting either service):
|
||||
|
||||
- Current boot ID differed from the saved pre-reboot baseline, confirming an actual reboot.
|
||||
- `artex.service` remained enabled and was `active (running)` under its non-root service user with `NRestarts=0`.
|
||||
- The local PostgreSQL cluster service was `active`.
|
||||
- `/api/health` returned HTTP 200.
|
||||
- `/api/auth/status` confirmed initialized authentication was preserved.
|
||||
|
||||
Observed timestamps, PIDs, and restart counts are host-specific examples, not fixed configuration values.
|
||||
|
||||
## Operations and troubleshooting
|
||||
|
||||
```bash
|
||||
sudo systemctl restart artex.service
|
||||
sudo systemctl stop artex.service
|
||||
sudo systemctl start artex.service
|
||||
journalctl -b -u artex.service --no-pager
|
||||
journalctl -u artex.service -f
|
||||
```
|
||||
|
||||
Treat journal output as potentially sensitive; never share unredacted setup tokens or credentials. If startup fails, check PostgreSQL status, database settings and permissions on `<install-dir>/config.json`, `<install-dir>/data`, and `<install-dir>/keys`, occupied ports (`8787`/`8788`), and the journal. After a PostgreSQL dependency failure, restart ARTEX explicitly once the database is healthy. To recover from the start limit:
|
||||
|
||||
```bash
|
||||
sudo systemctl reset-failed artex.service
|
||||
sudo systemctl start artex.service
|
||||
```
|
||||
|
||||
Back up PostgreSQL, `<install-dir>/config.json`, `<install-dir>/data`, and `<install-dir>/keys` (`jwt.key` and `secret.key`) securely before upgrades. The application stays loopback-only; remote access requires a separately reviewed tunnel or reverse proxy.
|
||||
@@ -0,0 +1,130 @@
|
||||
# Traffic HAR 1.2 Import and Export
|
||||
|
||||
ARTEX supports importing and exporting captured HTTP traffic using the **HAR 1.2** JSON format so operators can bring captures from browser DevTools or external proxies into the Traffic store and export filtered subsets out of ARTEX.
|
||||
|
||||
Both routes require the standard administrator JWT (`Authorization: Bearer <token>`) like the rest of `/api/traffic`, and return `503` when the traffic store is unavailable.
|
||||
|
||||
---
|
||||
|
||||
## Import: `POST /api/traffic/import/har`
|
||||
|
||||
### Request format
|
||||
|
||||
Send a raw HAR 1.2 JSON document directly as the HTTP request body (`Content-Type: application/json`), capped at the standard API JSON body limit (**32 MiB**; oversized bodies return `413 Request Entity Too Large`).
|
||||
|
||||
```bash
|
||||
curl -X POST \
|
||||
-H "Authorization: Bearer $TOKEN" \
|
||||
-H "Content-Type: application/json" \
|
||||
--data-binary @capture.har \
|
||||
http://127.0.0.1:8787/api/traffic/import/har
|
||||
```
|
||||
|
||||
The Traffic page also provides an **Import HAR** file picker (with the same 32 MiB limit) that reads a `.har` / `.json` file, posts it to this endpoint, displays loading/error state and a count summary, and refreshes the table.
|
||||
|
||||
### Validation & error handling
|
||||
|
||||
The request is rejected with `400 Bad Request` naming the reason when:
|
||||
|
||||
- the body is empty or malformed JSON (including trailing content after the root object),
|
||||
- the `log` object is missing,
|
||||
- `log.version` is not `"1.2"`,
|
||||
- `log.entries` is missing or `null`,
|
||||
- `log.entries` exceeds the per-import entry cap (`2000` entries).
|
||||
|
||||
Individual malformed entries (invalid `startedDateTime`, non-HTTP(S) URL, invalid HTTP method, header/cookie names or values containing CR/LF/NUL, out-of-range status, invalid base64 or unsupported body encoding) do **not** fail the whole import: they are counted in `failed` and reported in `errors` (up to 50 error details) while valid entries continue importing. HTTP/2 pseudo-headers starting with `:` (such as `:authority` or `:method` from browser DevTools) are skipped cleanly.
|
||||
|
||||
### Response
|
||||
|
||||
```json
|
||||
{
|
||||
"imported": 12,
|
||||
"skipped": 3,
|
||||
"failed": 1,
|
||||
"truncated": false,
|
||||
"errors": [
|
||||
{ "index": 4, "url": "notaurl", "reason": "invalid request url \"notaurl\"" }
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### Deterministic IDs, round-trip fidelity, & idempotence
|
||||
|
||||
- **ARTEX exports (`_artexExchangeId`)**: Every entry exported by ARTEX carries the HAR 1.2 custom field `_artexExchangeId` set to the exchange's stored ID. When a valid `_artexExchangeId` (`[A-Za-z0-9._:-]`, 1–128 chars) is present on import, ARTEX preserves it. This guarantees that two distinct ARTEX exchanges recorded within the same second with identical method, URL, status, and bodies do **not** collapse into one row when imported into a fresh store, and that re-importing an export into the source store stays idempotent (`skipped`).
|
||||
- **External HARs (no `_artexExchangeId`)**: Each entry receives a deterministic content-based ID:
|
||||
|
||||
```text
|
||||
har-<hex(sha256(ts_unix_seconds + NUL + METHOD + NUL + canonical_url + NUL + status + NUL + sha256(req_body) + NUL + sha256(resp_body)))>
|
||||
```
|
||||
|
||||
`ts_unix_seconds` is `startedDateTime` parsed as RFC 3339 and truncated to UTC Unix seconds (matching `exchanges.ts`). Re-importing the same external HAR skips existing IDs (`INSERT OR IGNORE`, hot rows always win). Identical entries in the same external HAR sharing `(ts_unix_seconds, method, canonical_url, status, req_body, resp_body)` are deduplicated (the first is imported, duplicates are counted in `skipped`).
|
||||
|
||||
### Storage, bodies, cookies, `postData.params`, and userinfo
|
||||
|
||||
- **URL userinfo**: Any `user:pass@` userinfo in `request.url` is stripped before storing, indexing, listing, exporting, or reporting errors (matching ARTEX's asset store).
|
||||
- `host` is derived from `URL.Hostname()` and `url_template` from `db.TemplatePath(URL.EscapedPath())`; `path` stays empty.
|
||||
- **Bodies & base64**: `response.content.text` and `request.postData.text` are stored as raw UTF-8 bytes when `encoding` is empty, and decoded via standard base64 when `encoding` is `"base64"`. When `request.postData.text` is empty and `request.postData.params` is populated, ARTEX reconstructs the form body as `application/x-www-form-urlencoded` (preserving parameter order).
|
||||
- **Cookies arrays**: When `request.headers` does not already include a `Cookie` header and `request.cookies` is non-empty, ARTEX synthesizes a `Cookie` header from `request.cookies`. Likewise, when `response.headers` does not already include a `Set-Cookie` header and `response.cookies` is non-empty, ARTEX synthesizes `Set-Cookie` headers from `response.cookies`. When the headers are already present, they are kept as-is without duplication.
|
||||
- `req_len` and `resp_len` record the actual decoded byte lengths.
|
||||
- `content_type` comes from `response.content.mimeType` (falling back to the response `Content-Type` header).
|
||||
- Bodies larger than the 256 KiB inline threshold spill to the content-addressed blob store (`_blobs/sha256/...`) with `blob_refs` rows, and searchable text bodies are added to the `ex_fts` full-text index — identical to proxy capture and `ImportArchive`.
|
||||
|
||||
### Capture rewrite rules are NOT applied
|
||||
|
||||
HAR import writes directly to the traffic store without passing through the MITM capture proxy. **Capture rewrite rules are never applied to imported exchanges**, no `exchange_rewrites` rows are created, and imported rows always have `rewritten: false`.
|
||||
|
||||
### Import limits
|
||||
|
||||
| Limit | Default | Behavior when exceeded |
|
||||
|---|---|---|
|
||||
| Raw HTTP request body | 32 MiB | `413 Request Entity Too Large` |
|
||||
| Entries per HAR | 2,000 | `400 Bad Request` |
|
||||
| Total decoded request + response body bytes | 32 MiB | Stops importing remaining entries, sets `"truncated": true`, counts remaining entries in `skipped`, and appends an explanatory item in `errors`. |
|
||||
|
||||
---
|
||||
|
||||
## Export: `GET /api/traffic/export/har`
|
||||
|
||||
### Request & filters
|
||||
|
||||
Returns an `application/json` HAR 1.2 document (`Content-Disposition: attachment; filename="artex-traffic.har"`) ordered deterministically by `(ts ASC, id ASC)`.
|
||||
|
||||
It reuses the same filter parser and SQL predicate builder as `GET /api/traffic`, supporting:
|
||||
|
||||
- `host`, `method`, `path`, `status`, `q`, `body`, `rewritten` (`all` | `rewritten` | `original` | `true` | `false`), `resp_min`, `resp_max`.
|
||||
|
||||
### HAR 1.2 compliance & unknown placeholders
|
||||
|
||||
- `log.version` is `"1.2"` and `log.creator` is `{"name": "ARTEX", "version": "<build-version>"}`.
|
||||
- `startedDateTime` is formatted from `exchanges.ts` as UTC RFC 3339, and `_artexExchangeId` carries the exchange's stored ID.
|
||||
- Request and response headers are parsed from the stored raw heads (`req_head` / `resp_head`). ARTEX does not invent `serverIPAddress` or headers that are not present in the store.
|
||||
- Required HAR 1.2 fields whose values are not recorded by ARTEX are emitted with explicit **unknown placeholders** rather than fabricated measurements:
|
||||
- `entry.time`: `0`
|
||||
- `entry.cache`: `{}`
|
||||
- `entry.timings`: `{"send": -1, "wait": -1, "receive": -1}` (unknown/unavailable per HAR 1.2)
|
||||
- `request.cookies`, `request.queryString`, `response.cookies`: `[]`
|
||||
- `request.headersSize`, `response.headersSize`: `-1` (unknown per HAR 1.2)
|
||||
- `response.redirectURL`: `""`
|
||||
- Bodies are read in full from inline columns or spilled blobs: valid NUL-free UTF-8 bodies are emitted as plain `text`, and binary / non-UTF-8 bodies are emitted with `encoding: "base64"`.
|
||||
|
||||
### Export limits, import-compatibility invariant, & truncation reporting
|
||||
|
||||
| Limit | Default | `truncatedReason` |
|
||||
|---|---|---|
|
||||
| Exported entries | 1,000 | `max_entries` |
|
||||
| Total raw request + response headers and bodies | 20 MiB | `max_bytes` |
|
||||
| Marshaled JSON size backstop | 31 MiB | `max_bytes` |
|
||||
|
||||
**Cap invariant**: Every HAR produced by `GET /api/traffic/export/har` fits inside `POST /api/traffic/import/har`'s **32 MiB** HTTP body limit (and the Traffic page's 32 MiB file limit). Raw headers and bodies are capped at **20 MiB** so worst-case base64 expansion (`4/3x ≈ 26.7 MiB`) plus JSON structure stays comfortably under 32 MiB, backed by an explicit **31 MiB** marshaled-JSON cap so even heavily JSON-escaped payloads cannot trigger a `413` on re-import.
|
||||
|
||||
Truncation is never silent. Every export reports it in both HTTP response headers and HAR 1.2 custom (`_`-prefixed) `log` fields:
|
||||
|
||||
- Headers:
|
||||
- `X-ARTEX-HAR-Truncated: true|false`
|
||||
- `X-ARTEX-HAR-Truncated-Reason: max_entries|max_bytes` (when truncated)
|
||||
- `X-ARTEX-HAR-Exported: <count>`
|
||||
- `X-ARTEX-HAR-Matched: <total matching rows>`
|
||||
- JSON (`log` object, omitted when not truncated):
|
||||
- `_truncated: true`
|
||||
- `_truncatedReason: "max_entries" | "max_bytes"`
|
||||
- `_totalMatched: <total matching rows>`
|
||||
@@ -4,9 +4,11 @@ A rewrite rule matches a request or a response that goes through the capture pro
|
||||
how to change it: the method, the path and query, headers, the body, the status code.
|
||||
|
||||
**Status: the capture proxy applies enabled rules to HTTP traffic (request and response phases),
|
||||
and records what it did.** Not yet in this change: archive format, a per-replay rule toggle, the web UI,
|
||||
and the proof flag. See [Application in the capture proxy](#application-in-the-capture-proxy) for
|
||||
what is covered and what is not.
|
||||
records what it did, tags bound evidence snapshots, supports per-replay rule opt-in, carries
|
||||
rewrite provenance in traffic archive v2, exposes rewrite counters and a rewritten filter/flag on
|
||||
`GET /api/traffic`, and shows the filter and badge on the Traffic page.** Not yet in this change:
|
||||
the rule-management web UI. See [Application in the capture proxy](#application-in-the-capture-proxy)
|
||||
for what is covered and what is not.
|
||||
|
||||
Rules are a convenience for the operator, not a security control: a rule that fails leaves the
|
||||
message unchanged (fail open).
|
||||
@@ -207,5 +209,52 @@ the slot may be converted into a tombstone if a new reservation needs the room.
|
||||
|
||||
### Replay
|
||||
|
||||
Replay goes through the recording proxy like any other traffic, so the enabled rules apply to a
|
||||
replay and the resulting exchange is traced like a captured one. There is no per-replay toggle yet.
|
||||
`POST /api/traffic/replay` sends the edited request through the recording proxy so the exchange is
|
||||
captured in Traffic, but **bypasses capture rewrite rules by default** (`apply_rules: false`). To
|
||||
run enabled capture rules against a replay and trace them like captured traffic, opt in with
|
||||
`"apply_rules": true` (or check **Apply capture rewrite rules** in the Replay panel).
|
||||
|
||||
When `apply_rules` is false, `traffic.Replay` registers a single-use random 32-byte hex nonce in an
|
||||
in-memory registry, attaches the internal header `X-ARTEX-Replay-Nonce: <nonce>`, and removes the
|
||||
nonce when the call returns. The capture proxy strips `X-ARTEX-Replay-Nonce` unconditionally in the
|
||||
request hook so the target never sees it; only a value matching a registered nonce bypasses both
|
||||
request and response rule phases, while any forged header is stripped and ignored.
|
||||
|
||||
### Stats
|
||||
|
||||
`GET /api/traffic` includes a `rewrite` object exposing the proxy's `RewriteStats` counters since
|
||||
start: `large_responses`, `capacity_refusals`, `tombstone_drops`, `conversions`, and `sweeps`.
|
||||
|
||||
### Traffic list
|
||||
|
||||
Each exchange returned by `GET /api/traffic` carries `"rewritten": true|false`, computed with an
|
||||
`EXISTS` check against `exchange_rewrites` for rows with `outcome = 'applied'` (skipped or failed
|
||||
rules do not mark an exchange as rewritten).
|
||||
|
||||
`GET /api/traffic` accepts an optional `rewritten` query parameter:
|
||||
|
||||
- `all` (default when omitted or unrecognized): returns all exchanges.
|
||||
- `rewritten` (alias `true`): returns only exchanges with at least one applied rewrite row.
|
||||
- `original` (alias `false`): returns only exchanges with no applied rewrite row.
|
||||
|
||||
The filter combines with `host`, `method`, `path`, `status`, `q`, `body`, `resp_min`, and
|
||||
`resp_max` using `AND`, and `total` and pagination reflect the filtered set. The Traffic page shows
|
||||
the filter next to the existing filters and renders a `Rewritten` badge on rewritten rows.
|
||||
|
||||
### Task archives (v2)
|
||||
|
||||
Task archives export captured traffic into `traffic/traffic.json` using **format version 2**:
|
||||
|
||||
- Each `ArchiveExchange` carries optional `rewritten` (`bool`) and `rewrite_rule_ids` (`[]int64`),
|
||||
matching `RewriteInfo` (applied rows only, sorted ascending, distinct). Exchanges with no applied
|
||||
rewrite omit both fields.
|
||||
- Output stays deterministic: exchanges are ordered by `(ts, id)`, `rewrite_rule_ids` are sorted
|
||||
and distinct, and `blobs` are sorted so re-exporting the same data produces a byte-identical
|
||||
`traffic.json`.
|
||||
- `ImportArchive` accepts versions 1 and 2 and refuses any other version. Version 1 entries import
|
||||
as unrewritten with no rule IDs. Version 2 entries marked `rewritten: true` reconstruct minimal
|
||||
applied rows in `exchange_rewrites` (`phase = 'archived'`, `outcome = 'applied'`,
|
||||
`reason = 'archived'`, `rule_snapshot = NULL`) for each distinct rule ID (or a single `NULL`
|
||||
`rule_id` row when `rewrite_rule_ids` is empty), preserving `RewriteInfo`, `traffic_get`'s
|
||||
`=== REWRITTEN ===` header, evidence-binding provenance, and the traffic list filter without
|
||||
fabricating a rule snapshot or request/response phase. Existing hot rows always win on import.
|
||||
|
||||
@@ -281,20 +281,6 @@ func hostOf(rawURL string) string {
|
||||
return u.Hostname()
|
||||
}
|
||||
|
||||
func isBlank(v any) bool {
|
||||
switch x := v.(type) {
|
||||
case nil:
|
||||
return true
|
||||
case string:
|
||||
return x == ""
|
||||
case float64:
|
||||
return x == 0
|
||||
case int:
|
||||
return x == 0
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func uniq(in []string) []string {
|
||||
seen := map[string]struct{}{}
|
||||
out := in[:0]
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
module github.com/Autumn-27/artex
|
||||
|
||||
go 1.26.10
|
||||
go 1.26.11
|
||||
|
||||
require (
|
||||
github.com/Autumn-27/norma v0.4.11
|
||||
@@ -13,19 +13,19 @@ require (
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/gorilla/websocket v1.5.3
|
||||
github.com/jackc/pgx/v5 v5.10.0
|
||||
github.com/klauspost/compress v1.18.6
|
||||
github.com/klauspost/compress v1.20.2
|
||||
github.com/lqqyt2423/go-mitmproxy v1.9.2
|
||||
github.com/miekg/dns v1.1.72
|
||||
github.com/projectdiscovery/dnsx v1.2.3
|
||||
golang.org/x/crypto v0.58.0
|
||||
golang.org/x/crypto v0.59.0
|
||||
golang.org/x/net v0.62.0
|
||||
golang.org/x/text v0.43.0
|
||||
golang.org/x/text v0.44.0
|
||||
modernc.org/sqlite v1.52.0
|
||||
mvdan.cc/sh/v3 v3.14.1
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/andybalholm/brotli v1.2.1 // indirect
|
||||
github.com/andybalholm/brotli v1.2.7 // indirect
|
||||
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25 // indirect
|
||||
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5 // indirect
|
||||
@@ -70,10 +70,10 @@ require (
|
||||
go.uber.org/atomic v1.11.0 // indirect
|
||||
go.uber.org/multierr v1.11.0 // indirect
|
||||
golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 // indirect
|
||||
golang.org/x/mod v0.41.0 // indirect
|
||||
golang.org/x/sync v0.24.0 // indirect
|
||||
golang.org/x/sys v0.49.0 // indirect
|
||||
golang.org/x/tools v0.51.0 // indirect
|
||||
golang.org/x/mod v0.42.0 // indirect
|
||||
golang.org/x/sync v0.25.0 // indirect
|
||||
golang.org/x/sys v0.50.0 // indirect
|
||||
golang.org/x/tools v0.52.0 // indirect
|
||||
gopkg.in/yaml.v3 v3.0.1 // indirect
|
||||
modernc.org/libc v1.72.3 // indirect
|
||||
modernc.org/mathutil v1.7.1 // indirect
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
github.com/BaaRai/Norma v0.4.11 h1:Z5lSRFKBDI0EzAw1YDA5iQ5GXsa9e7J19YmIe0zaVcQ=
|
||||
github.com/BaaRai/Norma v0.4.11/go.mod h1:BudWrf7iHl96FgHqFr/HwN3mKYmGjJDt+xL2ZHXfFZw=
|
||||
github.com/andybalholm/brotli v1.2.1 h1:R+f5xP285VArJDRgowrfb9DqL18yVK0gKAW/F+eTWro=
|
||||
github.com/andybalholm/brotli v1.2.1/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
|
||||
github.com/andybalholm/brotli v1.2.7 h1:UgafRPGMam5ySHfRkhthMqOFA6IFoeF3D7mWIDLjG5A=
|
||||
github.com/andybalholm/brotli v1.2.7/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
|
||||
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
|
||||
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
|
||||
github.com/aws/aws-sdk-go-v2 v1.47.5 h1:5yA+A+BiXbDq1ZLbYwPViwhEGDMdR0MEhL8Jh2LnLS4=
|
||||
@@ -81,8 +81,8 @@ github.com/jackc/pgx/v5 v5.10.0 h1:VhSvgU2jSli8o3AqIEOTJr7rZwAEUVo4E4XhR94Zfr0=
|
||||
github.com/jackc/pgx/v5 v5.10.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao=
|
||||
github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
|
||||
github.com/klauspost/compress v1.20.2 h1:v5tiZvm1KGLyg5d5oXdXe3lsSPrbEUiKoXGia//I7Qo=
|
||||
github.com/klauspost/compress v1.20.2/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
|
||||
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
|
||||
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
|
||||
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
|
||||
@@ -143,23 +143,23 @@ go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
|
||||
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
|
||||
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
|
||||
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
|
||||
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
|
||||
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
|
||||
golang.org/x/crypto v0.59.0 h1:xS2jhqYbzNrpvkWP2YTDf4TJwBy3ykR03i8vFDxEc7c=
|
||||
golang.org/x/crypto v0.59.0/go.mod h1:veDyUwATGs3c+vN3VfTbzViMGXeTBk3WyhBOkn+F/4U=
|
||||
golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 h1:yqrTHse8TCMW1M1ZCP+VAR/l0kKxwaAIqN/il7x4voA=
|
||||
golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
|
||||
golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c=
|
||||
golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o=
|
||||
golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg=
|
||||
golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs=
|
||||
golang.org/x/net v0.62.0 h1:18ELalfM5+XNRwzM2nYqXsZQ9ByS1uhj2O/U7+5jqRY=
|
||||
golang.org/x/net v0.62.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI=
|
||||
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
|
||||
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||
golang.org/x/sync v0.25.0 h1:dJnifr0nMV8/SBnBvdo4eSGGnrc3O4FFx6IqvtLcmRs=
|
||||
golang.org/x/sync v0.25.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
|
||||
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
|
||||
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
|
||||
golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI=
|
||||
golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA=
|
||||
golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs=
|
||||
golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||
golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo=
|
||||
golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY=
|
||||
golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs=
|
||||
golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
|
||||
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
|
||||
|
||||
+1
-1
@@ -106,7 +106,7 @@ JSON
|
||||
# embedding the frontend requires node to produce the static assets
|
||||
if command -v npm >/dev/null 2>&1; then
|
||||
info "building frontend static assets..."
|
||||
( cd web && npm ci && npm run build:static )
|
||||
( cd web && npm ci --ignore-scripts && npm run build:static )
|
||||
rm -rf server/webui/dist && cp -r web/out server/webui/dist
|
||||
info "compiling embedded single binary..."
|
||||
CGO_ENABLED=0 go build -tags embedui -trimpath -o artex ./cmd/artex
|
||||
|
||||
@@ -0,0 +1,169 @@
|
||||
package llmrec
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"log"
|
||||
"os"
|
||||
"strings"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/norma/llm"
|
||||
)
|
||||
|
||||
// ContextTelemetryEnv is the opt-in environment flag enabling per-call context
|
||||
// size telemetry into llm_context. Off by default: when unset/false, no sizing
|
||||
// work runs and no rows are written.
|
||||
const ContextTelemetryEnv = "ARTEX_CONTEXT_TELEMETRY"
|
||||
|
||||
// ContextTelemetryEnabled reports whether ARTEX_CONTEXT_TELEMETRY is enabled
|
||||
// (1, true, on, yes; case-insensitive). Default is false.
|
||||
func ContextTelemetryEnabled() bool {
|
||||
switch strings.ToLower(strings.TrimSpace(os.Getenv(ContextTelemetryEnv))) {
|
||||
case "1", "true", "on", "yes":
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// ContextMetrics holds size-only measurements of an assembled CompletionRequest
|
||||
// as it leaves for the provider. Never retains any prompt, tool, or message
|
||||
// content.
|
||||
type ContextMetrics struct {
|
||||
ToolCount int
|
||||
MessageCount int
|
||||
SystemStaticBytes int64
|
||||
SystemDynamicBytes int64
|
||||
ToolsBytes int64
|
||||
MessagesUserBytes int64
|
||||
MessagesAssistantBytes int64
|
||||
MessagesOtherBytes int64
|
||||
ToolResultBytes int64
|
||||
LastMessageBytes int64
|
||||
}
|
||||
|
||||
// MeasureContext computes deterministic byte sizes and counts for req without
|
||||
// retaining any content:
|
||||
//
|
||||
// - System: when DynamicBoundary > 0, req.System is split at
|
||||
// min(DynamicBoundary, len(req.System)) into SystemStaticBytes ([:b]) and
|
||||
// SystemDynamicBytes ([b:]). Within each slice, each segment is trimmed with
|
||||
// strings.TrimSpace, empty segments are dropped, and remaining segments are
|
||||
// joined with "\n\n", matching norma's llm.joinSystem. When
|
||||
// DynamicBoundary <= 0, the whole req.System is measured as a single static
|
||||
// block (SystemStaticBytes) and SystemDynamicBytes is 0.
|
||||
// - Tools: ToolCount = len(req.Tools); ToolsBytes = len(json.Marshal(req.Tools))
|
||||
// (0 when no tools). Go's encoding/json sorts map keys deterministically.
|
||||
// - Messages: MessageCount = len(req.Messages). Each message is measured by
|
||||
// len(json.Marshal(msg)) and summed into MessagesUserBytes (role "user"),
|
||||
// MessagesAssistantBytes (role "assistant"), or MessagesOtherBytes (any
|
||||
// other role). ToolResultBytes records the serialized size of tool_result
|
||||
// content blocks inside messages as an informational subset (not added to
|
||||
// the partition denominator). LastMessageBytes is the serialized byte size
|
||||
// of the final message (0 when no messages).
|
||||
func MeasureContext(req llm.CompletionRequest) ContextMetrics {
|
||||
var m ContextMetrics
|
||||
|
||||
// 1. System prompt bytes (split at DynamicBoundary when > 0, else single static block).
|
||||
if len(req.System) > 0 {
|
||||
if req.DynamicBoundary > 0 {
|
||||
b := req.DynamicBoundary
|
||||
if b > len(req.System) {
|
||||
b = len(req.System)
|
||||
}
|
||||
m.SystemStaticBytes = joinedSegmentBytes(req.System[:b])
|
||||
m.SystemDynamicBytes = joinedSegmentBytes(req.System[b:])
|
||||
} else {
|
||||
m.SystemStaticBytes = joinedSegmentBytes(req.System)
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Serialized tool schemas and count.
|
||||
m.ToolCount = len(req.Tools)
|
||||
if len(req.Tools) > 0 {
|
||||
if b, err := json.Marshal(req.Tools); err == nil {
|
||||
m.ToolsBytes = int64(len(b))
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Messages by role, tool_result subset, and last message size.
|
||||
m.MessageCount = len(req.Messages)
|
||||
for i, msg := range req.Messages {
|
||||
var msgBytes int64
|
||||
if b, err := json.Marshal(msg); err == nil {
|
||||
msgBytes = int64(len(b))
|
||||
}
|
||||
switch msg.Role {
|
||||
case llm.RoleUser:
|
||||
m.MessagesUserBytes += msgBytes
|
||||
case llm.RoleAssistant:
|
||||
m.MessagesAssistantBytes += msgBytes
|
||||
default:
|
||||
m.MessagesOtherBytes += msgBytes
|
||||
}
|
||||
if i == len(req.Messages)-1 {
|
||||
m.LastMessageBytes = msgBytes
|
||||
}
|
||||
for _, blk := range msg.Content {
|
||||
if blk.Type == llm.BlockToolResult {
|
||||
if b, err := json.Marshal(blk); err == nil {
|
||||
m.ToolResultBytes += int64(len(b))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
// joinedSegmentBytes returns the byte length of segs after trimming whitespace
|
||||
// from each segment, dropping empty segments, and joining the remaining ones
|
||||
// with "\n\n" — matching norma's llm.joinSystem without allocating a joined
|
||||
// string.
|
||||
func joinedSegmentBytes(segs []string) int64 {
|
||||
var total int64
|
||||
nonEmpty := 0
|
||||
for _, s := range segs {
|
||||
s = strings.TrimSpace(s)
|
||||
if s == "" {
|
||||
continue
|
||||
}
|
||||
if nonEmpty > 0 {
|
||||
total += 2 // "\n\n"
|
||||
}
|
||||
total += int64(len(s))
|
||||
nonEmpty++
|
||||
}
|
||||
return total
|
||||
}
|
||||
|
||||
// recordContext appends one row to llm_context when r.pg is configured.
|
||||
// Best-effort: logs and continues on error so telemetry never disrupts calls.
|
||||
func (r *Recorder) recordContext(taskID, worker string, m ContextMetrics, usage llm.Usage, status string) {
|
||||
if r.pg == nil {
|
||||
return
|
||||
}
|
||||
err := r.pg.InsertLLMContext(&db.LLMContext{
|
||||
TaskID: taskID,
|
||||
Worker: worker,
|
||||
Model: r.model,
|
||||
Profile: r.prof,
|
||||
ToolCount: m.ToolCount,
|
||||
MessageCount: m.MessageCount,
|
||||
SystemStaticBytes: m.SystemStaticBytes,
|
||||
SystemDynamicBytes: m.SystemDynamicBytes,
|
||||
ToolsBytes: m.ToolsBytes,
|
||||
MessagesUserBytes: m.MessagesUserBytes,
|
||||
MessagesAssistantBytes: m.MessagesAssistantBytes,
|
||||
MessagesOtherBytes: m.MessagesOtherBytes,
|
||||
ToolResultBytes: m.ToolResultBytes,
|
||||
LastMessageBytes: m.LastMessageBytes,
|
||||
InputTokens: usage.InputTokens,
|
||||
OutputTokens: usage.OutputTokens,
|
||||
CacheRead: usage.CacheReadTokens,
|
||||
CacheWrite: usage.CacheWriteTokens,
|
||||
Status: status,
|
||||
})
|
||||
if err != nil {
|
||||
log.Printf("[llmcontext] insert: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,371 @@
|
||||
package llmrec
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"iter"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/norma/llm"
|
||||
"github.com/Autumn-27/norma/transcript"
|
||||
)
|
||||
|
||||
type syntheticTelemetryProvider struct {
|
||||
usage llm.Usage
|
||||
streamErr error
|
||||
completeEr error
|
||||
}
|
||||
|
||||
func (p syntheticTelemetryProvider) Stream(context.Context, llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
|
||||
return func(yield func(llm.StreamEvent, error) bool) {
|
||||
if !yield(llm.StreamEvent{Type: llm.SEMessageStart, Usage: llm.Usage{
|
||||
InputTokens: p.usage.InputTokens,
|
||||
CacheReadTokens: p.usage.CacheReadTokens,
|
||||
CacheWriteTokens: p.usage.CacheWriteTokens,
|
||||
}}, nil) {
|
||||
return
|
||||
}
|
||||
if p.streamErr != nil {
|
||||
yield(llm.StreamEvent{}, p.streamErr)
|
||||
return
|
||||
}
|
||||
if !yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "ok"}, nil) {
|
||||
return
|
||||
}
|
||||
yield(llm.StreamEvent{
|
||||
Type: llm.SEMessageDelta,
|
||||
StopReason: "end_turn",
|
||||
Usage: llm.Usage{OutputTokens: p.usage.OutputTokens},
|
||||
}, nil)
|
||||
}
|
||||
}
|
||||
|
||||
func (p syntheticTelemetryProvider) Complete(context.Context, llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
|
||||
if p.completeEr != nil {
|
||||
return llm.Message{}, "", p.usage, p.completeEr
|
||||
}
|
||||
return llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{llm.TextBlock("done")}}, "end_turn", p.usage, nil
|
||||
}
|
||||
|
||||
func TestMeasureContextExactSizesAndBoundaryModes(t *testing.T) {
|
||||
tools := []llm.ToolSchema{
|
||||
{
|
||||
Name: "Bash",
|
||||
Description: "Run shell command",
|
||||
InputSchema: map[string]any{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"command": map[string]any{"type": "string"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
Name: "record_fact",
|
||||
Description: "Store a verified fact",
|
||||
InputSchema: map[string]any{"type": "object"},
|
||||
},
|
||||
}
|
||||
wantToolsBytes, err := json.Marshal(tools)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
msgUser1 := llm.UserText("first user prompt")
|
||||
msgAsst := llm.Message{
|
||||
Role: llm.RoleAssistant,
|
||||
Content: []llm.ContentBlock{
|
||||
{Type: llm.BlockToolUse, ID: "call_1", Name: "Bash", Input: json.RawMessage(`{"command":"id"}`)},
|
||||
},
|
||||
}
|
||||
toolResBlock := llm.ToolResultText("call_1", "uid=0(root) gid=0(root)", false)
|
||||
msgUser2 := llm.Message{
|
||||
Role: llm.RoleUser,
|
||||
Content: []llm.ContentBlock{toolResBlock},
|
||||
}
|
||||
msgOther := llm.Message{
|
||||
Role: llm.Role("tool"),
|
||||
Content: []llm.ContentBlock{llm.TextBlock("other role text")},
|
||||
}
|
||||
|
||||
mustLen := func(v any) int64 {
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return int64(len(b))
|
||||
}
|
||||
|
||||
// Case 1: DynamicBoundary == 0 -> all system segments as single static block (joined with "\n\n").
|
||||
reqNoSplit := llm.CompletionRequest{
|
||||
System: []string{"STATIC_ONE", "STATIC_TWO"},
|
||||
DynamicBoundary: 0,
|
||||
Tools: tools,
|
||||
Messages: []llm.Message{msgUser1, msgAsst, msgUser2, msgOther},
|
||||
}
|
||||
got1 := MeasureContext(reqNoSplit)
|
||||
if got1.SystemStaticBytes != int64(len("STATIC_ONE\n\nSTATIC_TWO")) || got1.SystemDynamicBytes != 0 {
|
||||
t.Fatalf("DynamicBoundary=0 system = (%d, %d), want (%d, 0)", got1.SystemStaticBytes, got1.SystemDynamicBytes, len("STATIC_ONE\n\nSTATIC_TWO"))
|
||||
}
|
||||
if got1.ToolCount != 2 || got1.ToolsBytes != int64(len(wantToolsBytes)) {
|
||||
t.Fatalf("tools = (count=%d, bytes=%d), want (2, %d)", got1.ToolCount, got1.ToolsBytes, len(wantToolsBytes))
|
||||
}
|
||||
wantUser := mustLen(msgUser1) + mustLen(msgUser2)
|
||||
wantAsst := mustLen(msgAsst)
|
||||
wantOther := mustLen(msgOther)
|
||||
wantToolRes := mustLen(toolResBlock)
|
||||
if got1.MessageCount != 4 ||
|
||||
got1.MessagesUserBytes != wantUser ||
|
||||
got1.MessagesAssistantBytes != wantAsst ||
|
||||
got1.MessagesOtherBytes != wantOther ||
|
||||
got1.ToolResultBytes != wantToolRes ||
|
||||
got1.LastMessageBytes != wantOther {
|
||||
t.Fatalf("messages = %+v, want count=4 user=%d asst=%d other=%d toolRes=%d last=%d",
|
||||
got1, wantUser, wantAsst, wantOther, wantToolRes, wantOther)
|
||||
}
|
||||
|
||||
// Case 2: 0 < DynamicBoundary < len(System) -> split at boundary.
|
||||
reqSplit := llm.CompletionRequest{
|
||||
System: []string{"AAA", "BBBB", "CCCCC", "DD"},
|
||||
DynamicBoundary: 2,
|
||||
}
|
||||
got2 := MeasureContext(reqSplit)
|
||||
if got2.SystemStaticBytes != int64(len("AAA\n\nBBBB")) || got2.SystemDynamicBytes != int64(len("CCCCC\n\nDD")) {
|
||||
t.Fatalf("DynamicBoundary=2 system = (%d, %d), want (%d, %d)",
|
||||
got2.SystemStaticBytes, got2.SystemDynamicBytes, len("AAA\n\nBBBB"), len("CCCCC\n\nDD"))
|
||||
}
|
||||
|
||||
// Case 3: DynamicBoundary >= len(System) -> whole prompt static, dynamic == 0.
|
||||
reqAllStatic := llm.CompletionRequest{
|
||||
System: []string{"AAA", "BBBB"},
|
||||
DynamicBoundary: 5,
|
||||
}
|
||||
got3 := MeasureContext(reqAllStatic)
|
||||
if got3.SystemStaticBytes != int64(len("AAA\n\nBBBB")) || got3.SystemDynamicBytes != 0 {
|
||||
t.Fatalf("DynamicBoundary=5 system = (%d, %d), want (%d, 0)",
|
||||
got3.SystemStaticBytes, got3.SystemDynamicBytes, len("AAA\n\nBBBB"))
|
||||
}
|
||||
|
||||
// Case 4: whitespace-padded and empty segments match norma's llm.joinSystem
|
||||
// (strings.TrimSpace per segment, drop empty, join remaining with "\n\n").
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
segs []string
|
||||
boundary int
|
||||
wantStat int64
|
||||
wantDyn int64
|
||||
}{
|
||||
{
|
||||
name: "padded and empty unsplit",
|
||||
segs: []string{" STATIC ", "", "\n", "TAIL\n\n"},
|
||||
boundary: 0,
|
||||
wantStat: int64(len("STATIC\n\nTAIL")),
|
||||
wantDyn: 0,
|
||||
},
|
||||
{
|
||||
name: "padded split at boundary 2",
|
||||
segs: []string{" A ", " B ", " C "},
|
||||
boundary: 2,
|
||||
wantStat: int64(len("A\n\nB")),
|
||||
wantDyn: int64(len("C")),
|
||||
},
|
||||
{
|
||||
name: "only empty and whitespace",
|
||||
segs: []string{"", " "},
|
||||
boundary: 1,
|
||||
wantStat: 0,
|
||||
wantDyn: 0,
|
||||
},
|
||||
{
|
||||
name: "empty segments around boundary",
|
||||
segs: []string{" ", "HEAD ", "", "\t\n", " TAIL"},
|
||||
boundary: 2,
|
||||
wantStat: int64(len("HEAD")),
|
||||
wantDyn: int64(len("TAIL")),
|
||||
},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := MeasureContext(llm.CompletionRequest{System: tc.segs, DynamicBoundary: tc.boundary})
|
||||
if got.SystemStaticBytes != tc.wantStat || got.SystemDynamicBytes != tc.wantDyn {
|
||||
t.Fatalf("MeasureContext(%q, b=%d) = (%d, %d), want (%d, %d)",
|
||||
tc.segs, tc.boundary, got.SystemStaticBytes, got.SystemDynamicBytes, tc.wantStat, tc.wantDyn)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestContextTelemetryFlagOffAndOnPostgres(t *testing.T) {
|
||||
dsn := os.Getenv("ARTEX_PG_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("ARTEX_PG_DSN not set")
|
||||
}
|
||||
pg, err := db.Open(dsn)
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer pg.Close()
|
||||
|
||||
stamp := time.Now().UnixNano()
|
||||
taskOff := fmt.Sprintf("ctx-off-%d", stamp)
|
||||
taskOn := fmt.Sprintf("ctx-on-%d", stamp)
|
||||
t.Cleanup(func() {
|
||||
_, _ = pg.Exec(`DELETE FROM llm_context WHERE task_id IN ($1,$2)`, taskOff, taskOn)
|
||||
_, _ = pg.Exec(`DELETE FROM llm_usage WHERE task_id IN ($1,$2)`, taskOff, taskOn)
|
||||
_, _ = pg.Exec(`DELETE FROM llm_records WHERE task_id IN ($1,$2)`, taskOff, taskOn)
|
||||
})
|
||||
|
||||
sentinelPrompt := "SECRET_PROMPT_SENTINEL_NEVER_STORE"
|
||||
sentinelMsg := "SECRET_USER_MSG_SENTINEL_NEVER_STORE"
|
||||
req := llm.CompletionRequest{
|
||||
System: []string{sentinelPrompt, "DYNAMIC_TAIL"},
|
||||
DynamicBoundary: 1,
|
||||
Tools: []llm.ToolSchema{
|
||||
{Name: "Bash", Description: "SECRET_TOOL_DESC", InputSchema: map[string]any{"type": "object"}},
|
||||
},
|
||||
Messages: []llm.Message{
|
||||
llm.UserText(sentinelMsg),
|
||||
},
|
||||
}
|
||||
wantMetrics := MeasureContext(req)
|
||||
wantUsage := llm.Usage{InputTokens: 1200, OutputTokens: 150, CacheReadTokens: 800, CacheWriteTokens: 100}
|
||||
|
||||
// 1. Flag OFF (default): zero rows in llm_context on both Stream and Complete,
|
||||
// identical behavior regardless of recordBodies.
|
||||
t.Setenv(ContextTelemetryEnv, "")
|
||||
if ContextTelemetryEnabled() {
|
||||
t.Fatal("expected telemetry disabled when env unset")
|
||||
}
|
||||
recOff := Wrap(syntheticTelemetryProvider{usage: wantUsage}, pg, "claude-test", "prof-a", "", "", func() bool { return false })
|
||||
ctxOff := transcript.WithSessionID(WithTaskID(context.Background(), taskOff), "exp1-worker-i1")
|
||||
var streamText string
|
||||
for ev, err := range recOff.Stream(ctxOff, req) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ev.Type == llm.SETextDelta {
|
||||
streamText += ev.Text
|
||||
}
|
||||
}
|
||||
if streamText != "ok" {
|
||||
t.Fatalf("flag-off stream text = %q, want ok", streamText)
|
||||
}
|
||||
msgOff, stopOff, usageOff, err := recOff.Complete(ctxOff, req)
|
||||
if err != nil || msgOff.Text() != "done" || stopOff != "end_turn" || usageOff != wantUsage {
|
||||
t.Fatalf("flag-off Complete = (%q, %q, %+v, %v)", msgOff.Text(), stopOff, usageOff, err)
|
||||
}
|
||||
var offCount int
|
||||
if err := pg.QueryRow(`SELECT COUNT(*) FROM llm_context WHERE task_id=$1`, taskOff).Scan(&offCount); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if offCount != 0 {
|
||||
t.Fatalf("flag-off wrote %d rows to llm_context, want 0", offCount)
|
||||
}
|
||||
|
||||
// 2. Flag ON with recordBodies=FALSE: rows ARE written on Stream (ok + error)
|
||||
// and Complete, with exact byte sizes and zero llm_records rows.
|
||||
t.Setenv(ContextTelemetryEnv, "1")
|
||||
if !ContextTelemetryEnabled() {
|
||||
t.Fatal("expected telemetry enabled when ARTEX_CONTEXT_TELEMETRY=1")
|
||||
}
|
||||
recOn := Wrap(syntheticTelemetryProvider{usage: wantUsage}, pg, "claude-test", "prof-a", "", "", func() bool { return false })
|
||||
ctxOn := transcript.WithSessionID(WithTaskID(context.Background(), taskOn), "exp2-planner")
|
||||
for _, err := range recOn.Stream(ctxOn, req) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if _, _, _, err := recOn.Complete(ctxOn, req); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Error path also records status='error'.
|
||||
recErr := Wrap(syntheticTelemetryProvider{usage: llm.Usage{InputTokens: 400}, streamErr: errors.New("upstream 500")}, pg, "claude-test", "prof-a", "", "", func() bool { return false })
|
||||
for _, err := range recErr.Stream(ctxOn, req) {
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
var recBodiesCount int
|
||||
if err := pg.QueryRow(`SELECT COUNT(*) FROM llm_records WHERE task_id=$1`, taskOn).Scan(&recBodiesCount); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if recBodiesCount != 0 {
|
||||
t.Fatalf("llm_records count = %d with recordBodies=false, want 0", recBodiesCount)
|
||||
}
|
||||
|
||||
rows, err := pg.Query(`
|
||||
SELECT worker, model, profile, tool_count, message_count,
|
||||
system_static_bytes, system_dynamic_bytes, tools_bytes,
|
||||
messages_user_bytes, messages_assistant_bytes, messages_other_bytes,
|
||||
tool_result_bytes, last_message_bytes,
|
||||
input_tokens, output_tokens, cache_read, cache_write, status
|
||||
FROM llm_context WHERE task_id=$1 ORDER BY id`, taskOn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var got []db.LLMContext
|
||||
for rows.Next() {
|
||||
var c db.LLMContext
|
||||
if err := rows.Scan(
|
||||
&c.Worker, &c.Model, &c.Profile, &c.ToolCount, &c.MessageCount,
|
||||
&c.SystemStaticBytes, &c.SystemDynamicBytes, &c.ToolsBytes,
|
||||
&c.MessagesUserBytes, &c.MessagesAssistantBytes, &c.MessagesOtherBytes,
|
||||
&c.ToolResultBytes, &c.LastMessageBytes,
|
||||
&c.InputTokens, &c.OutputTokens, &c.CacheRead, &c.CacheWrite, &c.Status,
|
||||
); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got = append(got, c)
|
||||
}
|
||||
if len(got) != 3 {
|
||||
t.Fatalf("llm_context rows = %d, want 3 (stream ok, complete ok, stream error)", len(got))
|
||||
}
|
||||
for i, c := range got {
|
||||
if c.Worker != "planner" || c.Model != "claude-test" || c.Profile != "prof-a" ||
|
||||
c.ToolCount != wantMetrics.ToolCount || c.MessageCount != wantMetrics.MessageCount ||
|
||||
c.SystemStaticBytes != wantMetrics.SystemStaticBytes ||
|
||||
c.SystemDynamicBytes != wantMetrics.SystemDynamicBytes ||
|
||||
c.ToolsBytes != wantMetrics.ToolsBytes ||
|
||||
c.MessagesUserBytes != wantMetrics.MessagesUserBytes ||
|
||||
c.MessagesAssistantBytes != wantMetrics.MessagesAssistantBytes ||
|
||||
c.MessagesOtherBytes != wantMetrics.MessagesOtherBytes ||
|
||||
c.ToolResultBytes != wantMetrics.ToolResultBytes ||
|
||||
c.LastMessageBytes != wantMetrics.LastMessageBytes {
|
||||
t.Fatalf("row %d metrics = %+v, want %+v", i, c, wantMetrics)
|
||||
}
|
||||
}
|
||||
if got[0].Status != "ok" || got[0].InputTokens != 1200 || got[0].CacheRead != 800 || got[0].CacheWrite != 100 ||
|
||||
got[1].Status != "ok" || got[1].OutputTokens != 150 ||
|
||||
got[2].Status != "error" || got[2].InputTokens != 400 {
|
||||
t.Fatalf("unexpected usage/status rows: %+v", got)
|
||||
}
|
||||
|
||||
// Verify schema contains zero content columns and stored rows hold none of the sentinels.
|
||||
var textCols int
|
||||
if err := pg.QueryRow(`SELECT COUNT(*) FROM information_schema.columns WHERE table_name='llm_context' AND column_name ~ '(body|content|prompt|text|raw|message$)'`).Scan(&textCols); err != nil || textCols != 0 {
|
||||
t.Fatalf("unexpected content-like columns in llm_context: count=%d err=%v", textCols, err)
|
||||
}
|
||||
var serializedRows string
|
||||
if err := pg.QueryRow(`SELECT COALESCE(string_agg(row_to_json(t)::text, ''), '') FROM llm_context t WHERE task_id=$1`, taskOn).Scan(&serializedRows); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, secret := range []string{sentinelPrompt, sentinelMsg, "SECRET_TOOL_DESC", "DYNAMIC_TAIL"} {
|
||||
if containsSubstr(serializedRows, secret) {
|
||||
t.Fatalf("llm_context leaked request content %q", secret)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func containsSubstr(s, sub string) bool {
|
||||
for i := 0; i+len(sub) <= len(s); i++ {
|
||||
if s[i:i+len(sub)] == sub {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -6,6 +6,7 @@ package llmrec
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"iter"
|
||||
"log"
|
||||
"strings"
|
||||
@@ -16,6 +17,11 @@ import (
|
||||
"github.com/Autumn-27/norma/transcript"
|
||||
)
|
||||
|
||||
// errStreamAbandoned marks a stream whose consumer stopped reading before
|
||||
// message_stop while its context was still live. The call did not complete,
|
||||
// so it is metered as an error rather than inferred from ctx.Err().
|
||||
var errStreamAbandoned = errors.New("llmrec: consumer stopped reading before message_stop")
|
||||
|
||||
type taskIDContextKey struct{}
|
||||
type workerContextKey struct{}
|
||||
|
||||
@@ -151,6 +157,7 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
|
||||
// stats and must be complete even for interrupted/failed runs, so it is NOT
|
||||
// gated. Only body serialization + response accumulation are skipped when off.
|
||||
recordBodies := r.enabled == nil || r.enabled()
|
||||
collectContext := ContextTelemetryEnabled()
|
||||
start := time.Now()
|
||||
session := transcript.SessionIDFrom(ctx)
|
||||
parsedID, worker := parseSession(session)
|
||||
@@ -165,6 +172,11 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
|
||||
taskID = parsedID
|
||||
}
|
||||
|
||||
var ctxMetrics ContextMetrics
|
||||
if collectContext {
|
||||
ctxMetrics = MeasureContext(req)
|
||||
}
|
||||
|
||||
// Serialize the request only when storing bodies (this is the expensive part).
|
||||
// Alongside it, attach a Capture so the HTTP transport can hand back the
|
||||
// untouched wire bodies — the normalized view below cannot reconstruct them
|
||||
@@ -184,6 +196,7 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
|
||||
usage llm.Usage
|
||||
stopReason string
|
||||
streamErr error
|
||||
complete bool // message_stop was seen
|
||||
)
|
||||
|
||||
finished := false
|
||||
@@ -198,6 +211,10 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
|
||||
}
|
||||
// Lightweight metering row — always written.
|
||||
r.recordUsage(ctx, taskID, expID, worker, usage, int(time.Since(start).Milliseconds()), status)
|
||||
// Opt-in context size telemetry — independent of recordBodies.
|
||||
if collectContext {
|
||||
r.recordContext(taskID, worker, ctxMetrics, usage, status)
|
||||
}
|
||||
// Heavy trace row — only when body recording is on.
|
||||
if recordBodies {
|
||||
r.record(req, session, taskID, worker, reqBody, capt, start, textBuf.String(), thinkingBuf.String(), usage, stopReason, err)
|
||||
@@ -236,8 +253,21 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
|
||||
stopReason = ev.StopReason
|
||||
}
|
||||
usage.MergeEcho(ev.Usage)
|
||||
case llm.SEMessageStop:
|
||||
complete = true
|
||||
}
|
||||
if !yield(ev, err) {
|
||||
// The consumer stopped early. Decide the status here from what
|
||||
// is known, not later in the deferred finish: the call only
|
||||
// counts as "ok" if message_stop arrived and ctx is live.
|
||||
switch {
|
||||
case ctx.Err() != nil:
|
||||
finish(ctx.Err())
|
||||
case !complete:
|
||||
finish(errStreamAbandoned)
|
||||
default:
|
||||
finish(nil)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
@@ -252,6 +282,7 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
|
||||
// usage metering, normalized body recording and raw wire capture as Stream.
|
||||
func (r *Recorder) Complete(ctx context.Context, req llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
|
||||
recordBodies := r.enabled == nil || r.enabled()
|
||||
collectContext := ContextTelemetryEnabled()
|
||||
start := time.Now()
|
||||
session := transcript.SessionIDFrom(ctx)
|
||||
parsedID, worker := parseSession(session)
|
||||
@@ -264,6 +295,11 @@ func (r *Recorder) Complete(ctx context.Context, req llm.CompletionRequest) (llm
|
||||
taskID = parsedID
|
||||
}
|
||||
|
||||
var ctxMetrics ContextMetrics
|
||||
if collectContext {
|
||||
ctxMetrics = MeasureContext(req)
|
||||
}
|
||||
|
||||
reqBody := ""
|
||||
var capt *Capture
|
||||
if recordBodies {
|
||||
@@ -279,6 +315,9 @@ func (r *Recorder) Complete(ctx context.Context, req llm.CompletionRequest) (llm
|
||||
reportStop(ctx, stopReason)
|
||||
}
|
||||
r.recordUsage(ctx, taskID, expID, worker, usage, int(time.Since(start).Milliseconds()), status)
|
||||
if collectContext {
|
||||
r.recordContext(taskID, worker, ctxMetrics, usage, status)
|
||||
}
|
||||
if recordBodies {
|
||||
r.record(req, session, taskID, worker, reqBody, capt, start, msg.Text(), thinkingText(msg), usage, stopReason, err)
|
||||
}
|
||||
|
||||
+12
-14
@@ -151,15 +151,9 @@ func (meteredStreamProvider) Stream(context.Context, llm.CompletionRequest) iter
|
||||
}
|
||||
|
||||
func TestSideUsageRecordedOnceOnConsumerCancellation(t *testing.T) {
|
||||
// Timing-sensitive on 2-core CI runners (BaaRai/ARTEX#9). Repro:
|
||||
// ARTEX_PG_DSN=postgres://artex:testpass@localhost:5432/artextest_race \
|
||||
// go test ./llmrec -run TestSideUsageRecordedOnceOnConsumerCancellation -count=20 -race -v
|
||||
// The `early=` t.Fatalf assertion below compares the single llm_usage row's
|
||||
// count/input/output/worker/status; in the `early` branch the status
|
||||
// occasionally comes back "ok" instead of "error" because the consumer's
|
||||
// cancellation and the recorder's deferred finish race on a loaded runner.
|
||||
// Keep the skip until the metering status is made cancellation-explicit.
|
||||
t.Skip("timing-sensitive on CI runners; repro and failing assertion documented above; BaaRai/ARTEX#9")
|
||||
// Previously skipped as timing-sensitive (BaaRai/ARTEX#9). The recorder now
|
||||
// decides the status at the point the consumer stops, so the result no
|
||||
// longer depends on when the deferred finish runs.
|
||||
dsn := os.Getenv("ARTEX_PG_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("requires isolated ARTEX_PG_DSN")
|
||||
@@ -169,7 +163,9 @@ func TestSideUsageRecordedOnceOnConsumerCancellation(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer pg.Close()
|
||||
for _, early := range []bool{false, true} {
|
||||
// full: read to the end. cancel: cancel ctx, then stop reading.
|
||||
// abandon: stop reading before message_stop with ctx still live.
|
||||
for _, mode := range []string{"full", "cancel", "abandon"} {
|
||||
profile := "btw-metering-" + uuid.NewString()
|
||||
ctx, cancel := context.WithCancel(transcript.WithSessionID(t.Context(), "exp0-btw-test"))
|
||||
recorder := Wrap(meteredStreamProvider{}, pg, "fixture", profile, "", "", func() bool { return false })
|
||||
@@ -177,8 +173,10 @@ func TestSideUsageRecordedOnceOnConsumerCancellation(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if early && event.Type == llm.SEMessageDelta {
|
||||
cancel()
|
||||
if mode != "full" && event.Type == llm.SEMessageDelta {
|
||||
if mode == "cancel" {
|
||||
cancel()
|
||||
}
|
||||
break // Consumer exits before the provider can return a cancellation event.
|
||||
}
|
||||
}
|
||||
@@ -192,11 +190,11 @@ FROM llm_usage WHERE profile_name=$1`, profile).Scan(&count, &input, &output, &w
|
||||
t.Fatal(err)
|
||||
}
|
||||
wantStatus := "ok"
|
||||
if early {
|
||||
if mode != "full" {
|
||||
wantStatus = "error"
|
||||
}
|
||||
if count != 1 || input != 23 || output != 5 || worker != "btw" || status != wantStatus {
|
||||
t.Fatalf("early=%v: count=%d usage=%d/%d worker=%q status=%q", early, count, input, output, worker, status)
|
||||
t.Fatalf("mode=%s: count=%d usage=%d/%d worker=%q status=%q", mode, count, input, output, worker, status)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,7 +16,7 @@ func TestChatUnavailableReasonDistinguishesStates(t *testing.T) {
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer m.Close()
|
||||
t.Cleanup(func() { _ = m.Close() })
|
||||
td := t.TempDir()
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
s := New(ctx, m, td, td, td)
|
||||
@@ -68,7 +68,7 @@ func TestResolveChatAgentHonoursConversationProfile(t *testing.T) {
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer m.Close()
|
||||
t.Cleanup(func() { _ = m.Close() })
|
||||
td := t.TempDir()
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
s := New(ctx, m, td, td, td)
|
||||
|
||||
@@ -73,6 +73,9 @@ func TestCoreTaskLifecyclePG(t *testing.T) {
|
||||
if id == "" || expID == 0 {
|
||||
t.Fatalf("bad task payload: %v", out)
|
||||
}
|
||||
defer func() {
|
||||
_, _ = m.pg.Exec(`DELETE FROM assets WHERE type = 'ip' AND ip = '127.0.0.1'`)
|
||||
}()
|
||||
|
||||
// the exploration owns goal node(s) — goal seeding is async, poll briefly
|
||||
var goals []*db.Node
|
||||
|
||||
@@ -168,6 +168,7 @@ type TrafficExchangeDTO struct {
|
||||
Status int `json:"status"`
|
||||
ContentType string `json:"content_type"`
|
||||
RespLen int `json:"resp_len"`
|
||||
Rewritten bool `json:"rewritten"`
|
||||
}
|
||||
|
||||
func trafficDTOs(ex []traffic.ExchangeMeta) []TrafficExchangeDTO {
|
||||
@@ -182,6 +183,7 @@ func trafficDTOs(ex []traffic.ExchangeMeta) []TrafficExchangeDTO {
|
||||
Status: e.Status,
|
||||
ContentType: e.ContentType,
|
||||
RespLen: e.RespLen,
|
||||
Rewritten: e.Rewritten,
|
||||
})
|
||||
}
|
||||
return out
|
||||
|
||||
@@ -84,7 +84,7 @@ func TestResetSettledRunReseedsBudgetFromUsage(t *testing.T) {
|
||||
if err != nil {
|
||||
pgdb.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer m.Close()
|
||||
t.Cleanup(func() { _ = m.Close() })
|
||||
|
||||
taskID := strconv.FormatInt(time.Now().UnixNano(), 10)
|
||||
t.Cleanup(func() {
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// The record_fact texts seeded by the releases v0.4.0 to v0.6.0, copied from
|
||||
// agent/tools.go at those tags. They are kept here, apart from the agent
|
||||
// package's list of known defaults, so the test fails when that list drifts
|
||||
// from the released bytes.
|
||||
const fix410ReleasedDescription = "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n" +
|
||||
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n" +
|
||||
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n" +
|
||||
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n" +
|
||||
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n" +
|
||||
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n" +
|
||||
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."
|
||||
|
||||
const fix410ReleasedFactsDescription = "[use when there are several distinct conclusions] array of facts; element fields same as the top-level fields below (summary/detail/evidence/confidence/intent_id/asset_ids); omitting intent_id falls back to the top-level intent_id. The returned ids match this array in length and order."
|
||||
|
||||
// A database seeded by a release stores the released record_fact description,
|
||||
// the released facts property description and facts items without properties.
|
||||
// The one-time refresh replaces both texts with the current ones and sets its
|
||||
// flag; texts an operator edited match no known default and stay as stored.
|
||||
func TestFix410ReleasedDefaultsRefreshed(t *testing.T) {
|
||||
for _, c := range []struct {
|
||||
name, text, sum string
|
||||
size int
|
||||
}{
|
||||
{"description", fix410ReleasedDescription, "0da5cec5cde7f5e6f41343418fcc2a7d132d6520f336efb39fcbf1ab6ac51957", 2038},
|
||||
{"facts description", fix410ReleasedFactsDescription, "eb054843a6b33dd39b94ba0648f292babb9cf9bdd106ee4eff6bf593d3f3edf4", 286},
|
||||
} {
|
||||
sum := sha256.Sum256([]byte(c.text))
|
||||
if len(c.text) != c.size || hex.EncodeToString(sum[:]) != c.sum {
|
||||
t.Fatalf("the released %s in this test is not the released text: %d bytes, sha256 %x", c.name, len(c.text), sum)
|
||||
}
|
||||
}
|
||||
skipWithoutDSN(t)
|
||||
m, err := NewManager(t.TempDir(), "")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer m.Close()
|
||||
s := &Server{m: m}
|
||||
const flag = "tool_schema_refresh_record_fact_facts_only"
|
||||
seed := recordFactSeed(t)
|
||||
seedSchema, _ := json.Marshal(seed.Schema)
|
||||
seedAgents, _ := json.Marshal(seed.Agents)
|
||||
defer func() {
|
||||
_ = m.pg.UpsertToolForce("record_fact", seed.Desc, seedSchema, seedAgents)
|
||||
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1`, flag)
|
||||
}()
|
||||
currentFacts := seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)["description"]
|
||||
|
||||
// start stores the row as a release seeded it, with the given two texts,
|
||||
// runs the startup steps and returns the two texts as stored afterwards.
|
||||
start := func(desc, factsDesc string) (string, any) {
|
||||
t.Helper()
|
||||
str := func(d string) map[string]any { return map[string]any{"type": "string", "description": d} }
|
||||
schema, _ := json.Marshal(map[string]any{"type": "object", "properties": map[string]any{
|
||||
"facts": map[string]any{"type": "array", "description": factsDesc, "items": map[string]any{"type": "object"}},
|
||||
"summary": str("a [one-sentence summary] of this exploration's conclusion (a condensation of detail)"),
|
||||
"intent_id": map[string]any{"type": "integer", "description": "the id of the intent that produced this fact (the intent you claimed; the default for each item in batch mode)"},
|
||||
"detail": str("details related to this fact: write all of this exploration's observations here"),
|
||||
"evidence": str("[one line] of key evidence: the command + the one or two most proving output lines. Keep it brief; don't paste large output blocks (details go in detail)."),
|
||||
"confidence": str("observed (seen directly in output) | inferred (inferred from phenomena). Always label negative conclusions honestly."),
|
||||
"asset_ids": map[string]any{"type": "array", "items": map[string]any{"type": "integer"}, "description": "related asset ids (optional, 0/1/many): which assets this fact involves"},
|
||||
}})
|
||||
if err := m.pg.UpsertToolForce("record_fact", desc, schema, seedAgents); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := m.pg.Exec(`DELETE FROM settings WHERE key=$1`, flag); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s.seedFactInputSchema()
|
||||
s.seedFactSourceSchema()
|
||||
s.refreshRecordFactContract()
|
||||
if v, _, _ := m.pg.GetSetting(flag); v != "true" {
|
||||
t.Errorf("flag = %q after the refresh, want true", v)
|
||||
}
|
||||
row, err := m.pg.GetTool("record_fact")
|
||||
if err != nil || row == nil {
|
||||
t.Fatalf("row: %v", err)
|
||||
}
|
||||
var stored struct {
|
||||
Properties map[string]map[string]any `json:"properties"`
|
||||
}
|
||||
if err := json.Unmarshal(row.Schema, &stored); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(stored.Properties) != 1 || stored.Properties["facts"] == nil {
|
||||
t.Fatalf("top level still holds fact fields: %s", row.Schema)
|
||||
}
|
||||
return row.Description, stored.Properties["facts"]["description"]
|
||||
}
|
||||
|
||||
desc, factsDesc := start(fix410ReleasedDescription, fix410ReleasedFactsDescription)
|
||||
if desc != seed.Desc {
|
||||
t.Errorf("released description not replaced by the current one: %.60q", desc)
|
||||
}
|
||||
if factsDesc != currentFacts {
|
||||
t.Errorf("released facts description not replaced by the current one: %v", factsDesc)
|
||||
}
|
||||
|
||||
editedDesc := fix410ReleasedDescription + "\nOperator note: record every negative result."
|
||||
editedFacts := fix410ReleasedFactsDescription + " Operator note: one fact per host."
|
||||
desc, factsDesc = start(editedDesc, editedFacts)
|
||||
if desc != editedDesc {
|
||||
t.Errorf("operator description changed: %.60q", desc)
|
||||
}
|
||||
if factsDesc != editedFacts {
|
||||
t.Errorf("operator facts description changed: %v", factsDesc)
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,99 @@ import (
|
||||
|
||||
// SeedTool only inserts new rows. Repair existing built-ins too, while keeping
|
||||
// descriptions, bindings, enabled/deferred flags and parameter annotations.
|
||||
|
||||
// refreshRecordFactContract brings an already-seeded record_fact row to the
|
||||
// facts-only contract (one-time, settings flag). SeedTool is first-insert-only
|
||||
// and ToolResolve serves the stored text, so without this an old database keeps
|
||||
// describing the earlier contract (fact fields at the top level beside facts[])
|
||||
// to the model. Only text equal to the previous code default is replaced:
|
||||
// - the tool description;
|
||||
// - the facts property and item descriptions that referred to the top level.
|
||||
//
|
||||
// Operator edits stay; a description that matches no known default is logged
|
||||
// as such and left in place. The schema structure itself is repaired by
|
||||
// seedFactInputSchema on every start (RepairRecordFactSchema).
|
||||
//
|
||||
// The flag is written only once the outcome is known: the UPDATE succeeded
|
||||
// (also when it changed no row) or the row is not the built-in one. A failed
|
||||
// read, decode or UPDATE leaves it unset, so the next start retries.
|
||||
func (s *Server) refreshRecordFactContract() {
|
||||
const flag = "tool_schema_refresh_record_fact_facts_only"
|
||||
if v, _, _ := s.m.pg.GetSetting(flag); v == "true" {
|
||||
return
|
||||
}
|
||||
done := func() { _ = s.m.pg.SetSetting(flag, "true") }
|
||||
var seed *agent.ToolSeed
|
||||
for _, sd := range agent.BuiltinToolSeeds() {
|
||||
if sd.Key == "record_fact" {
|
||||
seed = &sd
|
||||
break
|
||||
}
|
||||
}
|
||||
row, err := s.m.pg.GetTool("record_fact")
|
||||
if err != nil {
|
||||
log.Printf("[facts] read record_fact for the contract refresh: %v", err)
|
||||
return
|
||||
}
|
||||
if row == nil || seed == nil {
|
||||
return
|
||||
}
|
||||
if !row.System || row.Kind != "builtin" {
|
||||
done()
|
||||
return
|
||||
}
|
||||
legacyTool, legacyFacts, legacyItems := agent.RecordFactLegacyDescriptions()
|
||||
desc := row.Description
|
||||
switch {
|
||||
case desc == seed.Desc:
|
||||
case sliceHas(legacyTool, desc):
|
||||
desc = seed.Desc
|
||||
default:
|
||||
log.Printf("[facts] record_fact description does not match a known default (operator edit or an older release); the facts-only schema is published anyway, review the text in the tool catalog")
|
||||
}
|
||||
var schema map[string]any
|
||||
if err := json.Unmarshal(row.Schema, &schema); err != nil {
|
||||
log.Printf("[facts] decode record_fact schema: %v", err)
|
||||
return
|
||||
}
|
||||
repaired := agent.RepairRecordFactSchema(schema)
|
||||
facts := repaired["properties"].(map[string]any)["facts"].(map[string]any)
|
||||
canonFacts := seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)
|
||||
if d, ok := facts["description"].(string); ok && sliceHas(legacyFacts, d) {
|
||||
facts["description"] = canonFacts["description"]
|
||||
}
|
||||
items := facts["items"].(map[string]any)["properties"].(map[string]any)
|
||||
canonItems := canonFacts["items"].(map[string]any)["properties"].(map[string]any)
|
||||
for name, old := range legacyItems {
|
||||
prop, _ := items[name].(map[string]any)
|
||||
want, _ := canonItems[name].(map[string]any)
|
||||
if prop != nil && want != nil && prop["description"] == old {
|
||||
prop["description"] = want["description"]
|
||||
}
|
||||
}
|
||||
raw, err := json.Marshal(repaired)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if _, err := s.m.pg.Exec(`UPDATE tools SET description=$1, schema=$2::jsonb, updated_at=now()
|
||||
WHERE key='record_fact' AND system AND kind='builtin'
|
||||
AND (description IS DISTINCT FROM $1 OR schema IS DISTINCT FROM $2::jsonb)`, desc, string(raw)); err != nil {
|
||||
log.Printf("[facts] refresh record_fact contract: %v", err)
|
||||
return
|
||||
}
|
||||
done()
|
||||
log.Printf("[facts] record_fact now publishes the facts-only contract (one-time)")
|
||||
}
|
||||
|
||||
func sliceHas(list []string, s string) bool {
|
||||
for _, v := range list {
|
||||
if v == s {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (s *Server) seedFactInputSchema() {
|
||||
row, err := s.m.pg.GetTool("record_fact")
|
||||
if err != nil {
|
||||
|
||||
@@ -3,6 +3,7 @@ package server
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
@@ -42,10 +43,16 @@ func TestRecordFactInputSchemaUpgrade(t *testing.T) {
|
||||
if err := pg.UpdateTool("record_fact", "operator tool", raw, bindings, old.Enabled); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Facts-only contract: the top level holds facts and
|
||||
// nothing else; the earlier top-level fact fields and their operator
|
||||
// annotations are dropped (the handler still accepts the legacy shapes),
|
||||
// item annotations survive.
|
||||
check := func(schema map[string]any) {
|
||||
t.Helper()
|
||||
if _, ok := schema["required"]; ok {
|
||||
t.Fatal("top-level summary still required for batches")
|
||||
if req, _ := schema["required"].([]any); len(req) != 1 || req[0] != "facts" {
|
||||
if reqS, _ := schema["required"].([]string); len(reqS) != 1 || reqS[0] != "facts" {
|
||||
t.Fatalf("facts must be the only required property: %v", schema["required"])
|
||||
}
|
||||
}
|
||||
if _, ok := schema["anyOf"]; ok {
|
||||
t.Fatal("root anyOf still present")
|
||||
@@ -54,14 +61,13 @@ func TestRecordFactInputSchemaUpgrade(t *testing.T) {
|
||||
t.Fatal("unknown fields allowed")
|
||||
}
|
||||
props := schema["properties"].(map[string]any)
|
||||
if len(props) != 1 || props["facts"] == nil {
|
||||
t.Fatalf("top level must hold facts only: %v", props)
|
||||
}
|
||||
items := props["facts"].(map[string]any)["items"].(map[string]any)
|
||||
itemProps := items["properties"].(map[string]any)
|
||||
if props["tested_asset_ids"] == nil || itemProps["tested_asset_ids"] == nil || itemProps["summary"] == nil {
|
||||
t.Fatal("repaired schema missing alias or batch summary")
|
||||
}
|
||||
if props["summary"].(map[string]any)["description"] != "operator summary" ||
|
||||
props["confidence"].(map[string]any)["default"] != "inferred" || props["custom"] != nil {
|
||||
t.Fatal("operator annotations lost")
|
||||
if itemProps["tested_asset_ids"] == nil || itemProps["summary"] == nil || itemProps["source"] == nil {
|
||||
t.Fatal("repaired schema missing alias, batch summary or source")
|
||||
}
|
||||
if err := actool.ValidateInput(schema, json.RawMessage(`{"facts":[{"summary":"complete batch item"}]}`)); err != nil {
|
||||
t.Fatal("valid batch rejected", err)
|
||||
@@ -104,3 +110,217 @@ func TestRecordFactInputSchemaUpgrade(t *testing.T) {
|
||||
t.Fatal("second migration changed the row")
|
||||
}
|
||||
}
|
||||
|
||||
// recordFactLegacySchema is the stored record_fact schema of the earlier
|
||||
// contract: fact fields at the top level beside facts[], with the texts that
|
||||
// referred to the top level, plus an operator annotation on an item field.
|
||||
func recordFactLegacySchema(t *testing.T) (string, map[string]string) {
|
||||
t.Helper()
|
||||
_, legacyFacts, legacyItems := agent.RecordFactLegacyDescriptions()
|
||||
item := map[string]any{"type": "object", "required": []string{"summary"}, "additionalProperties": false, "properties": map[string]any{
|
||||
"summary": map[string]any{"type": "string", "minLength": 1, "description": legacyItems["summary"]},
|
||||
"intent_id": map[string]any{"type": "integer", "description": legacyItems["intent_id"]},
|
||||
"detail": map[string]any{"type": "string", "description": "Details of this fact, including all related observations."},
|
||||
"confidence": map[string]any{"type": "string", "description": "operator confidence note", "default": "inferred"},
|
||||
"source": map[string]any{"type": "string", "enum": []string{"target_response", "tool_output", "third_party_intel", "operator_input", "inference"}, "description": "where the content came from"},
|
||||
}}
|
||||
schema := map[string]any{"type": "object", "additionalProperties": false, "properties": map[string]any{
|
||||
"summary": map[string]any{"type": "string", "minLength": 1, "description": legacyItems["summary"]},
|
||||
"intent_id": map[string]any{"type": "integer", "description": legacyItems["intent_id"]},
|
||||
"detail": map[string]any{"type": "string", "description": "Details of this fact, including all related observations."},
|
||||
"source": map[string]any{"type": "string", "enum": []string{"inference"}},
|
||||
"facts": map[string]any{"type": "array", "minItems": 1, "description": legacyFacts[0], "items": item},
|
||||
}}
|
||||
raw, _ := json.Marshal(schema)
|
||||
return string(raw), legacyItems
|
||||
}
|
||||
|
||||
func recordFactSeed(t *testing.T) agent.ToolSeed {
|
||||
t.Helper()
|
||||
for _, sd := range agent.BuiltinToolSeeds() {
|
||||
if sd.Key == "record_fact" {
|
||||
return sd
|
||||
}
|
||||
}
|
||||
t.Fatal("record_fact seed missing")
|
||||
return agent.ToolSeed{}
|
||||
}
|
||||
|
||||
// A database that still stores the earlier record_fact contract (text and
|
||||
// schema) is brought to the facts-only contract once: description replaced
|
||||
// when it is the previous default, facts/item descriptions replaced when they
|
||||
// are the earlier texts, operator annotations kept, top-level fact fields
|
||||
// gone, source enum present on the items. A second run changes nothing, and
|
||||
// an operator-edited description is left alone.
|
||||
func TestRefreshRecordFactContract(t *testing.T) {
|
||||
skipWithoutDSN(t)
|
||||
m, err := NewManager(t.TempDir(), "")
|
||||
if err != nil {
|
||||
t.Skipf("postgres unavailable (%v)", err)
|
||||
}
|
||||
defer m.Close()
|
||||
s := &Server{m: m}
|
||||
seed := recordFactSeed(t)
|
||||
seedSchema, _ := json.Marshal(seed.Schema)
|
||||
seedAgents, _ := json.Marshal(seed.Agents)
|
||||
restore := func() {
|
||||
_ = m.pg.UpsertToolForce("record_fact", seed.Desc, seedSchema, seedAgents)
|
||||
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key='tool_schema_refresh_record_fact_facts_only'`)
|
||||
}
|
||||
defer restore()
|
||||
|
||||
legacyTool, _, legacyItems := agent.RecordFactLegacyDescriptions()
|
||||
legacySchema, _ := recordFactLegacySchema(t)
|
||||
run := func(desc string) {
|
||||
t.Helper()
|
||||
if err := m.pg.UpsertToolForce("record_fact", desc, json.RawMessage(legacySchema), seedAgents); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := m.pg.Exec(`DELETE FROM settings WHERE key='tool_schema_refresh_record_fact_facts_only'`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s.seedFactInputSchema()
|
||||
s.seedFactSourceSchema()
|
||||
s.refreshRecordFactContract()
|
||||
}
|
||||
for _, desc := range legacyTool {
|
||||
run(desc)
|
||||
row, err := m.pg.GetTool("record_fact")
|
||||
if err != nil || row == nil {
|
||||
t.Fatalf("row: %v", err)
|
||||
}
|
||||
if row.Description != seed.Desc {
|
||||
t.Fatalf("description not refreshed from a known default: %q", row.Description[:60])
|
||||
}
|
||||
var schema map[string]any
|
||||
if err := json.Unmarshal(row.Schema, &schema); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
props := schema["properties"].(map[string]any)
|
||||
if len(props) != 1 || props["facts"] == nil {
|
||||
t.Fatalf("top level still holds fact fields: %v", props)
|
||||
}
|
||||
facts := props["facts"].(map[string]any)
|
||||
items := facts["items"].(map[string]any)["properties"].(map[string]any)
|
||||
canonItems := seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)["items"].(map[string]any)["properties"].(map[string]any)
|
||||
if facts["description"] != seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)["description"] {
|
||||
t.Fatalf("facts description not refreshed: %v", facts["description"])
|
||||
}
|
||||
for name := range legacyItems {
|
||||
if items[name].(map[string]any)["description"] != canonItems[name].(map[string]any)["description"] {
|
||||
t.Fatalf("item %s description not refreshed: %v", name, items[name])
|
||||
}
|
||||
}
|
||||
if items["confidence"].(map[string]any)["description"] != "operator confidence note" || items["confidence"].(map[string]any)["default"] != "inferred" {
|
||||
t.Fatalf("operator annotation lost: %v", items["confidence"])
|
||||
}
|
||||
if enum, _ := items["source"].(map[string]any)["enum"].([]any); len(enum) != 5 {
|
||||
t.Fatalf("source enum missing on the items: %v", items["source"])
|
||||
}
|
||||
if v, _, _ := m.pg.GetSetting("tool_schema_refresh_record_fact_facts_only"); v != "true" {
|
||||
t.Fatal("flag not set")
|
||||
}
|
||||
// Second start: nothing changes.
|
||||
var updated1, updated2 string
|
||||
_ = m.pg.QueryRow(`SELECT updated_at::text FROM tools WHERE key='record_fact'`).Scan(&updated1)
|
||||
s.seedFactInputSchema()
|
||||
s.seedFactSourceSchema()
|
||||
s.refreshRecordFactContract()
|
||||
_ = m.pg.QueryRow(`SELECT updated_at::text FROM tools WHERE key='record_fact'`).Scan(&updated2)
|
||||
if updated1 != updated2 {
|
||||
t.Fatal("second start rewrote the row")
|
||||
}
|
||||
}
|
||||
// An operator-edited description is kept; the schema is still repaired.
|
||||
run("my own record_fact text")
|
||||
row, _ := m.pg.GetTool("record_fact")
|
||||
if row == nil || row.Description != "my own record_fact text" {
|
||||
t.Fatalf("operator description replaced: %v", row)
|
||||
}
|
||||
if !strings.Contains(string(row.Schema), `"facts"`) || strings.Contains(string(row.Schema), legacyItems["intent_id"]) {
|
||||
t.Fatalf("schema not repaired beside an operator description: %s", row.Schema)
|
||||
}
|
||||
}
|
||||
|
||||
// A start on which the refresh fails must not spend the one-time flag: the
|
||||
// next start retries and the stored default text is refreshed then.
|
||||
func TestFix410RefreshFlagNotSetOnFailure(t *testing.T) {
|
||||
skipWithoutDSN(t)
|
||||
m, err := NewManager(t.TempDir(), "")
|
||||
if err != nil {
|
||||
t.Skipf("postgres unavailable (%v)", err)
|
||||
}
|
||||
defer m.Close()
|
||||
s := &Server{m: m}
|
||||
const flag = "tool_schema_refresh_record_fact_facts_only"
|
||||
seed := recordFactSeed(t)
|
||||
seedSchema, _ := json.Marshal(seed.Schema)
|
||||
seedAgents, _ := json.Marshal(seed.Agents)
|
||||
legacyTool, _, _ := agent.RecordFactLegacyDescriptions()
|
||||
legacySchema, _ := recordFactLegacySchema(t)
|
||||
exec := func(query string, args ...any) {
|
||||
t.Helper()
|
||||
if _, err := m.pg.Exec(query, args...); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
const dropTrigger = `DROP TRIGGER IF EXISTS fix410_fail_update ON tools`
|
||||
defer func() {
|
||||
_, _ = m.pg.Exec(dropTrigger)
|
||||
_, _ = m.pg.Exec(`DROP FUNCTION IF EXISTS fix410_fail_update()`)
|
||||
_ = m.pg.UpsertToolForce("record_fact", seed.Desc, seedSchema, seedAgents)
|
||||
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1`, flag)
|
||||
}()
|
||||
exec(`CREATE OR REPLACE FUNCTION fix410_fail_update() RETURNS trigger LANGUAGE plpgsql AS
|
||||
'BEGIN RAISE EXCEPTION ''fix410: simulated transient failure''; END'`)
|
||||
|
||||
start := func() {
|
||||
s.seedFactInputSchema()
|
||||
s.seedFactSourceSchema()
|
||||
s.refreshRecordFactContract()
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
fail, clear func()
|
||||
}{
|
||||
{"update fails", func() {
|
||||
exec(`CREATE TRIGGER fix410_fail_update BEFORE UPDATE ON tools
|
||||
FOR EACH ROW WHEN (OLD.key = 'record_fact') EXECUTE FUNCTION fix410_fail_update()`)
|
||||
}, func() { exec(dropTrigger) }},
|
||||
{"schema does not decode", func() {
|
||||
exec(`UPDATE tools SET schema='[]'::jsonb WHERE key='record_fact'`)
|
||||
}, func() {
|
||||
exec(`UPDATE tools SET schema=$1::jsonb WHERE key='record_fact'`, legacySchema)
|
||||
}},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
// A database that stores the earlier default text and has not run the refresh.
|
||||
if err := m.pg.UpsertToolForce("record_fact", legacyTool[0], json.RawMessage(legacySchema), seedAgents); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
exec(`DELETE FROM settings WHERE key=$1`, flag)
|
||||
|
||||
tc.fail()
|
||||
start()
|
||||
if v, ok, _ := m.pg.GetSetting(flag); ok {
|
||||
t.Errorf("flag is %q after a failed refresh: later starts skip it", v)
|
||||
}
|
||||
if row, _ := m.pg.GetTool("record_fact"); row == nil || row.Description != legacyTool[0] {
|
||||
t.Fatal("the simulated failure did not leave the earlier description in place")
|
||||
}
|
||||
|
||||
tc.clear()
|
||||
start()
|
||||
row, err := m.pg.GetTool("record_fact")
|
||||
if err != nil || row == nil {
|
||||
t.Fatalf("row: %v", err)
|
||||
}
|
||||
if row.Description != seed.Desc {
|
||||
t.Errorf("the next start did not refresh the description: %.60q", row.Description)
|
||||
}
|
||||
if v, _, _ := m.pg.GetSetting(flag); v != "true" {
|
||||
t.Errorf("flag = %q after a successful refresh, want true", v)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -35,12 +35,13 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
|
||||
t.Cleanup(func() { pg.UpdateTool(old.Key, old.Description, old.Schema, bindings, old.Enabled) })
|
||||
|
||||
// Simulate a pre-provenance row customised by the operator: no source
|
||||
// property, an edited description and an edited parameter description.
|
||||
// property on the facts items, an edited description and an edited
|
||||
// parameter description (facts-only contract: the items carry the fields).
|
||||
var schema map[string]any
|
||||
if err := json.Unmarshal(old.Schema, &schema); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
props := schema["properties"].(map[string]any)
|
||||
props := schema["properties"].(map[string]any)["facts"].(map[string]any)["items"].(map[string]any)["properties"].(map[string]any)
|
||||
delete(props, "source")
|
||||
props["confidence"].(map[string]any)["description"] = "operator confidence text"
|
||||
custom, _ := json.Marshal(schema)
|
||||
@@ -72,16 +73,23 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var got struct {
|
||||
Properties map[string]map[string]any `json:"properties"`
|
||||
Properties struct {
|
||||
Facts struct {
|
||||
Items struct {
|
||||
Properties map[string]map[string]any `json:"properties"`
|
||||
} `json:"items"`
|
||||
} `json:"facts"`
|
||||
} `json:"properties"`
|
||||
}
|
||||
if err := json.Unmarshal(tool.Schema, &got); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
itemProps := got.Properties.Facts.Items.Properties
|
||||
wantEnum := "[target_response tool_output third_party_intel operator_input inference]"
|
||||
if src := got.Properties["source"]; src == nil || fmt.Sprint(src["enum"]) != wantEnum {
|
||||
if src := itemProps["source"]; src == nil || fmt.Sprint(src["enum"]) != wantEnum {
|
||||
t.Fatalf("upgrade did not add the source enum: %s", tool.Schema)
|
||||
}
|
||||
if tool.Description != "operator description" || got.Properties["confidence"]["description"] != "operator confidence text" || len(got.Properties) != len(props)+1 {
|
||||
if tool.Description != "operator description" || itemProps["confidence"]["description"] != "operator confidence text" || len(itemProps) != len(props)+1 {
|
||||
t.Fatalf("operator configuration overwritten: %q %s", tool.Description, tool.Schema)
|
||||
}
|
||||
|
||||
@@ -92,15 +100,18 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// resolvedRecordFactProps returns the properties of record_fact as ToolResolve
|
||||
// serves it to the worker.
|
||||
// resolvedRecordFactProps returns the facts[] item properties of record_fact as
|
||||
// ToolResolve serves it to the worker.
|
||||
func resolvedRecordFactProps(t *testing.T) map[string]any {
|
||||
t.Helper()
|
||||
tools := agent.ToolResolve()(context.Background(), "worker", agent.NewToolSet(nil, "").WorkerTools())
|
||||
for _, tl := range tools {
|
||||
if tl.Name() == "record_fact" {
|
||||
props, _ := tl.InputSchema()["properties"].(map[string]any)
|
||||
return props
|
||||
facts, _ := props["facts"].(map[string]any)
|
||||
items, _ := facts["items"].(map[string]any)
|
||||
itemProps, _ := items["properties"].(map[string]any)
|
||||
return itemProps
|
||||
}
|
||||
}
|
||||
t.Fatal("worker lost record_fact")
|
||||
|
||||
@@ -38,7 +38,11 @@ func trafficEvidenceServer(t *testing.T) (*Server, *db.RecordedFinding, func(str
|
||||
t.Fatal(err)
|
||||
}
|
||||
tid, _ := strconv.ParseInt(task.ID, 10, 64)
|
||||
t.Cleanup(func() { m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, tid); m.pg.DeleteTask(tid) })
|
||||
t.Cleanup(func() {
|
||||
_, _ = m.pg.DeleteFindingsByTask(tid)
|
||||
_, _ = m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, tid)
|
||||
_ = m.pg.DeleteTask(tid)
|
||||
})
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
|
||||
@@ -278,6 +282,7 @@ func TestFindingTrafficArchiveV3RoundTripAndRetry(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer s.m.pg.DeleteFinding(shared.FindingID)
|
||||
if _, err = s.m.traffic.DeleteHost("evidence.local"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
@@ -286,15 +286,19 @@ func TestDeepenAdmissionFailureDiscardsFollowUpIntent(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
|
||||
var findingID int64
|
||||
defer func() {
|
||||
_, _ = m.pg.Exec(`UPDATE tasks SET deleted_at=NULL WHERE id=$1`, taskID)
|
||||
if findingID > 0 {
|
||||
_, _ = m.pg.DeleteFinding(findingID)
|
||||
}
|
||||
_, _ = m.DeleteTask(task.ID, DeleteTaskOptions{})
|
||||
}()
|
||||
findingNodeID, err := task.Store.AddNode(db.KindFinding, map[string]any{"summary": "source"}, 5, "confirmed", "worker", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
findingID, err := m.pg.AddFinding(taskID, findingNodeID, "test", "source", db.SeverityHigh, "source", "", "worker", nil)
|
||||
findingID, err = m.pg.AddFinding(taskID, findingNodeID, "test", "source", db.SeverityHigh, "source", "", "worker", nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
@@ -36,7 +36,10 @@ func TestTaskLessonsExtractionAndIdempotency(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
|
||||
defer func() { _ = m.pg.DeleteTask(taskID) }()
|
||||
defer func() {
|
||||
_, _ = m.pg.DeleteFindingsByTask(taskID)
|
||||
_ = m.pg.DeleteTask(taskID)
|
||||
}()
|
||||
defer func() { _, _ = m.pg.Exec(`DELETE FROM rsi_lessons`) }()
|
||||
|
||||
if _, err := m.pg.Exec(`
|
||||
@@ -138,7 +141,10 @@ func TestTerminalStatusExtractsLessons(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
|
||||
defer func() { _ = m.pg.DeleteTask(taskID) }()
|
||||
defer func() {
|
||||
_, _ = m.pg.DeleteFindingsByTask(taskID)
|
||||
_ = m.pg.DeleteTask(taskID)
|
||||
}()
|
||||
if _, err := m.pg.Exec(`
|
||||
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
|
||||
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')`, taskID); err != nil {
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/artex/llmrec"
|
||||
)
|
||||
|
||||
// pgLLMContextSummary returns aggregated context-size telemetry from
|
||||
// llm_context: per-(worker, model) input percentiles, pro-rata section shares
|
||||
// over real input_tokens, cache_read/input ratio, and top tasks by input
|
||||
// tokens. Read-only reporting endpoint (no UI in Phase A).
|
||||
func (s *Server) pgLLMContextSummary(w http.ResponseWriter, r *http.Request) {
|
||||
pg := s.m.PG()
|
||||
if pg == nil {
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"enabled": llmrec.ContextTelemetryEnabled(),
|
||||
"by_worker_model": []db.LLMContextGroupStat{},
|
||||
"top_tasks": []db.LLMContextTaskStat{},
|
||||
})
|
||||
return
|
||||
}
|
||||
q := r.URL.Query()
|
||||
summary, err := pg.LLMContextSummary(db.LLMContextQuery{
|
||||
Days: atoiDefault(q.Get("days"), 30),
|
||||
TaskID: strings.TrimSpace(q.Get("task")),
|
||||
TopTasks: atoiDefault(q.Get("top"), 20),
|
||||
})
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusInternalServerError, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]any{
|
||||
"enabled": llmrec.ContextTelemetryEnabled(),
|
||||
"by_worker_model": summary.ByWorkerModel,
|
||||
"top_tasks": summary.TopTasks,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/artex/llmrec"
|
||||
)
|
||||
|
||||
func TestLLMContextSummaryEndpointAuthAndAggregation(t *testing.T) {
|
||||
s, request := ingestServer(t)
|
||||
|
||||
// Unauthenticated request -> 401.
|
||||
rNoAuth := httptest.NewRequest(http.MethodGet, "/api/llm/context/summary", nil)
|
||||
wNoAuth := httptest.NewRecorder()
|
||||
s.Handler().ServeHTTP(wNoAuth, rNoAuth)
|
||||
if wNoAuth.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("unauthenticated /api/llm/context/summary status=%d, want 401", wNoAuth.Code)
|
||||
}
|
||||
|
||||
taskID := fmt.Sprintf("srv-ctx-%d", time.Now().UnixNano())
|
||||
t.Cleanup(func() { _, _ = s.m.PG().Exec(`DELETE FROM llm_context WHERE task_id=$1`, taskID) })
|
||||
|
||||
if err := s.m.PG().InsertLLMContext(&db.LLMContext{
|
||||
TaskID: taskID, Worker: "worker", Model: "test-model", Profile: "p1",
|
||||
ToolCount: 8, MessageCount: 5,
|
||||
SystemStaticBytes: 250, ToolsBytes: 250,
|
||||
MessagesUserBytes: 400, MessagesAssistantBytes: 100, ToolResultBytes: 300,
|
||||
LastMessageBytes: 200,
|
||||
InputTokens: 1000, OutputTokens: 120, CacheRead: 700, CacheWrite: 100, Status: "ok",
|
||||
}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
t.Setenv(llmrec.ContextTelemetryEnv, "1")
|
||||
w := request(http.MethodGet, "/api/llm/context/summary?days=7&top=5&task="+taskID, "")
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("GET /api/llm/context/summary status=%d body=%s", w.Code, w.Body.String())
|
||||
}
|
||||
var resp struct {
|
||||
Enabled bool `json:"enabled"`
|
||||
ByWorkerModel []db.LLMContextGroupStat `json:"by_worker_model"`
|
||||
TopTasks []db.LLMContextTaskStat `json:"top_tasks"`
|
||||
}
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !resp.Enabled || len(resp.ByWorkerModel) != 1 || len(resp.TopTasks) != 1 {
|
||||
t.Fatalf("unexpected summary response: %+v", resp)
|
||||
}
|
||||
g := resp.ByWorkerModel[0]
|
||||
if g.Worker != "worker" || g.Model != "test-model" || g.Calls != 1 || g.InputTokensTotal != 1000 ||
|
||||
g.CacheReadRatio < 0.699 || g.CacheReadRatio > 0.701 ||
|
||||
g.Shares.SystemStatic < 0.249 || g.Shares.Tools < 0.249 || g.Shares.MessagesUser < 0.399 {
|
||||
t.Fatalf("unexpected group stat: %+v", g)
|
||||
}
|
||||
}
|
||||
@@ -74,6 +74,7 @@ func TestRecorderPersistsRawWireBodies(t *testing.T) {
|
||||
if _, err := pg.Exec(`DELETE FROM llm_records WHERE session_id = $1`, session); err != nil {
|
||||
t.Logf("cleanup: %v", err)
|
||||
}
|
||||
_, _ = pg.Exec(`DELETE FROM llm_usage WHERE task_id = '999999' AND profile_name = 'raw-test-profile'`)
|
||||
}()
|
||||
|
||||
ctx := transcript.WithSessionID(context.Background(), session)
|
||||
|
||||
@@ -18,7 +18,7 @@ func TestSeedAssociatesTargetAssetWithTask(t *testing.T) {
|
||||
if err != nil {
|
||||
pgdb.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer m.Close()
|
||||
t.Cleanup(func() { _ = m.Close() })
|
||||
task, err := m.CreateTask("seed ownership", "seed ownership", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
|
||||
@@ -72,7 +72,10 @@ func newNotifyFixture(t *testing.T) *notifyFixture {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { pg.Exec(`DELETE FROM tasks WHERE id=$1`, taskID) })
|
||||
t.Cleanup(func() {
|
||||
_, _ = pg.DeleteFindingsByTask(taskID)
|
||||
_ = pg.DeleteTask(taskID)
|
||||
})
|
||||
|
||||
var mark int64
|
||||
if err := pg.QueryRow(`SELECT COALESCE(max(id),0) FROM notification_events`).Scan(&mark); err != nil {
|
||||
|
||||
+16
-3
@@ -573,6 +573,7 @@ func (s *Server) seedOrchestrationTools() {
|
||||
s.seedFindingEvidenceSchema() // optional counterevidence / confidence_rationale on report_finding, added once per DB
|
||||
s.seedFactInputSchema() // restore record_fact single/batch contracts
|
||||
s.seedFactSourceSchema() // source enum on record_fact, added once per DB
|
||||
s.refreshRecordFactContract() // record_fact publishes the facts-only contract (one-time)
|
||||
s.seedTaskScopeDescription() // add_task_scope: "coverage scope, not enforced" replaces the authorization-boundary text
|
||||
// Note: pentest's default tool bindings need no migration — BuiltinToolSeeds already seeds
|
||||
// list_assets/insert_assets/report_finding/list_findings/list_companies together with
|
||||
@@ -602,11 +603,23 @@ func (s *Server) seedFactSourceSchema() {
|
||||
if err := json.Unmarshal(obj["properties"], &properties); err != nil {
|
||||
return
|
||||
}
|
||||
if len(properties["source"]) == 0 {
|
||||
// The source enum lives on the facts[] items (facts-only contract); the
|
||||
// top level has no fact fields any more.
|
||||
var facts map[string]json.RawMessage
|
||||
var items map[string]json.RawMessage
|
||||
var itemProps map[string]json.RawMessage
|
||||
if err := json.Unmarshal(properties["facts"], &facts); err != nil {
|
||||
return
|
||||
}
|
||||
_, err = s.m.pg.Exec(`UPDATE tools SET schema=jsonb_set(schema,ARRAY['properties','source'],$1::jsonb,true),updated_at=now()
|
||||
WHERE key='record_fact' AND system AND NOT(COALESCE(schema->'properties','{}'::jsonb) ? 'source')`, string(properties["source"]))
|
||||
if err := json.Unmarshal(facts["items"], &items); err != nil {
|
||||
return
|
||||
}
|
||||
if err := json.Unmarshal(items["properties"], &itemProps); err != nil || len(itemProps["source"]) == 0 {
|
||||
return
|
||||
}
|
||||
_, err = s.m.pg.Exec(`UPDATE tools SET schema=jsonb_set(schema,ARRAY['properties','facts','items','properties','source'],$1::jsonb,true),updated_at=now()
|
||||
WHERE key='record_fact' AND system AND (schema->'properties'->'facts'->'items') ? 'properties'
|
||||
AND NOT(COALESCE(schema->'properties'->'facts'->'items'->'properties','{}'::jsonb) ? 'source')`, string(itemProps["source"]))
|
||||
if err != nil {
|
||||
log.Printf("[facts] upgrade record_fact.source: %v", err)
|
||||
}
|
||||
|
||||
@@ -24,6 +24,7 @@ func TestPlannerQuietSkipEdge(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = m.DeleteTask(created.ID, DeleteTaskOptions{}) })
|
||||
tt, ok := m.Task(created.ID)
|
||||
if !ok {
|
||||
t.Fatal("task not found after creation")
|
||||
@@ -93,6 +94,7 @@ func TestPlannerQuietModeToggleMidRun(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = m.DeleteTask(created.ID, DeleteTaskOptions{}) })
|
||||
tt, ok := m.Task(created.ID)
|
||||
if !ok {
|
||||
t.Fatal("task not found")
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/norma/harness"
|
||||
"github.com/Autumn-27/norma/llm"
|
||||
actool "github.com/Autumn-27/norma/tool"
|
||||
|
||||
"github.com/Autumn-27/artex/agent"
|
||||
"github.com/Autumn-27/artex/db"
|
||||
)
|
||||
|
||||
// acceptsRawInput is the assertion norma's harness makes before its schema
|
||||
// check: only a tool that reports AcceptsRawInput skips it.
|
||||
func acceptsRawInput(t actool.CoreTool) bool {
|
||||
r, ok := t.(interface{ AcceptsRawInput() bool })
|
||||
return ok && r.AcceptsRawInput()
|
||||
}
|
||||
|
||||
// record_fact opts out of the harness schema check and validates its own
|
||||
// input. Every wrapper between the handler and the harness has to forward
|
||||
// that opt-out: an embedded CoreTool alone hides it from the harness's type
|
||||
// assertion, and the stricter published schema then rejects the calls the
|
||||
// handler exists to answer.
|
||||
func TestFix410AcceptsRawInputSurvivesWrappers(t *testing.T) {
|
||||
oldAugment, oldResolve := agent.ToolAugment(), agent.ToolResolve()
|
||||
t.Cleanup(func() {
|
||||
agent.SetToolAugment(oldAugment)
|
||||
agent.SetToolResolve(oldResolve)
|
||||
})
|
||||
ctx := context.Background()
|
||||
probe := func(raw bool) actool.CoreTool {
|
||||
return actool.Build(actool.Spec{Name: "fix410_probe", Schema: map[string]any{"type": "object"}, RawInput: raw})
|
||||
}
|
||||
|
||||
// AugmentTools without hooks applies guardPanic and nothing else.
|
||||
t.Run("guardedTool", func(t *testing.T) {
|
||||
agent.SetToolAugment(nil)
|
||||
agent.SetToolResolve(nil)
|
||||
for _, raw := range []bool{true, false} {
|
||||
out, _, cleanup := agent.AugmentTools(ctx, "worker", []actool.CoreTool{probe(raw)})
|
||||
cleanup()
|
||||
if len(out) != 1 {
|
||||
t.Fatalf("AugmentTools returned %d tools, want 1", len(out))
|
||||
}
|
||||
if got := acceptsRawInput(out[0]); got != raw {
|
||||
t.Errorf("%T: AcceptsRawInput = %v, wrapped tool reports %v", out[0], got, raw)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("meteredTool", func(t *testing.T) {
|
||||
for _, raw := range []bool{true, false} {
|
||||
wrapped := meterTool(probe(raw), &recordingToolUsage{}, "fix410_probe", "worker", agent.RunInfo{})
|
||||
if got := acceptsRawInput(wrapped); got != raw {
|
||||
t.Errorf("%T: AcceptsRawInput = %v, wrapped tool reports %v", wrapped, got, raw)
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
// The chain a worker's record_fact goes through on the server: the catalog
|
||||
// decorator and the usage meter (ToolResolve, wireTools), then guardPanic
|
||||
// (AugmentTools), then the harness itself.
|
||||
t.Run("server chain", func(t *testing.T) {
|
||||
dsn, _, err := db.DSN()
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
pg, err := db.Open(dsn)
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
t.Cleanup(func() { _ = pg.Close() })
|
||||
agent.SetToolAugment(nil)
|
||||
wireTools(pg, nil)
|
||||
task, err := pg.CreateTaskWithOptions("fix410", "record_fact through the wrapper chain", db.TaskCreateOptions{})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = pg.DeleteTask(task.ID) })
|
||||
ts := agent.NewToolSet(pg.Exploration(task.ExplorationID), "worker")
|
||||
tools, _, cleanup := agent.AugmentTools(ctx, "worker", ts.WorkerTools())
|
||||
defer cleanup()
|
||||
recordFact := names(tools)["record_fact"]
|
||||
if recordFact == nil {
|
||||
t.Fatal("worker has no record_fact")
|
||||
}
|
||||
if !acceptsRawInput(recordFact) {
|
||||
t.Errorf("record_fact lost the harness opt-out behind %T", recordFact)
|
||||
}
|
||||
|
||||
// The first call is malformed (facts is not an array): the harness
|
||||
// schema check answers it with its generic error unless the tool opted
|
||||
// out. The second is the legacy single fact, which the published
|
||||
// schema does not describe and the handler still accepts.
|
||||
p := &toolScript{results: make(chan string, 4), calls: []scriptedCall{
|
||||
{"record_fact", `{"facts":{"summary":"not an array"}}`},
|
||||
{"record_fact", `{"summary":"legacy single fact"}`},
|
||||
}}
|
||||
for _, err := range harness.Query(ctx, harness.QueryInput{
|
||||
Provider: p,
|
||||
Tools: actool.NewRegistry(recordFact),
|
||||
Messages: []llm.Message{llm.UserText("record the facts")},
|
||||
}, harness.QueryDeps{}) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if refusal := p.next(t); !strings.Contains(refusal, "invalid record_fact input: facts must be an array") {
|
||||
t.Errorf("malformed call: want the handler's own refusal, not the SDK schema error, got: %s", refusal)
|
||||
}
|
||||
if legacy := p.next(t); strings.HasPrefix(legacy, "[error]") || ts.Writes().Facts != 1 {
|
||||
t.Errorf("legacy single fact not written (facts=%d): %s", ts.Writes().Facts, legacy)
|
||||
}
|
||||
})
|
||||
}
|
||||
+14
-14
@@ -898,9 +898,12 @@ func (s *Server) Handler() http.Handler {
|
||||
mux.HandleFunc("GET /api/traffic/blob", s.getTrafficBlob)
|
||||
mux.HandleFunc("POST /api/traffic/ingest", s.ingestTraffic)
|
||||
mux.HandleFunc("POST /api/traffic/replay", s.replayTraffic)
|
||||
mux.HandleFunc("POST /api/traffic/import/har", s.importTrafficHAR)
|
||||
mux.HandleFunc("GET /api/traffic/export/har", s.exportTrafficHAR)
|
||||
mux.HandleFunc("GET /api/commands", s.pgListCommands)
|
||||
mux.HandleFunc("GET /api/commands/stats", s.pgToolStats) // aggregate call counts per tool
|
||||
mux.HandleFunc("GET /api/llm/records", s.pgListLLMRecords)
|
||||
mux.HandleFunc("GET /api/llm/context/summary", s.pgLLMContextSummary)
|
||||
mux.HandleFunc("DELETE /api/llm/records", s.pgDeleteLLMRecords)
|
||||
mux.HandleFunc("GET /api/llm/records/tasks", s.pgLLMTasks)
|
||||
mux.HandleFunc("GET /api/llm/records/by-model", s.pgTokenByModel) // aggregate this task's token usage by model
|
||||
@@ -3535,24 +3538,13 @@ func taskActivityDetail(t *Task, seq int64) (string, error) {
|
||||
func (s *Server) getTraffic(w http.ResponseWriter, r *http.Request) {
|
||||
tr := s.m.Traffic()
|
||||
if tr == nil {
|
||||
writeJSON(w, 200, map[string]any{"enabled": false, "exchanges": []any{}})
|
||||
writeJSON(w, 200, map[string]any{"enabled": false, "exchanges": []any{}, "rewrite": traffic.RewriteStats{}})
|
||||
return
|
||||
}
|
||||
q := r.URL.Query()
|
||||
page := atoiDefault(q.Get("page"), 0)
|
||||
size := atoiDefault(q.Get("size"), 100)
|
||||
ex, matched, _ := tr.Page(traffic.PageQuery{
|
||||
Host: q.Get("host"),
|
||||
Method: q.Get("method"),
|
||||
Query: q.Get("q"),
|
||||
Body: q.Get("body"),
|
||||
Path: q.Get("path"),
|
||||
Status: q.Get("status"),
|
||||
RespMin: int64(atoiDefault(q.Get("resp_min"), -1)),
|
||||
RespMax: int64(atoiDefault(q.Get("resp_max"), -1)),
|
||||
Sort: q.Get("sort"),
|
||||
Order: q.Get("order"),
|
||||
}, page, size)
|
||||
ex, matched, _ := tr.Page(parseTrafficPageQuery(q), page, size)
|
||||
count, _ := tr.Count() // global total, for the stat card
|
||||
writeJSON(w, 200, map[string]any{
|
||||
"enabled": s.m.TrafficEnabled(), // reflect the capture toggle
|
||||
@@ -3562,6 +3554,7 @@ func (s *Server) getTraffic(w http.ResponseWriter, r *http.Request) {
|
||||
"page": page,
|
||||
"size": size,
|
||||
"exchanges": trafficDTOs(ex),
|
||||
"rewrite": tr.RewriteStats(),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -3740,6 +3733,7 @@ func (s *Server) replayTraffic(w http.ResponseWriter, r *http.Request) {
|
||||
Headers []traffic.ReplayHeader `json:"headers"`
|
||||
Body string `json:"body"`
|
||||
BodyBase64 bool `json:"body_base64"`
|
||||
ApplyRules bool `json:"apply_rules"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
||||
var tooLarge *http.MaxBytesError
|
||||
@@ -3761,7 +3755,13 @@ func (s *Server) replayTraffic(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
|
||||
defer cancel()
|
||||
res, err := tr.Replay(ctx, traffic.ReplayRequest{Method: body.Method, URL: body.URL, Headers: body.Headers, Body: payload})
|
||||
res, err := tr.Replay(ctx, traffic.ReplayRequest{
|
||||
Method: body.Method,
|
||||
URL: body.URL,
|
||||
Headers: body.Headers,
|
||||
Body: payload,
|
||||
ApplyRules: body.ApplyRules,
|
||||
})
|
||||
switch {
|
||||
case errors.Is(err, traffic.ErrReplayTooLarge):
|
||||
writeErr(w, 413, err.Error())
|
||||
|
||||
@@ -83,6 +83,7 @@ func (g *gateServer) cleanupTask(t *testing.T, id string) {
|
||||
_ = g.m.pg.DeleteTask(n)
|
||||
_, _ = g.m.pg.Exec(`DELETE FROM target_pins WHERE task_id=$1`, n)
|
||||
_, _ = g.m.pg.Exec(`DELETE FROM intercept_pending WHERE task_id=$1`, id)
|
||||
_, _ = g.m.pg.Exec(`DELETE FROM assets WHERE type = 'ip' AND ip = '127.0.0.1'`)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -174,6 +174,7 @@ func (f *targetScopeFixture) newTask(t *testing.T) *Task {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = f.m.DeleteTask(created.ID, DeleteTaskOptions{}) })
|
||||
task, ok := f.m.Task(created.ID)
|
||||
if !ok {
|
||||
t.Fatal("task not found after creation")
|
||||
|
||||
@@ -650,6 +650,15 @@ func TestTaskLLMResolutionReportsDatabaseFailure(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
taskID := mustTaskID(t, task.ID)
|
||||
t.Cleanup(func() {
|
||||
if dsn, _, err := db.DSN(); err == nil {
|
||||
if pg, err := db.Open(dsn); err == nil {
|
||||
_ = pg.DeleteTask(taskID)
|
||||
_ = pg.Close()
|
||||
}
|
||||
}
|
||||
})
|
||||
if err := m.pg.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
@@ -49,7 +49,14 @@ func TestTaskCredentialsFlow(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { s.m.PG().Exec(`DELETE FROM tasks WHERE id=$1`, id) })
|
||||
t.Cleanup(func() {
|
||||
_ = s.m.pg.DeleteTask(id)
|
||||
// The first POST with an invalid credential entry returns 400 after
|
||||
// creating a task/exploration row; remove any remaining fixture rows.
|
||||
_, _ = s.m.PG().Exec(`DELETE FROM tasks WHERE description = 'credential flow test'`)
|
||||
_, _ = s.m.PG().Exec(`DELETE FROM explorations WHERE description = 'credential flow test'`)
|
||||
_, _ = s.m.PG().Exec(`DELETE FROM assets WHERE type = 'ip' AND ip = '127.0.0.1'`)
|
||||
})
|
||||
|
||||
// List: both rows, user source, order stable.
|
||||
resp = request("GET", fmt.Sprintf("/api/tasks/%s/credentials", created.ID), "")
|
||||
|
||||
@@ -21,7 +21,7 @@ func TestReviveClearsBudgetEndReason(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { pg.Exec(`DELETE FROM tasks WHERE id=$1`, id) })
|
||||
t.Cleanup(func() { _ = pg.DeleteTask(id) })
|
||||
endReason := func() string {
|
||||
t.Helper()
|
||||
var r string
|
||||
|
||||
+9
-11
@@ -193,20 +193,18 @@ func healthIDFor(prov llm.Provider, profileID int64) int64 {
|
||||
return profileID
|
||||
}
|
||||
|
||||
// current resolves the provider this role runs on, by precedence:
|
||||
// Agent binding → task LLM profile chain → global/environment configuration.
|
||||
// currentFor resolves the provider this role runs on, by precedence:
|
||||
// Agent binding → task LLM profile chain → global/environment configuration,
|
||||
// honoring a per-run profile pin set by the engine for per-intent rotation (#85).
|
||||
// Binding wins over the task chain: a role explicitly assigned a model keeps running
|
||||
// on that model; only when the binding is missing or fails to build does it fall back
|
||||
// to the task chain, and to the global configuration when the chain is empty.
|
||||
// The returned profile id is non-zero only on the task-chain path — streamTaskLLM uses it to decide whether a quota error should advance the task's failover state (binding/global paths leave the chain state untouched, preserving existing semantics).
|
||||
func (r *taskLLMRuntime) current() (taskLLMSelection, error) {
|
||||
return r.currentFor(context.Background())
|
||||
}
|
||||
|
||||
// currentFor resolves like current, honoring a per-run profile pin set by the
|
||||
// engine for per-intent rotation (#85). A pin is only a dispatch preference:
|
||||
// the chain must still be in a ready state (an exhausted chain with no active
|
||||
// head stays exhausted) and the pinned id must belong to the task's chain.
|
||||
// A pin is only a dispatch preference: the chain must still be in a ready state
|
||||
// (an exhausted chain with no active head stays exhausted) and the pinned id must
|
||||
// belong to the task's chain. The returned profile id is non-zero only on the
|
||||
// task-chain path — streamTaskLLM uses it to decide whether a quota error should
|
||||
// advance the task's failover state (binding/global paths leave the chain state
|
||||
// untouched, preserving existing semantics).
|
||||
func (r *taskLLMRuntime) currentFor(ctx context.Context) (taskLLMSelection, error) {
|
||||
taskNum, err := parseTaskID(r.taskID)
|
||||
if err != nil {
|
||||
|
||||
@@ -75,7 +75,10 @@ func TestRotationConcurrentProvidersAndPrecedence(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer m.DeleteTask(task.ID, DeleteTaskOptions{})
|
||||
defer func() {
|
||||
_, _ = m.pg.Exec(`DELETE FROM llm_usage WHERE task_id = $1`, task.ID)
|
||||
_, _ = m.DeleteTask(task.ID, DeleteTaskOptions{})
|
||||
}()
|
||||
s := &Server{m: m, provByProfile: map[int64]*provEntry{}}
|
||||
runtime := &taskLLMRuntime{s: s, taskID: task.ID, agentKey: "worker"}
|
||||
done := make(chan error, 3)
|
||||
@@ -343,7 +346,10 @@ func TestRunIntentRotatesPinnedProfileWithCachedExecCtx(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer m.DeleteTask(task.ID, DeleteTaskOptions{})
|
||||
defer func() {
|
||||
_, _ = m.pg.Exec(`DELETE FROM llm_usage WHERE task_id = $1`, task.ID)
|
||||
_, _ = m.DeleteTask(task.ID, DeleteTaskOptions{})
|
||||
}()
|
||||
|
||||
e := NewEngine(m)
|
||||
// Warm the per-task cached execCtx before any worker intent runs.
|
||||
|
||||
@@ -656,7 +656,7 @@ func TestProfileDeleteRestoresQuotaBlockedIntentWhenFallbackAvailable(t *testing
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer m.Close()
|
||||
t.Cleanup(func() { _ = m.Close() })
|
||||
|
||||
profileID, err := m.pg.SaveProfile(&db.LLMProfile{
|
||||
Name: fmt.Sprintf("delete-quota-fallback-%d", time.Now().UnixNano()),
|
||||
|
||||
@@ -22,7 +22,10 @@ func TestTaskOutcomeCard(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
|
||||
defer func() { _ = m.pg.DeleteTask(taskID) }()
|
||||
defer func() {
|
||||
_, _ = m.pg.DeleteFindingsByTask(taskID)
|
||||
_ = m.pg.DeleteTask(taskID)
|
||||
}()
|
||||
// skill_usage has no foreign keys, so DeleteTask leaves these rows behind,
|
||||
// and their misses would outrank TestSkillGapsReport's fixture in later runs.
|
||||
defer func() { _, _ = m.pg.Exec(`DELETE FROM skill_usage WHERE task_id=$1`, taskID) }()
|
||||
|
||||
@@ -24,7 +24,7 @@ func TestPauseShiftsTaskDeadlineOnResume(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { pg.Exec(`DELETE FROM tasks WHERE id=$1`, id) })
|
||||
t.Cleanup(func() { _ = pg.DeleteTask(id) })
|
||||
|
||||
// A running task with a stamped deadline (first_run_at + 1h budget).
|
||||
if _, err := m.StampTaskFirstRun(task.ID); err != nil {
|
||||
|
||||
@@ -42,7 +42,7 @@ func (s *Server) resolutionFromProfile(p *db.LLMProfile, source string) taskLLMR
|
||||
return result
|
||||
}
|
||||
|
||||
// resolveTaskRoleLLM mirrors taskLLMRuntime.current without creating a provider:
|
||||
// resolveTaskRoleLLM mirrors taskLLMRuntime.currentFor without creating a provider:
|
||||
// role Agent binding -> explicit task chain -> active/global environment config.
|
||||
// Database failures are returned rather than represented as an unavailable model.
|
||||
func (s *Server) resolveTaskRoleLLM(t *Task, agentKey string) (taskLLMResolution, error) {
|
||||
|
||||
@@ -91,7 +91,7 @@ func TestConversationPatchReturnsPinState(t *testing.T) {
|
||||
if err != nil {
|
||||
db.SkipPGUnavailable(t, err)
|
||||
}
|
||||
defer m.Close()
|
||||
t.Cleanup(func() { _ = m.Close() })
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
|
||||
defer stopTestServer(t, s, cancel)
|
||||
|
||||
@@ -33,6 +33,14 @@ func meterTool(t actool.CoreTool, recorder toolUsageRecorder, toolKey, agentKey
|
||||
return &meteredTool{CoreTool: t, recorder: recorder, toolKey: toolKey, agentKey: agentKey, ri: ri}
|
||||
}
|
||||
|
||||
// AcceptsRawInput forwards the resolved tool's opt-out of the harness schema
|
||||
// check; the embedded interface alone would hide it from the harness's type
|
||||
// assertion.
|
||||
func (m *meteredTool) AcceptsRawInput() bool {
|
||||
r, ok := m.CoreTool.(interface{ AcceptsRawInput() bool })
|
||||
return ok && r.AcceptsRawInput()
|
||||
}
|
||||
|
||||
func (m *meteredTool) Call(ctx context.Context, input json.RawMessage, tc *actool.ToolContext) (actool.Result, error) {
|
||||
if err := m.recorder.InsertToolUsage(&db.ToolUsage{
|
||||
ToolKey: m.toolKey,
|
||||
|
||||
@@ -73,12 +73,19 @@ func TestWireTools(t *testing.T) {
|
||||
// Edit description + add a default to a scalar param, then confirm the resolved
|
||||
// worker tool reflects both. Restore from code default on cleanup.
|
||||
t.Cleanup(func() { _ = pg.UpsertToolForce(rf.Key, rf.Description, rf.Schema, mustJSON(rf.Agents)) })
|
||||
// Facts-only contract: the fact fields, and so the
|
||||
// editable scalar annotations, live on the facts[] items.
|
||||
var schema map[string]any
|
||||
_ = json.Unmarshal(rf.Schema, &schema)
|
||||
if props, ok := schema["properties"].(map[string]any); ok {
|
||||
if conf, ok := props["confidence"].(map[string]any); ok {
|
||||
conf["default"] = "inferred"
|
||||
}
|
||||
itemProps := func(sc map[string]any) map[string]any {
|
||||
props, _ := sc["properties"].(map[string]any)
|
||||
facts, _ := props["facts"].(map[string]any)
|
||||
items, _ := facts["items"].(map[string]any)
|
||||
ip, _ := items["properties"].(map[string]any)
|
||||
return ip
|
||||
}
|
||||
if conf, ok := itemProps(schema)["confidence"].(map[string]any); ok {
|
||||
conf["default"] = "inferred"
|
||||
}
|
||||
edited := mustJSON(schema)
|
||||
if err := pg.UpdateTool(rf.Key, "EDITED DESC", edited, mustJSON([]string{"worker"}), true); err != nil {
|
||||
@@ -96,9 +103,8 @@ func TestWireTools(t *testing.T) {
|
||||
// Default injection: omit confidence → handler input should carry the default.
|
||||
// We can't run the real handler (nil store), but InputSchema must show the default.
|
||||
sc := got.InputSchema()
|
||||
props := sc["properties"].(map[string]any)
|
||||
conf := props["confidence"].(map[string]any)
|
||||
if conf["default"] != "inferred" {
|
||||
conf, _ := itemProps(sc)["confidence"].(map[string]any)
|
||||
if conf == nil || conf["default"] != "inferred" {
|
||||
t.Errorf("confidence.default = %v, want inferred", conf["default"])
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
|
||||
"github.com/Autumn-27/artex/traffic"
|
||||
)
|
||||
|
||||
func parseTrafficPageQuery(q url.Values) traffic.PageQuery {
|
||||
return traffic.PageQuery{
|
||||
Host: q.Get("host"),
|
||||
Method: q.Get("method"),
|
||||
Query: q.Get("q"),
|
||||
Body: q.Get("body"),
|
||||
Path: q.Get("path"),
|
||||
Status: q.Get("status"),
|
||||
Rewritten: q.Get("rewritten"),
|
||||
RespMin: int64(atoiDefault(q.Get("resp_min"), -1)),
|
||||
RespMax: int64(atoiDefault(q.Get("resp_max"), -1)),
|
||||
Sort: q.Get("sort"),
|
||||
Order: q.Get("order"),
|
||||
}
|
||||
}
|
||||
|
||||
// importTrafficHAR accepts a raw HAR 1.2 JSON document (capped at decodeMaxBytes,
|
||||
// 32 MiB) and imports valid entries into the traffic store with deterministic
|
||||
// IDs. Imported traffic never passes through capture rewrite rules.
|
||||
func (s *Server) importTrafficHAR(w http.ResponseWriter, r *http.Request) {
|
||||
tr := s.m.Traffic()
|
||||
if tr == nil {
|
||||
writeErr(w, http.StatusServiceUnavailable, "traffic store is not available")
|
||||
return
|
||||
}
|
||||
body := r.Body
|
||||
if _, already := body.(*limitedBody); !already {
|
||||
body = http.MaxBytesReader(w, body, decodeMaxBytes)
|
||||
}
|
||||
raw, err := io.ReadAll(body)
|
||||
if err != nil {
|
||||
var tooLarge *http.MaxBytesError
|
||||
if errors.As(err, &tooLarge) {
|
||||
writeErr(w, http.StatusRequestEntityTooLarge, "HAR payload exceeds 32 MiB limit")
|
||||
return
|
||||
}
|
||||
writeErr(w, http.StatusBadRequest, "failed to read HAR body: "+err.Error())
|
||||
return
|
||||
}
|
||||
res, err := tr.ImportHAR(raw, traffic.HARImportOptions{})
|
||||
if err != nil {
|
||||
if errors.Is(err, traffic.ErrInvalidHAR) {
|
||||
writeErr(w, http.StatusBadRequest, err.Error())
|
||||
return
|
||||
}
|
||||
writeErr(w, http.StatusInternalServerError, err.Error())
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, res)
|
||||
}
|
||||
|
||||
// exportTrafficHAR exports recorded traffic matching the query filters as an
|
||||
// application/json HAR 1.2 document in stable chronological order. Entry and
|
||||
// total-byte caps are enforced and reported via both X-ARTEX-HAR-* headers and
|
||||
// HAR 1.2 custom fields (_truncated, _truncatedReason, _totalMatched).
|
||||
func (s *Server) exportTrafficHAR(w http.ResponseWriter, r *http.Request) {
|
||||
tr := s.m.Traffic()
|
||||
if tr == nil {
|
||||
writeErr(w, http.StatusServiceUnavailable, "traffic store is not available")
|
||||
return
|
||||
}
|
||||
pq := parseTrafficPageQuery(r.URL.Query())
|
||||
doc, meta, err := tr.ExportHAR(pq, traffic.HARExportOptions{CreatorVersion: BuildVersion})
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusInternalServerError, err.Error())
|
||||
return
|
||||
}
|
||||
payload, err := json.Marshal(doc)
|
||||
if err != nil {
|
||||
writeErr(w, http.StatusInternalServerError, err.Error())
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
w.Header().Set("Content-Disposition", `attachment; filename="artex-traffic.har"`)
|
||||
w.Header().Set("X-ARTEX-HAR-Truncated", strconv.FormatBool(meta.Truncated))
|
||||
w.Header().Set("X-ARTEX-HAR-Exported", strconv.Itoa(meta.Exported))
|
||||
w.Header().Set("X-ARTEX-HAR-Matched", strconv.Itoa(meta.TotalMatched))
|
||||
if meta.Truncated {
|
||||
w.Header().Set("X-ARTEX-HAR-Truncated-Reason", meta.TruncatedReason)
|
||||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
_, _ = w.Write(payload)
|
||||
}
|
||||
@@ -0,0 +1,256 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/artex/traffic"
|
||||
)
|
||||
|
||||
func TestTrafficHAREndpointsRoundTripFilterAndErrors(t *testing.T) {
|
||||
s, request := ingestServer(t)
|
||||
|
||||
binPayload := []byte{0x00, 0x01, 0x89, 0x50, 0xfe, 0xff}
|
||||
harIn := traffic.HAR{
|
||||
Log: &traffic.HARLog{
|
||||
Version: "1.2",
|
||||
Creator: traffic.HARCreator{Name: "TestSuite", Version: "1.0"},
|
||||
Entries: []traffic.HAREntry{
|
||||
{
|
||||
StartedDateTime: "2026-06-01T08:00:00Z",
|
||||
Request: traffic.HARRequest{
|
||||
Method: "POST",
|
||||
URL: "https://har-a.example/api/login",
|
||||
Headers: []traffic.HARHeader{{Name: "Content-Type", Value: "application/json"}},
|
||||
PostData: &traffic.HARPostData{
|
||||
MimeType: "application/json",
|
||||
Text: `{"user":"alice"}`,
|
||||
},
|
||||
},
|
||||
Response: traffic.HARResponse{
|
||||
Status: 200,
|
||||
Headers: []traffic.HARHeader{{Name: "Content-Type", Value: "application/json"}},
|
||||
Content: traffic.HARContent{
|
||||
MimeType: "application/json",
|
||||
Text: `{"ok":true}`,
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
StartedDateTime: "2026-06-01T08:00:10Z",
|
||||
Request: traffic.HARRequest{
|
||||
Method: "GET",
|
||||
URL: "https://har-b.example/blob.bin",
|
||||
Headers: []traffic.HARHeader{},
|
||||
},
|
||||
Response: traffic.HARResponse{
|
||||
Status: 200,
|
||||
Headers: []traffic.HARHeader{{Name: "Content-Type", Value: "application/octet-stream"}},
|
||||
Content: traffic.HARContent{
|
||||
MimeType: "application/octet-stream",
|
||||
Text: base64.StdEncoding.EncodeToString(binPayload),
|
||||
Encoding: "base64",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
rawIn, err := json.Marshal(harIn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Import via HTTP endpoint.
|
||||
w := request(http.MethodPost, "/api/traffic/import/har", string(rawIn))
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("POST /api/traffic/import/har status=%d body=%s", w.Code, w.Body.String())
|
||||
}
|
||||
var importRes traffic.HARImportResult
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &importRes); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if importRes.Imported != 2 || importRes.Skipped != 0 || importRes.Failed != 0 {
|
||||
t.Fatalf("importRes = %+v, want 2/0/0", importRes)
|
||||
}
|
||||
|
||||
// Re-import is idempotent.
|
||||
w2 := request(http.MethodPost, "/api/traffic/import/har", string(rawIn))
|
||||
if w2.Code != http.StatusOK {
|
||||
t.Fatalf("re-import status=%d body=%s", w2.Code, w2.Body.String())
|
||||
}
|
||||
var importRes2 traffic.HARImportResult
|
||||
if err := json.Unmarshal(w2.Body.Bytes(), &importRes2); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if importRes2.Imported != 0 || importRes2.Skipped != 2 || importRes2.Failed != 0 {
|
||||
t.Fatalf("re-import res = %+v, want 0/2/0", importRes2)
|
||||
}
|
||||
|
||||
// Imported rows are listed on GET /api/traffic with rewritten=false and zero exchange_rewrites rows.
|
||||
wList := request(http.MethodGet, "/api/traffic?host=har-", "")
|
||||
if wList.Code != http.StatusOK {
|
||||
t.Fatalf("GET /api/traffic status=%d body=%s", wList.Code, wList.Body.String())
|
||||
}
|
||||
var listResp struct {
|
||||
Total int `json:"total"`
|
||||
Exchanges []TrafficExchangeDTO `json:"exchanges"`
|
||||
}
|
||||
if err := json.Unmarshal(wList.Body.Bytes(), &listResp); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if listResp.Total != 2 || len(listResp.Exchanges) != 2 {
|
||||
t.Fatalf("listResp = %+v, want 2 exchanges", listResp)
|
||||
}
|
||||
for _, row := range listResp.Exchanges {
|
||||
if row.Rewritten {
|
||||
t.Fatalf("imported row %s marked rewritten", row.ID)
|
||||
}
|
||||
}
|
||||
var rwCount int
|
||||
if err := s.m.Traffic().DB().QueryRow(`SELECT COUNT(*) FROM exchange_rewrites`).Scan(&rwCount); err != nil || rwCount != 0 {
|
||||
t.Fatalf("exchange_rewrites count after HTTP HAR import = %d err=%v, want 0", rwCount, err)
|
||||
}
|
||||
|
||||
// Filtered export by host returns only har-b.example with binary payload preserved as base64.
|
||||
wExp := request(http.MethodGet, "/api/traffic/export/har?host=har-b.example", "")
|
||||
if wExp.Code != http.StatusOK {
|
||||
t.Fatalf("GET /api/traffic/export/har status=%d body=%s", wExp.Code, wExp.Body.String())
|
||||
}
|
||||
if ct := wExp.Header().Get("Content-Type"); !strings.HasPrefix(ct, "application/json") {
|
||||
t.Fatalf("export Content-Type = %q, want application/json", ct)
|
||||
}
|
||||
if wExp.Header().Get("X-ARTEX-HAR-Truncated") != "false" || wExp.Header().Get("X-ARTEX-HAR-Exported") != "1" || wExp.Header().Get("X-ARTEX-HAR-Matched") != "1" {
|
||||
t.Fatalf("unexpected export headers: %+v", wExp.Header())
|
||||
}
|
||||
var exported traffic.HAR
|
||||
if err := json.Unmarshal(wExp.Body.Bytes(), &exported); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if exported.Log == nil || exported.Log.Version != "1.2" || len(exported.Log.Entries) != 1 {
|
||||
t.Fatalf("filtered export = %+v", exported.Log)
|
||||
}
|
||||
entry := exported.Log.Entries[0]
|
||||
if entry.Request.URL != "https://har-b.example/blob.bin" || entry.Response.Content.Encoding != "base64" {
|
||||
t.Fatalf("exported binary entry = %+v", entry)
|
||||
}
|
||||
decoded, err := base64.StdEncoding.DecodeString(entry.Response.Content.Text)
|
||||
if err != nil || !bytes.Equal(decoded, binPayload) {
|
||||
t.Fatalf("exported binary bytes mismatch: got=%x err=%v", decoded, err)
|
||||
}
|
||||
|
||||
// Re-importing the exported HAR via HTTP is idempotent.
|
||||
wReimp := request(http.MethodPost, "/api/traffic/import/har", wExp.Body.String())
|
||||
if wReimp.Code != http.StatusOK || !strings.Contains(wReimp.Body.String(), `"imported":0`) || !strings.Contains(wReimp.Body.String(), `"skipped":1`) {
|
||||
t.Fatalf("re-import exported HAR status=%d body=%s", wReimp.Code, wReimp.Body.String())
|
||||
}
|
||||
|
||||
// Error cases -> 400 naming the reason.
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
body string
|
||||
want string
|
||||
}{
|
||||
{"malformed", `{"log":`, "malformed JSON"},
|
||||
{"missing entries", `{"log":{"version":"1.2"}}`, "missing log.entries"},
|
||||
{"unsupported version", `{"log":{"version":"2.0","entries":[]}}`, "unsupported HAR version"},
|
||||
} {
|
||||
wErr := request(http.MethodPost, "/api/traffic/import/har", tc.body)
|
||||
if wErr.Code != http.StatusBadRequest || !strings.Contains(wErr.Body.String(), tc.want) {
|
||||
t.Fatalf("%s: status=%d body=%s, want 400 containing %q", tc.name, wErr.Code, wErr.Body.String(), tc.want)
|
||||
}
|
||||
}
|
||||
|
||||
// Traffic store unavailable -> 503 on both import and export.
|
||||
sOff := &Server{m: &Manager{}}
|
||||
wOffImp := httptest.NewRecorder()
|
||||
sOff.importTrafficHAR(wOffImp, httptest.NewRequest(http.MethodPost, "/api/traffic/import/har", strings.NewReader(`{}`)))
|
||||
if wOffImp.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("import with traffic off status=%d, want 503", wOffImp.Code)
|
||||
}
|
||||
wOffExp := httptest.NewRecorder()
|
||||
sOff.exportTrafficHAR(wOffExp, httptest.NewRequest(http.MethodGet, "/api/traffic/export/har", nil))
|
||||
if wOffExp.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("export with traffic off status=%d, want 503", wOffExp.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrafficHAREndpointsRequireAuth(t *testing.T) {
|
||||
s, _ := ingestServer(t)
|
||||
|
||||
rImp := httptest.NewRequest(http.MethodPost, "/api/traffic/import/har", strings.NewReader(`{"log":{"version":"1.2","entries":[]}}`))
|
||||
wImp := httptest.NewRecorder()
|
||||
s.Handler().ServeHTTP(wImp, rImp)
|
||||
if wImp.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("unauthenticated HAR import status=%d, want 401", wImp.Code)
|
||||
}
|
||||
|
||||
rExp := httptest.NewRequest(http.MethodGet, "/api/traffic/export/har", nil)
|
||||
wExp := httptest.NewRecorder()
|
||||
s.Handler().ServeHTTP(wExp, rExp)
|
||||
if wExp.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("unauthenticated HAR export status=%d, want 401", wExp.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrafficHARExportNearCapReimportsThroughHTTPHandler(t *testing.T) {
|
||||
s, request := ingestServer(t)
|
||||
tr := s.m.Traffic()
|
||||
|
||||
// Seed a binary exchange near the 20 MiB export raw cap (~19.5 MiB).
|
||||
const bodySize = 19*1024*1024 + 512*1024
|
||||
binBody := make([]byte, bodySize)
|
||||
for i := range binBody {
|
||||
binBody[i] = byte((i*17 + 0x81) & 0xff)
|
||||
}
|
||||
binBody[0] = 0x00
|
||||
|
||||
rawSeed, err := json.Marshal(traffic.HAR{
|
||||
Log: &traffic.HARLog{
|
||||
Version: "1.2",
|
||||
Entries: []traffic.HAREntry{{
|
||||
StartedDateTime: "2026-06-02T00:00:00Z",
|
||||
Request: traffic.HARRequest{Method: "GET", URL: "https://nearcap.example/bin", Headers: []traffic.HARHeader{}},
|
||||
Response: traffic.HARResponse{
|
||||
Status: 200,
|
||||
Headers: []traffic.HARHeader{{Name: "Content-Type", Value: "application/octet-stream"}},
|
||||
Content: traffic.HARContent{
|
||||
Size: len(binBody),
|
||||
MimeType: "application/octet-stream",
|
||||
Text: base64.StdEncoding.EncodeToString(binBody),
|
||||
Encoding: "base64",
|
||||
},
|
||||
},
|
||||
}},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := tr.ImportHAR(rawSeed, traffic.HARImportOptions{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
wExp := request(http.MethodGet, "/api/traffic/export/har?host=nearcap.example", "")
|
||||
if wExp.Code != http.StatusOK {
|
||||
t.Fatalf("export status=%d", wExp.Code)
|
||||
}
|
||||
if wExp.Header().Get("X-ARTEX-HAR-Truncated") != "false" {
|
||||
t.Fatalf("expected non-truncated export, headers=%+v", wExp.Header())
|
||||
}
|
||||
if wExp.Body.Len() >= decodeMaxBytes {
|
||||
t.Fatalf("exported HAR size=%d exceeds decodeMaxBytes=%d", wExp.Body.Len(), decodeMaxBytes)
|
||||
}
|
||||
|
||||
// Re-import the exact exported bytes through the HTTP handler (including
|
||||
// limitRequestBody 32 MiB middleware) — must answer 200, never 413.
|
||||
wImp := request(http.MethodPost, "/api/traffic/import/har", wExp.Body.String())
|
||||
if wImp.Code != http.StatusOK {
|
||||
t.Fatalf("re-import near-cap export via HTTP status=%d body=%s, want 200", wImp.Code, wImp.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// apply_rules is a boolean in the API contract: a string or a number is a 400,
|
||||
// not a silent false or true.
|
||||
func TestAdversarialReplayRouteRejectsNonBoolApplyRules(t *testing.T) {
|
||||
_, replay := replayServer(t, true, false)
|
||||
for _, body := range []string{
|
||||
`{"method":"GET","url":"http://example.com/","apply_rules":"yes"}`,
|
||||
`{"method":"GET","url":"http://example.com/","apply_rules":1}`,
|
||||
} {
|
||||
w := replay(body)
|
||||
if w.Code != http.StatusBadRequest {
|
||||
t.Fatalf("%s = %d %s, want 400", body, w.Code, w.Body)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -14,6 +14,7 @@ import (
|
||||
"time"
|
||||
|
||||
"github.com/Autumn-27/artex/traffic"
|
||||
"github.com/Autumn-27/artex/traffic/rewrite"
|
||||
)
|
||||
|
||||
// replayServer wires a Server like ingestServer. With traffic off,
|
||||
@@ -161,3 +162,80 @@ func TestTrafficReplayRouteEndToEnd(t *testing.T) {
|
||||
time.Sleep(20 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetTrafficExposesRewriteStats(t *testing.T) {
|
||||
// Traffic disabled: rewrite object still present with zero counters.
|
||||
sOff := &Server{m: &Manager{}}
|
||||
wOff := httptest.NewRecorder()
|
||||
sOff.getTraffic(wOff, httptest.NewRequest(http.MethodGet, "/api/traffic", nil))
|
||||
if wOff.Code != http.StatusOK {
|
||||
t.Fatalf("getTraffic(off) status = %d", wOff.Code)
|
||||
}
|
||||
var bodyOff map[string]any
|
||||
if err := json.Unmarshal(wOff.Body.Bytes(), &bodyOff); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
rwOff, ok := bodyOff["rewrite"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("getTraffic(off) missing rewrite object: %s", wOff.Body.String())
|
||||
}
|
||||
for _, k := range []string{"large_responses", "capacity_refusals", "tombstone_drops", "conversions", "sweeps"} {
|
||||
if _, exists := rwOff[k]; !exists {
|
||||
t.Fatalf("getTraffic(off) rewrite object missing key %q: %v", k, rwOff)
|
||||
}
|
||||
}
|
||||
|
||||
// Traffic store open: rewrite counters mirror tr.RewriteStats().
|
||||
tr, err := traffic.Open(t.TempDir(), ":0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { tr.Close() })
|
||||
sOn := &Server{m: &Manager{traffic: tr}}
|
||||
wOn := httptest.NewRecorder()
|
||||
sOn.getTraffic(wOn, httptest.NewRequest(http.MethodGet, "/api/traffic", nil))
|
||||
if wOn.Code != http.StatusOK {
|
||||
t.Fatalf("getTraffic(on) status = %d", wOn.Code)
|
||||
}
|
||||
var bodyOn struct {
|
||||
Rewrite traffic.RewriteStats `json:"rewrite"`
|
||||
}
|
||||
if err := json.Unmarshal(wOn.Body.Bytes(), &bodyOn); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if bodyOn.Rewrite != tr.RewriteStats() {
|
||||
t.Fatalf("getTraffic rewrite = %+v, want %+v", bodyOn.Rewrite, tr.RewriteStats())
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrafficReplayRouteApplyRulesToggle(t *testing.T) {
|
||||
s, replay := replayServer(t, true, true)
|
||||
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("X-Seen-Rule", r.Header.Get("X-Rule-Tag"))
|
||||
_, _ = io.WriteString(w, "ok")
|
||||
}))
|
||||
t.Cleanup(target.Close)
|
||||
|
||||
set := rewrite.Compile([]rewrite.Rule{{
|
||||
ID: 7, Name: "tag", Enabled: true, Phase: rewrite.PhaseRequest,
|
||||
Actions: []rewrite.Action{{Type: rewrite.ActionSetHeader, Name: "X-Rule-Tag", Value: "on"}},
|
||||
}}, rewrite.Options{})
|
||||
if len(set.LoadErrors()) != 0 {
|
||||
t.Fatalf("load errors: %v", set.LoadErrors())
|
||||
}
|
||||
s.m.Traffic().SetRewriteRules(set)
|
||||
|
||||
// Default (apply_rules absent -> false): bypasses rule.
|
||||
reqOff, _ := json.Marshal(map[string]any{"method": "GET", "url": target.URL + "/toggle-off"})
|
||||
wOff := replay(string(reqOff))
|
||||
if wOff.Code != 200 || strings.Contains(wOff.Body.String(), `"X-Seen-Rule","value":"on"`) {
|
||||
t.Fatalf("default replay applied rewrite rule: %d %s", wOff.Code, wOff.Body.String())
|
||||
}
|
||||
|
||||
// Opt-in (apply_rules: true): applies rule.
|
||||
reqOn, _ := json.Marshal(map[string]any{"method": "GET", "url": target.URL + "/toggle-on", "apply_rules": true})
|
||||
wOn := replay(string(reqOn))
|
||||
if wOn.Code != 200 || !strings.Contains(wOn.Body.String(), `"value":"on"`) {
|
||||
t.Fatalf("apply_rules=true did not apply rewrite rule: %d %s", wOn.Code, wOn.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,364 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Autumn-27/artex/db"
|
||||
"github.com/Autumn-27/artex/traffic"
|
||||
)
|
||||
|
||||
func TestGetTrafficRewrittenFlagAndFilter(t *testing.T) {
|
||||
tr, err := traffic.Open(t.TempDir(), ":0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { tr.Close() })
|
||||
|
||||
insertEx := func(id string, ts int64, host string, status int) {
|
||||
t.Helper()
|
||||
if _, err := tr.DB().Exec(`INSERT INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
|
||||
VALUES(?,?,?,?,?,?,?,?,?,?,?)`, id, ts, host, "GET", "/"+id, "https://"+host+"/"+id, status, "application/json", 0, 12, ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
insertEx("rw-alpha-200", 10, "alpha.example", 200)
|
||||
insertEx("rw-beta-404", 20, "beta.example", 404)
|
||||
insertEx("orig-alpha-200", 30, "alpha.example", 200)
|
||||
insertEx("skip-alpha-404", 40, "alpha.example", 404)
|
||||
|
||||
if _, err := tr.DB().Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,outcome) VALUES
|
||||
('rw-alpha-200',0,'request',1,'applied'),
|
||||
('rw-beta-404',0,'response',2,'applied'),
|
||||
('skip-alpha-404',0,'request',3,'skipped')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
s := &Server{m: &Manager{traffic: tr}}
|
||||
|
||||
type respPayload struct {
|
||||
Count int `json:"count"`
|
||||
Total int `json:"total"`
|
||||
Exchanges []TrafficExchangeDTO `json:"exchanges"`
|
||||
}
|
||||
fetch := func(query string) (respPayload, []map[string]any) {
|
||||
t.Helper()
|
||||
w := httptest.NewRecorder()
|
||||
s.getTraffic(w, httptest.NewRequest(http.MethodGet, "/api/traffic"+query, nil))
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("GET /api/traffic%s status=%d body=%s", query, w.Code, w.Body.String())
|
||||
}
|
||||
var out respPayload
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var raw struct {
|
||||
Exchanges []map[string]any `json:"exchanges"`
|
||||
}
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &raw); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return out, raw.Exchanges
|
||||
}
|
||||
|
||||
// Default (absent) and rewritten=all return all 4 exchanges and each row carries explicit "rewritten" bool.
|
||||
for _, q := range []string{"", "?rewritten=all"} {
|
||||
res, rawRows := fetch(q)
|
||||
if res.Count != 4 || res.Total != 4 || len(res.Exchanges) != 4 {
|
||||
t.Fatalf("query %q count=%d total=%d len=%d, want 4/4/4", q, res.Count, res.Total, len(res.Exchanges))
|
||||
}
|
||||
flags := map[string]bool{}
|
||||
for i, row := range res.Exchanges {
|
||||
if _, ok := rawRows[i]["rewritten"].(bool); !ok {
|
||||
t.Fatalf("query %q row %s missing boolean rewritten field: %v", q, row.ID, rawRows[i])
|
||||
}
|
||||
flags[row.ID] = row.Rewritten
|
||||
}
|
||||
if !flags["rw-alpha-200"] || !flags["rw-beta-404"] || flags["orig-alpha-200"] || flags["skip-alpha-404"] {
|
||||
t.Fatalf("query %q flags=%v", q, flags)
|
||||
}
|
||||
}
|
||||
|
||||
// Filter rewritten (true and canonical "rewritten").
|
||||
for _, q := range []string{"?rewritten=true", "?rewritten=rewritten"} {
|
||||
res, _ := fetch(q)
|
||||
if res.Count != 4 || res.Total != 2 || len(res.Exchanges) != 2 {
|
||||
t.Fatalf("query %q count=%d total=%d len=%d, want 4/2/2", q, res.Count, res.Total, len(res.Exchanges))
|
||||
}
|
||||
ids := []string{res.Exchanges[0].ID, res.Exchanges[1].ID}
|
||||
slices.Sort(ids)
|
||||
if !slices.Equal(ids, []string{"rw-alpha-200", "rw-beta-404"}) {
|
||||
t.Fatalf("query %q ids=%v", q, ids)
|
||||
}
|
||||
for _, row := range res.Exchanges {
|
||||
if !row.Rewritten {
|
||||
t.Fatalf("query %q returned non-rewritten row %s", q, row.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Filter original (false and canonical "original"): finds plain + skipped-only, excludes rewritten.
|
||||
for _, q := range []string{"?rewritten=false", "?rewritten=original"} {
|
||||
res, _ := fetch(q)
|
||||
if res.Count != 4 || res.Total != 2 || len(res.Exchanges) != 2 {
|
||||
t.Fatalf("query %q count=%d total=%d len=%d, want 4/2/2", q, res.Count, res.Total, len(res.Exchanges))
|
||||
}
|
||||
ids := []string{res.Exchanges[0].ID, res.Exchanges[1].ID}
|
||||
slices.Sort(ids)
|
||||
if !slices.Equal(ids, []string{"orig-alpha-200", "skip-alpha-404"}) {
|
||||
t.Fatalf("query %q ids=%v", q, ids)
|
||||
}
|
||||
for _, row := range res.Exchanges {
|
||||
if row.Rewritten {
|
||||
t.Fatalf("query %q returned rewritten row %s", q, row.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Combined with host and status.
|
||||
resHostRW, _ := fetch("?rewritten=true&host=alpha.example&status=200")
|
||||
if resHostRW.Total != 1 || len(resHostRW.Exchanges) != 1 || resHostRW.Exchanges[0].ID != "rw-alpha-200" {
|
||||
t.Fatalf("combined rewritten+host+status = %+v", resHostRW)
|
||||
}
|
||||
resHostOrig, _ := fetch("?rewritten=false&host=alpha.example&status=4xx")
|
||||
if resHostOrig.Total != 1 || len(resHostOrig.Exchanges) != 1 || resHostOrig.Exchanges[0].ID != "skip-alpha-404" {
|
||||
t.Fatalf("combined original+host+4xx = %+v", resHostOrig)
|
||||
}
|
||||
|
||||
// Pagination stays consistent with total under rewritten filter.
|
||||
p0, _ := fetch("?rewritten=rewritten&page=0&size=1")
|
||||
p1, _ := fetch("?rewritten=rewritten&page=1&size=1")
|
||||
if p0.Total != 2 || p1.Total != 2 || len(p0.Exchanges) != 1 || len(p1.Exchanges) != 1 || p0.Exchanges[0].ID == p1.Exchanges[0].ID {
|
||||
t.Fatalf("paginated rewritten p0=%+v p1=%+v", p0, p1)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskArchiveRestorePreservesRewriteProvenanceAndV1DoesNot(t *testing.T) {
|
||||
s, f, req := trafficEvidenceServer(t)
|
||||
ctx := context.Background()
|
||||
finding, err := s.m.pg.GetFinding(f.FindingID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tid := *finding.TaskID
|
||||
s.ctx = ctx
|
||||
|
||||
seedHostFlow := func(host, id, path string) {
|
||||
t.Helper()
|
||||
if _, err := s.m.traffic.DB().Exec(`INSERT INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
|
||||
VALUES(?,100,?,'GET',?,?,200,'text/plain',0,4,'')`, id, host, path, "https://"+host+path); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := s.m.traffic.DB().Exec(`INSERT INTO exchange_bodies(id,req_head,resp_head,req_body,resp_body)
|
||||
VALUES(?,?, 'HTTP/1.1 200 OK', ?, ?)`, id, "GET "+path+" HTTP/1.1\nHost: "+host, []byte{}, []byte("body")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
callTrafficGet := func(id string) string {
|
||||
t.Helper()
|
||||
for _, tool := range s.m.traffic.Tools() {
|
||||
if tool.Name() != "traffic_get" {
|
||||
continue
|
||||
}
|
||||
res, err := tool.Call(ctx, json.RawMessage(fmt.Sprintf(`{"id":%q}`, id)), nil)
|
||||
if err != nil || res.IsError {
|
||||
t.Fatalf("traffic_get(%s) err=%v res=%s", id, err, res.Flatten())
|
||||
}
|
||||
return res.Flatten()
|
||||
}
|
||||
t.Fatal("traffic_get tool not found")
|
||||
return ""
|
||||
}
|
||||
|
||||
bindAndFetchViewer := func(findingID int64, trafficID string) (rewritten bool, ruleIDs []int64) {
|
||||
t.Helper()
|
||||
list, err := s.evidenceStore().Bind(ctx, findingID, []db.TrafficRef{{TrafficID: trafficID, Role: "proof"}})
|
||||
if err != nil {
|
||||
t.Fatalf("Bind(%s): %v", trafficID, err)
|
||||
}
|
||||
var bindingID int64
|
||||
for _, b := range list.Bindings {
|
||||
if b.Snapshot.SourceTrafficID == trafficID {
|
||||
bindingID = b.ID
|
||||
break
|
||||
}
|
||||
}
|
||||
if bindingID == 0 {
|
||||
t.Fatalf("binding for %s not found in %+v", trafficID, list.Bindings)
|
||||
}
|
||||
w := req(http.MethodGet, fmt.Sprintf("/api/exploration/findings/%d/traffic/%d", findingID, bindingID), "")
|
||||
if w.Code != http.StatusOK {
|
||||
t.Fatalf("evidence viewer GET status=%d body=%s", w.Code, w.Body.String())
|
||||
}
|
||||
var detail struct {
|
||||
Binding db.FindingTrafficBinding `json:"binding"`
|
||||
}
|
||||
if err := json.Unmarshal(w.Body.Bytes(), &detail); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return detail.Binding.Snapshot.Rewritten, detail.Binding.Snapshot.RewriteRuleIDs
|
||||
}
|
||||
|
||||
// ---- Part 1: v2 rewritten archive restored into task ----
|
||||
const v2Host = "v2-archive-provenance.local"
|
||||
var v2AssetID int64
|
||||
if err := s.m.pg.QueryRow(`INSERT INTO assets(type,domain,root_domain,task_ids) VALUES('subdomain',$1,$1,ARRAY[$2]::bigint[]) RETURNING id`, v2Host, tid).Scan(&v2AssetID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = s.m.pg.Exec(`DELETE FROM assets WHERE id=$1`, v2AssetID) })
|
||||
|
||||
seedHostFlow(v2Host, "ex-v2-rw", "/rw")
|
||||
seedHostFlow(v2Host, "ex-v2-orig", "/orig")
|
||||
if _, err := s.m.traffic.DB().Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,outcome) VALUES
|
||||
('ex-v2-rw',0,'request',7,'applied'),
|
||||
('ex-v2-rw',1,'response',2,'applied'),
|
||||
('ex-v2-rw',2,'response',9,'skipped')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if err := s.m.SetTaskPaused(strconv.FormatInt(tid, 10), true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
job, err := s.m.pg.QueueTaskArchive(tid)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.runOneTaskArchiveJob(); err != nil {
|
||||
t.Fatalf("archive v2 task: %v", err)
|
||||
}
|
||||
// Exclusive host traffic must have been compacted out of the hot SQLite store.
|
||||
if _, _, err := s.m.traffic.Get("ex-v2-rw"); err == nil {
|
||||
t.Fatal("expected hot traffic to be compacted by archive")
|
||||
}
|
||||
|
||||
if _, err := s.m.pg.QueueTaskArchiveRestore(job.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.runOneTaskArchiveJob(); err != nil {
|
||||
t.Fatalf("restore v2 task: %v", err)
|
||||
}
|
||||
|
||||
if out := callTrafficGet("ex-v2-rw"); !strings.HasPrefix(out, "=== REWRITTEN === rewrite rules [2 7] ") {
|
||||
t.Fatalf("restored v2 traffic_get(ex-v2-rw) = %q, want REWRITTEN line", out)
|
||||
}
|
||||
if out := callTrafficGet("ex-v2-orig"); strings.Contains(out, "REWRITTEN") {
|
||||
t.Fatalf("restored v2 traffic_get(ex-v2-orig) unexpectedly had REWRITTEN: %q", out)
|
||||
}
|
||||
if rw, ids := bindAndFetchViewer(f.FindingID, "ex-v2-rw"); !rw || !slices.Equal(ids, []int64{2, 7}) {
|
||||
t.Fatalf("restored v2 evidence viewer(ex-v2-rw) = (%v, %v), want (true, [2 7])", rw, ids)
|
||||
}
|
||||
if rw, ids := bindAndFetchViewer(f.FindingID, "ex-v2-orig"); rw || len(ids) != 0 {
|
||||
t.Fatalf("restored v2 evidence viewer(ex-v2-orig) = (%v, %v), want (false, nil)", rw, ids)
|
||||
}
|
||||
|
||||
// ---- Part 2: v1 traffic archive restored into a task must NOT gain a REWRITTEN line ----
|
||||
taskV1, err := s.m.CreateTask("v1 traffic archive", "verify v1 restore", nil, 0, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tidV1, _ := strconv.ParseInt(taskV1.ID, 10, 64)
|
||||
t.Cleanup(func() {
|
||||
_, _ = s.m.pg.DeleteFindingsByTask(tidV1)
|
||||
_, _ = s.m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, tidV1)
|
||||
_ = s.m.pg.DeleteTask(tidV1)
|
||||
})
|
||||
fV1, err := s.evidenceStore().Record(ctx, db.RecordFindingInput{
|
||||
TaskID: tidV1, ExplorationID: taskV1.ExpID, Worker: "test",
|
||||
VulnClass: "TEST", Summary: "v1 evidence", Name: "V1 Finding", Severity: "low",
|
||||
}, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
const v1Host = "v1-archive-legacy.local"
|
||||
var v1AssetID int64
|
||||
if err := s.m.pg.QueryRow(`INSERT INTO assets(type,domain,root_domain,task_ids) VALUES('subdomain',$1,$1,ARRAY[$2]::bigint[]) RETURNING id`, v1Host, tidV1).Scan(&v1AssetID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _, _ = s.m.pg.Exec(`DELETE FROM assets WHERE id=$1`, v1AssetID) })
|
||||
|
||||
seedHostFlow(v1Host, "ex-v1-legacy", "/legacy")
|
||||
if err := s.m.SetTaskPaused(taskV1.ID, true); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
jobV1, err := s.m.pg.QueueTaskArchive(tidV1)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.runOneTaskArchiveJob(); err != nil {
|
||||
t.Fatalf("archive v1 fixture task: %v", err)
|
||||
}
|
||||
|
||||
// Repackage the task archive with a version-1 traffic.json (no rewrite provenance fields).
|
||||
archivedV1, err := s.m.pg.GetTaskArchive(jobV1.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
repackDir := t.TempDir()
|
||||
if err := extractTaskArchivePackage(archivedV1.ArchivePath, archivedV1.SHA256, repackDir); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
manifestRaw, err := os.ReadFile(filepath.Join(repackDir, "manifest.json"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var taskSnap db.TaskArchiveSnapshot
|
||||
if err := json.Unmarshal(manifestRaw, &taskSnap); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
trafficPath := filepath.Join(repackDir, "traffic", "traffic.json")
|
||||
rawTraffic, err := os.ReadFile(trafficPath)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var trafficSnap traffic.ArchiveSnapshot
|
||||
if err := json.Unmarshal(rawTraffic, &trafficSnap); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
trafficSnap.Version = 1
|
||||
for i := range trafficSnap.Exchanges {
|
||||
trafficSnap.Exchanges[i].Rewritten = false
|
||||
trafficSnap.Exchanges[i].RewriteRuleIDs = nil
|
||||
}
|
||||
v1Raw, err := json.Marshal(trafficSnap)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(trafficPath, v1Raw, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.Remove(archivedV1.ArchivePath); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
_, _, newSHA, err := writeTaskArchivePackage(archivedV1.ArchivePath, repackDir, &taskSnap)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := s.m.pg.Exec(`UPDATE task_archives SET sha256=$1 WHERE id=$2`, newSHA, jobV1.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if _, err := s.m.pg.QueueTaskArchiveRestore(jobV1.ID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.runOneTaskArchiveJob(); err != nil {
|
||||
t.Fatalf("restore v1 task: %v", err)
|
||||
}
|
||||
if out := callTrafficGet("ex-v1-legacy"); strings.Contains(out, "REWRITTEN") {
|
||||
t.Fatalf("restored v1 traffic_get(ex-v1-legacy) unexpectedly gained REWRITTEN: %q", out)
|
||||
}
|
||||
if rw, ids := bindAndFetchViewer(fV1.FindingID, "ex-v1-legacy"); rw || len(ids) != 0 {
|
||||
t.Fatalf("restored v1 evidence viewer(ex-v1-legacy) = (%v, %v), want (false, nil)", rw, ids)
|
||||
}
|
||||
}
|
||||
@@ -69,16 +69,6 @@ func workspacePathDenied(realRoot, realPath string) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
// wsResolve maps a user-supplied relative path to an absolute path INSIDE the work
|
||||
// dir. It returns ok=false if the path would escape the root (including via symlinks).
|
||||
func (s *Server) wsResolve(rel string) (string, bool) {
|
||||
cp, ok := s.wsResolveConfined(rel)
|
||||
if !ok {
|
||||
return "", false
|
||||
}
|
||||
return cp.realPath, true
|
||||
}
|
||||
|
||||
// wsRel renders an absolute path back as a workspace-relative path (forward slashes).
|
||||
func (s *Server) wsRel(abs string) string {
|
||||
base, err := resolveRealRoot(s.m.dir)
|
||||
|
||||
+85
-85
@@ -13,7 +13,7 @@
|
||||
},
|
||||
"node_modules/@puppeteer/browsers": {
|
||||
"version": "2.6.1",
|
||||
"resolved": "https://registry.npmmirror.com/@puppeteer/browsers/-/browsers-2.6.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.6.1.tgz",
|
||||
"integrity": "sha512-aBSREisdsGH890S2rQqK82qmQYU3uFpSH8wcZWHgHzl3LfzsxAKbLNiAG9mO8v1Y0UICBeClICxPJvyr0rcuxg==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -35,13 +35,13 @@
|
||||
},
|
||||
"node_modules/@tootallnate/quickjs-emscripten": {
|
||||
"version": "0.23.0",
|
||||
"resolved": "https://registry.npmmirror.com/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz",
|
||||
"integrity": "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/node": {
|
||||
"version": "26.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/@types/node/-/node-26.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-26.0.1.tgz",
|
||||
"integrity": "sha512-fc3KiUoBt6kie0N9bIW3E47vZsuaMf0PM2AaUpLCLT0s/LvX1nxAim6Fc049cNxODPpGm6qRAuUOB86SkRuPQw==",
|
||||
"license": "MIT",
|
||||
"optional": true,
|
||||
@@ -51,7 +51,7 @@
|
||||
},
|
||||
"node_modules/@types/yauzl": {
|
||||
"version": "2.10.3",
|
||||
"resolved": "https://registry.npmmirror.com/@types/yauzl/-/yauzl-2.10.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
|
||||
"integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
|
||||
"license": "MIT",
|
||||
"optional": true,
|
||||
@@ -61,7 +61,7 @@
|
||||
},
|
||||
"node_modules/agent-base": {
|
||||
"version": "7.1.4",
|
||||
"resolved": "https://registry.npmmirror.com/agent-base/-/agent-base-7.1.4.tgz",
|
||||
"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
|
||||
"integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -70,7 +70,7 @@
|
||||
},
|
||||
"node_modules/ansi-regex": {
|
||||
"version": "5.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
|
||||
"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -79,7 +79,7 @@
|
||||
},
|
||||
"node_modules/ansi-styles": {
|
||||
"version": "4.3.0",
|
||||
"resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
|
||||
"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -94,7 +94,7 @@
|
||||
},
|
||||
"node_modules/ast-types": {
|
||||
"version": "0.13.4",
|
||||
"resolved": "https://registry.npmmirror.com/ast-types/-/ast-types-0.13.4.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz",
|
||||
"integrity": "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -106,7 +106,7 @@
|
||||
},
|
||||
"node_modules/b4a": {
|
||||
"version": "1.8.1",
|
||||
"resolved": "https://registry.npmmirror.com/b4a/-/b4a-1.8.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.1.tgz",
|
||||
"integrity": "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==",
|
||||
"license": "Apache-2.0",
|
||||
"peerDependencies": {
|
||||
@@ -120,7 +120,7 @@
|
||||
},
|
||||
"node_modules/bare-events": {
|
||||
"version": "2.9.1",
|
||||
"resolved": "https://registry.npmmirror.com/bare-events/-/bare-events-2.9.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.9.1.tgz",
|
||||
"integrity": "sha512-Z0oHEHAFDZkffN8Qc39zNZjQlMDkPJRyyyZieU1VH7u8c5S+qHZ2S8ixdKIAxEjfHO7FJxXmJWgteOghVanIsg==",
|
||||
"license": "Apache-2.0",
|
||||
"peerDependencies": {
|
||||
@@ -134,7 +134,7 @@
|
||||
},
|
||||
"node_modules/bare-fs": {
|
||||
"version": "4.7.2",
|
||||
"resolved": "https://registry.npmmirror.com/bare-fs/-/bare-fs-4.7.2.tgz",
|
||||
"resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.2.tgz",
|
||||
"integrity": "sha512-aTvMFUWkBmjzKtEQMDGGDNF8bkfpD5N1b/FCwt7A3wrU4t1o/e/85Wzkluh6JlODCjqVESYCkQCdTXqZ9G7VFg==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -158,7 +158,7 @@
|
||||
},
|
||||
"node_modules/bare-os": {
|
||||
"version": "3.9.3",
|
||||
"resolved": "https://registry.npmmirror.com/bare-os/-/bare-os-3.9.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.9.3.tgz",
|
||||
"integrity": "sha512-fF4Q7QsyKVF5Rj0qvI8BgUNjqzC2JvQlpTaPLjVJVxYVUX5Zr9un+y3w1HmA4nNKdFmRBT8z/WmrjvXzXVerKQ==",
|
||||
"license": "Apache-2.0",
|
||||
"engines": {
|
||||
@@ -167,7 +167,7 @@
|
||||
},
|
||||
"node_modules/bare-path": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/bare-path/-/bare-path-3.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.1.tgz",
|
||||
"integrity": "sha512-ghj2DSK/2e99a1anTVPCV4m4YIYtrbXhfM7V3D7XZLOTsybnYyaJloymGqssQc8l/or0UoDyRtNQkmkEF/ysgQ==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -176,7 +176,7 @@
|
||||
},
|
||||
"node_modules/bare-stream": {
|
||||
"version": "2.13.3",
|
||||
"resolved": "https://registry.npmmirror.com/bare-stream/-/bare-stream-2.13.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.13.3.tgz",
|
||||
"integrity": "sha512-Kc+brLqvEqGkjyfiwJmImAOqLZL7OsoLKuavx+hJjgVV3nLTOjloJyPMFxjUPerGGHrNH0fLU06jjykMLWrERQ==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -203,7 +203,7 @@
|
||||
},
|
||||
"node_modules/bare-url": {
|
||||
"version": "2.4.5",
|
||||
"resolved": "https://registry.npmmirror.com/bare-url/-/bare-url-2.4.5.tgz",
|
||||
"resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.4.5.tgz",
|
||||
"integrity": "sha512-K+y9xF1tN+CdPu4qWwr0QiK1Al07eFPGYK5M2pDXcmHdMdgC/tT/bpmMe1hrmRHaidKLkXrC+cRNYf3XVDUhSQ==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -212,7 +212,7 @@
|
||||
},
|
||||
"node_modules/base64-js": {
|
||||
"version": "1.5.1",
|
||||
"resolved": "https://registry.npmmirror.com/base64-js/-/base64-js-1.5.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
|
||||
"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
|
||||
"funding": [
|
||||
{
|
||||
@@ -232,7 +232,7 @@
|
||||
},
|
||||
"node_modules/basic-ftp": {
|
||||
"version": "5.3.1",
|
||||
"resolved": "https://registry.npmmirror.com/basic-ftp/-/basic-ftp-5.3.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.3.1.tgz",
|
||||
"integrity": "sha512-bopVNp6ugyA150DDuZfPFdt1KZ5a94ZDiwX4hMgZDzF+GttD80lEy8kj98kbyhLXnPvhtIo93mdnLIjpCAeeOw==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -241,7 +241,7 @@
|
||||
},
|
||||
"node_modules/buffer": {
|
||||
"version": "5.7.1",
|
||||
"resolved": "https://registry.npmmirror.com/buffer/-/buffer-5.7.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
|
||||
"integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
|
||||
"funding": [
|
||||
{
|
||||
@@ -265,7 +265,7 @@
|
||||
},
|
||||
"node_modules/buffer-crc32": {
|
||||
"version": "0.2.13",
|
||||
"resolved": "https://registry.npmmirror.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
|
||||
"resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
|
||||
"integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -274,7 +274,7 @@
|
||||
},
|
||||
"node_modules/chromium-bidi": {
|
||||
"version": "0.11.0",
|
||||
"resolved": "https://registry.npmmirror.com/chromium-bidi/-/chromium-bidi-0.11.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-0.11.0.tgz",
|
||||
"integrity": "sha512-6CJWHkNRoyZyjV9Rwv2lYONZf1Xm0IuDyNq97nwSsxxP3wf5Bwy15K5rOvVKMtJ127jJBmxFUanSAOjgFRxgrA==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -287,7 +287,7 @@
|
||||
},
|
||||
"node_modules/cliui": {
|
||||
"version": "8.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/cliui/-/cliui-8.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
|
||||
"integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
|
||||
"license": "ISC",
|
||||
"dependencies": {
|
||||
@@ -301,7 +301,7 @@
|
||||
},
|
||||
"node_modules/color-convert": {
|
||||
"version": "2.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
|
||||
"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -313,13 +313,13 @@
|
||||
},
|
||||
"node_modules/color-name": {
|
||||
"version": "1.1.4",
|
||||
"resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz",
|
||||
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
|
||||
"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/data-uri-to-buffer": {
|
||||
"version": "6.0.2",
|
||||
"resolved": "https://registry.npmmirror.com/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
|
||||
"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
|
||||
"integrity": "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -328,7 +328,7 @@
|
||||
},
|
||||
"node_modules/debug": {
|
||||
"version": "4.4.3",
|
||||
"resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
|
||||
"integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -345,7 +345,7 @@
|
||||
},
|
||||
"node_modules/degenerator": {
|
||||
"version": "5.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/degenerator/-/degenerator-5.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz",
|
||||
"integrity": "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -359,19 +359,19 @@
|
||||
},
|
||||
"node_modules/devtools-protocol": {
|
||||
"version": "0.0.1367902",
|
||||
"resolved": "https://registry.npmmirror.com/devtools-protocol/-/devtools-protocol-0.0.1367902.tgz",
|
||||
"resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1367902.tgz",
|
||||
"integrity": "sha512-XxtPuC3PGakY6PD7dG66/o8KwJ/LkH2/EKe19Dcw58w53dv4/vSQEkn/SzuyhHE2q4zPgCkxQBxus3VV4ql+Pg==",
|
||||
"license": "BSD-3-Clause"
|
||||
},
|
||||
"node_modules/emoji-regex": {
|
||||
"version": "8.0.0",
|
||||
"resolved": "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
|
||||
"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/end-of-stream": {
|
||||
"version": "1.4.5",
|
||||
"resolved": "https://registry.npmmirror.com/end-of-stream/-/end-of-stream-1.4.5.tgz",
|
||||
"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
|
||||
"integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -380,7 +380,7 @@
|
||||
},
|
||||
"node_modules/escalade": {
|
||||
"version": "3.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/escalade/-/escalade-3.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
|
||||
"integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -389,7 +389,7 @@
|
||||
},
|
||||
"node_modules/escodegen": {
|
||||
"version": "2.1.0",
|
||||
"resolved": "https://registry.npmmirror.com/escodegen/-/escodegen-2.1.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz",
|
||||
"integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==",
|
||||
"license": "BSD-2-Clause",
|
||||
"dependencies": {
|
||||
@@ -410,7 +410,7 @@
|
||||
},
|
||||
"node_modules/esprima": {
|
||||
"version": "4.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/esprima/-/esprima-4.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
|
||||
"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
|
||||
"license": "BSD-2-Clause",
|
||||
"bin": {
|
||||
@@ -423,7 +423,7 @@
|
||||
},
|
||||
"node_modules/estraverse": {
|
||||
"version": "5.3.0",
|
||||
"resolved": "https://registry.npmmirror.com/estraverse/-/estraverse-5.3.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
|
||||
"integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
|
||||
"license": "BSD-2-Clause",
|
||||
"engines": {
|
||||
@@ -432,7 +432,7 @@
|
||||
},
|
||||
"node_modules/esutils": {
|
||||
"version": "2.0.3",
|
||||
"resolved": "https://registry.npmmirror.com/esutils/-/esutils-2.0.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
|
||||
"integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
|
||||
"license": "BSD-2-Clause",
|
||||
"engines": {
|
||||
@@ -441,7 +441,7 @@
|
||||
},
|
||||
"node_modules/events-universal": {
|
||||
"version": "1.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/events-universal/-/events-universal-1.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
|
||||
"integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -450,7 +450,7 @@
|
||||
},
|
||||
"node_modules/extract-zip": {
|
||||
"version": "2.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/extract-zip/-/extract-zip-2.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
|
||||
"integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
|
||||
"license": "BSD-2-Clause",
|
||||
"dependencies": {
|
||||
@@ -470,13 +470,13 @@
|
||||
},
|
||||
"node_modules/fast-fifo": {
|
||||
"version": "1.3.2",
|
||||
"resolved": "https://registry.npmmirror.com/fast-fifo/-/fast-fifo-1.3.2.tgz",
|
||||
"resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
|
||||
"integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/fd-slicer": {
|
||||
"version": "1.1.0",
|
||||
"resolved": "https://registry.npmmirror.com/fd-slicer/-/fd-slicer-1.1.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
|
||||
"integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -485,7 +485,7 @@
|
||||
},
|
||||
"node_modules/get-caller-file": {
|
||||
"version": "2.0.5",
|
||||
"resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz",
|
||||
"resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
|
||||
"integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
|
||||
"license": "ISC",
|
||||
"engines": {
|
||||
@@ -494,7 +494,7 @@
|
||||
},
|
||||
"node_modules/get-stream": {
|
||||
"version": "5.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/get-stream/-/get-stream-5.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
|
||||
"integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -509,7 +509,7 @@
|
||||
},
|
||||
"node_modules/get-uri": {
|
||||
"version": "6.0.5",
|
||||
"resolved": "https://registry.npmmirror.com/get-uri/-/get-uri-6.0.5.tgz",
|
||||
"resolved": "https://registry.npmjs.org/get-uri/-/get-uri-6.0.5.tgz",
|
||||
"integrity": "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -523,7 +523,7 @@
|
||||
},
|
||||
"node_modules/http-proxy-agent": {
|
||||
"version": "7.0.2",
|
||||
"resolved": "https://registry.npmmirror.com/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
|
||||
"resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
|
||||
"integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -536,7 +536,7 @@
|
||||
},
|
||||
"node_modules/https-proxy-agent": {
|
||||
"version": "7.0.6",
|
||||
"resolved": "https://registry.npmmirror.com/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
|
||||
"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
|
||||
"integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -549,7 +549,7 @@
|
||||
},
|
||||
"node_modules/ieee754": {
|
||||
"version": "1.2.1",
|
||||
"resolved": "https://registry.npmmirror.com/ieee754/-/ieee754-1.2.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
|
||||
"integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
|
||||
"funding": [
|
||||
{
|
||||
@@ -569,7 +569,7 @@
|
||||
},
|
||||
"node_modules/ip-address": {
|
||||
"version": "10.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/ip-address/-/ip-address-10.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.2.0.tgz",
|
||||
"integrity": "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -578,7 +578,7 @@
|
||||
},
|
||||
"node_modules/is-fullwidth-code-point": {
|
||||
"version": "3.0.0",
|
||||
"resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
|
||||
"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -587,7 +587,7 @@
|
||||
},
|
||||
"node_modules/lru-cache": {
|
||||
"version": "7.18.3",
|
||||
"resolved": "https://registry.npmmirror.com/lru-cache/-/lru-cache-7.18.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz",
|
||||
"integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==",
|
||||
"license": "ISC",
|
||||
"engines": {
|
||||
@@ -596,19 +596,19 @@
|
||||
},
|
||||
"node_modules/mitt": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/mitt/-/mitt-3.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
|
||||
"integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/ms": {
|
||||
"version": "2.1.3",
|
||||
"resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
|
||||
"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/netmask": {
|
||||
"version": "2.1.1",
|
||||
"resolved": "https://registry.npmmirror.com/netmask/-/netmask-2.1.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/netmask/-/netmask-2.1.1.tgz",
|
||||
"integrity": "sha512-eonl3sLUha+S1GzTPxychyhnUzKyeQkZ7jLjKrBagJgPla13F+uQ71HgpFefyHgqrjEbCPkDArxYsjY8/+gLKA==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -617,7 +617,7 @@
|
||||
},
|
||||
"node_modules/once": {
|
||||
"version": "1.4.0",
|
||||
"resolved": "https://registry.npmmirror.com/once/-/once-1.4.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
|
||||
"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
|
||||
"license": "ISC",
|
||||
"dependencies": {
|
||||
@@ -626,7 +626,7 @@
|
||||
},
|
||||
"node_modules/pac-proxy-agent": {
|
||||
"version": "7.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.2.0.tgz",
|
||||
"integrity": "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -645,7 +645,7 @@
|
||||
},
|
||||
"node_modules/pac-resolver": {
|
||||
"version": "7.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/pac-resolver/-/pac-resolver-7.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz",
|
||||
"integrity": "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -658,13 +658,13 @@
|
||||
},
|
||||
"node_modules/pend": {
|
||||
"version": "1.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/pend/-/pend-1.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
|
||||
"integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/progress": {
|
||||
"version": "2.0.3",
|
||||
"resolved": "https://registry.npmmirror.com/progress/-/progress-2.0.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
|
||||
"integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -673,7 +673,7 @@
|
||||
},
|
||||
"node_modules/proxy-agent": {
|
||||
"version": "6.5.0",
|
||||
"resolved": "https://registry.npmmirror.com/proxy-agent/-/proxy-agent-6.5.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.5.0.tgz",
|
||||
"integrity": "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -692,13 +692,13 @@
|
||||
},
|
||||
"node_modules/proxy-from-env": {
|
||||
"version": "1.1.0",
|
||||
"resolved": "https://registry.npmmirror.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
|
||||
"integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/pump": {
|
||||
"version": "3.0.4",
|
||||
"resolved": "https://registry.npmmirror.com/pump/-/pump-3.0.4.tgz",
|
||||
"resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz",
|
||||
"integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -708,7 +708,7 @@
|
||||
},
|
||||
"node_modules/puppeteer-core": {
|
||||
"version": "23.11.1",
|
||||
"resolved": "https://registry.npmmirror.com/puppeteer-core/-/puppeteer-core-23.11.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-23.11.1.tgz",
|
||||
"integrity": "sha512-3HZ2/7hdDKZvZQ7dhhITOUg4/wOrDRjyK2ZBllRB0ZCOi9u0cwq1ACHDjBB+nX+7+kltHjQvBRdeY7+W0T+7Gg==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -725,7 +725,7 @@
|
||||
},
|
||||
"node_modules/require-directory": {
|
||||
"version": "2.1.1",
|
||||
"resolved": "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
|
||||
"integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -734,7 +734,7 @@
|
||||
},
|
||||
"node_modules/semver": {
|
||||
"version": "7.8.5",
|
||||
"resolved": "https://registry.npmmirror.com/semver/-/semver-7.8.5.tgz",
|
||||
"resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
|
||||
"integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
|
||||
"license": "ISC",
|
||||
"bin": {
|
||||
@@ -746,7 +746,7 @@
|
||||
},
|
||||
"node_modules/smart-buffer": {
|
||||
"version": "4.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/smart-buffer/-/smart-buffer-4.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
|
||||
"integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -756,7 +756,7 @@
|
||||
},
|
||||
"node_modules/socks": {
|
||||
"version": "2.8.9",
|
||||
"resolved": "https://registry.npmmirror.com/socks/-/socks-2.8.9.tgz",
|
||||
"resolved": "https://registry.npmjs.org/socks/-/socks-2.8.9.tgz",
|
||||
"integrity": "sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -770,7 +770,7 @@
|
||||
},
|
||||
"node_modules/socks-proxy-agent": {
|
||||
"version": "8.0.5",
|
||||
"resolved": "https://registry.npmmirror.com/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
|
||||
"resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
|
||||
"integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -784,7 +784,7 @@
|
||||
},
|
||||
"node_modules/source-map": {
|
||||
"version": "0.6.1",
|
||||
"resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.6.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
|
||||
"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
|
||||
"license": "BSD-3-Clause",
|
||||
"optional": true,
|
||||
@@ -794,7 +794,7 @@
|
||||
},
|
||||
"node_modules/streamx": {
|
||||
"version": "2.28.0",
|
||||
"resolved": "https://registry.npmmirror.com/streamx/-/streamx-2.28.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/streamx/-/streamx-2.28.0.tgz",
|
||||
"integrity": "sha512-1Yowhzjf0ivGMrTIkY9hav5TxobO9qIVqUE41fiCGMGgc3CLlf4MY+9AHmZqBWgDTue0fY9zWjYFVyf6Diuobw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -805,7 +805,7 @@
|
||||
},
|
||||
"node_modules/string-width": {
|
||||
"version": "4.2.3",
|
||||
"resolved": "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
|
||||
"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -819,7 +819,7 @@
|
||||
},
|
||||
"node_modules/strip-ansi": {
|
||||
"version": "6.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
|
||||
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -831,7 +831,7 @@
|
||||
},
|
||||
"node_modules/tar-fs": {
|
||||
"version": "3.1.3",
|
||||
"resolved": "https://registry.npmmirror.com/tar-fs/-/tar-fs-3.1.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.3.tgz",
|
||||
"integrity": "sha512-/hU4AXnIdZu+Gvl1pk0oI5f5HxWsCJRtY2aFaJdk9VvyL48DWU6iU5WAIPG+wIi1YvWA6eTJvIviP/tMAZZNwQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -845,7 +845,7 @@
|
||||
},
|
||||
"node_modules/tar-stream": {
|
||||
"version": "3.2.0",
|
||||
"resolved": "https://registry.npmmirror.com/tar-stream/-/tar-stream-3.2.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.2.0.tgz",
|
||||
"integrity": "sha512-ojzvCvVaNp6aOTFmG7jaRD0meowIAuPc3cMMhSgKiVWws1GyHbGd/xvnyuRKcKlMpt3qvxx6r0hreCNITP9hIg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -857,7 +857,7 @@
|
||||
},
|
||||
"node_modules/teex": {
|
||||
"version": "1.0.1",
|
||||
"resolved": "https://registry.npmmirror.com/teex/-/teex-1.0.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz",
|
||||
"integrity": "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -866,7 +866,7 @@
|
||||
},
|
||||
"node_modules/text-decoder": {
|
||||
"version": "1.2.7",
|
||||
"resolved": "https://registry.npmmirror.com/text-decoder/-/text-decoder-1.2.7.tgz",
|
||||
"resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.7.tgz",
|
||||
"integrity": "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
@@ -875,25 +875,25 @@
|
||||
},
|
||||
"node_modules/through": {
|
||||
"version": "2.3.8",
|
||||
"resolved": "https://registry.npmmirror.com/through/-/through-2.3.8.tgz",
|
||||
"resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
|
||||
"integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/tslib": {
|
||||
"version": "2.8.1",
|
||||
"resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.8.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
|
||||
"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
|
||||
"license": "0BSD"
|
||||
},
|
||||
"node_modules/typed-query-selector": {
|
||||
"version": "2.12.2",
|
||||
"resolved": "https://registry.npmmirror.com/typed-query-selector/-/typed-query-selector-2.12.2.tgz",
|
||||
"resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.2.tgz",
|
||||
"integrity": "sha512-EOPFbyIub4ngnEdqi2yOcNeDLaX/0jcE1JoAXQDDMIthap7FoN795lc/SHfIq2d416VufXpM8z/lD+WRm2gfOQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/unbzip2-stream": {
|
||||
"version": "1.4.3",
|
||||
"resolved": "https://registry.npmmirror.com/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz",
|
||||
"integrity": "sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -903,14 +903,14 @@
|
||||
},
|
||||
"node_modules/undici-types": {
|
||||
"version": "8.3.0",
|
||||
"resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-8.3.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz",
|
||||
"integrity": "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ==",
|
||||
"license": "MIT",
|
||||
"optional": true
|
||||
},
|
||||
"node_modules/wrap-ansi": {
|
||||
"version": "7.0.0",
|
||||
"resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
|
||||
"integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -927,13 +927,13 @@
|
||||
},
|
||||
"node_modules/wrappy": {
|
||||
"version": "1.0.2",
|
||||
"resolved": "https://registry.npmmirror.com/wrappy/-/wrappy-1.0.2.tgz",
|
||||
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
|
||||
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
|
||||
"license": "ISC"
|
||||
},
|
||||
"node_modules/ws": {
|
||||
"version": "8.21.0",
|
||||
"resolved": "https://registry.npmmirror.com/ws/-/ws-8.21.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
|
||||
"integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
@@ -954,7 +954,7 @@
|
||||
},
|
||||
"node_modules/y18n": {
|
||||
"version": "5.0.8",
|
||||
"resolved": "https://registry.npmmirror.com/y18n/-/y18n-5.0.8.tgz",
|
||||
"resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
|
||||
"integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
|
||||
"license": "ISC",
|
||||
"engines": {
|
||||
@@ -963,7 +963,7 @@
|
||||
},
|
||||
"node_modules/yargs": {
|
||||
"version": "17.7.3",
|
||||
"resolved": "https://registry.npmmirror.com/yargs/-/yargs-17.7.3.tgz",
|
||||
"resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.3.tgz",
|
||||
"integrity": "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -981,7 +981,7 @@
|
||||
},
|
||||
"node_modules/yargs-parser": {
|
||||
"version": "21.1.1",
|
||||
"resolved": "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-21.1.1.tgz",
|
||||
"resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
|
||||
"integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
|
||||
"license": "ISC",
|
||||
"engines": {
|
||||
@@ -990,7 +990,7 @@
|
||||
},
|
||||
"node_modules/yauzl": {
|
||||
"version": "2.10.0",
|
||||
"resolved": "https://registry.npmmirror.com/yauzl/-/yauzl-2.10.0.tgz",
|
||||
"resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
|
||||
"integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
@@ -1000,7 +1000,7 @@
|
||||
},
|
||||
"node_modules/zod": {
|
||||
"version": "3.23.8",
|
||||
"resolved": "https://registry.npmmirror.com/zod/-/zod-3.23.8.tgz",
|
||||
"resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
|
||||
"integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
|
||||
+98
-28
@@ -9,10 +9,16 @@ import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
archiveVersionV1 = 1
|
||||
archiveVersionV2 = 2
|
||||
)
|
||||
|
||||
// ArchiveSnapshot is the portable traffic subset embedded in one task archive.
|
||||
// Large content-addressed bodies are copied alongside this manifest rather than
|
||||
// base64-encoded, preserving deduplication and allowing the tar writer to stream.
|
||||
@@ -23,22 +29,24 @@ type ArchiveSnapshot struct {
|
||||
}
|
||||
|
||||
type ArchiveExchange struct {
|
||||
ID string `json:"id"`
|
||||
TS int64 `json:"ts"`
|
||||
Host string `json:"host"`
|
||||
Method string `json:"method"`
|
||||
URLTemplate string `json:"url_template"`
|
||||
URL string `json:"url"`
|
||||
Status int `json:"status"`
|
||||
ContentType string `json:"content_type"`
|
||||
ReqLen int `json:"req_len"`
|
||||
RespLen int `json:"resp_len"`
|
||||
ReqHead string `json:"req_head"`
|
||||
ReqBody []byte `json:"req_body,omitempty"`
|
||||
ReqBlob string `json:"req_blob,omitempty"`
|
||||
RespHead string `json:"resp_head"`
|
||||
RespBody []byte `json:"resp_body,omitempty"`
|
||||
RespBlob string `json:"resp_blob,omitempty"`
|
||||
ID string `json:"id"`
|
||||
TS int64 `json:"ts"`
|
||||
Host string `json:"host"`
|
||||
Method string `json:"method"`
|
||||
URLTemplate string `json:"url_template"`
|
||||
URL string `json:"url"`
|
||||
Status int `json:"status"`
|
||||
ContentType string `json:"content_type"`
|
||||
ReqLen int `json:"req_len"`
|
||||
RespLen int `json:"resp_len"`
|
||||
ReqHead string `json:"req_head"`
|
||||
ReqBody []byte `json:"req_body,omitempty"`
|
||||
ReqBlob string `json:"req_blob,omitempty"`
|
||||
RespHead string `json:"resp_head"`
|
||||
RespBody []byte `json:"resp_body,omitempty"`
|
||||
RespBlob string `json:"resp_blob,omitempty"`
|
||||
Rewritten bool `json:"rewritten,omitempty"`
|
||||
RewriteRuleIDs []int64 `json:"rewrite_rule_ids,omitempty"`
|
||||
}
|
||||
|
||||
// ExportHosts writes an exact-host snapshot to dir. It holds the traffic writer
|
||||
@@ -66,7 +74,7 @@ FROM exchanges WHERE host IN (`+strings.Join(placeholders, ",")+`) ORDER BY ts,i
|
||||
return 0, err
|
||||
}
|
||||
defer rows.Close()
|
||||
snapshot := ArchiveSnapshot{Version: 1}
|
||||
snapshot := ArchiveSnapshot{Version: archiveVersionV2}
|
||||
blobs := map[string]struct{}{}
|
||||
for rows.Next() {
|
||||
var item ArchiveExchange
|
||||
@@ -102,21 +110,37 @@ FROM exchange_bodies WHERE id=?`, item.ID).Scan(&item.ReqHead, &item.ReqBody, &r
|
||||
if err := rows.Err(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for hash := range blobs {
|
||||
source, err := t.blobPath(hash)
|
||||
_ = rows.Close()
|
||||
for i := range snapshot.Exchanges {
|
||||
rewritten, ruleIDs, err := t.RewriteInfo(snapshot.Exchanges[i].ID)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
data, err := os.ReadFile(source)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
if rewritten {
|
||||
snapshot.Exchanges[i].Rewritten = true
|
||||
snapshot.Exchanges[i].RewriteRuleIDs = ruleIDs
|
||||
}
|
||||
}
|
||||
if len(blobs) > 0 {
|
||||
snapshot.Blobs = make([]string, 0, len(blobs))
|
||||
for hash := range blobs {
|
||||
snapshot.Blobs = append(snapshot.Blobs, hash)
|
||||
}
|
||||
sort.Strings(snapshot.Blobs)
|
||||
for _, hash := range snapshot.Blobs {
|
||||
source, err := t.blobPath(hash)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
data, err := os.ReadFile(source)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "blobs", hash+".bin"), data, 0o600); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "blobs", hash+".bin"), data, 0o600); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
snapshot.Blobs = append(snapshot.Blobs, hash)
|
||||
}
|
||||
sort.Strings(snapshot.Blobs)
|
||||
raw, err := json.Marshal(snapshot)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
@@ -129,6 +153,11 @@ FROM exchange_bodies WHERE id=?`, item.ID).Scan(&item.ReqHead, &item.ReqBody, &r
|
||||
|
||||
// ImportArchive imports only missing exchange IDs. Current hot rows always win,
|
||||
// and repeated restore attempts are safe after a partial external failure.
|
||||
// Version 1 archives carry no rewrite provenance (imported as unrewritten).
|
||||
// Version 2 archives carry per-exchange rewritten + rewrite_rule_ids and
|
||||
// reconstruct minimal applied rows in exchange_rewrites (phase='archived',
|
||||
// outcome='applied', rule_snapshot=NULL) so RewriteInfo and the rewritten list
|
||||
// filter return the same provenance without inventing a rule snapshot.
|
||||
func (t *Traffic) ImportArchive(dir string) (int64, error) {
|
||||
if t == nil {
|
||||
return 0, nil
|
||||
@@ -144,7 +173,7 @@ func (t *Traffic) ImportArchive(dir string) (int64, error) {
|
||||
if err := json.Unmarshal(raw, &snapshot); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if snapshot.Version != 1 {
|
||||
if snapshot.Version != archiveVersionV1 && snapshot.Version != archiveVersionV2 {
|
||||
return 0, fmt.Errorf("unsupported traffic archive version %d", snapshot.Version)
|
||||
}
|
||||
t.wmu.Lock()
|
||||
@@ -200,6 +229,11 @@ VALUES(?,?,?,?,?,?,?)`, item.ID, item.ReqHead, item.ReqBody, nullIfEmpty(item.Re
|
||||
}
|
||||
}
|
||||
}
|
||||
if snapshot.Version >= archiveVersionV2 && item.Rewritten {
|
||||
if err := insertArchivedRewriteProvenance(tx, item.ID, item.RewriteRuleIDs); err != nil {
|
||||
return imported, err
|
||||
}
|
||||
}
|
||||
if t.fts {
|
||||
var rowID int64
|
||||
if err := tx.QueryRow(`SELECT rowid FROM exchanges WHERE id=?`, item.ID).Scan(&rowID); err != nil {
|
||||
@@ -218,6 +252,42 @@ VALUES(?,?,?,?,?,?,?)`, item.ID, item.ReqHead, item.ReqBody, nullIfEmpty(item.Re
|
||||
return imported, nil
|
||||
}
|
||||
|
||||
// insertArchivedRewriteProvenance writes minimal applied rows so RewriteInfo
|
||||
// and the traffic list's rewritten flag/filter return the exact archived
|
||||
// provenance without fabricating a rule snapshot or request/response phase.
|
||||
func insertArchivedRewriteProvenance(tx *sql.Tx, exchangeID string, ruleIDs []int64) error {
|
||||
ids := normalizeArchiveRuleIDs(ruleIDs)
|
||||
if len(ids) == 0 {
|
||||
_, err := tx.Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,outcome,reason)
|
||||
VALUES(?,0,'archived',NULL,'applied','archived')`, exchangeID)
|
||||
return err
|
||||
}
|
||||
for seq, rid := range ids {
|
||||
if _, err := tx.Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,outcome,reason)
|
||||
VALUES(?,?,'archived',?,'applied','archived')`, exchangeID, seq, rid); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func normalizeArchiveRuleIDs(ids []int64) []int64 {
|
||||
if len(ids) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]int64, 0, len(ids))
|
||||
for _, id := range ids {
|
||||
if id > 0 {
|
||||
out = append(out, id)
|
||||
}
|
||||
}
|
||||
if len(out) == 0 {
|
||||
return nil
|
||||
}
|
||||
slices.Sort(out)
|
||||
return slices.Compact(out)
|
||||
}
|
||||
|
||||
func uniqueArchiveHosts(hosts []string) []string {
|
||||
seen := make(map[string]struct{}, len(hosts))
|
||||
out := make([]string, 0, len(hosts))
|
||||
|
||||
@@ -1,8 +1,13 @@
|
||||
package traffic
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
@@ -156,3 +161,291 @@ func simulateTrafficStageProcessExit(t *testing.T, stage *HostDeleteStage) {
|
||||
stage.done = true
|
||||
stage.traffic.wmu.Unlock()
|
||||
}
|
||||
|
||||
func callTrafficGetTool(t *testing.T, tr *Traffic, id string) string {
|
||||
t.Helper()
|
||||
for _, tool := range tr.Tools() {
|
||||
if tool.Name() != "traffic_get" {
|
||||
continue
|
||||
}
|
||||
res, err := tool.Call(context.Background(), json.RawMessage(`{"id":`+mustJSON(t, id)+`}`), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("traffic_get(%s) error: %v", id, err)
|
||||
}
|
||||
if res.IsError {
|
||||
t.Fatalf("traffic_get(%s) tool error: %s", id, res.Flatten())
|
||||
}
|
||||
return res.Flatten()
|
||||
}
|
||||
t.Fatal("traffic_get tool not found")
|
||||
return ""
|
||||
}
|
||||
|
||||
func mustJSON(t *testing.T, v any) string {
|
||||
t.Helper()
|
||||
b, err := json.Marshal(v)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
func TestTrafficArchiveV2RewriteProvenanceRoundTripAndByteIdentical(t *testing.T) {
|
||||
src, err := Open(t.TempDir(), "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer src.Close()
|
||||
|
||||
const host = "v2-provenance.example"
|
||||
insertEx := func(id string, ts int64, urlPath string) {
|
||||
t.Helper()
|
||||
if _, err := src.DB().Exec(`INSERT INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
|
||||
VALUES(?,?,?,?,?,?,?,?,?,?,?)`, id, ts, host, "GET", urlPath, "https://"+host+urlPath, 200, "text/plain", 0, 2, ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := src.DB().Exec(`INSERT INTO exchange_bodies(id,req_head,req_body,resp_head,resp_body)
|
||||
VALUES(?,?,?,?,?)`, id, "GET "+urlPath+" HTTP/1.1\nHost: "+host, []byte{}, "HTTP/1.1 200 OK", []byte("ok")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Rewritten exchange with out-of-order + duplicate applied rule IDs plus skipped/error rows.
|
||||
insertEx("ex-rewritten", 10, "/rewritten")
|
||||
for seq, row := range []struct {
|
||||
phase string
|
||||
ruleID any
|
||||
outcome string
|
||||
}{
|
||||
{"request", 7, "applied"},
|
||||
{"request", 99, "skipped"},
|
||||
{"response", 2, "applied"},
|
||||
{"response", 7, "applied"},
|
||||
{"response", 88, "error"},
|
||||
} {
|
||||
if _, err := src.DB().Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,rule_snapshot,outcome,reason)
|
||||
VALUES(?,?,?,?,?,?,?)`, "ex-rewritten", seq, row.phase, row.ruleID, `{"id":1}`, row.outcome, ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Rewritten exchange with applied row carrying NULL rule_id.
|
||||
insertEx("ex-rewritten-null-rule", 20, "/rewritten-null")
|
||||
if _, err := src.DB().Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,outcome,reason)
|
||||
VALUES('ex-rewritten-null-rule',0,'request',NULL,'applied','')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// 3. Exchange with only skipped/error rows -> NOT rewritten.
|
||||
insertEx("ex-skipped-only", 30, "/skipped")
|
||||
if _, err := src.DB().Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,outcome,reason)
|
||||
VALUES('ex-skipped-only',0,'request',5,'skipped','not rewritten: binary'),('ex-skipped-only',1,'response',6,'error','boom')`); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// 4. Plain original exchange with no rewrite rows.
|
||||
insertEx("ex-plain", 40, "/plain")
|
||||
|
||||
export1Dir := filepath.Join(t.TempDir(), "export1")
|
||||
count, err := src.ExportHosts([]string{host}, export1Dir)
|
||||
if err != nil || count != 4 {
|
||||
t.Fatalf("ExportHosts = (%d, %v), want (4, nil)", count, err)
|
||||
}
|
||||
raw1, err := os.ReadFile(filepath.Join(export1Dir, "traffic.json"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var snap ArchiveSnapshot
|
||||
if err := json.Unmarshal(raw1, &snap); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if snap.Version != 2 {
|
||||
t.Fatalf("archive version = %d, want 2", snap.Version)
|
||||
}
|
||||
if len(snap.Exchanges) != 4 {
|
||||
t.Fatalf("archive exchanges = %d, want 4", len(snap.Exchanges))
|
||||
}
|
||||
if !snap.Exchanges[0].Rewritten || !slices.Equal(snap.Exchanges[0].RewriteRuleIDs, []int64{2, 7}) {
|
||||
t.Fatalf("ex-rewritten exported = (%v, %v), want (true, [2 7])", snap.Exchanges[0].Rewritten, snap.Exchanges[0].RewriteRuleIDs)
|
||||
}
|
||||
if !snap.Exchanges[1].Rewritten || len(snap.Exchanges[1].RewriteRuleIDs) != 0 {
|
||||
t.Fatalf("ex-rewritten-null-rule exported = (%v, %v), want (true, nil)", snap.Exchanges[1].Rewritten, snap.Exchanges[1].RewriteRuleIDs)
|
||||
}
|
||||
if snap.Exchanges[2].Rewritten || len(snap.Exchanges[2].RewriteRuleIDs) != 0 {
|
||||
t.Fatalf("ex-skipped-only exported = (%v, %v), want (false, nil)", snap.Exchanges[2].Rewritten, snap.Exchanges[2].RewriteRuleIDs)
|
||||
}
|
||||
if snap.Exchanges[3].Rewritten || len(snap.Exchanges[3].RewriteRuleIDs) != 0 {
|
||||
t.Fatalf("ex-plain exported = (%v, %v), want (false, nil)", snap.Exchanges[3].Rewritten, snap.Exchanges[3].RewriteRuleIDs)
|
||||
}
|
||||
|
||||
// Import into a fresh store and verify RewriteInfo, reconstructed rows, traffic_get, and Page.
|
||||
dst, err := Open(t.TempDir(), "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer dst.Close()
|
||||
|
||||
imported, err := dst.ImportArchive(export1Dir)
|
||||
if err != nil || imported != 4 {
|
||||
t.Fatalf("ImportArchive = (%d, %v), want (4, nil)", imported, err)
|
||||
}
|
||||
|
||||
if rw, ids, err := dst.RewriteInfo("ex-rewritten"); err != nil || !rw || !slices.Equal(ids, []int64{2, 7}) {
|
||||
t.Fatalf("dst RewriteInfo(ex-rewritten) = (%v, %v, %v), want (true, [2 7], nil)", rw, ids, err)
|
||||
}
|
||||
if rw, ids, err := dst.RewriteInfo("ex-rewritten-null-rule"); err != nil || !rw || len(ids) != 0 {
|
||||
t.Fatalf("dst RewriteInfo(ex-rewritten-null-rule) = (%v, %v, %v), want (true, nil, nil)", rw, ids, err)
|
||||
}
|
||||
for _, id := range []string{"ex-skipped-only", "ex-plain"} {
|
||||
if rw, ids, err := dst.RewriteInfo(id); err != nil || rw || len(ids) != 0 {
|
||||
t.Fatalf("dst RewriteInfo(%s) = (%v, %v, %v), want (false, nil, nil)", id, rw, ids, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Reconstructed rows must not fabricate a rule_snapshot.
|
||||
var snapCount int
|
||||
if err := dst.DB().QueryRow(`SELECT COUNT(*) FROM exchange_rewrites WHERE exchange_id='ex-rewritten' AND rule_snapshot IS NOT NULL`).Scan(&snapCount); err != nil || snapCount != 0 {
|
||||
t.Fatalf("reconstructed rows should have NULL rule_snapshot, got count=%d err=%v", snapCount, err)
|
||||
}
|
||||
var phase, outcome string
|
||||
var rid sql.NullInt64
|
||||
if err := dst.DB().QueryRow(`SELECT phase, outcome, rule_id FROM exchange_rewrites WHERE exchange_id='ex-rewritten' AND seq=0`).Scan(&phase, &outcome, &rid); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if phase != "archived" || outcome != "applied" || !rid.Valid || rid.Int64 != 2 {
|
||||
t.Fatalf("reconstructed row 0 = (%q, %q, %+v), want ('archived', 'applied', 2)", phase, outcome, rid)
|
||||
}
|
||||
|
||||
// traffic_get shows === REWRITTEN === for rewritten exchange and not for plain/skipped-only.
|
||||
if out := callTrafficGetTool(t, dst, "ex-rewritten"); !strings.HasPrefix(out, "=== REWRITTEN === rewrite rules [2 7] ") {
|
||||
t.Fatalf("traffic_get(ex-rewritten) = %q, want REWRITTEN header", out)
|
||||
}
|
||||
if out := callTrafficGetTool(t, dst, "ex-plain"); strings.Contains(out, "REWRITTEN") {
|
||||
t.Fatalf("traffic_get(ex-plain) unexpectedly contained REWRITTEN: %q", out)
|
||||
}
|
||||
if out := callTrafficGetTool(t, dst, "ex-skipped-only"); strings.Contains(out, "REWRITTEN") {
|
||||
t.Fatalf("traffic_get(ex-skipped-only) unexpectedly contained REWRITTEN: %q", out)
|
||||
}
|
||||
|
||||
// Re-export from the imported store must be byte-identical.
|
||||
export2Dir := filepath.Join(t.TempDir(), "export2")
|
||||
if count2, err := dst.ExportHosts([]string{host}, export2Dir); err != nil || count2 != 4 {
|
||||
t.Fatalf("re-export ExportHosts = (%d, %v), want (4, nil)", count2, err)
|
||||
}
|
||||
raw2, err := os.ReadFile(filepath.Join(export2Dir, "traffic.json"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !bytes.Equal(raw1, raw2) {
|
||||
t.Fatalf("re-exported traffic.json differs:\nfirst: %s\nsecond: %s", string(raw1), string(raw2))
|
||||
}
|
||||
|
||||
// Re-importing over the original hot store must preserve the original live trace rows.
|
||||
if importedAgain, err := src.ImportArchive(export1Dir); err != nil || importedAgain != 0 {
|
||||
t.Fatalf("ImportArchive over hot store = (%d, %v), want (0, nil)", importedAgain, err)
|
||||
}
|
||||
var liveTraceRows int
|
||||
if err := src.DB().QueryRow(`SELECT COUNT(*) FROM exchange_rewrites WHERE exchange_id='ex-rewritten'`).Scan(&liveTraceRows); err != nil || liveTraceRows != 5 {
|
||||
t.Fatalf("hot store live trace rows = %d err=%v, want 5", liveTraceRows, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrafficArchiveV1FixtureImportsWithoutRewritten(t *testing.T) {
|
||||
dir := filepath.Join(t.TempDir(), "traffic")
|
||||
if err := os.MkdirAll(filepath.Join(dir, "blobs"), 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// v1 fixture: first entry is standard v1 without rewrite fields; second entry
|
||||
// tries to smuggle rewrite fields under version 1 and must still import as unrewritten.
|
||||
v1JSON := `{
|
||||
"version": 1,
|
||||
"exchanges": [
|
||||
{
|
||||
"id": "v1-plain",
|
||||
"ts": 100,
|
||||
"host": "legacy.example",
|
||||
"method": "GET",
|
||||
"url_template": "/legacy",
|
||||
"url": "https://legacy.example/legacy",
|
||||
"status": 200,
|
||||
"content_type": "text/plain",
|
||||
"req_len": 0,
|
||||
"resp_len": 2,
|
||||
"req_head": "GET /legacy HTTP/1.1\nHost: legacy.example",
|
||||
"resp_head": "HTTP/1.1 200 OK",
|
||||
"resp_body": "b2s="
|
||||
},
|
||||
{
|
||||
"id": "v1-ignored-fields",
|
||||
"ts": 101,
|
||||
"host": "legacy.example",
|
||||
"method": "GET",
|
||||
"url_template": "/legacy2",
|
||||
"url": "https://legacy.example/legacy2",
|
||||
"status": 200,
|
||||
"content_type": "text/plain",
|
||||
"req_len": 0,
|
||||
"resp_len": 2,
|
||||
"req_head": "GET /legacy2 HTTP/1.1\nHost: legacy.example",
|
||||
"resp_head": "HTTP/1.1 200 OK",
|
||||
"resp_body": "b2s=",
|
||||
"rewritten": true,
|
||||
"rewrite_rule_ids": [3, 9]
|
||||
}
|
||||
],
|
||||
"blobs": []
|
||||
}`
|
||||
if err := os.WriteFile(filepath.Join(dir, "traffic.json"), []byte(v1JSON), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
tr, err := Open(t.TempDir(), "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer tr.Close()
|
||||
|
||||
imported, err := tr.ImportArchive(dir)
|
||||
if err != nil || imported != 2 {
|
||||
t.Fatalf("ImportArchive(v1) = (%d, %v), want (2, nil)", imported, err)
|
||||
}
|
||||
for _, id := range []string{"v1-plain", "v1-ignored-fields"} {
|
||||
if rw, ids, err := tr.RewriteInfo(id); err != nil || rw || len(ids) != 0 {
|
||||
t.Fatalf("v1 RewriteInfo(%s) = (%v, %v, %v), want (false, nil, nil)", id, rw, ids, err)
|
||||
}
|
||||
if out := callTrafficGetTool(t, tr, id); strings.Contains(out, "REWRITTEN") {
|
||||
t.Fatalf("v1 traffic_get(%s) unexpectedly has REWRITTEN: %q", id, out)
|
||||
}
|
||||
}
|
||||
rows, total, err := tr.Page(PageQuery{RespMin: -1, RespMax: -1}, 0, 10)
|
||||
if err != nil || total != 2 || len(rows) != 2 {
|
||||
t.Fatalf("Page after v1 import = (%d, %d, %v), want (2, 2, nil)", len(rows), total, err)
|
||||
}
|
||||
for _, r := range rows {
|
||||
if r.Rewritten {
|
||||
t.Fatalf("v1 row %s marked rewritten", r.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTrafficArchiveUnknownVersionRefused(t *testing.T) {
|
||||
tr, err := Open(t.TempDir(), "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer tr.Close()
|
||||
|
||||
for _, ver := range []int{-1, 0, 3, 99} {
|
||||
dir := filepath.Join(t.TempDir(), "traffic")
|
||||
if err := os.MkdirAll(dir, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
payload := mustJSON(t, ArchiveSnapshot{Version: ver})
|
||||
if err := os.WriteFile(filepath.Join(dir, "traffic.json"), []byte(payload), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := tr.ImportArchive(dir); err == nil || !strings.Contains(err.Error(), "unsupported traffic archive version") {
|
||||
t.Fatalf("ImportArchive(version=%d) err = %v, want unsupported version error", ver, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user