Compare commits

..
Author SHA1 Message Date
BaaRai 2d5906295c docs(traffic): note that IP/CIDR rules apply on transparent TCP (no hostname) 2026-11-20 23:08:42 +01:00
BaaRai bd59d7d9d5 docs: document Linux transparent TCP inbound (P4.1b) and firewall rules/cleanup 2026-11-20 22:52:51 +01:00
BaaRai 095d3a57d4 test(traffic): add transparent TCP unit, policy, store, and Linux iptables REDIRECT tests 2026-11-20 22:52:51 +01:00
BaaRai 82691f1cc2 feat(traffic): add opt-in Linux IPv4 transparent TCP listener (SO_ORIGINAL_DST) 2026-11-20 22:52:50 +01:00
BaaRai 792e965f26 fix(traffic): atomic temp+rename raw TCP blob spill and document SOCKS5 proxy caveats 2026-11-20 22:44:20 +01:00
BaaRai afa5d0e1a1 docs: document opt-in SOCKS5 raw TCP capture (P4.1a) and update CHANGELOG 2026-11-20 22:32:18 +01:00
BaaRai 8b49362db4 test(traffic): add SOCKS5 listener and raw TCP recording tests 2026-11-20 22:30:08 +01:00
BaaRai 551c14e644 feat(traffic): record raw TCP streams in SQLite store with previews and blob refs 2026-11-20 22:23:24 +01:00
BaaRai 19af5ba329 feat(traffic): add opt-in RFC 1928 SOCKS5 CONNECT listener with target gate and egress governor 2026-11-20 22:22:13 +01:00
BaaRai 79119ae9bd test: clean up residual findings, retest conversations, parent assets, and test rows 2026-11-20 22:18:53 +01:00
BaaRai b3b9334dc8 perf(db): add partial covering indexes for dashboard/usage queries (migration 0010) 2026-11-20 21:48:31 +01:00
BaaRai 33e8d79426 chore: remove provably unused unexported Go helpers and dead web template files 2026-11-20 21:43:43 +01:00
BaaRai 42e8d3554d chore(deps): bump Go to 1.26.11 and x/crypto to v0.59.0 (govulncheck) 2026-11-20 21:28:26 +01:00
BaaRai caa38f6ca8 chore(web): remove dead imports, unused template components, and 18 unused dependencies 2026-11-20 21:02:09 +01:00
BaaRai 0d85fc9b06 Merge pull request #427 from BaaRai/feat/worker-cache-prefix
feat(agent): opt-in worker cache-prefix split (P3.5 phase C)
2026-11-20 20:57:10 +01:00
BaaRai 40a43580fe Merge pull request #410 from tglemser/fix/record-fact-facts-only-schema
fix(agent): publish record_fact as a facts-only contract
2026-11-20 20:48:32 +01:00
BaaRai 944c131e90 docs(context-telemetry): align Phase C expected-gain bullet with minimal split 2026-11-20 20:41:48 +01:00
BaaRai 0dbb6de8d5 feat(agent): opt-in worker system cache-prefix split (P3.5 phase C) 2026-11-20 20:29:17 +01:00
BaaRai 5def7bf57e docs(server): correct the record_fact refresh comment 2026-11-20 20:07:50 +01:00
BaaRai 268693066a Merge pull request #413 from BlackGownQ/feat/i18n-zh-cn
feat(i18n): add Simplified Chinese locale using the existing translation layer
2026-11-20 20:00:03 +01:00
BaaRai 0ffb0a68c4 Merge pull request #420 from ldevbr/contrib/api-recon-npm-registry
skills(api-recon): point the lockfile at the public npm registry
2026-11-20 19:59:45 +01:00
BaaRai 892d1330f6 Merge pull request #416 from ldevbr/contrib/npm-ci-ignore-scripts
build: run npm ci with --ignore-scripts in the build/install/update s…
2026-11-20 19:59:28 +01:00
BaaRai 11adad32ce Merge pull request #415 from ldevbr/contrib/bump-vuln-deps
deps: bump klauspost/compress and brotli to fix known advisories
2026-11-20 19:59:10 +01:00
BaaRai 49c5e8fa8a Merge pull request #406 from maheshBawa/fix/compose-llm-private-endpoints
fix(compose): pass ARTEX_LLM_PRIVATE_ENDPOINTS to the artex container
2026-11-20 19:58:40 +01:00
BaaRai f6f9575b19 Merge pull request #401 from YunzhouLi-hub/feat/neon-theme-preset
feat(web): add an optional Neon theme preset
2026-11-20 19:58:29 +01:00
BaaRai 280e99eace Merge pull request #396 from YunzhouLi-hub/docs/tool-input-troubleshooting
docs: troubleshoot empty tool input in session transcripts
2026-11-20 19:58:19 +01:00
BaaRai e2ca0118e7 Merge pull request #400 from YunzhouLi-hub/docs/first-time-contributors
docs: add a first-contribution guide
2026-11-20 19:58:08 +01:00
BaaRai 1e9079267b Merge pull request #411 from adam-33-pixel/fix/llmrec-explicit-stop-status
llmrec: decide usage status when the consumer stops reading
2026-11-20 19:57:57 +01:00
BaaRai 3559be6482 Merge pull request #426 from BaaRai/feat/context-telemetry
feat(llmrec): opt-in LLM context size telemetry and aggregation (P3.5 phase A)
2026-11-20 19:37:48 +01:00
BaaRai aa8ba54efb fix(server): reword the record_fact default-mismatch log line 2026-11-20 19:13:38 +01:00
BaaRai 5e1c55db4d fix(server): recognise the released record_fact descriptions as known defaults
The releases v0.4.0 to v0.6.0 seed a record_fact description without the source bullet and their own facts property description. Neither was in the list of known defaults, so the one-time refresh kept both texts on a database seeded by a release and logged the description as an operator edit.

Both released texts are now known defaults, taken byte for byte from agent/tools.go at those tags, and the log line says the description does not match a known default.
2026-11-20 18:48:06 +01:00
BaaRai 5679618ea7 ci: drop the stale skip note for the llmrec usage status test 2026-11-20 18:17:05 +01:00
BaaRai 9ab895f2b7 docs: link SECURITY.md in the first-contribution guide 2026-11-20 18:16:44 +01:00
BaaRai e10c2b76aa Merge pull request #419 from ldevbr/contrib/next-telemetry-off
build(web): disable Next.js telemetry in the web build stage
2026-11-20 18:16:00 +01:00
BaaRai 8793f7b56c Merge pull request #408 from Lusitaniae/pr/tool-checksums
build: pin tool and node digests instead of fetching their checksums files
2026-11-20 18:15:21 +01:00
BaaRai f758b4d964 fix(server): keep the record_fact refresh flag unset when the refresh fails
refreshRecordFactContract wrote its one-time flag in a defer, so a start on
which GetTool, the schema decode or the UPDATE failed still spent the flag.
No later start retried and the database kept the earlier description.

The flag is now written once the outcome is known: after the UPDATE
succeeded (also when it changed no row), or when the row is not the
built-in one. A failed read, decode or UPDATE leaves it unset and the next
start retries.

Test: TestFix410RefreshFlagNotSetOnFailure (an UPDATE refused by a trigger,
and a stored schema that does not decode; the next start refreshes the
text and sets the flag).
2026-11-20 18:11:42 +01:00
BaaRai c5cb1afad7 fix(agent): keep the record_fact harness opt-out through tool wrappers
record_fact opts out of the harness schema check (norma Spec.RawInput) and
validates its own input. The harness finds the opt-out with a type
assertion on the tool it is handed, and that tool is a wrapper: catalog
tools are metered (meteredTool), and guardPanic wraps every tool last
(guardedTool). Both embed CoreTool, which hides AcceptsRawInput, so the
opt-out was lost and a malformed call was answered by the SDK ("invalid
tool input: facts: expected array") instead of by the handler.

guardedTool and meteredTool now forward AcceptsRawInput, as overriddenTool
already does.

Test: TestFix410AcceptsRawInputSurvivesWrappers covers each wrapper and
record_fact through wireTools, AugmentTools and harness.Query.
2026-11-20 18:11:16 +01:00
Luis 3feeb37a3a deps: bump klauspost/compress and brotli to fix known advisories
- github.com/klauspost/compress 1.18.6 -> 1.20.2 (GO-2026-5841, GO-2026-6865)
- github.com/andybalholm/brotli 1.2.1 -> 1.2.7 (GO-2026-6888)

`go mod tidy` and `go build ./...` pass; the change is limited to these two
modules in go.mod/go.sum.
2026-11-20 10:26:02 -05:00
Luis bbe95d085b skills(api-recon): point the lockfile at the public npm registry
Every `resolved` URL in skills/api-recon/scripts/package-lock.json pointed at
registry.npmmirror.com (a third-party mirror). Repoint them to
registry.npmjs.org. The integrity hashes are unchanged and still valid, so the
tarballs are byte-identical; `npm ci --registry=https://registry.npmjs.org`
installs cleanly and puppeteer-core loads.
2026-11-20 10:26:01 -05:00
Luis 9be6b76420 build: run npm ci with --ignore-scripts in the build/install/update scripts
The Dockerfile already uses `npm ci --ignore-scripts`; the host-side build
helpers (build.sh, install.sh, update.sh) did not. Align them so a lifecycle
script in a dependency cannot run during a local rebuild. No package in the
current lockfile declares install scripts, so this is a hardening no-op today.
2026-11-20 10:26:01 -05:00
Luis ef25384063 build(web): disable Next.js telemetry in the web build stage
`next build` contacts telemetry.nextjs.org during the image build. Set
NEXT_TELEMETRY_DISABLED=1 in the web stage so the build makes no telemetry
request. No runtime behavior changes.
2026-11-20 10:26:01 -05:00
BlackGownQ ada0092168 feat(i18n): add Simplified Chinese translations 2026-11-20 23:21:59 +08:00
BlackGownQ 2d6d5c4e2b feat(i18n): register and document Simplified Chinese 2026-11-20 23:21:13 +08:00
BlackGownQ 12f0ec0432 test(i18n): validate catalogs and locale behavior 2026-11-20 23:20:24 +08:00
BlackGownQ 2ff2fc59ac test(i18n): run locale validation and runtime regression tests 2026-11-20 23:19:32 +08:00
Adam Rufaro Dzitiro 2db355389a llmrec: decide usage status when the consumer stops reading 2026-11-20 12:21:22 +02:00
tglemserandClaude Mythos 5.1 6e906b4920 fix(agent): publish record_fact as a facts-only contract
The schema the model sees for record_fact declared every fact field twice:
at the top level (single-fact shape) and inside facts[] (batch shape), with
the handler deciding which shape a call is. A model that fills every
declared property sends the single fact inside facts[] and a copy, or a
placeholder such as "", [] or "x", of each field beside it; since PR #282
every such call is refused by name, and the refusal text ("summary is not
allowed at the top level") leads the model to send a dummy value next, so
the same refusal repeats until the intent ends. Observed with a model over
the OpenAI Responses API: 209 of 212 record_fact calls of two tasks were
refused, 156 of them identical in one intent.

The published schema is now {facts:[{...}]} and nothing else (required:
facts, additionalProperties false). The handler keeps the strict contract
of PR #282: unknown or mis-cased fields, invalid or foreign asset ids,
missing summaries, empty batches and any top-level field beside facts
(other than the legacy intent_id) are refused before anything is written,
with an error that names the fields and the one accepted shape. It still
accepts the legacy single fact and the legacy batch with a top-level
intent_id. An item without intent_id is linked to the intent the worker is
running (SetOwnerNode), as report_finding already does.

record_fact opts out of the harness schema check (norma Spec.RawInput) so
the stricter published schema does not reject the legacy shapes before the
handler sees them; the catalog decorator forwards the opt-out.
RepairRecordFactSchema republishes stored and cached schemas as facts-only
and keeps the annotations of facts and its items. A one-time startup
refresh replaces the stored description and the texts that referred to the
top level when they equal the previous defaults; operator edits stay and
are logged. seedFactSourceSchema adds the source enum on the items.

Tests: the handler contract (TestRecordFactSummaryContract,
TestRecordFactStrictFields, TestRecordFactBatchTopLevelConflicts,
TestRecordFactRefusesTopLevelCopiesBesideFacts), the published schema and
its repair (TestRecordFactSchemaIsFactsOnly, TestRecordFactStoredContractRepair,
TestRecordFactInputSchemaUpgrade, TestRecordFactSourceSchemaUpgrade,
TestWireTools), the running-intent default, the one-time refresh
(TestRefreshRecordFactContract) and a synthetic replay of the call shapes
(TestRecordFactShapesReplay).

Co-Authored-By: Claude Mythos 5.1 <noreply@anthropic.com>
2026-11-20 10:03:52 +00:00
Pedro Gomes b7bc9f9517 build: pin tool and node digests instead of fetching their checksums files
Each tool archive was verified against the *_checksums.txt of its own GitHub
release, fetched in the same build step as the archive. That catches a truncated
download, a stale CDN entry and a moved tag. It does not catch the publisher: the
digest and the artifact it describes ship from the same release, so a replaced
asset plus a replaced checksums file agree with each other and the build goes
green. The build was trusting the channel it downloads from to vouch for itself.

Pin the digests in the Dockerfile instead — one per asset per architecture, next
to the version ARG — and have fetch() take the expected digest as an argument.
The assets and their URLs are unchanged; a swapped asset now fails the build
unless the diff that swaps it also changes a digest a reviewer reads. Node's
tarball in the runtime stage gets the same treatment for the same reason; it was
the last fetched-SHASUMS256 check left.

The digests were taken from the artifacts themselves and cross-checked against
the published sums files, so this change is build-identical: same 14 bytes of
input, same output, different trust anchor. Verified by building the tools stage
for both arches with the pinned values.

Cost, and it is a real one: a version bump is three edits instead of one, and a
publisher re-uploading an asset under an existing tag breaks the build until the
digest is bumped deliberately. Two hashes per tool bump is the chore that buys
not trusting the release channel.

sqlmap already worked this way (pinned tag, asserted commit); this makes the
binary tools consistent with it.
2026-11-20 09:29:34 +00:00
maheshBawaandClaude Opus 5.5 594d1918fd fix(compose): pass ARTEX_LLM_PRIVATE_ENDPOINTS to the artex container
The model-list allow-list (#390) is read from the
environment, but docker-compose.yml never forwarded it, so a Docker install
could not list models from a local Ollama at host.docker.internal:11434.
Empty by default, so the strict public-only policy is unchanged.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-20 14:43:27 +05:30
李云周 84c77021c4 feat(web): add an optional Neon theme preset 2026-11-20 15:24:57 +08:00
李云周 5e979f102a docs: add a first-contribution guide 2026-11-20 15:18:38 +08:00
李云周 cc465be782 docs: explain empty tool input in session transcripts 2026-11-20 14:59:02 +08:00
116 changed files with 8560 additions and 3285 deletions
+2
View File
@@ -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);
-2
View File
@@ -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
+4
View File
@@ -23,6 +23,9 @@ 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 Linux transparent TCP inbound & raw TCP recording (P4.1b)**: on Linux when traffic capture is enabled, setting `ARTEX_TRANSPARENT_TCP_ENABLED=1` (loopback `127.0.0.1:1081` by default) or `ARTEX_TRANSPARENT_TCP_ADDR=<ipv4:port>` starts an IPv4 transparent TCP listener fed by operator-managed `iptables`/`nftables` `REDIRECT` rules (off by default; ARTEX never touches the host firewall; root/`CAP_NET_ADMIN` is required only for the operator's redirect rules; IPv6 is not covered). Recovers original IPv4 destinations via `SO_ORIGINAL_DST` with self-redirect loop protection, reuses the P4.1a target gate (`intercept.Interceptor.DialSOCKS5`), egress governor (`egress.Do`), half-close relay bounds, and SQLite `raw_tcp_streams` store (atomic `_blobs` spill, no HTTP `exchanges` row, no PostgreSQL migration). See `docs/traffic-transparent.md`.
- **Opt-in SOCKS5 inbound proxy & raw TCP recording (P4.1a)**: when traffic capture is enabled, setting `ARTEX_SOCKS5_ENABLED=1` (loopback `127.0.0.1:1080` by default) or `ARTEX_SOCKS5_ADDR=<addr>` starts an RFC 1928 SOCKS5 `CONNECT` listener alongside the HTTP recording proxy (off by default; HTTP proxy and agent proxy env vars are unchanged; listener does not start if traffic recording is disabled). Accepts loopback no-auth and RFC 1929 username/password without verifying credentials (carrying `artex-pace` in the username; binding to a non-loopback address therefore exposes an unauthenticated proxy, though the target gate and governor still apply), rejects `BIND`/`UDP ASSOCIATE` with `0x07`, enforces the existing target gate (`intercept.Interceptor.DialSOCKS5` / `intercept.PinnedDialer`) and egress governor (`egress.Do`) before dialing, relays half-close-aware TCP with concurrency/byte/idle/handshake bounds, and records one row per connection in SQLite `raw_tcp_streams` with capped directional previews and atomic (temp+rename) `_blobs` refs without writing HTTP `exchanges` rows. See `docs/traffic-socks5.md`.
- **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`.
@@ -52,6 +55,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.
+7
View File
@@ -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
View File
@@ -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/
+19
View File
@@ -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
+8
View File
@@ -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 {
+1 -1
View File
@@ -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)
+2 -2
View File
@@ -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 {
+1 -1
View File
@@ -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 {
+3 -4
View File
@@ -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
View File
@@ -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 {
+54
View File
@@ -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
View File
@@ -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)
}
}
+4 -1
View File
@@ -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 }{
+8 -2
View File
@@ -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
+128
View File
@@ -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)
}
}
}
}
}
+1 -1
View File
@@ -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)
+8
View File
@@ -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
View File
@@ -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
View File
@@ -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)
+326
View File
@@ -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))
}
}
+1 -1
View File
@@ -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"
+1
View File
@@ -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)
+96
View File
@@ -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)
}
}
+1
View File
@@ -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)
}
+2
View File
@@ -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: {"", ""},
+5 -1
View File
@@ -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
View File
@@ -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
View File
@@ -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)
+21 -2
View File
@@ -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
}
+2 -2
View File
@@ -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{
+2 -2
View File
@@ -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"}, {9, "0009_llm_context.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 9", 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,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
View File
@@ -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)
+11 -2
View File
@@ -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)
+5 -1
View File
@@ -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 {
+2
View File
@@ -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:-}
+14 -2
View File
@@ -131,6 +131,18 @@ ORDER BY input_tokens DESC;
| 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. Splitting `worker` system segments at `DynamicBoundary` — placing the task-stable prefix (`workerDefaultTmpl` + `untrustedContentTail` + `workerTrafficBlock` + `noiseProfileBlock` + `frameLessonsBlock` + `constraintBlock` + `def.FindingGuidance` + `<available-deferred-tools>`) **before** `DynamicBoundary` (`system_static`) and the per-intent suffix (`workerArtifactSpec(runDir)` + `renderIntentTask(intent)` + target assets JSON + closing launch line) **after** `DynamicBoundary` (`system_dynamic`) — 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).
- **`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 segment reordering using `norma`'s existing `DynamicBoundary` contract; 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).
- **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`.
+56
View File
@@ -0,0 +1,56 @@
# Opt-in SOCKS5 Inbound Proxy & Raw TCP Recording (P4.1a)
ARTEX ships an opt-in **RFC 1928 SOCKS5 `CONNECT`** inbound listener in `traffic/` that records raw TCP connections separately from HTTP traffic.
## Opt-in Configuration (Off by Default)
| Environment Variable | Default | Behavior |
|---|---|---|
| `ARTEX_SOCKS5_ENABLED` | unset (off) | Set to `1` / `true` / `on` / `yes` to start the SOCKS5 listener on `127.0.0.1:1080` (loopback). Explicit `0` / `false` / `off` / `no` forces it off even if `ARTEX_SOCKS5_ADDR` is set. |
| `ARTEX_SOCKS5_ADDR` | `127.0.0.1:1080` | Explicit TCP bind address; setting a non-empty value also enables the listener unless `ARTEX_SOCKS5_ENABLED` is explicitly false. |
- **Flag off**: no SOCKS5 listener is started and the HTTP MITM recording proxy is byte-identical.
- **Requires traffic recorder**: the server only starts the SOCKS5 listener when the traffic recorder is enabled (inside the traffic proxy block in `server/manager.go`). If traffic capture is disabled, setting `ARTEX_SOCKS5_ENABLED` / `ARTEX_SOCKS5_ADDR` does not open a listener.
- **Agents unchanged**: workers and tools keep `HTTP_PROXY`, `HTTPS_PROXY`, and `ALL_PROXY` pointing to the existing HTTP proxy; ARTEX does not silently switch agents to SOCKS5.
- **Non-loopback bind warning**: RFC 1929 username/password (`0x02`) accepts **any** username and password without verifying credentials (so the pace marker `artex-pace` can ride in the username). Binding `ARTEX_SOCKS5_ADDR` to a non-loopback address therefore exposes an **unauthenticated proxy** to anyone who can reach that port. The target gate and egress governor still apply to every connection, but keep the listener on loopback (`127.0.0.1`) or restrict access at the host firewall.
## Protocol Scope (P4.1a)
- **Commands**: `CONNECT` (`0x01`) only. `BIND` (`0x02`), `UDP ASSOCIATE` (`0x03`, planned for P4.1c), and unknown commands return RFC 1928 reply `0x07` (*Command not supported*).
- **Addressing**: IPv4 (`0x01`), domain name (`0x03`), and IPv6 (`0x04`). Unknown address types return `0x08` (*Address type not supported*).
- **Authentication**:
- Loopback peers (`net.IP.IsLoopback()`) may connect with **No Auth** (`0x00`). Non-loopback peers offering only `0x00` are rejected with `0x05 0xFF`.
- **Username/Password** (`0x02`, RFC 1929) is accepted without requiring credentials so clients can pass the pace marker (`artex-pace`, `egress.PaceUser`) in the username.
- **Relay**: Full-duplex, half-close aware (`CloseWrite` on EOF in each direction).
## Policy Enforcement Before Dialing
Before opening any outbound TCP socket, the listener invokes the same controls used by the HTTP path:
1. **Egress governor (`egress.Do(egress.Current(), ...)`)**: enforces the active noise profile (`off` is a zero-delay passthrough). If waiting for a slot/token exceeds `PaceTimeout`, the connection is refused before dialing with SOCKS5 reply `0x02` (*Connection not allowed by ruleset*).
2. **Target gate (`intercept.Interceptor.DialSOCKS5` / `intercept.PinnedDialer`)**: enforces global asset block rules (before and after fresh DNS resolution) and any enabled `intercept.TargetScope` pins/exemptions, dialing only verified addresses. Blocked targets return `0x02` before dialing; DNS lookup failures return `0x04` (*Host unreachable*).
## Raw TCP Storage (SQLite)
Each completed relayed connection writes one row to the `raw_tcp_streams` table in the SQLite traffic index (`traffic/traffic.go`, `indexSchema` — no PostgreSQL migration):
- Columns: `id` (`tcp-<ms>-<seq>`), `protocol` (`'tcp'`), `host`, `port`, `started_at`, `ended_at`, `duration_ms`, `c2s_bytes`, `s2c_bytes`, `truncated`, `c2s_preview`, `c2s_blob`, `s2c_preview`, `s2c_blob`.
- **No HTTP exchange row**: raw TCP streams never insert into `exchanges`.
- **Preview & blob spilling**:
- Directional payloads up to `PreviewBytes` (default `8 KiB`) stay inline in `c2s_preview` / `s2c_preview`.
- Payloads above `PreviewBytes` keep the leading `PreviewBytes` inline and spill the captured bytes (up to `MaxBytesPerDir`) atomically (temp file + rename) into `_blobs/sha256/` with references registered in `blob_refs` under the stream's `tcp-*` ID.
- Exceeding `MaxBytesPerDir` sets `truncated = 1` while continuing to count exact total relayed `c2s_bytes` / `s2c_bytes`.
## Operational Bounds
| Parameter | Default |
|---|---|
| `MaxConcurrent` | `64` active streams (excess connections receive `0x01`) |
| `MaxBytesPerDir` | `4 MiB` captured per direction |
| `PreviewBytes` | `8 KiB` inline preview per direction |
| `IdleTimeout` | `2m` per-direction read/write deadline |
| `HandshakeTimeout` | `10s` for greeting, auth, and `CONNECT` request |
| `DialTimeout` | `30s` outbound TCP connect timeout |
| `PaceTimeout` | `30s` egress governor wait bound |
Closing `Traffic` stops accepting new SOCKS5 connections, closes active sockets, and waits for all handler goroutines to exit before closing SQLite.
+81
View File
@@ -0,0 +1,81 @@
# Opt-in Linux Transparent TCP Inbound & Raw TCP Recording (P4.1b)
ARTEX ships an opt-in **Linux-only IPv4 transparent TCP inbound listener** in `traffic/` that accepts connections redirected by `iptables` or `nftables` `REDIRECT` rules, recovers each socket's original IPv4 destination via `getsockopt(SOL_IP, SO_ORIGINAL_DST)`, enforces the existing target gate and egress governor before dialing, and records the connection in SQLite `raw_tcp_streams`.
## Opt-in Configuration (Off by Default)
| Environment Variable | Default | Behavior |
|---|---|---|
| `ARTEX_TRANSPARENT_TCP_ENABLED` | unset (off) | Set to `1` / `true` / `on` / `yes` to start the transparent TCP listener on `127.0.0.1:1081` (IPv4 loopback). Explicit `0` / `false` / `off` / `no` forces it off even if `ARTEX_TRANSPARENT_TCP_ADDR` is set. |
| `ARTEX_TRANSPARENT_TCP_ADDR` | `127.0.0.1:1081` | Explicit IPv4 TCP bind address; setting a non-empty value also enables the listener unless `ARTEX_TRANSPARENT_TCP_ENABLED` is explicitly false. Use `0.0.0.0:1081` only when redirecting traffic from other interfaces (`PREROUTING`) and protect the port with a host firewall. |
- **Flag off**: no transparent TCP listener is started, no firewall rules are touched, and the HTTP MITM proxy is unchanged.
- **Requires traffic recorder**: the server only starts the transparent TCP listener when the traffic recorder is enabled (inside the traffic proxy block in `server/manager.go`). If traffic capture is disabled, setting these environment variables does not open a listener.
- **Linux only**: on non-Linux operating systems (`windows`, `darwin`), leaving the flag off is a no-op; explicitly enabling it logs `ErrTransparentTCPNotLinux` and leaves the listener disabled.
- **IPv4 only (IPv6 not covered)**: P4.1b recovers `SO_ORIGINAL_DST` (`SOL_IP`, `AF_INET`) for IPv4 TCP sockets only. IPv6 (`IP6T_SO_ORIGINAL_DST`) is **not covered**; IPv6 bind addresses and IPv6 sockets are refused.
- **Firewall never touched by ARTEX**: ARTEX never installs, modifies, or deletes `iptables`/`nftables` rules. Root or `CAP_NET_ADMIN` is required **only** by the operator when installing and cleaning up the host redirect rules—never to run ARTEX itself.
## Firewall Rules & Cleanup (Operator-Managed)
Choose **either** `iptables` **or** `nftables`. Always exclude the UID running ARTEX (example: `artex`) from local `OUTPUT` redirect rules so ARTEX's own outbound dials do not loop back into the transparent listener.
### Option 1: `iptables` (IPv4 local `OUTPUT` REDIRECT)
Install into a dedicated chain so cleanup is atomic:
```bash
# Requires root or CAP_NET_ADMIN
sudo iptables -t nat -N ARTEX_TRANSPARENT
# Never redirect ARTEX's own outbound dials or loopback traffic
sudo iptables -t nat -A ARTEX_TRANSPARENT -m owner --uid-owner artex -j RETURN
sudo iptables -t nat -A ARTEX_TRANSPARENT -d 127.0.0.0/8 -j RETURN
# Example: redirect outbound TCP to lab target 198.51.100.0/24 into ARTEX on 127.0.0.1:1081
sudo iptables -t nat -A ARTEX_TRANSPARENT -p tcp -d 198.51.100.0/24 -j REDIRECT --to-ports 1081
sudo iptables -t nat -A OUTPUT -p tcp -j ARTEX_TRANSPARENT
```
Cleanup (exact removal):
```bash
sudo iptables -t nat -D OUTPUT -p tcp -j ARTEX_TRANSPARENT
sudo iptables -t nat -F ARTEX_TRANSPARENT
sudo iptables -t nat -X ARTEX_TRANSPARENT
```
*(For traffic arriving on another interface—for example a container or routed VM—bind `ARTEX_TRANSPARENT_TCP_ADDR=0.0.0.0:1081`, attach `ARTEX_TRANSPARENT` to `PREROUTING` instead of `OUTPUT`, and drop direct non-redirected packets to port 1081 at the host firewall.)*
### Option 2: `nftables` (IPv4 local `OUTPUT` REDIRECT)
Install into a dedicated table so cleanup is a single command:
```bash
# Requires root or CAP_NET_ADMIN
sudo nft -f - <<'NFT'
table ip artex_transparent {
chain output {
type nat hook output priority -100; policy accept;
meta skuid "artex" return
ip daddr 127.0.0.0/8 return
ip daddr 198.51.100.0/24 tcp redirect to :1081
}
}
NFT
```
Cleanup (exact removal):
```bash
sudo nft delete table ip artex_transparent
```
## Policy Enforcement, Loop Guard & Storage (Shared with P4.1a)
For every accepted TCP connection:
1. **Original destination recovery**: reads `getsockopt(SOL_IP, SO_ORIGINAL_DST)` under `HandshakeTimeout` (default `10s`), parses `struct sockaddr_in` (rejecting short buffers, non-`AF_INET` families including IPv6, port `0`, and `0.0.0.0`), and rejects **self-redirects** (direct non-redirected connections where `SO_ORIGINAL_DST` equals the listener's own address/port) before dialing.
2. **Egress governor (`egress.Do(egress.Current(), ...)`)**: enforces the active noise profile (`PaceTimeout`, default `30s`) before dialing.
3. **Target gate (`intercept.Interceptor.DialSOCKS5` / `intercept.PinnedDialer`)**: enforces global asset block rules and any enabled `intercept.TargetScope` pins/exemptions before opening any outbound socket. Because the transparent listener only knows the recovered destination IP (never a DNS hostname), hostname-based block or allow rules cannot match—IP and CIDR rules are the ones that apply. Refused connections are closed immediately without dialing and without writing a store row.
4. **Relay & bounds**: reuses the P4.1a full-duplex half-close-aware relay (`CloseWrite`) and defaults (`MaxConcurrent=64`, `MaxBytesPerDir=4 MiB`, `PreviewBytes=8 KiB`, `IdleTimeout=2m`, `HandshakeTimeout=10s`, `DialTimeout=30s`, `PaceTimeout=30s`).
5. **SQLite storage**: records one row per completed connection in `raw_tcp_streams` (`protocol='tcp'`, atomic temp+rename `_blobs/sha256/` spill + `blob_refs`), with **zero HTTP `exchanges` rows** and **no PostgreSQL migration**.
Closing `Traffic` stops accepting new transparent connections, closes active sockets, and waits for all handler goroutines to exit before closing SQLite.
-14
View File
@@ -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]
+9 -9
View File
@@ -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
+16 -16
View File
@@ -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
View File
@@ -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
+59
View File
@@ -3,12 +3,15 @@ package intercept
import (
"context"
"encoding/json"
"errors"
"fmt"
"net"
"net/netip"
"strconv"
"strings"
"time"
"github.com/Autumn-27/artex/db"
)
// The HTTP clients the platform owns (WebFetch and the custom http tool)
@@ -178,3 +181,59 @@ func (e *dialError) Error() string {
}
return msg + " Do not fetch the target with another tool or by its address."
}
// IsTargetBlocked reports whether err came from PinnedDialer / DialSOCKS5
// refusing a target before dialing (rule block, unpinned target, or unavailable
// target gate), returning its platform control code.
func IsTargetBlocked(err error) (string, bool) {
var de *dialError
if errors.As(err, &de) {
return de.code, true
}
return "", false
}
// DialSOCKS5 enforces the platform's target gate before dialing a SOCKS5
// CONNECT destination, reusing the same policy functions as PinnedDialer:
// - When ctx carries an enabled TargetScope, delegates directly to dialTarget
// (asset block rules, exemptions, fresh DNS resolution, and pin checks).
// - Otherwise enforces global asset block rules (domain, IP, and CIDR, before
// and after fresh DNS resolution) and dials only the resolved addresses that
// passed those rules.
func (i *Interceptor) DialSOCKS5(ctx context.Context, network, addr string) (net.Conn, error) {
if i == nil {
return baseDial(ctx, network, addr)
}
if scope, ok := TargetScopeFromContext(ctx); ok && scope.Enabled != nil && scope.Enabled() {
return i.dialTarget(ctx, scope, "socks5", network, addr)
}
t, err := addrTarget(network, addr)
if err != nil {
return nil, &dialError{code: TargetGateUnavailable, target: addr, reason: "the address of the connection could not be read (" + err.Error() + ")"}
}
if i.targets == nil {
return i.baseDialer()(ctx, network, addr)
}
rules, err := i.targets.BlockRules(db.TargetScopeRef{})
if err != nil {
return nil, &dialError{code: TargetGateUnavailable, target: t.String(), reason: "the asset rules could not be read: " + err.Error()}
}
ct := &checkedTarget{Target: t}
if t.Kind != TargetDomain {
ct.ips, ct.resolver, ct.resolvedAt = []string{t.Host}, literalResolver, time.Now().UTC()
}
if rule, hit := blockRule(rules, ct); hit {
return nil, &dialError{code: TargetRuleBlocked, target: t.String(), reason: fmt.Sprintf("%s is blocked by an asset rule. %s", t, rule.Reason())}
}
if t.Kind == TargetDomain {
c := &targetCheck{i: i, ctx: ctx, tool: "socks5", fresh: true}
c.resolve(ct, true)
if ct.err != nil {
return nil, ct.err
}
if rule, hit := blockRule(rules, ct); hit {
return nil, &dialError{code: TargetRuleBlocked, target: t.String(), reason: fmt.Sprintf("%s is blocked by an asset rule. %s", t, rule.Reason())}
}
}
return i.dialAddrs(ctx, network, ct.ips, t.Port)
}
+20
View File
@@ -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{}
@@ -190,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
@@ -246,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
}
}
+12 -14
View File
@@ -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)
}
}
}
+2 -2
View File
@@ -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)
+1 -1
View File
@@ -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() {
+117
View File
@@ -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)
}
}
+93
View File
@@ -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 {
+228 -8
View File
@@ -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)
}
})
}
}
+19 -8
View File
@@ -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")
+5 -1
View File
@@ -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())
+8 -2
View File
@@ -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 {
+16
View File
@@ -463,6 +463,22 @@ func NewManager(dir, proxyAddr string) (*Manager, error) {
if tr != nil {
m.traffic = tr
m.reloadRewriteRules() // in place before the proxy accepts a connection
if scfg, ok := traffic.SOCKS5ConfigFromEnv(); ok {
scfg.DialContext = m.interceptor.DialSOCKS5
if bound, serr := tr.StartSOCKS5(scfg); serr != nil {
log.Printf("[traffic/socks5] disabled: %v", serr)
} else {
log.Printf("[traffic/socks5] opt-in SOCKS5 CONNECT listener on %s", bound)
}
}
if tcfg, ok := traffic.TransparentTCPConfigFromEnv(); ok {
tcfg.DialContext = m.interceptor.DialSOCKS5
if bound, terr := tr.StartTransparentTCP(tcfg); terr != nil {
log.Printf("[traffic/transparent] disabled: %v", terr)
} else {
log.Printf("[traffic/transparent] opt-in transparent TCP listener on %s (Linux IPv4 SO_ORIGINAL_DST)", bound)
}
}
go func() {
log.Printf("[traffic] recording proxy on %s (set HTTP_PROXY=%s + trust _ca CA)", proxyAddr, tr.ProxyAddr())
if err := tr.Start(); err != nil {
+1 -1
View File
@@ -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)
+4 -1
View File
@@ -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
View File
@@ -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)
}
+2
View File
@@ -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")
+119
View File
@@ -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)
}
})
}
+108
View File
@@ -0,0 +1,108 @@
package server
import (
"encoding/binary"
"fmt"
"io"
"net"
"strconv"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/traffic"
)
func TestManagerSOCKS5OptInFlagAndAssetBlockRuleRefusal(t *testing.T) {
// 1. Flag off (default): Manager starts NO SOCKS5 listener.
t.Setenv(traffic.SOCKS5EnabledEnv, "")
t.Setenv(traffic.SOCKS5AddrEnv, "")
mOff, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
db.SkipPGUnavailable(t, err)
}
t.Cleanup(func() { _ = mOff.Close() })
if mOff.traffic == nil {
t.Fatal("expected HTTP recording proxy to start")
}
if got := mOff.traffic.SOCKS5Addr(); got != "" {
t.Fatalf("SOCKS5Addr with flag off = %q, want empty", got)
}
// 2. Flag on (ARTEX_SOCKS5_ADDR=127.0.0.1:0): listener starts and enforces
// global asset block rules via m.interceptor.DialSOCKS5 BEFORE dialing.
t.Setenv(traffic.SOCKS5AddrEnv, "127.0.0.1:0")
mOn, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mOn.Close() })
socksAddr := mOn.traffic.SOCKS5Addr()
if socksAddr == "" {
t.Fatal("expected SOCKS5 listener when ARTEX_SOCKS5_ADDR is set")
}
// Add a global asset block rule for 127.0.0.1 and ensure cleanup.
rule, err := mOn.pg.CreateAssetInterceptRule(
"exact_ip",
"127.0.0.1",
fmt.Sprintf("p41a-block-test-%d", time.Now().UnixNano()),
true,
)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mOn.pg.DeleteAssetInterceptRule(rule.ID) })
// Target TCP server on 127.0.0.1: must NEVER receive a connection.
targetLn, err := net.Listen("tcp4", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer targetLn.Close()
var accepted atomic.Int32
go func() {
for {
c, err := targetLn.Accept()
if err != nil {
return
}
accepted.Add(1)
_ = c.Close()
}
}()
_, portStr, _ := net.SplitHostPort(targetLn.Addr().String())
port, _ := strconv.Atoi(portStr)
c, err := net.DialTimeout("tcp", socksAddr, 3*time.Second)
if err != nil {
t.Fatal(err)
}
defer c.Close()
_ = c.SetDeadline(time.Now().Add(5 * time.Second))
// Greeting: VER=5, NMETHODS=1, NO AUTH
if _, err := c.Write([]byte{0x05, 0x01, 0x00}); err != nil {
t.Fatal(err)
}
var sel [2]byte
if _, err := io.ReadFull(c, sel[:]); err != nil || sel != [2]byte{0x05, 0x00} {
t.Fatalf("method selection = %v err=%v", sel, err)
}
// CONNECT 127.0.0.1:<port>
req := []byte{0x05, 0x01, 0x00, 0x01, 127, 0, 0, 1, 0, 0}
binary.BigEndian.PutUint16(req[8:10], uint16(port))
if _, err := c.Write(req); err != nil {
t.Fatal(err)
}
var rep [10]byte
if _, err := io.ReadFull(c, rep[:]); err != nil {
t.Fatal(err)
}
if rep[1] != 0x02 {
t.Fatalf("blocked target SOCKS5 reply = 0x%02x, want 0x02 (not allowed by ruleset)", rep[1])
}
if accepted.Load() != 0 {
t.Fatalf("blocked target accepted %d connections, want 0", accepted.Load())
}
}
+1
View File
@@ -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")
+9
View File
@@ -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)
}
+1
View File
@@ -49,6 +49,7 @@ func TestTaskCredentialsFlow(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = s.m.pg.DeleteTask(id) })
t.Cleanup(func() { s.m.PG().Exec(`DELETE FROM tasks WHERE id=$1`, id) })
// List: both rows, user source, order stable.
+9 -11
View File
@@ -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 {
+1 -1
View File
@@ -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()),
+4 -1
View File
@@ -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) }()
+1 -1
View File
@@ -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) {
+1 -1
View File
@@ -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)
+8
View File
@@ -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,
+13 -7
View File
@@ -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"])
}
}
+1
View File
@@ -269,6 +269,7 @@ VALUES(?,?, 'HTTP/1.1 200 OK', ?, ?)`, id, "GET "+path+" HTTP/1.1\nHost: "+host,
}
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)
})
+48
View File
@@ -0,0 +1,48 @@
package server
import (
"runtime"
"testing"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/traffic"
)
func TestManagerTransparentTCPOptInFlag(t *testing.T) {
// 1. Flag off (default): Manager starts NO transparent TCP listener.
t.Setenv(traffic.TransparentTCPEnabledEnv, "")
t.Setenv(traffic.TransparentTCPAddrEnv, "")
mOff, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer mOff.Close()
if mOff.traffic == nil {
t.Fatal("expected traffic recorder to be initialized")
}
if got := mOff.traffic.TransparentTCPAddr(); got != "" {
t.Fatalf("TransparentTCPAddr with flag off = %q, want empty", got)
}
// 2. Flag on (ARTEX_TRANSPARENT_TCP_ADDR=127.0.0.1:0): starts on Linux,
// stays cleanly disabled on non-Linux without crashing NewManager.
t.Setenv(traffic.TransparentTCPAddrEnv, "127.0.0.1:0")
mOn, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer mOn.Close()
gotAddr := mOn.traffic.TransparentTCPAddr()
if runtime.GOOS == "linux" {
if gotAddr == "" {
t.Fatal("expected transparent TCP listener on Linux when ARTEX_TRANSPARENT_TCP_ADDR is set")
}
} else {
if gotAddr != "" {
t.Fatalf("expected transparent TCP listener disabled on %s, got %q", runtime.GOOS, gotAddr)
}
}
}
-10
View File
@@ -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
View File
@@ -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": {
+296
View File
@@ -0,0 +1,296 @@
package traffic
import (
"crypto/sha256"
"database/sql"
"encoding/hex"
"fmt"
"log"
"os"
"path/filepath"
"strings"
"time"
)
// RawTCPStream is one recorded raw TCP connection relayed by the opt-in SOCKS5
// listener. It never creates an HTTP exchanges row.
type RawTCPStream struct {
ID string `json:"id"`
Protocol string `json:"protocol"`
Host string `json:"host"`
Port int `json:"port"`
StartedAt int64 `json:"started_at"` // unix milliseconds
EndedAt int64 `json:"ended_at"` // unix milliseconds
DurationMs int64 `json:"duration_ms"` // non-negative duration in milliseconds
C2SBytes int64 `json:"c2s_bytes"`
S2CBytes int64 `json:"s2c_bytes"`
Truncated bool `json:"truncated"`
C2SPreview []byte `json:"c2s_preview,omitempty"`
C2SBlob string `json:"c2s_blob,omitempty"`
S2CPreview []byte `json:"s2c_preview,omitempty"`
S2CBlob string `json:"s2c_blob,omitempty"`
}
// RawTCPFilter narrows ListRawTCPStreams queries.
type RawTCPFilter struct {
Host string
Port int
Limit int
Offset int
}
func (t *Traffic) newRawTCPStreamID(started time.Time) string {
n := t.seq.Add(1)
return fmt.Sprintf("tcp-%d-%04d", started.UnixMilli(), n%10000)
}
// spillRawDir stores one direction's captured bytes: up to previewCap stays
// inline in preview with no blob; beyond previewCap, the full captured bytes
// are written to the content-addressed _blobs store and preview holds the
// leading previewCap bytes.
func (t *Traffic) spillRawDir(data []byte, previewCap int) (preview []byte, blobHash string) {
if len(data) == 0 {
return nil, ""
}
if previewCap <= 0 {
previewCap = DefaultSOCKS5PreviewBytes
}
if len(data) <= previewCap {
cp := make([]byte, len(data))
copy(cp, data)
return cp, ""
}
sum := sha256.Sum256(data)
h := hex.EncodeToString(sum[:])
blobDir := filepath.Join(t.dir, "_blobs", "sha256", h[:2])
if err := os.MkdirAll(blobDir, 0o755); err != nil {
log.Printf("[traffic/socks5] failed to create blob directory: %v", err)
return append([]byte(nil), data[:previewCap]...), ""
}
blobPath := filepath.Join(blobDir, h+".bin")
if _, err := os.Stat(blobPath); os.IsNotExist(err) {
if err := writeBlobAtomic(blobDir, blobPath, h, data); err != nil {
log.Printf("[traffic/socks5] failed to write blob %s: %v", h, err)
return append([]byte(nil), data[:previewCap]...), ""
}
}
return append([]byte(nil), data[:previewCap]...), h
}
// writeBlobAtomic writes data to a temporary file inside blobDir and renames it
// into place at blobPath so a crash mid-write cannot leave a partial file under
// a content-addressed SHA-256 hash.
func writeBlobAtomic(blobDir, blobPath, hash string, data []byte) error {
tmp, err := os.CreateTemp(blobDir, hash+".*.tmp")
if err != nil {
return err
}
tmpPath := tmp.Name()
cleanup := true
defer func() {
if cleanup {
_ = os.Remove(tmpPath)
}
}()
if _, err := tmp.Write(data); err != nil {
_ = tmp.Close()
return err
}
if err := tmp.Chmod(0o644); err != nil {
_ = tmp.Close()
return err
}
if err := tmp.Close(); err != nil {
return err
}
if err := os.Rename(tmpPath, blobPath); err != nil {
// Another goroutine may have won the race writing the same
// content-addressed hash (notably on Windows where Rename can fail
// if the destination already exists).
if _, statErr := os.Stat(blobPath); statErr == nil {
return nil
}
return err
}
cleanup = false
return nil
}
// RecordRawTCPStream persists one raw TCP connection into raw_tcp_streams and
// registers any spilled directional blobs in blob_refs. It never writes to the
// HTTP exchanges table.
func (t *Traffic) RecordRawTCPStream(rec RawTCPCapture, previewBytes int) (string, error) {
if t == nil || t.db == nil {
return "", fmt.Errorf("traffic store unavailable")
}
started := rec.StartedAt.UTC()
if started.IsZero() {
started = time.Now().UTC()
}
ended := rec.EndedAt.UTC()
if ended.IsZero() || ended.Before(started) {
ended = started
}
durMs := ended.Sub(started).Milliseconds()
if durMs < 0 {
durMs = 0
}
c2sPrev, c2sBlob := t.spillRawDir(rec.C2SData, previewBytes)
s2cPrev, s2cBlob := t.spillRawDir(rec.S2CData, previewBytes)
t.wmu.Lock()
defer t.wmu.Unlock()
id := t.newRawTCPStreamID(started)
trunc := 0
if rec.Truncated {
trunc = 1
}
tx, err := t.db.Begin()
if err != nil {
return "", fmt.Errorf("begin raw tcp tx: %w", err)
}
defer tx.Rollback() //nolint:errcheck
if _, err := tx.Exec(`
INSERT INTO raw_tcp_streams(
id, protocol, host, port, started_at, ended_at, duration_ms,
c2s_bytes, s2c_bytes, truncated, c2s_preview, c2s_blob, s2c_preview, s2c_blob
) VALUES(?, 'tcp', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
id, strings.ToLower(strings.TrimSpace(rec.Host)), rec.Port,
started.UnixMilli(), ended.UnixMilli(), durMs,
rec.C2SBytes, rec.S2CBytes, trunc,
c2sPrev, nullIfEmpty(c2sBlob), s2cPrev, nullIfEmpty(s2cBlob),
); err != nil {
return "", fmt.Errorf("insert raw_tcp_streams: %w", err)
}
for _, h := range []string{c2sBlob, s2cBlob} {
if h == "" {
continue
}
if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash, exchange_id) VALUES(?, ?)`, h, id); err != nil {
return "", fmt.Errorf("register raw tcp blob ref: %w", err)
}
}
if err := tx.Commit(); err != nil {
return "", fmt.Errorf("commit raw tcp tx: %w", err)
}
return id, nil
}
// GetRawTCPStream fetches a single recorded raw TCP stream by ID. Returns nil, nil
// when not found.
func (t *Traffic) GetRawTCPStream(id string) (*RawTCPStream, error) {
if t == nil || t.db == nil {
return nil, fmt.Errorf("traffic store unavailable")
}
var s RawTCPStream
var trunc int
var c2sBlob, s2cBlob sql.NullString
err := t.db.QueryRow(`
SELECT id, protocol, host, port, started_at, ended_at, duration_ms,
c2s_bytes, s2c_bytes, truncated, c2s_preview, c2s_blob, s2c_preview, s2c_blob
FROM raw_tcp_streams WHERE id = ?`, id).Scan(
&s.ID, &s.Protocol, &s.Host, &s.Port, &s.StartedAt, &s.EndedAt, &s.DurationMs,
&s.C2SBytes, &s.S2CBytes, &trunc, &s.C2SPreview, &c2sBlob, &s.S2CPreview, &s2cBlob,
)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, err
}
s.Truncated = trunc != 0
s.C2SBlob = c2sBlob.String
s.S2CBlob = s2cBlob.String
return &s, nil
}
// ListRawTCPStreams returns raw TCP streams newest-first along with the total
// count matching the filter.
func (t *Traffic) ListRawTCPStreams(f RawTCPFilter) ([]RawTCPStream, int, error) {
if t == nil || t.db == nil {
return nil, 0, fmt.Errorf("traffic store unavailable")
}
var conds []string
var args []any
if h := strings.ToLower(strings.TrimSpace(f.Host)); h != "" {
conds = append(conds, "host = ?")
args = append(args, h)
}
if f.Port > 0 {
conds = append(conds, "port = ?")
args = append(args, f.Port)
}
where := ""
if len(conds) > 0 {
where = " WHERE " + strings.Join(conds, " AND ")
}
var total int
if err := t.db.QueryRow(`SELECT COUNT(*) FROM raw_tcp_streams`+where, args...).Scan(&total); err != nil {
return nil, 0, err
}
limit := f.Limit
if limit <= 0 {
limit = 50
}
if limit > 500 {
limit = 500
}
offset := f.Offset
if offset < 0 {
offset = 0
}
qArgs := append(append([]any{}, args...), limit, offset)
rows, err := t.db.Query(`
SELECT id, protocol, host, port, started_at, ended_at, duration_ms,
c2s_bytes, s2c_bytes, truncated, c2s_preview, c2s_blob, s2c_preview, s2c_blob
FROM raw_tcp_streams`+where+`
ORDER BY started_at DESC, id DESC
LIMIT ? OFFSET ?`, qArgs...)
if err != nil {
return nil, 0, err
}
defer rows.Close()
out := []RawTCPStream{}
for rows.Next() {
var s RawTCPStream
var trunc int
var c2sBlob, s2cBlob sql.NullString
if err := rows.Scan(
&s.ID, &s.Protocol, &s.Host, &s.Port, &s.StartedAt, &s.EndedAt, &s.DurationMs,
&s.C2SBytes, &s.S2CBytes, &trunc, &s.C2SPreview, &c2sBlob, &s.S2CPreview, &s2cBlob,
); err != nil {
return nil, 0, err
}
s.Truncated = trunc != 0
s.C2SBlob = c2sBlob.String
s.S2CBlob = s2cBlob.String
out = append(out, s)
}
return out, total, rows.Err()
}
// CountRawTCPStreams returns the number of recorded raw TCP streams (all hosts
// when host is empty, or filtered to one exact host).
func (t *Traffic) CountRawTCPStreams(host string) (int, error) {
if t == nil || t.db == nil {
return 0, fmt.Errorf("traffic store unavailable")
}
var n int
h := strings.ToLower(strings.TrimSpace(host))
if h == "" {
err := t.db.QueryRow(`SELECT COUNT(*) FROM raw_tcp_streams`).Scan(&n)
return n, err
}
err := t.db.QueryRow(`SELECT COUNT(*) FROM raw_tcp_streams WHERE host = ?`, h).Scan(&n)
return n, err
}
+693
View File
@@ -0,0 +1,693 @@
package traffic
import (
"context"
"encoding/binary"
"errors"
"fmt"
"io"
"log"
"net"
"net/url"
"os"
"strconv"
"strings"
"sync"
"syscall"
"time"
"github.com/Autumn-27/artex/egress"
"github.com/Autumn-27/artex/intercept"
)
// Opt-in environment flags for the SOCKS5 inbound listener (P4.1a).
// Off by default: when neither is set, no SOCKS5 listener is started and the
// HTTP recording proxy is unchanged.
const (
// SOCKS5EnabledEnv turns on the SOCKS5 CONNECT listener on DefaultSOCKS5Addr
// (loopback) when set to 1/true/on/yes.
SOCKS5EnabledEnv = "ARTEX_SOCKS5_ENABLED"
// SOCKS5AddrEnv optionally overrides the bind address (default 127.0.0.1:1080).
// Setting a non-empty address also enables the listener unless
// ARTEX_SOCKS5_ENABLED is explicitly false/0/off/no.
SOCKS5AddrEnv = "ARTEX_SOCKS5_ADDR"
DefaultSOCKS5Addr = "127.0.0.1:1080"
DefaultSOCKS5MaxConcurrent = 64
DefaultSOCKS5MaxBytesPerDir = 4 * 1024 * 1024
DefaultSOCKS5PreviewBytes = blobPreview
DefaultSOCKS5IdleTimeout = 2 * time.Minute
DefaultSOCKS5HandshakeTimeout = 10 * time.Second
DefaultSOCKS5DialTimeout = 30 * time.Second
DefaultSOCKS5PaceTimeout = paceWaitMax
)
// RFC 1928 / RFC 1929 protocol constants.
const (
socks5Version = 0x05
socks5AuthNone = 0x00
socks5AuthUserPass = 0x02
socks5AuthNoAccept = 0xFF
socks5UserPassVer = 0x01
socks5CmdConnect = 0x01
socks5CmdBind = 0x02
socks5CmdUDPAssociate = 0x03
socks5AtypIPv4 = 0x01
socks5AtypDomain = 0x03
socks5AtypIPv6 = 0x04
socks5RepSuccess = 0x00
socks5RepGeneralFailure = 0x01
socks5RepNotAllowed = 0x02
socks5RepNetworkUnreachable = 0x03
socks5RepHostUnreachable = 0x04
socks5RepConnectionRefused = 0x05
socks5RepTTLExpired = 0x06
socks5RepCmdNotSupported = 0x07
socks5RepAtypNotSupported = 0x08
)
// SOCKS5Config configures the opt-in RFC 1928 SOCKS5 CONNECT listener.
type SOCKS5Config struct {
// Addr is the TCP bind address (default DefaultSOCKS5Addr, loopback-bound).
Addr string
// MaxConcurrent bounds simultaneous active SOCKS5 streams (default 64).
MaxConcurrent int
// MaxBytesPerDir caps bytes captured for storage per direction (default 4 MiB).
// Relay continues counting total bytes; exceeding the cap sets Truncated=true.
MaxBytesPerDir int64
// PreviewBytes caps the inline preview per direction (default 8 KiB).
PreviewBytes int
// IdleTimeout closes a relayed stream after no bytes move in either direction.
IdleTimeout time.Duration
// HandshakeTimeout bounds the RFC 1928 greeting, auth, and CONNECT request.
HandshakeTimeout time.Duration
// DialTimeout bounds the outbound TCP dial.
DialTimeout time.Duration
// PaceTimeout bounds waiting on the egress governor before refusing the dial.
PaceTimeout time.Duration
// DialContext opens the outbound TCP connection after policy checks.
// Defaults to intercept.PinnedDialer("socks5", false).
DialContext func(ctx context.Context, network, addr string) (net.Conn, error)
// BaseContext, when non-nil, derives the context passed to the egress
// governor and DialContext (e.g. carrying an intercept.TargetScope).
BaseContext func() context.Context
// OnRecord, when non-nil, receives each completed raw TCP capture.
// When nil and attached to a Traffic store, the store's raw-TCP recorder runs.
OnRecord func(RawTCPCapture)
}
// RawTCPCapture is the completed metadata and bounded directional payloads of
// one relayed SOCKS5 TCP connection.
type RawTCPCapture struct {
Host string
Port int
StartedAt time.Time
EndedAt time.Time
C2SBytes int64
S2CBytes int64
C2SData []byte
S2CData []byte
Truncated bool
Paced bool
}
// SOCKS5ConfigFromEnv parses ARTEX_SOCKS5_ENABLED and ARTEX_SOCKS5_ADDR.
// Returns (cfg, false) when disabled (the default).
func SOCKS5ConfigFromEnv() (SOCKS5Config, bool) {
rawEnabled := strings.ToLower(strings.TrimSpace(os.Getenv(SOCKS5EnabledEnv)))
rawAddr := strings.TrimSpace(os.Getenv(SOCKS5AddrEnv))
switch rawEnabled {
case "0", "false", "off", "no":
return SOCKS5Config{}, false
case "1", "true", "on", "yes":
addr := rawAddr
if addr == "" {
addr = DefaultSOCKS5Addr
}
return SOCKS5Config{Addr: addr}, true
case "":
if rawAddr == "" {
return SOCKS5Config{}, false
}
return SOCKS5Config{Addr: rawAddr}, true
default:
log.Printf("[traffic] %s=%q is not a boolean; leaving SOCKS5 disabled", SOCKS5EnabledEnv, rawEnabled)
return SOCKS5Config{}, false
}
}
func (c SOCKS5Config) withDefaults() SOCKS5Config {
if strings.TrimSpace(c.Addr) == "" {
c.Addr = DefaultSOCKS5Addr
}
if c.MaxConcurrent <= 0 {
c.MaxConcurrent = DefaultSOCKS5MaxConcurrent
}
if c.MaxBytesPerDir <= 0 {
c.MaxBytesPerDir = DefaultSOCKS5MaxBytesPerDir
}
if c.PreviewBytes <= 0 {
c.PreviewBytes = DefaultSOCKS5PreviewBytes
}
if c.IdleTimeout <= 0 {
c.IdleTimeout = DefaultSOCKS5IdleTimeout
}
if c.HandshakeTimeout <= 0 {
c.HandshakeTimeout = DefaultSOCKS5HandshakeTimeout
}
if c.DialTimeout <= 0 {
c.DialTimeout = DefaultSOCKS5DialTimeout
}
if c.PaceTimeout <= 0 {
c.PaceTimeout = DefaultSOCKS5PaceTimeout
}
if c.DialContext == nil {
c.DialContext = intercept.PinnedDialer("socks5", false)
}
return c
}
type socks5Server struct {
t *Traffic
cfg SOCKS5Config
ln net.Listener
sem chan struct{}
stop chan struct{}
once sync.Once
wg sync.WaitGroup
mu sync.Mutex
active map[net.Conn]struct{}
}
// StartSOCKS5 binds and starts the opt-in RFC 1928 SOCKS5 CONNECT listener on t.
// Returns the actual bound address (useful when cfg.Addr uses port 0).
func (t *Traffic) StartSOCKS5(cfg SOCKS5Config) (string, error) {
cfg = cfg.withDefaults()
ln, err := net.Listen("tcp", cfg.Addr)
if err != nil {
return "", fmt.Errorf("socks5 listen %s: %w", cfg.Addr, err)
}
srv := &socks5Server{
t: t,
cfg: cfg,
ln: ln,
sem: make(chan struct{}, cfg.MaxConcurrent),
stop: make(chan struct{}),
active: map[net.Conn]struct{}{},
}
t.socksMu.Lock()
if t.socks != nil {
t.socksMu.Unlock()
_ = ln.Close()
return "", errors.New("socks5 listener already running")
}
t.socks = srv
t.socksMu.Unlock()
srv.wg.Add(1)
go srv.serve()
return ln.Addr().String(), nil
}
// SOCKS5Addr returns the bound SOCKS5 listener address, or "" when disabled.
func (t *Traffic) SOCKS5Addr() string {
t.socksMu.Lock()
defer t.socksMu.Unlock()
if t.socks == nil || t.socks.ln == nil {
return ""
}
return t.socks.ln.Addr().String()
}
func (s *socks5Server) Close() error {
var closeErr error
s.once.Do(func() {
close(s.stop)
closeErr = s.ln.Close()
s.mu.Lock()
for c := range s.active {
_ = c.Close()
}
s.mu.Unlock()
})
s.wg.Wait()
return closeErr
}
func (s *socks5Server) stopping() bool {
select {
case <-s.stop:
return true
default:
return false
}
}
func (s *socks5Server) trackConn(c net.Conn) bool {
s.mu.Lock()
defer s.mu.Unlock()
if s.stopping() {
return false
}
s.active[c] = struct{}{}
return true
}
func (s *socks5Server) untrackConn(c net.Conn) {
s.mu.Lock()
delete(s.active, c)
s.mu.Unlock()
}
func (s *socks5Server) serve() {
defer s.wg.Done()
for {
conn, err := s.ln.Accept()
if err != nil {
if s.stopping() || errors.Is(err, net.ErrClosed) {
return
}
var ne net.Error
if errors.As(err, &ne) && ne.Timeout() {
continue
}
log.Printf("[traffic/socks5] accept error: %v", err)
return
}
if !s.trackConn(conn) {
_ = conn.Close()
return
}
s.wg.Add(1)
go func(c net.Conn) {
defer s.wg.Done()
defer s.untrackConn(c)
defer c.Close()
s.handleConn(c)
}(conn)
}
}
func (s *socks5Server) handleConn(client net.Conn) {
// 1. Handshake (greeting + optional RFC 1929 auth + CONNECT request) under HandshakeTimeout.
_ = client.SetDeadline(time.Now().Add(s.cfg.HandshakeTimeout))
paced, ok := s.negotiateAuth(client)
if !ok {
return
}
host, port, rep := readSOCKS5Request(client)
if rep != socks5RepSuccess {
_ = writeSOCKS5Reply(client, rep, nil)
return
}
// 2. Enforce max concurrent streams before touching policy or dialing.
select {
case s.sem <- struct{}{}:
defer func() { <-s.sem }()
default:
_ = writeSOCKS5Reply(client, socks5RepGeneralFailure, nil)
return
}
// 3. Apply the egress governor and target gate before dialing.
targetAddr := net.JoinHostPort(host, strconv.Itoa(port))
upstream, rep := s.dialTarget(host, port, targetAddr)
if rep != socks5RepSuccess {
_ = writeSOCKS5Reply(client, rep, nil)
return
}
if !s.trackConn(upstream) {
_ = upstream.Close()
_ = writeSOCKS5Reply(client, socks5RepGeneralFailure, nil)
return
}
defer s.untrackConn(upstream)
defer upstream.Close()
// Clear handshake deadline before replying and starting the relay.
_ = client.SetDeadline(time.Time{})
if err := writeSOCKS5Reply(client, socks5RepSuccess, upstream.LocalAddr()); err != nil {
return
}
// 4. Bidirectional half-close-aware relay with idle timeout and bounded capture.
startedAt := time.Now().UTC()
c2sCap := &limitedCapture{max: s.cfg.MaxBytesPerDir}
s2cCap := &limitedCapture{max: s.cfg.MaxBytesPerDir}
var relayWG sync.WaitGroup
relayWG.Add(2)
go func() {
defer relayWG.Done()
relayHalf(upstream, client, c2sCap, s.cfg.IdleTimeout)
closeWrite(upstream)
}()
go func() {
defer relayWG.Done()
relayHalf(client, upstream, s2cCap, s.cfg.IdleTimeout)
closeWrite(client)
}()
relayWG.Wait()
endedAt := time.Now().UTC()
rec := RawTCPCapture{
Host: host,
Port: port,
StartedAt: startedAt,
EndedAt: endedAt,
C2SBytes: c2sCap.total,
S2CBytes: s2cCap.total,
C2SData: c2sCap.buf,
S2CData: s2cCap.buf,
Truncated: c2sCap.truncated || s2cCap.truncated,
Paced: paced,
}
s.recordCapture(rec)
}
func (s *socks5Server) recordCapture(rec RawTCPCapture) {
if s.t != nil && s.t.db != nil {
if _, err := s.t.RecordRawTCPStream(rec, s.cfg.PreviewBytes); err != nil {
log.Printf("[traffic/socks5] failed to record raw tcp stream %s:%d: %v", rec.Host, rec.Port, err)
}
}
if s.cfg.OnRecord != nil {
s.cfg.OnRecord(rec)
}
}
func (s *socks5Server) negotiateAuth(conn net.Conn) (paced bool, ok bool) {
var hdr [2]byte
if _, err := io.ReadFull(conn, hdr[:]); err != nil {
return false, false
}
if hdr[0] != socks5Version || hdr[1] == 0 {
return false, false
}
methods := make([]byte, int(hdr[1]))
if _, err := io.ReadFull(conn, methods); err != nil {
return false, false
}
var hasNone, hasUserPass bool
for _, m := range methods {
switch m {
case socks5AuthNone:
hasNone = true
case socks5AuthUserPass:
hasUserPass = true
}
}
// Prefer username/password when offered so clients carrying the pace marker
// (egress.PaceUser) can pass it through without requiring real credentials.
// Accept no-auth for loopback clients.
if hasUserPass {
if _, err := conn.Write([]byte{socks5Version, socks5AuthUserPass}); err != nil {
return false, false
}
return readSOCKS5UserPass(conn)
}
if hasNone && isLoopbackRemote(conn.RemoteAddr()) {
if _, err := conn.Write([]byte{socks5Version, socks5AuthNone}); err != nil {
return false, false
}
return false, true
}
_, _ = conn.Write([]byte{socks5Version, socks5AuthNoAccept})
return false, false
}
// readSOCKS5UserPass parses an RFC 1929 username/password subnegotiation.
// Credentials are never required (any username/password succeeds); a username
// equal to egress.PaceUser marks the connection as paced.
func readSOCKS5UserPass(conn net.Conn) (paced bool, ok bool) {
var head [2]byte
if _, err := io.ReadFull(conn, head[:]); err != nil {
return false, false
}
if head[0] != socks5UserPassVer {
_, _ = conn.Write([]byte{socks5UserPassVer, 0x01})
return false, false
}
uname := make([]byte, int(head[1]))
if _, err := io.ReadFull(conn, uname); err != nil {
return false, false
}
var plen [1]byte
if _, err := io.ReadFull(conn, plen[:]); err != nil {
return false, false
}
if plen[0] > 0 {
pass := make([]byte, int(plen[0]))
if _, err := io.ReadFull(conn, pass); err != nil {
return false, false
}
}
if _, err := conn.Write([]byte{socks5UserPassVer, 0x00}); err != nil {
return false, false
}
return string(uname) == egress.PaceUser, true
}
func readSOCKS5Request(conn net.Conn) (host string, port int, rep byte) {
var hdr [4]byte
if _, err := io.ReadFull(conn, hdr[:]); err != nil {
return "", 0, socks5RepGeneralFailure
}
if hdr[0] != socks5Version || hdr[2] != 0x00 {
return "", 0, socks5RepGeneralFailure
}
cmd := hdr[1]
atyp := hdr[3]
// Read the address + port before rejecting unsupported commands so the stream
// stays cleanly framed if the peer reads our reply.
switch atyp {
case socks5AtypIPv4:
var ip [4]byte
if _, err := io.ReadFull(conn, ip[:]); err != nil {
return "", 0, socks5RepGeneralFailure
}
host = net.IP(ip[:]).String()
case socks5AtypDomain:
var l [1]byte
if _, err := io.ReadFull(conn, l[:]); err != nil {
return "", 0, socks5RepGeneralFailure
}
if l[0] == 0 {
return "", 0, socks5RepGeneralFailure
}
dom := make([]byte, int(l[0]))
if _, err := io.ReadFull(conn, dom); err != nil {
return "", 0, socks5RepGeneralFailure
}
host = strings.TrimSpace(string(dom))
if host == "" {
return "", 0, socks5RepGeneralFailure
}
case socks5AtypIPv6:
var ip [16]byte
if _, err := io.ReadFull(conn, ip[:]); err != nil {
return "", 0, socks5RepGeneralFailure
}
host = net.IP(ip[:]).String()
default:
return "", 0, socks5RepAtypNotSupported
}
var pbuf [2]byte
if _, err := io.ReadFull(conn, pbuf[:]); err != nil {
return "", 0, socks5RepGeneralFailure
}
port = int(binary.BigEndian.Uint16(pbuf[:]))
if cmd != socks5CmdConnect {
return "", 0, socks5RepCmdNotSupported
}
if port <= 0 || port > 65535 {
return "", 0, socks5RepGeneralFailure
}
return host, port, socks5RepSuccess
}
func writeSOCKS5Reply(conn net.Conn, rep byte, bindAddr net.Addr) error {
var bndIP net.IP
var bndPort int
if tcpAddr, ok := bindAddr.(*net.TCPAddr); ok && tcpAddr != nil {
bndIP = tcpAddr.IP
bndPort = tcpAddr.Port
}
var out []byte
if ip4 := bndIP.To4(); ip4 != nil {
out = make([]byte, 0, 10)
out = append(out, socks5Version, rep, 0x00, socks5AtypIPv4)
out = append(out, ip4...)
} else if ip16 := bndIP.To16(); ip16 != nil {
out = make([]byte, 0, 22)
out = append(out, socks5Version, rep, 0x00, socks5AtypIPv6)
out = append(out, ip16...)
} else {
out = make([]byte, 0, 10)
out = append(out, socks5Version, rep, 0x00, socks5AtypIPv4, 0, 0, 0, 0)
}
var p [2]byte
binary.BigEndian.PutUint16(p[:], uint16(bndPort))
out = append(out, p[:]...)
_, err := conn.Write(out)
return err
}
func (s *socks5Server) dialTarget(host string, port int, targetAddr string) (net.Conn, byte) {
baseCtx := context.Background()
if s.cfg.BaseContext != nil {
if ctx := s.cfg.BaseContext(); ctx != nil {
baseCtx = ctx
}
}
stopCtx, stopCancel := context.WithCancel(baseCtx)
defer stopCancel()
go func() {
select {
case <-s.stop:
stopCancel()
case <-stopCtx.Done():
}
}()
// Run through the same egress governor (egress.Do) and target gate dialer
// (intercept.PinnedDialer / Interceptor.DialSOCKS5) the HTTP path uses.
govCtx, govCancel := context.WithTimeout(stopCtx, s.cfg.PaceTimeout)
defer govCancel()
targetURL := &url.URL{Scheme: "tcp", Host: targetAddr}
dialCalled := false
conn, err := egress.Do(egress.Current(), govCtx, targetURL, func() (net.Conn, error) {
dialCalled = true
dialCtx, dialCancel := context.WithTimeout(stopCtx, s.cfg.DialTimeout)
defer dialCancel()
return s.cfg.DialContext(dialCtx, "tcp", targetAddr)
})
if err != nil {
if !dialCalled {
// Refused by the egress governor before dialing.
return nil, socks5RepNotAllowed
}
return nil, mapDialErrorToSOCKS5Reply(err)
}
return conn, socks5RepSuccess
}
func mapDialErrorToSOCKS5Reply(err error) byte {
if _, blocked := intercept.IsTargetBlocked(err); blocked {
return socks5RepNotAllowed
}
var dnsErr *net.DNSError
if errors.As(err, &dnsErr) {
return socks5RepHostUnreachable
}
if errors.Is(err, syscall.ECONNREFUSED) {
return socks5RepConnectionRefused
}
if errors.Is(err, syscall.ENETUNREACH) {
return socks5RepNetworkUnreachable
}
if errors.Is(err, syscall.EHOSTUNREACH) {
return socks5RepHostUnreachable
}
if errors.Is(err, context.DeadlineExceeded) {
return socks5RepTTLExpired
}
low := strings.ToLower(err.Error())
switch {
case strings.Contains(low, "connection refused"):
return socks5RepConnectionRefused
case strings.Contains(low, "network is unreachable"):
return socks5RepNetworkUnreachable
case strings.Contains(low, "no route to host"), strings.Contains(low, "no such host"), strings.Contains(low, "host is unreachable"):
return socks5RepHostUnreachable
}
return socks5RepGeneralFailure
}
func isLoopbackRemote(addr net.Addr) bool {
if addr == nil {
return false
}
switch a := addr.(type) {
case *net.TCPAddr:
return a.IP != nil && a.IP.IsLoopback()
default:
h, _, err := net.SplitHostPort(addr.String())
if err != nil {
h = addr.String()
}
ip := net.ParseIP(strings.Trim(h, "[]"))
return ip != nil && ip.IsLoopback()
}
}
type limitedCapture struct {
max int64
total int64
buf []byte
truncated bool
}
func (c *limitedCapture) record(p []byte) {
if len(p) == 0 {
return
}
c.total += int64(len(p))
rem := c.max - int64(len(c.buf))
if rem <= 0 {
c.truncated = true
return
}
if int64(len(p)) > rem {
c.buf = append(c.buf, p[:rem]...)
c.truncated = true
return
}
c.buf = append(c.buf, p...)
}
func relayHalf(dst, src net.Conn, cap *limitedCapture, idle time.Duration) {
buf := make([]byte, 32*1024)
for {
if idle > 0 {
_ = src.SetReadDeadline(time.Now().Add(idle))
}
n, rerr := src.Read(buf)
if n > 0 {
chunk := buf[:n]
cap.record(chunk)
if idle > 0 {
_ = dst.SetWriteDeadline(time.Now().Add(idle))
}
if _, werr := dst.Write(chunk); werr != nil {
return
}
}
if rerr != nil {
return
}
}
}
func closeWrite(c net.Conn) {
type halfCloser interface {
CloseWrite() error
}
if hc, ok := c.(halfCloser); ok {
_ = hc.CloseWrite()
}
}
+897
View File
@@ -0,0 +1,897 @@
package traffic
import (
"bytes"
"context"
"encoding/binary"
"errors"
"io"
"net"
"os"
"path/filepath"
"runtime"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/egress"
"github.com/Autumn-27/artex/intercept"
)
func startEchoServer(t *testing.T, network, addr string) (net.Listener, *atomic.Int32) {
t.Helper()
ln, err := net.Listen(network, addr)
if err != nil {
t.Fatalf("listen %s %s: %v", network, addr, err)
}
var accepted atomic.Int32
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
for {
c, err := ln.Accept()
if err != nil {
return
}
accepted.Add(1)
wg.Add(1)
go func(conn net.Conn) {
defer wg.Done()
defer conn.Close()
_, _ = io.Copy(conn, conn)
}(c)
}
}()
t.Cleanup(func() {
_ = ln.Close()
wg.Wait()
})
return ln, &accepted
}
func socks5BuildRequest(cmd byte, host string, port int) []byte {
req := []byte{socks5Version, cmd, 0x00}
if ip := net.ParseIP(host); ip != nil {
if ip4 := ip.To4(); ip4 != nil {
req = append(req, socks5AtypIPv4)
req = append(req, ip4...)
} else {
req = append(req, socks5AtypIPv6)
req = append(req, ip.To16()...)
}
} else {
req = append(req, socks5AtypDomain, byte(len(host)))
req = append(req, []byte(host)...)
}
var p [2]byte
binary.BigEndian.PutUint16(p[:], uint16(port))
return append(req, p[:]...)
}
func socks5ReadReply(t *testing.T, conn net.Conn) byte {
t.Helper()
var hdr [4]byte
if _, err := io.ReadFull(conn, hdr[:]); err != nil {
t.Fatalf("read socks5 reply header: %v", err)
}
if hdr[0] != socks5Version {
t.Fatalf("reply version = 0x%02x, want 0x05", hdr[0])
}
switch hdr[3] {
case socks5AtypIPv4:
var buf [6]byte
if _, err := io.ReadFull(conn, buf[:]); err != nil {
t.Fatalf("read ipv4 reply tail: %v", err)
}
case socks5AtypIPv6:
var buf [18]byte
if _, err := io.ReadFull(conn, buf[:]); err != nil {
t.Fatalf("read ipv6 reply tail: %v", err)
}
case socks5AtypDomain:
var l [1]byte
if _, err := io.ReadFull(conn, l[:]); err != nil {
t.Fatalf("read domain len: %v", err)
}
buf := make([]byte, int(l[0])+2)
if _, err := io.ReadFull(conn, buf); err != nil {
t.Fatalf("read domain tail: %v", err)
}
default:
t.Fatalf("unexpected reply atyp 0x%02x", hdr[3])
}
return hdr[1]
}
func socks5DialNoAuth(t *testing.T, proxyAddr, host string, port int) (net.Conn, byte) {
t.Helper()
c, err := net.DialTimeout("tcp", proxyAddr, 3*time.Second)
if err != nil {
t.Fatalf("dial proxy %s: %v", proxyAddr, err)
}
_ = c.SetDeadline(time.Now().Add(5 * time.Second))
if _, err := c.Write([]byte{socks5Version, 1, socks5AuthNone}); err != nil {
_ = c.Close()
t.Fatalf("write greeting: %v", err)
}
var sel [2]byte
if _, err := io.ReadFull(c, sel[:]); err != nil {
_ = c.Close()
t.Fatalf("read method selection: %v", err)
}
if sel[0] != socks5Version || sel[1] != socks5AuthNone {
_ = c.Close()
t.Fatalf("method selection = %v, want [5 0]", sel)
}
if _, err := c.Write(socks5BuildRequest(socks5CmdConnect, host, port)); err != nil {
_ = c.Close()
t.Fatalf("write connect req: %v", err)
}
rep := socks5ReadReply(t, c)
_ = c.SetDeadline(time.Time{})
return c, rep
}
func socks5DialUserPass(t *testing.T, proxyAddr, user, pass, host string, port int) (net.Conn, byte) {
t.Helper()
c, err := net.DialTimeout("tcp", proxyAddr, 3*time.Second)
if err != nil {
t.Fatalf("dial proxy %s: %v", proxyAddr, err)
}
_ = c.SetDeadline(time.Now().Add(5 * time.Second))
if _, err := c.Write([]byte{socks5Version, 2, socks5AuthNone, socks5AuthUserPass}); err != nil {
_ = c.Close()
t.Fatalf("write greeting: %v", err)
}
var sel [2]byte
if _, err := io.ReadFull(c, sel[:]); err != nil {
_ = c.Close()
t.Fatalf("read method selection: %v", err)
}
if sel[0] != socks5Version || sel[1] != socks5AuthUserPass {
_ = c.Close()
t.Fatalf("method selection = %v, want [5 2]", sel)
}
auth := []byte{socks5UserPassVer, byte(len(user))}
auth = append(auth, []byte(user)...)
auth = append(auth, byte(len(pass)))
auth = append(auth, []byte(pass)...)
if _, err := c.Write(auth); err != nil {
_ = c.Close()
t.Fatalf("write user/pass: %v", err)
}
var aresp [2]byte
if _, err := io.ReadFull(c, aresp[:]); err != nil {
_ = c.Close()
t.Fatalf("read user/pass reply: %v", err)
}
if aresp[0] != socks5UserPassVer || aresp[1] != 0x00 {
_ = c.Close()
t.Fatalf("auth reply = %v, want [1 0]", aresp)
}
if _, err := c.Write(socks5BuildRequest(socks5CmdConnect, host, port)); err != nil {
_ = c.Close()
t.Fatalf("write connect req: %v", err)
}
rep := socks5ReadReply(t, c)
_ = c.SetDeadline(time.Time{})
return c, rep
}
func waitForRawStreams(t *testing.T, tr *Traffic, want int) []RawTCPStream {
t.Helper()
deadline := time.Now().Add(3 * time.Second)
for time.Now().Before(deadline) {
items, total, err := tr.ListRawTCPStreams(RawTCPFilter{Limit: 100})
if err != nil {
t.Fatalf("ListRawTCPStreams: %v", err)
}
if total >= want {
return items
}
time.Sleep(15 * time.Millisecond)
}
items, total, _ := tr.ListRawTCPStreams(RawTCPFilter{Limit: 100})
t.Fatalf("timed out waiting for %d raw tcp streams; got total=%d (%+v)", want, total, items)
return nil
}
func TestSOCKS5FlagOffMeansNoListener(t *testing.T) {
t.Setenv(SOCKS5EnabledEnv, "")
t.Setenv(SOCKS5AddrEnv, "")
if cfg, ok := SOCKS5ConfigFromEnv(); ok || cfg.Addr != "" {
t.Fatalf("default SOCKS5ConfigFromEnv = (%+v, %v), want disabled", cfg, ok)
}
t.Setenv(SOCKS5EnabledEnv, "0")
t.Setenv(SOCKS5AddrEnv, "127.0.0.1:1080")
if _, ok := SOCKS5ConfigFromEnv(); ok {
t.Fatalf("explicit ARTEX_SOCKS5_ENABLED=0 must stay disabled even when addr is set")
}
t.Setenv(SOCKS5EnabledEnv, "1")
t.Setenv(SOCKS5AddrEnv, "")
cfg, ok := SOCKS5ConfigFromEnv()
if !ok || cfg.Addr != DefaultSOCKS5Addr {
t.Fatalf("enabled default = (%+v, %v), want (%s, true)", cfg, ok, DefaultSOCKS5Addr)
}
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
if got := tr.SOCKS5Addr(); got != "" {
t.Fatalf("SOCKS5Addr with flag off = %q, want empty", got)
}
}
func TestSOCKS5HandshakeSuccessAuthAndHalfCloseNoHTTPExchange(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
// Server that reads until client half-closes (CloseWrite), then replies.
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer ln.Close()
go func() {
for {
c, err := ln.Accept()
if err != nil {
return
}
go func(conn net.Conn) {
defer conn.Close()
req, _ := io.ReadAll(conn)
_, _ = conn.Write(append([]byte("ACK:"), req...))
}(c)
}
}()
targetHost, targetPortStr, _ := net.SplitHostPort(ln.Addr().String())
targetPort, _ := strconv.Atoi(targetPortStr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
var pacedSeen atomic.Bool
var unpacedSeen atomic.Bool
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
OnRecord: func(rec RawTCPCapture) {
if rec.Paced {
pacedSeen.Store(true)
} else {
unpacedSeen.Store(true)
}
},
})
if err != nil {
t.Fatal(err)
}
// 1. Loopback no-auth + half-close relay.
c1, rep := socks5DialNoAuth(t, proxyAddr, targetHost, targetPort)
if rep != socks5RepSuccess {
t.Fatalf("no-auth connect rep = 0x%02x, want 0x00", rep)
}
if _, err := c1.Write([]byte("hello-half-close")); err != nil {
t.Fatal(err)
}
if err := c1.(*net.TCPConn).CloseWrite(); err != nil {
t.Fatal(err)
}
resp1, err := io.ReadAll(c1)
_ = c1.Close()
if err != nil {
t.Fatal(err)
}
if string(resp1) != "ACK:hello-half-close" {
t.Fatalf("half-close reply = %q, want %q", resp1, "ACK:hello-half-close")
}
// 2. Username/password with pace marker (egress.PaceUser).
c2, rep := socks5DialUserPass(t, proxyAddr, egress.PaceUser, egress.PaceUser, targetHost, targetPort)
if rep != socks5RepSuccess {
t.Fatalf("user/pass pace connect rep = 0x%02x, want 0x00", rep)
}
_, _ = c2.Write([]byte("paced-payload"))
_ = c2.(*net.TCPConn).CloseWrite()
resp2, err := io.ReadAll(c2)
_ = c2.Close()
if err != nil || string(resp2) != "ACK:paced-payload" {
t.Fatalf("paced reply = %q err=%v", resp2, err)
}
// 3. Username/password with arbitrary/empty credentials still accepted.
c3, rep := socks5DialUserPass(t, proxyAddr, "", "", targetHost, targetPort)
if rep != socks5RepSuccess {
t.Fatalf("empty user/pass connect rep = 0x%02x, want 0x00", rep)
}
_, _ = c3.Write([]byte("anon"))
_ = c3.(*net.TCPConn).CloseWrite()
_, _ = io.ReadAll(c3)
_ = c3.Close()
streams := waitForRawStreams(t, tr, 3)
if !pacedSeen.Load() || !unpacedSeen.Load() {
t.Fatalf("paced=%v unpaced=%v, want both true", pacedSeen.Load(), unpacedSeen.Load())
}
// Verify store fields, CountRawTCPStreams, GetRawTCPStream, and ZERO HTTP exchanges.
cntAll, err := tr.CountRawTCPStreams("")
if err != nil || cntAll != 3 {
t.Fatalf("CountRawTCPStreams('') = %d err=%v, want 3", cntAll, err)
}
cntHost, err := tr.CountRawTCPStreams(targetHost)
if err != nil || cntHost != 3 {
t.Fatalf("CountRawTCPStreams(%q) = %d err=%v, want 3", targetHost, cntHost, err)
}
got, err := tr.GetRawTCPStream(streams[0].ID)
if err != nil || got == nil {
t.Fatalf("GetRawTCPStream(%q) = %+v err=%v", streams[0].ID, got, err)
}
if got.Protocol != "tcp" || got.Host != targetHost || got.Port != targetPort || got.Truncated {
t.Fatalf("unexpected stream metadata: %+v", got)
}
if got.C2SBlob != "" || got.S2CBlob != "" {
t.Fatalf("small payload unexpectedly spilled to blob: %+v", got)
}
var httpRows int
if err := tr.DB().QueryRow(`SELECT COUNT(*) FROM exchanges`).Scan(&httpRows); err != nil {
t.Fatal(err)
}
if httpRows != 0 {
t.Fatalf("raw TCP streams created %d HTTP exchanges rows, want 0", httpRows)
}
}
type fakeRemoteAddrConn struct {
net.Conn
remote net.Addr
}
func (f fakeRemoteAddrConn) RemoteAddr() net.Addr { return f.remote }
func TestSOCKS5HandshakeFailuresUnsupportedCommandsAndMalformedInput(t *testing.T) {
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
HandshakeTimeout: 150 * time.Millisecond,
})
if err != nil {
t.Fatal(err)
}
// 1. BIND and UDP ASSOCIATE rejected with 0x07 (command not supported).
for _, tc := range []struct {
name string
cmd byte
}{
{"bind", socks5CmdBind},
{"udp_associate", socks5CmdUDPAssociate},
{"unknown_cmd", 0x09},
} {
t.Run(tc.name, func(t *testing.T) {
c, err := net.DialTimeout("tcp", proxyAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
defer c.Close()
_, _ = c.Write([]byte{socks5Version, 1, socks5AuthNone})
var sel [2]byte
if _, err := io.ReadFull(c, sel[:]); err != nil {
t.Fatal(err)
}
_, _ = c.Write(socks5BuildRequest(tc.cmd, "127.0.0.1", 8080))
if rep := socks5ReadReply(t, c); rep != socks5RepCmdNotSupported {
t.Fatalf("%s reply = 0x%02x, want 0x%02x", tc.name, rep, socks5RepCmdNotSupported)
}
})
}
// 2. Unsupported auth method -> 0x05 0xFF.
t.Run("unsupported_auth_method", func(t *testing.T) {
c, err := net.DialTimeout("tcp", proxyAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
defer c.Close()
_, _ = c.Write([]byte{socks5Version, 1, 0x03})
var sel [2]byte
if _, err := io.ReadFull(c, sel[:]); err != nil {
t.Fatal(err)
}
if sel != [2]byte{socks5Version, socks5AuthNoAccept} {
t.Fatalf("reply = %v, want [5 255]", sel)
}
})
// 3. Non-loopback client offering only no-auth -> rejected with 0x05 0xFF.
t.Run("non_loopback_no_auth_rejected", func(t *testing.T) {
srvSide, cliSide := net.Pipe()
defer cliSide.Close()
done := make(chan struct{})
go func() {
defer close(done)
defer srvSide.Close()
tr.socks.handleConn(fakeRemoteAddrConn{
Conn: srvSide,
remote: &net.TCPAddr{IP: net.ParseIP("198.51.100.10"), Port: 54321},
})
}()
_, _ = cliSide.Write([]byte{socks5Version, 1, socks5AuthNone})
var sel [2]byte
if _, err := io.ReadFull(cliSide, sel[:]); err != nil {
t.Fatal(err)
}
if sel != [2]byte{socks5Version, socks5AuthNoAccept} {
t.Fatalf("non-loopback no-auth reply = %v, want [5 255]", sel)
}
<-done
})
// 4. Unsupported ATYP -> 0x08.
t.Run("unsupported_atyp", func(t *testing.T) {
c, err := net.DialTimeout("tcp", proxyAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
defer c.Close()
_, _ = c.Write([]byte{socks5Version, 1, socks5AuthNone})
var sel [2]byte
_, _ = io.ReadFull(c, sel[:])
_, _ = c.Write([]byte{socks5Version, socks5CmdConnect, 0x00, 0x09, 0x00, 0x50})
if rep := socks5ReadReply(t, c); rep != socks5RepAtypNotSupported {
t.Fatalf("atyp reply = 0x%02x, want 0x%02x", rep, socks5RepAtypNotSupported)
}
})
// 5. Malformed inputs & handshake deadline: must close cleanly without panic.
malformed := [][]byte{
{0x04, 0x01, 0x00}, // wrong version
{0x05, 0x00}, // 0 methods
{0x05}, // truncated greeting
{0x05, 0x01, 0x02, 0x02, 0x01, 'a', 0x01, 'b'}, // bad RFC1929 version
{0x05, 0x01, 0x00, 0x05, 0x01, 0xFF, 0x01, 127, 0, 0, 1, 0, 80}, // bad RSV
{0x05, 0x01, 0x00, 0x05, 0x01, 0x00, 0x03, 0x00, 0, 80}, // empty domain
{0x05, 0x01, 0x00, 0x05, 0x01, 0x00, 0x01, 127, 0, 0, 1, 0, 0}, // zero port
nil, // silent client -> handshake timeout
}
baseG := runtime.NumGoroutine()
for i, payload := range malformed {
c, err := net.DialTimeout("tcp", proxyAddr, 2*time.Second)
if err != nil {
t.Fatalf("malformed[%d] dial: %v", i, err)
}
if len(payload) > 0 {
_, _ = c.Write(payload)
_ = c.(*net.TCPConn).CloseWrite()
}
_ = c.SetReadDeadline(time.Now().Add(time.Second))
_, _ = io.Copy(io.Discard, c)
_ = c.Close()
}
time.Sleep(50 * time.Millisecond)
if afterG := runtime.NumGoroutine(); afterG > baseG+4 {
t.Fatalf("possible goroutine leak after malformed handshakes: before=%d after=%d", baseG, afterG)
}
}
func TestSOCKS5DeniedTargetRefusedBeforeDial(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
echoLn, accepted := startEchoServer(t, "tcp4", "127.0.0.1:0")
host, portStr, _ := net.SplitHostPort(echoLn.Addr().String())
port, _ := strconv.Atoi(portStr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
// Use intercept.PinnedDialer with a gated TargetScope whose Interceptor is nil:
// PinnedDialer returns TargetGateUnavailable (a platform dialError) BEFORE dialing.
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
BaseContext: func() context.Context {
return intercept.WithTargetScope(context.Background(), intercept.TargetScope{
TaskID: "99",
Enabled: func() bool { return true },
})
},
DialContext: intercept.PinnedDialer("socks5", true),
})
if err != nil {
t.Fatal(err)
}
c, rep := socks5DialNoAuth(t, proxyAddr, host, port)
_ = c.Close()
if rep != socks5RepNotAllowed {
t.Fatalf("denied target reply = 0x%02x, want 0x%02x", rep, socks5RepNotAllowed)
}
if accepted.Load() != 0 {
t.Fatalf("upstream accepted %d connections despite target gate refusal", accepted.Load())
}
if n, _ := tr.CountRawTCPStreams(""); n != 0 {
t.Fatalf("refused connection recorded %d raw streams, want 0", n)
}
}
func TestSOCKS5GovernorRefusalBeforeDial(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
// 1 token burst, very slow refill: 2nd request must wait far longer than PaceTimeout.
egress.SetProfile(egress.Profile{Name: "tight", RPS: 0.01, Burst: 1, MaxPerHost: 1, MaxGlobal: 1})
echoLn, _ := startEchoServer(t, "tcp4", "127.0.0.1:0")
host, portStr, _ := net.SplitHostPort(echoLn.Addr().String())
port, _ := strconv.Atoi(portStr)
var dialCalls atomic.Int32
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
PaceTimeout: 40 * time.Millisecond,
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
dialCalls.Add(1)
return (&net.Dialer{Timeout: 2 * time.Second}).DialContext(ctx, network, addr)
},
})
if err != nil {
t.Fatal(err)
}
// First call consumes the single burst token.
c1, rep1 := socks5DialUserPass(t, proxyAddr, egress.PaceUser, egress.PaceUser, host, port)
if rep1 != socks5RepSuccess {
t.Fatalf("first connect rep = 0x%02x, want 0x00", rep1)
}
_ = c1.Close()
// Second call exceeds PaceTimeout inside egress.Do and is refused BEFORE dial.
before := dialCalls.Load()
c2, rep2 := socks5DialUserPass(t, proxyAddr, egress.PaceUser, egress.PaceUser, host, port)
_ = c2.Close()
if rep2 != socks5RepNotAllowed {
t.Fatalf("governor refusal reply = 0x%02x, want 0x%02x", rep2, socks5RepNotAllowed)
}
if dialCalls.Load() != before {
t.Fatalf("dialer was called despite egress governor refusal (before=%d after=%d)", before, dialCalls.Load())
}
}
func TestSOCKS5ByteCapsTruncationAndBlobSpill(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
echoLn, _ := startEchoServer(t, "tcp4", "127.0.0.1:0")
host, portStr, _ := net.SplitHostPort(echoLn.Addr().String())
port, _ := strconv.Atoi(portStr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
const (
maxPerDir = 2048
previewCap = 256
sendTotal = 6144
)
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
MaxBytesPerDir: maxPerDir,
PreviewBytes: previewCap,
})
if err != nil {
t.Fatal(err)
}
payload := make([]byte, sendTotal)
for i := range payload {
payload[i] = byte(i % 251) // includes NUL bytes (binary stream)
}
c, rep := socks5DialNoAuth(t, proxyAddr, host, port)
if rep != socks5RepSuccess {
t.Fatalf("connect rep = 0x%02x", rep)
}
go func() {
_, _ = c.Write(payload)
_ = c.(*net.TCPConn).CloseWrite()
}()
echoed, err := io.ReadAll(c)
_ = c.Close()
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(echoed, payload) {
t.Fatalf("relayed payload len=%d differed from sent len=%d", len(echoed), len(payload))
}
streams := waitForRawStreams(t, tr, 1)
s := streams[0]
if !s.Truncated {
t.Fatalf("expected Truncated=true when %d > %d", sendTotal, maxPerDir)
}
if s.C2SBytes != sendTotal || s.S2CBytes != sendTotal {
t.Fatalf("byte counts = (%d, %d), want (%d, %d)", s.C2SBytes, s.S2CBytes, sendTotal, sendTotal)
}
if len(s.C2SPreview) != previewCap || len(s.S2CPreview) != previewCap {
t.Fatalf("preview lengths = (%d, %d), want (%d, %d)", len(s.C2SPreview), len(s.S2CPreview), previewCap, previewCap)
}
if !bytes.Equal(s.C2SPreview, payload[:previewCap]) || !bytes.Equal(s.S2CPreview, payload[:previewCap]) {
t.Fatalf("preview bytes mismatch")
}
if s.C2SBlob == "" || s.S2CBlob == "" {
t.Fatalf("expected spilled blob hashes, got c2s=%q s2c=%q", s.C2SBlob, s.S2CBlob)
}
// Blob must be readable via Traffic.Blob and registered in blob_refs.
f, sz, err := tr.Blob(s.C2SBlob)
if err != nil {
t.Fatalf("tr.Blob(%q): %v", s.C2SBlob, err)
}
defer f.Close()
blobData, _ := io.ReadAll(f)
if sz != maxPerDir || !bytes.Equal(blobData, payload[:maxPerDir]) {
t.Fatalf("spilled blob size=%d len=%d, want %d matching prefix", sz, len(blobData), maxPerDir)
}
var refs int
if err := tr.DB().QueryRow(`SELECT COUNT(*) FROM blob_refs WHERE hash=? AND exchange_id=?`, s.C2SBlob, s.ID).Scan(&refs); err != nil || refs != 1 {
t.Fatalf("blob_refs count = %d err=%v, want 1", refs, err)
}
}
func TestSOCKS5IPv4IPv6HostnameAndDNSFailure(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
echo4, _ := startEchoServer(t, "tcp4", "127.0.0.1:0")
_, p4s, _ := net.SplitHostPort(echo4.Addr().String())
p4, _ := strconv.Atoi(p4s)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
h, _, _ := net.SplitHostPort(addr)
if h == "nonexistent.invalid" {
return nil, &net.DNSError{Err: "no such host", Name: h, IsNotFound: true}
}
return (&net.Dialer{Timeout: 2 * time.Second}).DialContext(ctx, network, addr)
},
})
if err != nil {
t.Fatal(err)
}
// 1. IPv4 literal
c4, rep := socks5DialNoAuth(t, proxyAddr, "127.0.0.1", p4)
if rep != socks5RepSuccess {
t.Fatalf("ipv4 rep = 0x%02x", rep)
}
_, _ = c4.Write([]byte("v4"))
_ = c4.(*net.TCPConn).CloseWrite()
got4, _ := io.ReadAll(c4)
_ = c4.Close()
if string(got4) != "v4" {
t.Fatalf("ipv4 echo = %q", got4)
}
// 2. Hostname (localhost)
ch, rep := socks5DialNoAuth(t, proxyAddr, "localhost", p4)
if rep != socks5RepSuccess {
t.Fatalf("hostname rep = 0x%02x", rep)
}
_, _ = ch.Write([]byte("host"))
_ = ch.(*net.TCPConn).CloseWrite()
goth, _ := io.ReadAll(ch)
_ = ch.Close()
if string(goth) != "host" {
t.Fatalf("hostname echo = %q", goth)
}
// 3. DNS failure -> 0x04 Host unreachable
cd, rep := socks5DialNoAuth(t, proxyAddr, "nonexistent.invalid", 443)
_ = cd.Close()
if rep != socks5RepHostUnreachable {
t.Fatalf("dns failure rep = 0x%02x, want 0x%02x", rep, socks5RepHostUnreachable)
}
// 4. IPv6 literal (::1) if available in this kernel/environment.
wantStreams := 2
if echo6, err := net.Listen("tcp6", "[::1]:0"); err == nil {
t.Cleanup(func() { _ = echo6.Close() })
go func() {
for {
c, err := echo6.Accept()
if err != nil {
return
}
go func(conn net.Conn) {
defer conn.Close()
_, _ = io.Copy(conn, conn)
}(c)
}
}()
_, p6s, _ := net.SplitHostPort(echo6.Addr().String())
p6, _ := strconv.Atoi(p6s)
c6, rep6 := socks5DialNoAuth(t, proxyAddr, "::1", p6)
if rep6 != socks5RepSuccess {
t.Fatalf("ipv6 rep = 0x%02x", rep6)
}
_, _ = c6.Write([]byte("v6"))
_ = c6.(*net.TCPConn).CloseWrite()
got6, _ := io.ReadAll(c6)
_ = c6.Close()
if string(got6) != "v6" {
t.Fatalf("ipv6 echo = %q", got6)
}
wantStreams++
}
waitForRawStreams(t, tr, wantStreams)
}
func TestSOCKS5ConcurrentStreamsMaxLimitAndIdleTimeout(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
echoLn, _ := startEchoServer(t, "tcp4", "127.0.0.1:0")
host, portStr, _ := net.SplitHostPort(echoLn.Addr().String())
port, _ := strconv.Atoi(portStr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
proxyAddr, err := tr.StartSOCKS5(SOCKS5Config{
Addr: "127.0.0.1:0",
MaxConcurrent: 2,
IdleTimeout: 200 * time.Millisecond,
})
if err != nil {
t.Fatal(err)
}
// Open 2 concurrent streams simultaneously.
c1, rep1 := socks5DialNoAuth(t, proxyAddr, host, port)
if rep1 != socks5RepSuccess {
t.Fatalf("stream 1 rep = 0x%02x", rep1)
}
defer c1.Close()
c2, rep2 := socks5DialNoAuth(t, proxyAddr, host, port)
if rep2 != socks5RepSuccess {
t.Fatalf("stream 2 rep = 0x%02x", rep2)
}
defer c2.Close()
// 3rd simultaneous stream must be rejected with 0x01 (MaxConcurrent=2).
c3, rep3 := socks5DialNoAuth(t, proxyAddr, host, port)
_ = c3.Close()
if rep3 != socks5RepGeneralFailure {
t.Fatalf("3rd concurrent stream rep = 0x%02x, want 0x%02x", rep3, socks5RepGeneralFailure)
}
// Exchange bytes on both active streams while both are open.
var wg sync.WaitGroup
wg.Add(2)
checkEcho := func(c net.Conn, msg string) {
defer wg.Done()
if _, err := c.Write([]byte(msg)); err != nil {
t.Errorf("write %s: %v", msg, err)
return
}
buf := make([]byte, len(msg))
if _, err := io.ReadFull(c, buf); err != nil || string(buf) != msg {
t.Errorf("echo %s: got %q err=%v", msg, buf, err)
}
}
go checkEcho(c1, "stream-one")
go checkEcho(c2, "stream-two")
wg.Wait()
// Leave both idle past IdleTimeout (200ms): relay must close them cleanly and record both.
_ = c1.SetReadDeadline(time.Now().Add(2 * time.Second))
buf := make([]byte, 1)
_, rerr := c1.Read(buf)
if rerr == nil || !errors.Is(rerr, io.EOF) {
// Peer close on idle may return EOF or connection reset depending on OS timing.
if rerr == nil {
t.Fatalf("expected idle stream 1 to close after IdleTimeout")
}
}
_ = c1.Close()
_ = c2.Close()
streams := waitForRawStreams(t, tr, 2)
if len(streams) < 2 {
t.Fatalf("want at least 2 recorded concurrent streams, got %d", len(streams))
}
}
func TestRawTCPAtomicBlobSpillConcurrent(t *testing.T) {
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
payload := bytes.Repeat([]byte("ATOMIC-BLOB-"), 128) // 1536 bytes > 64 preview
const workers = 8
var wg sync.WaitGroup
hashes := make([]string, workers)
for i := 0; i < workers; i++ {
wg.Add(1)
go func(idx int) {
defer wg.Done()
prev, h := tr.spillRawDir(payload, 64)
if len(prev) != 64 {
t.Errorf("worker %d preview len = %d, want 64", idx, len(prev))
}
hashes[idx] = h
}(i)
}
wg.Wait()
wantHash := hashes[0]
if wantHash == "" {
t.Fatal("expected non-empty blob hash")
}
for i, h := range hashes {
if h != wantHash {
t.Fatalf("worker %d hash = %q, want %q", i, h, wantHash)
}
}
blobDir := filepath.Join(tr.dir, "_blobs", "sha256", wantHash[:2])
entries, err := os.ReadDir(blobDir)
if err != nil {
t.Fatalf("ReadDir(%s): %v", blobDir, err)
}
for _, e := range entries {
if strings.HasSuffix(e.Name(), ".tmp") {
t.Fatalf("leftover temp blob file: %s", e.Name())
}
}
got, err := os.ReadFile(filepath.Join(blobDir, wantHash+".bin"))
if err != nil {
t.Fatalf("ReadFile blob: %v", err)
}
if !bytes.Equal(got, payload) {
t.Fatalf("blob content mismatch: got %d bytes, want %d", len(got), len(payload))
}
}
+44
View File
@@ -113,6 +113,29 @@ CREATE TABLE IF NOT EXISTS exchange_rewrites (
after_blob TEXT,
PRIMARY KEY (exchange_id, seq)
);
-- Raw TCP streams relayed through the opt-in SOCKS5 CONNECT listener (P4.1a).
-- Stored separately from HTTP exchanges: a raw TCP stream never creates a row
-- in exchanges. Oversized directional payloads spill to _blobs/sha256 and
-- register their hashes in blob_refs under the stream's tcp-* id.
CREATE TABLE IF NOT EXISTS raw_tcp_streams (
id TEXT PRIMARY KEY,
protocol TEXT NOT NULL DEFAULT 'tcp',
host TEXT NOT NULL,
port INTEGER NOT NULL,
started_at INTEGER NOT NULL, -- unix milliseconds
ended_at INTEGER NOT NULL, -- unix milliseconds
duration_ms INTEGER NOT NULL,
c2s_bytes INTEGER NOT NULL DEFAULT 0,
s2c_bytes INTEGER NOT NULL DEFAULT 0,
truncated INTEGER NOT NULL DEFAULT 0,
c2s_preview BLOB,
c2s_blob TEXT,
s2c_preview BLOB,
s2c_blob TEXT
);
CREATE INDEX IF NOT EXISTS idx_raw_tcp_host ON raw_tcp_streams(host);
CREATE INDEX IF NOT EXISTS idx_raw_tcp_started ON raw_tcp_streams(started_at DESC, id DESC);
`
// ftsSchema is applied separately from indexSchema: a driver build without FTS5
@@ -232,6 +255,13 @@ type Traffic struct {
// sweeping tracks the snapshot sweeper, which runs until Close. It is kept
// apart from reaping, which only ever holds work that finishes on its own.
sweeping sync.WaitGroup
// socks holds the opt-in SOCKS5 CONNECT listener when started via StartSOCKS5.
socksMu sync.Mutex
socks *socks5Server
// transparent holds the opt-in Linux transparent TCP listener when started
// via StartTransparentTCP (P4.1b).
transparentMu sync.Mutex
transparent *transparentServer
}
// Open initializes the traffic tree, blob store and SQLite index under dir.
@@ -445,6 +475,20 @@ func (t *Traffic) Close() error {
if t.closed != nil {
t.closeOnce.Do(func() { close(t.closed) })
}
t.socksMu.Lock()
srv := t.socks
t.socks = nil
t.socksMu.Unlock()
if srv != nil {
_ = srv.Close()
}
t.transparentMu.Lock()
tsrv := t.transparent
t.transparent = nil
t.transparentMu.Unlock()
if tsrv != nil {
_ = tsrv.Close()
}
t.reaping.Wait()
t.sweeping.Wait()
return t.db.Close()
+460
View File
@@ -0,0 +1,460 @@
package traffic
import (
"context"
"encoding/binary"
"errors"
"fmt"
"log"
"net"
"net/url"
"os"
"strconv"
"strings"
"sync"
"time"
"github.com/Autumn-27/artex/egress"
)
// Opt-in environment flags for the Linux transparent TCP inbound listener (P4.1b).
// Off by default: when neither is set, no transparent listener is started, no
// firewall rules are touched, and the HTTP proxy is unchanged.
const (
// TransparentTCPEnabledEnv turns on the Linux transparent TCP listener on
// DefaultTransparentTCPAddr when set to a truthy value (1/true/yes/on).
TransparentTCPEnabledEnv = "ARTEX_TRANSPARENT_TCP_ENABLED"
// TransparentTCPAddrEnv optionally overrides the IPv4 bind address
// (default 127.0.0.1:1081). Setting a non-empty address also enables the
// listener unless ARTEX_TRANSPARENT_TCP_ENABLED is explicitly false/0/off/no.
TransparentTCPAddrEnv = "ARTEX_TRANSPARENT_TCP_ADDR"
DefaultTransparentTCPAddr = "127.0.0.1:1081"
// afInet matches POSIX/Linux AF_INET (IPv4) in struct sockaddr_in.sin_family.
afInet = 2
// sockaddrInSize is sizeof(struct sockaddr_in) on Linux.
sockaddrInSize = 16
)
var (
// ErrTransparentTCPNotLinux is returned when transparent TCP inbound is
// explicitly enabled on a non-Linux OS.
ErrTransparentTCPNotLinux = errors.New("transparent TCP inbound (SO_ORIGINAL_DST) is only supported on Linux")
// ErrTransparentTCPIPv6Unsupported is returned when an IPv6 bind address or
// IPv6 redirected socket is encountered (P4.1b covers IPv4 only).
ErrTransparentTCPIPv6Unsupported = errors.New("transparent TCP inbound currently supports IPv4 only; IPv6 is not covered")
)
// TransparentTCPConfig configures the opt-in Linux transparent TCP listener
// fed by iptables/nftables REDIRECT rules.
type TransparentTCPConfig struct {
// Addr is the IPv4 TCP bind address (default DefaultTransparentTCPAddr).
Addr string
// MaxConcurrent bounds simultaneous active transparent streams (default 64).
MaxConcurrent int
// MaxBytesPerDir caps captured payload bytes per direction (default 4 MiB).
MaxBytesPerDir int64
// PreviewBytes caps inline SQLite preview per direction before blob spill (default 8 KiB).
PreviewBytes int
// IdleTimeout bounds per-direction read/write inactivity during relay (default 2m).
IdleTimeout time.Duration
// HandshakeTimeout bounds original-destination recovery before dialing (default 10s).
HandshakeTimeout time.Duration
// DialTimeout bounds outbound TCP connect attempts (default 30s).
DialTimeout time.Duration
// PaceTimeout bounds waiting on the egress governor before refusing (default 30s).
PaceTimeout time.Duration
// DialContext dials the recovered original destination. In production the
// server wires intercept.Interceptor.DialSOCKS5 so asset block rules and
// target pinning are enforced before any socket is opened.
DialContext func(ctx context.Context, network, addr string) (net.Conn, error)
// BaseContext optionally supplies a parent context for outbound dials.
BaseContext func() context.Context
// origDst overrides kernel SO_ORIGINAL_DST lookup in unit tests.
origDst func(conn net.Conn) (net.IP, int, error)
}
// TransparentTCPConfigFromEnv parses ARTEX_TRANSPARENT_TCP_ENABLED and
// ARTEX_TRANSPARENT_TCP_ADDR. Returns (cfg, false) when disabled (default).
func TransparentTCPConfigFromEnv() (TransparentTCPConfig, bool) {
rawEnabled := strings.ToLower(strings.TrimSpace(os.Getenv(TransparentTCPEnabledEnv)))
rawAddr := strings.TrimSpace(os.Getenv(TransparentTCPAddrEnv))
switch rawEnabled {
case "0", "false", "no", "off":
return TransparentTCPConfig{}, false
case "1", "true", "yes", "on":
addr := rawAddr
if addr == "" {
addr = DefaultTransparentTCPAddr
}
return TransparentTCPConfig{Addr: addr}, true
case "":
if rawAddr == "" {
return TransparentTCPConfig{}, false
}
return TransparentTCPConfig{Addr: rawAddr}, true
default:
log.Printf("[traffic] %s=%q is not a boolean; leaving transparent TCP disabled", TransparentTCPEnabledEnv, rawEnabled)
return TransparentTCPConfig{}, false
}
}
func (c TransparentTCPConfig) withDefaults() TransparentTCPConfig {
if strings.TrimSpace(c.Addr) == "" {
c.Addr = DefaultTransparentTCPAddr
}
if c.MaxConcurrent <= 0 {
c.MaxConcurrent = DefaultSOCKS5MaxConcurrent
}
if c.MaxBytesPerDir <= 0 {
c.MaxBytesPerDir = DefaultSOCKS5MaxBytesPerDir
}
if c.PreviewBytes <= 0 {
c.PreviewBytes = DefaultSOCKS5PreviewBytes
}
if c.IdleTimeout <= 0 {
c.IdleTimeout = DefaultSOCKS5IdleTimeout
}
if c.HandshakeTimeout <= 0 {
c.HandshakeTimeout = DefaultSOCKS5HandshakeTimeout
}
if c.DialTimeout <= 0 {
c.DialTimeout = DefaultSOCKS5DialTimeout
}
if c.PaceTimeout <= 0 {
c.PaceTimeout = DefaultSOCKS5PaceTimeout
}
if c.DialContext == nil {
var d net.Dialer
c.DialContext = d.DialContext
}
if c.origDst == nil {
c.origDst = originalDstIPv4
}
return c
}
// parseOriginalDstIPv4 parses a Linux struct sockaddr_in returned by
// getsockopt(SOL_IP, SO_ORIGINAL_DST) into an IPv4 address and TCP port.
//
// Layout on Linux (16 bytes):
// - bytes 0..1: sin_family (host-endian uint16, must be AF_INET = 2)
// - bytes 2..3: sin_port (network/big-endian uint16, 1..65535)
// - bytes 4..7: sin_addr (4-byte IPv4 address, must not be 0.0.0.0)
// - bytes 8..15: sin_zero
func parseOriginalDstIPv4(raw []byte) (net.IP, int, error) {
if len(raw) < sockaddrInSize {
return nil, 0, fmt.Errorf("short SO_ORIGINAL_DST buffer: got %d bytes, want %d", len(raw), sockaddrInSize)
}
family := binary.NativeEndian.Uint16(raw[0:2])
if family != afInet {
if family == 10 { // Linux AF_INET6
return nil, 0, ErrTransparentTCPIPv6Unsupported
}
return nil, 0, fmt.Errorf("unsupported SO_ORIGINAL_DST address family %d (want AF_INET=%d)", family, afInet)
}
port := int(binary.BigEndian.Uint16(raw[2:4]))
if port <= 0 || port > 65535 {
return nil, 0, fmt.Errorf("invalid SO_ORIGINAL_DST port %d", port)
}
ip := net.IPv4(raw[4], raw[5], raw[6], raw[7]).To4()
if ip == nil || ip.IsUnspecified() {
return nil, 0, fmt.Errorf("invalid SO_ORIGINAL_DST IPv4 address %v", ip)
}
return ip, port, nil
}
// isSelfRedirect reports whether (origIP, origPort) points back at the
// transparent listener itself (which happens when a client connects directly
// to the transparent port without an iptables/nftables REDIRECT rule).
func isSelfRedirect(origIP net.IP, origPort int, localAddr net.Addr) bool {
if origIP == nil || origPort <= 0 || localAddr == nil {
return false
}
localTCP, ok := localAddr.(*net.TCPAddr)
if !ok || localTCP == nil || localTCP.Port != origPort {
return false
}
if localTCP.IP == nil || localTCP.IP.IsUnspecified() {
return true
}
return origIP.Equal(localTCP.IP)
}
type transparentServer struct {
t *Traffic
cfg TransparentTCPConfig
ln net.Listener
sem chan struct{}
stopOnce sync.Once
stop chan struct{}
wg sync.WaitGroup
mu sync.Mutex
active map[net.Conn]struct{}
}
// StartTransparentTCP binds and starts the opt-in Linux transparent TCP
// inbound listener on t. Returns the bound listener address. On non-Linux OSes
// it returns ErrTransparentTCPNotLinux unless a test origDst hook is supplied.
func (t *Traffic) StartTransparentTCP(cfg TransparentTCPConfig) (string, error) {
if !transparentTCPSupported && cfg.origDst == nil {
return "", ErrTransparentTCPNotLinux
}
cfg = cfg.withDefaults()
host, _, err := net.SplitHostPort(cfg.Addr)
if err != nil {
return "", fmt.Errorf("invalid transparent TCP listen address %q: %w", cfg.Addr, err)
}
if ip := net.ParseIP(strings.Trim(host, "[]")); ip != nil && ip.To4() == nil {
return "", ErrTransparentTCPIPv6Unsupported
}
ln, err := net.Listen("tcp4", cfg.Addr)
if err != nil {
return "", fmt.Errorf("listen transparent TCP on %s: %w", cfg.Addr, err)
}
srv := &transparentServer{
t: t,
cfg: cfg,
ln: ln,
sem: make(chan struct{}, cfg.MaxConcurrent),
stop: make(chan struct{}),
active: make(map[net.Conn]struct{}),
}
t.transparentMu.Lock()
if t.transparent != nil {
t.transparentMu.Unlock()
_ = ln.Close()
return "", fmt.Errorf("transparent TCP listener already running on %s", t.transparent.ln.Addr().String())
}
t.transparent = srv
t.transparentMu.Unlock()
srv.wg.Add(1)
go srv.serve()
return ln.Addr().String(), nil
}
// TransparentTCPAddr returns the bound transparent TCP listener address, or ""
// when disabled.
func (t *Traffic) TransparentTCPAddr() string {
t.transparentMu.Lock()
defer t.transparentMu.Unlock()
if t.transparent == nil || t.transparent.ln == nil {
return ""
}
return t.transparent.ln.Addr().String()
}
func (s *transparentServer) Close() error {
var err error
s.stopOnce.Do(func() {
close(s.stop)
err = s.ln.Close()
s.mu.Lock()
for c := range s.active {
_ = c.Close()
}
s.mu.Unlock()
})
s.wg.Wait()
return err
}
func (s *transparentServer) stopping() bool {
select {
case <-s.stop:
return true
default:
return false
}
}
func (s *transparentServer) trackConn(c net.Conn) bool {
s.mu.Lock()
defer s.mu.Unlock()
if s.stopping() {
return false
}
s.active[c] = struct{}{}
return true
}
func (s *transparentServer) untrackConn(c net.Conn) {
s.mu.Lock()
delete(s.active, c)
s.mu.Unlock()
}
func (s *transparentServer) serve() {
defer s.wg.Done()
for {
conn, err := s.ln.Accept()
if err != nil {
if s.stopping() || errors.Is(err, net.ErrClosed) {
return
}
var ne net.Error
if errors.As(err, &ne) && ne.Timeout() {
continue
}
log.Printf("[traffic/transparent] accept error: %v", err)
return
}
if !s.trackConn(conn) {
_ = conn.Close()
return
}
s.wg.Add(1)
go func(c net.Conn) {
defer s.wg.Done()
defer s.untrackConn(c)
defer c.Close()
s.handleConn(c)
}(conn)
}
}
func (s *transparentServer) handleConn(client net.Conn) {
// 1. Recover original IPv4 destination under HandshakeTimeout.
_ = client.SetDeadline(time.Now().Add(s.cfg.HandshakeTimeout))
origIP, origPort, err := s.recoverOriginalDst(client)
if err != nil {
return
}
if isSelfRedirect(origIP, origPort, s.ln.Addr()) {
return
}
// 2. Enforce max concurrent streams before touching policy or dialing.
select {
case s.sem <- struct{}{}:
defer func() { <-s.sem }()
default:
return
}
// 3. Apply the same egress governor and target gate before dialing.
host := origIP.String()
targetAddr := net.JoinHostPort(host, strconv.Itoa(origPort))
upstream, err := s.dialTarget(targetAddr)
if err != nil {
return
}
if !s.trackConn(upstream) {
_ = upstream.Close()
return
}
defer s.untrackConn(upstream)
defer upstream.Close()
// Clear handshake deadline before starting the relay.
_ = client.SetDeadline(time.Time{})
// 4. Bidirectional half-close-aware relay with idle timeout and bounded capture.
startedAt := time.Now().UTC()
c2sCap := &limitedCapture{max: s.cfg.MaxBytesPerDir}
s2cCap := &limitedCapture{max: s.cfg.MaxBytesPerDir}
var relayWG sync.WaitGroup
relayWG.Add(2)
go func() {
defer relayWG.Done()
relayHalf(upstream, client, c2sCap, s.cfg.IdleTimeout)
closeWrite(upstream)
}()
go func() {
defer relayWG.Done()
relayHalf(client, upstream, s2cCap, s.cfg.IdleTimeout)
closeWrite(client)
}()
relayWG.Wait()
endedAt := time.Now().UTC()
// 5. Record one raw_tcp_streams row in SQLite (never an HTTP exchanges row).
if s.t != nil {
if _, err := s.t.RecordRawTCPStream(RawTCPCapture{
Host: host,
Port: origPort,
StartedAt: startedAt,
EndedAt: endedAt,
C2SBytes: c2sCap.total,
S2CBytes: s2cCap.total,
Truncated: c2sCap.truncated || s2cCap.truncated,
C2SData: c2sCap.buf,
S2CData: s2cCap.buf,
}, s.cfg.PreviewBytes); err != nil {
log.Printf("[traffic/transparent] failed to record raw TCP stream %s: %v", targetAddr, err)
}
}
}
func (s *transparentServer) recoverOriginalDst(client net.Conn) (net.IP, int, error) {
type res struct {
ip net.IP
port int
err error
}
ch := make(chan res, 1)
go func() {
ip, port, err := s.cfg.origDst(client)
ch <- res{ip: ip, port: port, err: err}
}()
timer := time.NewTimer(s.cfg.HandshakeTimeout)
defer timer.Stop()
select {
case r := <-ch:
if r.err != nil {
return nil, 0, r.err
}
if r.ip == nil || r.ip.To4() == nil {
return nil, 0, ErrTransparentTCPIPv6Unsupported
}
if r.port <= 0 || r.port > 65535 {
return nil, 0, fmt.Errorf("invalid original destination port %d", r.port)
}
if r.ip.To4().IsUnspecified() {
return nil, 0, fmt.Errorf("unspecified original destination IP")
}
return r.ip.To4(), r.port, nil
case <-timer.C:
return nil, 0, context.DeadlineExceeded
case <-s.stop:
return nil, 0, net.ErrClosed
}
}
func (s *transparentServer) dialTarget(targetAddr string) (net.Conn, error) {
baseCtx := context.Background()
if s.cfg.BaseContext != nil {
if ctx := s.cfg.BaseContext(); ctx != nil {
baseCtx = ctx
}
}
stopCtx, stopCancel := context.WithCancel(baseCtx)
defer stopCancel()
go func() {
select {
case <-s.stop:
stopCancel()
case <-stopCtx.Done():
}
}()
// Reuse the exact same egress governor (egress.Do) and target gate dialer
// (intercept.PinnedDialer / Interceptor.DialSOCKS5) used by HTTP and SOCKS5.
govCtx, govCancel := context.WithTimeout(stopCtx, s.cfg.PaceTimeout)
defer govCancel()
targetURL := &url.URL{Scheme: "tcp", Host: targetAddr}
return egress.Do(egress.Current(), govCtx, targetURL, func() (net.Conn, error) {
dialCtx, dialCancel := context.WithTimeout(stopCtx, s.cfg.DialTimeout)
defer dialCancel()
return s.cfg.DialContext(dialCtx, "tcp", targetAddr)
})
}
+58
View File
@@ -0,0 +1,58 @@
//go:build linux
package traffic
import (
"fmt"
"net"
"syscall"
"unsafe"
)
const (
transparentTCPSupported = true
// soOriginalDst is Linux SO_ORIGINAL_DST from <linux/netfilter_ipv4.h>.
soOriginalDst = 80
)
// originalDstIPv4 recovers the pre-REDIRECT IPv4 destination of an accepted
// Linux TCP connection using getsockopt(SOL_IP, SO_ORIGINAL_DST).
func originalDstIPv4(conn net.Conn) (net.IP, int, error) {
if ta, ok := conn.LocalAddr().(*net.TCPAddr); ok && ta.IP != nil && ta.IP.To4() == nil {
return nil, 0, ErrTransparentTCPIPv6Unsupported
}
sc, ok := conn.(syscall.Conn)
if !ok {
return nil, 0, fmt.Errorf("connection %T does not expose syscall.Conn", conn)
}
rc, err := sc.SyscallConn()
if err != nil {
return nil, 0, fmt.Errorf("syscall conn: %w", err)
}
var raw [sockaddrInSize]byte
optlen := uint32(len(raw))
var sockErr error
if err := rc.Control(func(fd uintptr) {
_, _, errno := syscall.Syscall6(
syscall.SYS_GETSOCKOPT,
fd,
uintptr(syscall.SOL_IP),
uintptr(soOriginalDst),
uintptr(unsafe.Pointer(&raw[0])),
uintptr(unsafe.Pointer(&optlen)),
0,
)
if errno != 0 {
sockErr = errno
}
}); err != nil {
return nil, 0, fmt.Errorf("control fd: %w", err)
}
if sockErr != nil {
return nil, 0, fmt.Errorf("getsockopt(SO_ORIGINAL_DST): %w", sockErr)
}
if int(optlen) > len(raw) {
optlen = uint32(len(raw))
}
return parseOriginalDstIPv4(raw[:optlen])
}
+167
View File
@@ -0,0 +1,167 @@
//go:build linux
package traffic
import (
"bytes"
"fmt"
"io"
"net"
"os"
"os/exec"
"strconv"
"testing"
"time"
"github.com/Autumn-27/artex/egress"
)
const transparentRedirectChildEnv = "ARTEX_TRANSPARENT_REDIRECT_CHILD"
// TestTransparentTCPLinuxRealIptablesRedirect exercises real Linux kernel
// iptables REDIRECT + getsockopt(SOL_IP, SO_ORIGINAL_DST) inside an isolated
// user+network namespace (unshare -rn) so the host firewall is never touched.
// Skips cleanly when unshare/ip/iptables are unavailable in the environment.
func TestTransparentTCPLinuxRealIptablesRedirect(t *testing.T) {
if os.Getenv(transparentRedirectChildEnv) != "1" {
for _, bin := range []string{"unshare", "ip", "iptables"} {
if _, err := exec.LookPath(bin); err != nil {
t.Skipf("skipping real iptables REDIRECT test: %s not found: %v", bin, err)
}
}
probe := exec.Command("unshare", "-rn", "sh", "-c", "ip link set lo up && iptables -t nat -L OUTPUT -n >/dev/null")
if out, err := probe.CombinedOutput(); err != nil {
t.Skipf("skipping real iptables REDIRECT test: isolated netns/iptables unavailable: %v (%s)", err, bytes.TrimSpace(out))
}
cmd := exec.Command("unshare", "-rn", os.Args[0], "-test.v", "-test.run", "^TestTransparentTCPLinuxRealIptablesRedirect$")
cmd.Env = append(os.Environ(), transparentRedirectChildEnv+"=1")
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("isolated netns iptables REDIRECT test failed: %v\n%s", err, string(out))
}
return
}
// Inside isolated user+network namespace: bring up loopback.
if out, err := exec.Command("ip", "link", "set", "lo", "up").CombinedOutput(); err != nil {
t.Fatalf("ip link set lo up: %v (%s)", err, string(out))
}
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
// Upstream target echo server listening on 127.0.0.2:<echoPort>.
echoLn, err := net.Listen("tcp4", "127.0.0.2:0")
if err != nil {
t.Fatalf("listen echo on 127.0.0.2:0: %v", err)
}
defer echoLn.Close()
go func() {
for {
c, err := echoLn.Accept()
if err != nil {
return
}
go func(conn net.Conn) {
defer conn.Close()
req, _ := io.ReadAll(conn)
_, _ = conn.Write(append([]byte("NETNS-ECHO:"), req...))
}(c)
}
}()
echoPort := echoLn.Addr().(*net.TCPAddr).Port
// Start transparent TCP listener on 127.0.0.1:0 with NO origDst hook (uses real SO_ORIGINAL_DST).
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
bound, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "127.0.0.1:0",
})
if err != nil {
t.Fatalf("StartTransparentTCP: %v", err)
}
transPort := func() int {
_, p, err := net.SplitHostPort(bound)
if err != nil {
t.Fatal(err)
}
n, err := strconv.Atoi(p)
if err != nil {
t.Fatal(err)
}
return n
}()
// Redirect ONLY packets sourced from 127.0.0.3 destined to 127.0.0.2:<echoPort>
// into the transparent listener on <transPort>. ARTEX's own outbound dial uses
// default loopback source 127.0.0.1 and therefore bypasses REDIRECT cleanly.
iptArgs := []string{
"-t", "nat", "-A", "OUTPUT",
"-p", "tcp",
"-s", "127.0.0.3",
"-d", "127.0.0.2",
"--dport", strconv.Itoa(echoPort),
"-j", "REDIRECT", "--to-ports", strconv.Itoa(transPort),
}
if out, err := exec.Command("iptables", iptArgs...).CombinedOutput(); err != nil {
t.Fatalf("iptables %v: %v (%s)", iptArgs, err, string(out))
}
// 1. Real redirected client connection to 127.0.0.2:<echoPort> from 127.0.0.3.
dialer := net.Dialer{
Timeout: 2 * time.Second,
LocalAddr: &net.TCPAddr{IP: net.IPv4(127, 0, 0, 3)},
}
client, err := dialer.Dial("tcp4", fmt.Sprintf("127.0.0.2:%d", echoPort))
if err != nil {
t.Fatalf("dial redirected target: %v", err)
}
msg := []byte("real-so-original-dst-payload")
if _, err := client.Write(msg); err != nil {
t.Fatal(err)
}
if err := client.(*net.TCPConn).CloseWrite(); err != nil {
t.Fatal(err)
}
reply, err := io.ReadAll(client)
if err != nil {
t.Fatal(err)
}
_ = client.Close()
want := append([]byte("NETNS-ECHO:"), msg...)
if !bytes.Equal(reply, want) {
t.Fatalf("redirected reply = %q, want %q", reply, want)
}
// Verify real SO_ORIGINAL_DST recovered 127.0.0.2:<echoPort> and stored raw_tcp_streams row.
streams := waitForRawStreams(t, tr, 1)
st := streams[0]
if st.Protocol != "tcp" || st.Host != "127.0.0.2" || st.Port != echoPort {
t.Fatalf("recorded stream = %+v, want host=127.0.0.2 port=%d", st, echoPort)
}
if st.C2SBytes != int64(len(msg)) || st.S2CBytes != int64(len(want)) {
t.Fatalf("recorded bytes = (%d, %d), want (%d, %d)", st.C2SBytes, st.S2CBytes, len(msg), len(want))
}
var httpCount int
if err := tr.DB().QueryRow(`SELECT COUNT(*) FROM exchanges`).Scan(&httpCount); err != nil || httpCount != 0 {
t.Fatalf("HTTP exchanges = (%d, %v), want 0", httpCount, err)
}
// 2. Direct non-redirected connection to the transparent port must be refused as a self-loop.
direct, err := net.DialTimeout("tcp4", bound, 2*time.Second)
if err != nil {
t.Fatalf("dial direct: %v", err)
}
_ = direct.SetReadDeadline(time.Now().Add(2 * time.Second))
buf := make([]byte, 1)
if _, rerr := direct.Read(buf); rerr == nil {
t.Fatal("expected direct non-redirected connection to transparent port to be refused")
}
_ = direct.Close()
}
+11
View File
@@ -0,0 +1,11 @@
//go:build !linux
package traffic
import "net"
const transparentTCPSupported = false
func originalDstIPv4(_ net.Conn) (net.IP, int, error) {
return nil, 0, ErrTransparentTCPNotLinux
}
+579
View File
@@ -0,0 +1,579 @@
package traffic
import (
"bytes"
"context"
"encoding/binary"
"errors"
"io"
"net"
"os"
"path/filepath"
"runtime"
"strconv"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/egress"
"github.com/Autumn-27/artex/intercept"
)
func makeSockaddrInBytes(family uint16, port uint16, ip [4]byte) []byte {
var raw [sockaddrInSize]byte
binary.NativeEndian.PutUint16(raw[0:2], family)
binary.BigEndian.PutUint16(raw[2:4], port)
copy(raw[4:8], ip[:])
return raw[:]
}
func TestParseOriginalDstIPv4(t *testing.T) {
t.Run("valid_ipv4", func(t *testing.T) {
raw := makeSockaddrInBytes(afInet, 8443, [4]byte{198, 51, 100, 42})
ip, port, err := parseOriginalDstIPv4(raw)
if err != nil {
t.Fatalf("parseOriginalDstIPv4: %v", err)
}
if ip.String() != "198.51.100.42" || port != 8443 {
t.Fatalf("got (%s, %d), want (198.51.100.42, 8443)", ip, port)
}
})
t.Run("valid_port_boundaries", func(t *testing.T) {
for _, wantPort := range []uint16{1, 80, 443, 65535} {
raw := makeSockaddrInBytes(afInet, wantPort, [4]byte{127, 0, 0, 2})
ip, port, err := parseOriginalDstIPv4(raw)
if err != nil || ip.String() != "127.0.0.2" || port != int(wantPort) {
t.Fatalf("port %d: got (%v, %d, %v)", wantPort, ip, port, err)
}
}
})
t.Run("short_buffer", func(t *testing.T) {
for _, n := range []int{0, 2, 8, 15} {
if _, _, err := parseOriginalDstIPv4(make([]byte, n)); err == nil {
t.Fatalf("expected error for %d-byte buffer", n)
}
}
})
t.Run("ipv6_family_rejected", func(t *testing.T) {
raw := makeSockaddrInBytes(10, 443, [4]byte{198, 51, 100, 1})
_, _, err := parseOriginalDstIPv4(raw)
if !errors.Is(err, ErrTransparentTCPIPv6Unsupported) {
t.Fatalf("err = %v, want ErrTransparentTCPIPv6Unsupported", err)
}
})
t.Run("unknown_family_rejected", func(t *testing.T) {
raw := makeSockaddrInBytes(99, 443, [4]byte{198, 51, 100, 1})
if _, _, err := parseOriginalDstIPv4(raw); err == nil {
t.Fatal("expected error for unknown address family")
}
})
t.Run("port_zero_rejected", func(t *testing.T) {
raw := makeSockaddrInBytes(afInet, 0, [4]byte{198, 51, 100, 1})
if _, _, err := parseOriginalDstIPv4(raw); err == nil {
t.Fatal("expected error for port 0")
}
})
t.Run("unspecified_ip_rejected", func(t *testing.T) {
raw := makeSockaddrInBytes(afInet, 80, [4]byte{0, 0, 0, 0})
if _, _, err := parseOriginalDstIPv4(raw); err == nil {
t.Fatal("expected error for 0.0.0.0")
}
})
}
func TestIsSelfRedirect(t *testing.T) {
localLoopback := &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1081}
localAny := &net.TCPAddr{IP: net.IPv4zero, Port: 1081}
cases := []struct {
name string
ip net.IP
port int
local net.Addr
want bool
}{
{"exact_self_loop", net.IPv4(127, 0, 0, 1), 1081, localLoopback, true},
{"wildcard_same_port", net.IPv4(198, 51, 100, 9), 1081, localAny, true},
{"different_port", net.IPv4(127, 0, 0, 1), 8080, localLoopback, false},
{"different_loopback_ip_same_port", net.IPv4(127, 0, 0, 2), 1081, localLoopback, false},
{"wildcard_different_port", net.IPv4(198, 51, 100, 9), 443, localAny, false},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
if got := isSelfRedirect(tc.ip, tc.port, tc.local); got != tc.want {
t.Fatalf("isSelfRedirect(%s:%d, %v) = %v, want %v", tc.ip, tc.port, tc.local, got, tc.want)
}
})
}
}
func TestTransparentTCPFlagOffAndIPv6BindRejected(t *testing.T) {
t.Setenv(TransparentTCPEnabledEnv, "")
t.Setenv(TransparentTCPAddrEnv, "")
if cfg, ok := TransparentTCPConfigFromEnv(); ok || cfg.Addr != "" {
t.Fatalf("default TransparentTCPConfigFromEnv = (%+v, %v), want disabled", cfg, ok)
}
t.Setenv(TransparentTCPEnabledEnv, "0")
t.Setenv(TransparentTCPAddrEnv, "127.0.0.1:1081")
if _, ok := TransparentTCPConfigFromEnv(); ok {
t.Fatal("explicit ARTEX_TRANSPARENT_TCP_ENABLED=0 must stay disabled even when addr is set")
}
t.Setenv(TransparentTCPEnabledEnv, "1")
t.Setenv(TransparentTCPAddrEnv, "")
cfg, ok := TransparentTCPConfigFromEnv()
if !ok || cfg.Addr != DefaultTransparentTCPAddr {
t.Fatalf("enabled default = (%+v, %v), want (%s, true)", cfg, ok, DefaultTransparentTCPAddr)
}
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
if got := tr.TransparentTCPAddr(); got != "" {
t.Fatalf("TransparentTCPAddr with flag off = %q, want empty", got)
}
// IPv6 bind address must be rejected explicitly (P4.1b covers IPv4 only).
if _, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "[::1]:0",
origDst: func(net.Conn) (net.IP, int, error) { return net.IPv4(127, 0, 0, 1), 80, nil },
}); !errors.Is(err, ErrTransparentTCPIPv6Unsupported) {
t.Fatalf("IPv6 bind err = %v, want ErrTransparentTCPIPv6Unsupported", err)
}
}
func TestTransparentTCPRelayHalfCloseAndStoreRow(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
// Echo-after-EOF server to verify bidirectional half-close propagation.
ln, err := net.Listen("tcp4", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer ln.Close()
go func() {
for {
c, err := ln.Accept()
if err != nil {
return
}
go func(conn net.Conn) {
defer conn.Close()
req, _ := io.ReadAll(conn)
_, _ = conn.Write(append([]byte("TPROXY-REPLY:"), req...))
}(c)
}
}()
echoAddr := ln.Addr().(*net.TCPAddr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
listenAddr, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "127.0.0.1:0",
origDst: func(net.Conn) (net.IP, int, error) {
return echoAddr.IP.To4(), echoAddr.Port, nil
},
})
if err != nil {
t.Fatal(err)
}
c, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
defer c.Close()
payload := []byte("hello-transparent-tcp")
if _, err := c.Write(payload); err != nil {
t.Fatal(err)
}
if err := c.(*net.TCPConn).CloseWrite(); err != nil {
t.Fatal(err)
}
got, err := io.ReadAll(c)
if err != nil {
t.Fatal(err)
}
want := append([]byte("TPROXY-REPLY:"), payload...)
if !bytes.Equal(got, want) {
t.Fatalf("reply = %q, want %q", got, want)
}
_ = c.Close()
streams := waitForRawStreams(t, tr, 1)
s := streams[0]
if s.Protocol != "tcp" || s.Host != "127.0.0.1" || s.Port != echoAddr.Port {
t.Fatalf("unexpected stream metadata: %+v", s)
}
if s.C2SBytes != int64(len(payload)) || s.S2CBytes != int64(len(want)) || s.Truncated {
t.Fatalf("unexpected stream counters: %+v", s)
}
if !bytes.Equal(s.C2SPreview, payload) || !bytes.Equal(s.S2CPreview, want) {
t.Fatalf("preview mismatch: c2s=%q s2c=%q", s.C2SPreview, s.S2CPreview)
}
// Raw TCP stream must NEVER create an HTTP exchanges row.
var httpRows int
if err := tr.DB().QueryRow(`SELECT COUNT(*) FROM exchanges`).Scan(&httpRows); err != nil {
t.Fatal(err)
}
if httpRows != 0 {
t.Fatalf("HTTP exchanges rows = %d, want 0", httpRows)
}
}
func TestTransparentTCPMalformedOrigDstAndSelfLoopRefusedBeforeDial(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
cases := []struct {
name string
origDst func(listenAddr *net.TCPAddr) func(net.Conn) (net.IP, int, error)
}{
{
name: "getsockopt_error",
origDst: func(*net.TCPAddr) func(net.Conn) (net.IP, int, error) {
return func(net.Conn) (net.IP, int, error) { return nil, 0, errors.New("ENOENT") }
},
},
{
name: "ipv6_orig_dst_rejected",
origDst: func(*net.TCPAddr) func(net.Conn) (net.IP, int, error) {
return func(net.Conn) (net.IP, int, error) { return net.ParseIP("2001:db8::1"), 443, nil }
},
},
{
name: "port_zero_rejected",
origDst: func(*net.TCPAddr) func(net.Conn) (net.IP, int, error) {
return func(net.Conn) (net.IP, int, error) { return net.IPv4(198, 51, 100, 1), 0, nil }
},
},
{
name: "unspecified_ip_rejected",
origDst: func(*net.TCPAddr) func(net.Conn) (net.IP, int, error) {
return func(net.Conn) (net.IP, int, error) { return net.IPv4zero, 80, nil }
},
},
{
name: "self_loop_rejected",
origDst: func(lnAddr *net.TCPAddr) func(net.Conn) (net.IP, int, error) {
return func(net.Conn) (net.IP, int, error) { return lnAddr.IP.To4(), lnAddr.Port, nil }
},
},
}
baseGoroutines := runtime.NumGoroutine()
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
var dialCalls atomic.Int32
var boundTCP atomic.Pointer[net.TCPAddr]
listenAddr, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "127.0.0.1:0",
HandshakeTimeout: 500 * time.Millisecond,
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
dialCalls.Add(1)
return nil, errors.New("must not dial")
},
origDst: func(c net.Conn) (net.IP, int, error) {
return tc.origDst(boundTCP.Load())(c)
},
})
if err != nil {
t.Fatal(err)
}
la, err := net.ResolveTCPAddr("tcp4", listenAddr)
if err != nil {
t.Fatal(err)
}
boundTCP.Store(la)
c, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
_ = c.SetReadDeadline(time.Now().Add(2 * time.Second))
buf := make([]byte, 1)
if _, rerr := c.Read(buf); rerr == nil {
t.Fatal("expected connection to be closed on malformed/self-loop origDst")
}
_ = c.Close()
if dialCalls.Load() != 0 {
t.Fatalf("DialContext called %d times, want 0", dialCalls.Load())
}
n, err := tr.CountRawTCPStreams("")
if err != nil || n != 0 {
t.Fatalf("CountRawTCPStreams = (%d, %v), want 0", n, err)
}
})
}
deadline := time.Now().Add(2 * time.Second)
for time.Now().Before(deadline) {
if runtime.NumGoroutine() <= baseGoroutines+10 {
return
}
time.Sleep(25 * time.Millisecond)
}
if after := runtime.NumGoroutine(); after > baseGoroutines+10 {
t.Fatalf("possible goroutine leak: before=%d after=%d", baseGoroutines, after)
}
}
func TestTransparentTCPDeniedTargetAndGovernorRefusedBeforeDial(t *testing.T) {
t.Run("target_gate_refuses_before_dial", func(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
echo, accepted := startEchoServer(t, "tcp4", "127.0.0.1:0")
echoAddr := echo.Addr().(*net.TCPAddr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
// Use intercept.PinnedDialer with a gated TargetScope whose Interceptor is nil:
// PinnedDialer refuses BEFORE dialing any socket.
listenAddr, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "127.0.0.1:0",
BaseContext: func() context.Context {
return intercept.WithTargetScope(context.Background(), intercept.TargetScope{
TaskID: "99",
Enabled: func() bool { return true },
})
},
DialContext: intercept.PinnedDialer("transparent", true),
origDst: func(net.Conn) (net.IP, int, error) {
return echoAddr.IP.To4(), echoAddr.Port, nil
},
})
if err != nil {
t.Fatal(err)
}
c, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
_ = c.SetReadDeadline(time.Now().Add(2 * time.Second))
buf := make([]byte, 1)
if _, rerr := c.Read(buf); rerr == nil {
t.Fatal("expected blocked target connection to close immediately")
}
_ = c.Close()
if accepted.Load() != 0 {
t.Fatalf("target accepted %d connections despite target gate refusal, want 0", accepted.Load())
}
n, err := tr.CountRawTCPStreams("")
if err != nil || n != 0 {
t.Fatalf("CountRawTCPStreams = (%d, %v), want 0", n, err)
}
})
t.Run("governor_refuses_before_dial", func(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
// 1 token burst, very slow refill: 2nd connection exceeds PaceTimeout and is refused BEFORE dial.
egress.SetProfile(egress.Profile{Name: "tight", RPS: 0.01, Burst: 1, MaxPerHost: 1, MaxGlobal: 1})
echo, _ := startEchoServer(t, "tcp4", "127.0.0.1:0")
echoAddr := echo.Addr().(*net.TCPAddr)
var dialCalls atomic.Int32
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
listenAddr, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "127.0.0.1:0",
PaceTimeout: 40 * time.Millisecond,
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
dialCalls.Add(1)
return (&net.Dialer{Timeout: 2 * time.Second}).DialContext(ctx, network, addr)
},
origDst: func(net.Conn) (net.IP, int, error) {
return echoAddr.IP.To4(), echoAddr.Port, nil
},
})
if err != nil {
t.Fatal(err)
}
// 1st connection consumes the single burst token.
c1, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
_, _ = c1.Write([]byte("ok"))
buf2 := make([]byte, 2)
if _, err := io.ReadFull(c1, buf2); err != nil {
t.Fatalf("first connection failed: %v", err)
}
_ = c1.Close()
// 2nd connection exceeds PaceTimeout inside egress.Do and is refused BEFORE dial.
before := dialCalls.Load()
c2, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
_ = c2.SetReadDeadline(time.Now().Add(2 * time.Second))
one := make([]byte, 1)
if _, rerr := c2.Read(one); rerr == nil {
t.Fatal("expected governor-refused connection to close")
}
_ = c2.Close()
if dialCalls.Load() != before {
t.Fatalf("DialContext called despite governor refusal (before=%d after=%d)", before, dialCalls.Load())
}
})
}
func TestTransparentTCPByteCapsTruncationBlobSpillAndConcurrency(t *testing.T) {
prev := egress.CurrentProfile()
t.Cleanup(func() { egress.SetProfile(prev) })
egress.SetProfile(egress.Profile{Name: "off"})
echo, _ := startEchoServer(t, "tcp4", "127.0.0.1:0")
echoAddr := echo.Addr().(*net.TCPAddr)
tr, err := Open(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer tr.Close()
listenAddr, err := tr.StartTransparentTCP(TransparentTCPConfig{
Addr: "127.0.0.1:0",
MaxConcurrent: 2,
MaxBytesPerDir: 512,
PreviewBytes: 64,
IdleTimeout: 200 * time.Millisecond,
origDst: func(net.Conn) (net.IP, int, error) {
return echoAddr.IP.To4(), echoAddr.Port, nil
},
})
if err != nil {
t.Fatal(err)
}
// 1. Oversized stream -> truncated=true, preview=64, blob spilled atomically with blob_refs.
c, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
big := bytes.Repeat([]byte("TP"), 512) // 1024 bytes > MaxBytesPerDir(512) > PreviewBytes(64)
if _, err := c.Write(big); err != nil {
t.Fatal(err)
}
if err := c.(*net.TCPConn).CloseWrite(); err != nil {
t.Fatal(err)
}
got, err := io.ReadAll(c)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(got, big) {
t.Fatalf("relayed %d bytes, want %d", len(got), len(big))
}
_ = c.Close()
streams := waitForRawStreams(t, tr, 1)
st := streams[0]
if !st.Truncated || st.C2SBytes != 1024 || st.S2CBytes != 1024 {
t.Fatalf("unexpected truncation/counts: %+v", st)
}
if len(st.C2SPreview) != 64 || st.C2SBlob == "" || st.S2CBlob == "" {
t.Fatalf("expected 64-byte preview and blob hashes: %+v", st)
}
blobFile := filepath.Join(tr.dir, "_blobs", "sha256", st.C2SBlob[:2], st.C2SBlob+".bin")
blobBytes, err := os.ReadFile(blobFile)
if err != nil || len(blobBytes) != 512 {
t.Fatalf("blob file (%s): len=%d err=%v, want 512", blobFile, len(blobBytes), err)
}
var refs int
if err := tr.DB().QueryRow(`SELECT COUNT(*) FROM blob_refs WHERE exchange_id = ?`, st.ID).Scan(&refs); err != nil || refs < 1 {
t.Fatalf("blob_refs for %s = (%d, %v), want >= 1", st.ID, refs, err)
}
// 2. MaxConcurrent=2 + IdleTimeout: hold 2 active streams, verify 3rd is rejected cleanly.
c1, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
defer c1.Close()
c2, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
defer c2.Close()
// Send one byte on each so both goroutines acquire semaphore slots.
var wg sync.WaitGroup
wg.Add(2)
for _, conn := range []net.Conn{c1, c2} {
go func(cn net.Conn) {
defer wg.Done()
_, _ = cn.Write([]byte("hi"))
buf := make([]byte, 2)
_, _ = io.ReadFull(cn, buf)
}(conn)
}
wg.Wait()
c3, err := net.DialTimeout("tcp4", listenAddr, 2*time.Second)
if err != nil {
t.Fatal(err)
}
_ = c3.SetReadDeadline(time.Now().Add(2 * time.Second))
one := make([]byte, 1)
if _, rerr := c3.Read(one); rerr == nil {
t.Fatal("expected 3rd concurrent stream beyond MaxConcurrent=2 to close")
}
_ = c3.Close()
// IdleTimeout closes c1 and c2 cleanly.
_ = c1.SetReadDeadline(time.Now().Add(2 * time.Second))
if _, rerr := c1.Read(one); rerr == nil {
t.Fatal("expected idle stream to close after IdleTimeout")
}
_ = c1.Close()
_ = c2.Close()
all := waitForRawStreams(t, tr, 3)
if len(all) != 3 {
t.Fatalf("want 3 recorded streams (1 big + 2 concurrent), got %d", len(all))
}
_ = strconv.Itoa(len(all))
}
+1 -1
View File
@@ -56,7 +56,7 @@ update_local(){
if command -v npm >/dev/null 2>&1; then
info "Rebuilding 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 "Recompiling the embedded single binary…"
CGO_ENABLED=0 go build -tags embedui -trimpath -o artex ./cmd/artex
+1 -321
View File
@@ -11,51 +11,33 @@
"@antv/g6": "^5.1.1",
"@base-ui/react": "^1.6.0",
"@dnd-kit/core": "^6.3.1",
"@dnd-kit/modifiers": "^9.0.0",
"@dnd-kit/sortable": "^10.0.0",
"@fullcalendar/react": "^7.0.0",
"@hookform/resolvers": "^5.4.0",
"@shadcn/react": "^0.1.0",
"@tanstack/react-table": "^8.21.3",
"@xyflow/react": "^12.3.0",
"class-variance-authority": "^0.7.1",
"clsx": "^2.1.1",
"cmdk": "^1.1.1",
"d3-geo": "^3.1.1",
"date-fns": "^4.4.0",
"embla-carousel-react": "^8.6.0",
"geist": "^1.7.2",
"input-otp": "^1.4.2",
"lucide-react": "^1.22.0",
"next": "^16.4.6",
"next-themes": "^0.4.6",
"radix-ui": "^1.6.0",
"react": "^19.2.7",
"react-day-picker": "^10.0.1",
"react-dom": "^19.2.7",
"react-hook-form": "^7.80.0",
"react-is": "^19.2.7",
"react-markdown": "^10.1.0",
"react-resizable-panels": "^4.12.0",
"recharts": "^3.8.0",
"remark-gfm": "^4.0.1",
"simple-icons": "^16.24.1",
"sonner": "^2.0.7",
"tailwind-merge": "^3.6.0",
"temporal-polyfill": "^1.0.1",
"topojson-client": "^3.1.0",
"vaul": "^1.1.2",
"zod": "^4.4.3",
"zustand": "^5.0.14"
},
"devDependencies": {
"@biomejs/biome": "^2.5.1",
"@tailwindcss/postcss": "^4.3.2",
"@types/d3-geo": "^3.1.0",
"@types/node": "^22.20.0",
"@types/react": "^19.2.17",
"@types/react-dom": "^19.2.3",
"@types/topojson-client": "^3.1.5",
"babel-plugin-react-compiler": "^1.0.0",
"husky": "^9.1.7",
"lint-staged": "^16.4.0",
@@ -1004,12 +986,6 @@
"@jridgewell/sourcemap-codec": "^1.4.10"
}
},
"node_modules/@date-fns/tz": {
"version": "1.5.0",
"resolved": "https://registry.npmjs.org/@date-fns/tz/-/tz-1.5.0.tgz",
"integrity": "sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==",
"license": "MIT"
},
"node_modules/@dnd-kit/accessibility": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
@@ -1037,34 +1013,6 @@
"react-dom": ">=16.8.0"
}
},
"node_modules/@dnd-kit/modifiers": {
"version": "9.0.0",
"resolved": "https://registry.npmjs.org/@dnd-kit/modifiers/-/modifiers-9.0.0.tgz",
"integrity": "sha512-ybiLc66qRGuZoC20wdSSG6pDXFikui/dCNGthxv4Ndy8ylErY0N3KVxY2bgo7AWwIbxDmXDg3ylAFmnrjcbVvw==",
"license": "MIT",
"dependencies": {
"@dnd-kit/utilities": "^3.2.2",
"tslib": "^2.0.0"
},
"peerDependencies": {
"@dnd-kit/core": "^6.3.0",
"react": ">=16.8.0"
}
},
"node_modules/@dnd-kit/sortable": {
"version": "10.0.0",
"resolved": "https://registry.npmjs.org/@dnd-kit/sortable/-/sortable-10.0.0.tgz",
"integrity": "sha512-+xqhmIIzvAYMGfBYYnbKuNicfSsk4RksY2XdmJhT+HAC01nix6fHCztU68jooFiMUB01Ky3F0FyOvhG/BZrWkg==",
"license": "MIT",
"dependencies": {
"@dnd-kit/utilities": "^3.2.2",
"tslib": "^2.0.0"
},
"peerDependencies": {
"@dnd-kit/core": "^6.3.0",
"react": ">=16.8.0"
}
},
"node_modules/@dnd-kit/utilities": {
"version": "3.2.2",
"resolved": "https://registry.npmjs.org/@dnd-kit/utilities/-/utilities-3.2.2.tgz",
@@ -1346,40 +1294,6 @@
"integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==",
"license": "MIT"
},
"node_modules/@full-ui/headless-calendar": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/@full-ui/headless-calendar/-/headless-calendar-7.0.0.tgz",
"integrity": "sha512-47Y2NoiSt/DJy/+PD9yv4OLhaVJqn8oknFXhS6kiMnoXSOiYkoz6gqVIOCF2nvvQPqKUepb3W3403Qj34QfjtQ==",
"license": "MIT",
"peerDependencies": {
"temporal-polyfill": "^1.0.1"
}
},
"node_modules/@fullcalendar/core": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/@fullcalendar/core/-/core-7.0.0.tgz",
"integrity": "sha512-cZobng3rB7PQp8zdRp7SIeA4ZEvOWhnwHuFWQf3xXIM9BPfmKb5EFhpiNHCT6zzn041A2wv9ztqiQ60S1sY5KA==",
"license": "MIT",
"peerDependencies": {
"@full-ui/headless-calendar": "7.0.0",
"temporal-polyfill": "^1.0.1"
}
},
"node_modules/@fullcalendar/react": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/@fullcalendar/react/-/react-7.0.0.tgz",
"integrity": "sha512-klabENcKYXPom8UB8eTzLSaSNeB/gpe11XVBOnjnsVmOJqLftnkBBQXtAF6lFuXQrj0goHdIan8xicOTLJhSeA==",
"license": "MIT",
"dependencies": {
"@full-ui/headless-calendar": "7.0.0",
"@fullcalendar/core": "7.0.0"
},
"peerDependencies": {
"react": "^17 || ^18 || ^19",
"react-dom": "^17 || ^18 || ^19",
"temporal-polyfill": "^1.0.1"
}
},
"node_modules/@hono/node-server": {
"version": "1.19.14",
"resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.14.tgz",
@@ -1393,18 +1307,6 @@
"hono": "^4"
}
},
"node_modules/@hookform/resolvers": {
"version": "5.4.0",
"resolved": "https://registry.npmjs.org/@hookform/resolvers/-/resolvers-5.4.0.tgz",
"integrity": "sha512-EIsqr/t/qbinPIhGjMdtvutIN1Kk4uwbROE9/UQ93CAVGR7GkA7Y92+fX80OzXi/OB67jVFYwKGO1WzkxmkFZw==",
"license": "MIT",
"dependencies": {
"@standard-schema/utils": "^0.3.0"
},
"peerDependencies": {
"react-hook-form": "^7.55.0"
}
},
"node_modules/@img/colour": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
@@ -3765,24 +3667,6 @@
"dev": true,
"license": "MIT"
},
"node_modules/@shadcn/react": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/@shadcn/react/-/react-0.1.0.tgz",
"integrity": "sha512-6i67TEnqValsZY7e4exJ4rkHo2OdHXmDH152YulwSpuEUnTQYumHkXzFsaje7HB7GbMTWuI9x1Jn6sSduCYdeA==",
"license": "MIT",
"peerDependencies": {
"@types/react": ">=19",
"react": ">=19"
},
"peerDependenciesMeta": {
"@types/react": {
"optional": true
},
"react": {
"optional": true
}
}
},
"node_modules/@sindresorhus/merge-streams": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz",
@@ -4088,39 +3972,6 @@
"tailwindcss": "4.3.2"
}
},
"node_modules/@tanstack/react-table": {
"version": "8.21.3",
"resolved": "https://registry.npmjs.org/@tanstack/react-table/-/react-table-8.21.3.tgz",
"integrity": "sha512-5nNMTSETP4ykGegmVkhjcS8tTLW6Vl4axfEGQN3v0zdHYbK4UfoqfPChclTrJ4EoK9QynqAu9oUf8VEmrpZ5Ww==",
"license": "MIT",
"dependencies": {
"@tanstack/table-core": "8.21.3"
},
"engines": {
"node": ">=12"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/tannerlinsley"
},
"peerDependencies": {
"react": ">=16.8",
"react-dom": ">=16.8"
}
},
"node_modules/@tanstack/table-core": {
"version": "8.21.3",
"resolved": "https://registry.npmjs.org/@tanstack/table-core/-/table-core-8.21.3.tgz",
"integrity": "sha512-ldZXEhOBb8Is7xLs01fR3YEc3DERiz5silj8tnGkFZytt1abEvl/GhUmCE0PMLaMPTa3Jk4HbKmRlHmu+gCftg==",
"license": "MIT",
"engines": {
"node": ">=12"
},
"funding": {
"type": "github",
"url": "https://github.com/sponsors/tannerlinsley"
}
},
"node_modules/@ts-morph/common": {
"version": "0.27.0",
"resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.27.0.tgz",
@@ -4407,27 +4258,6 @@
"@types/react": "^19.2.0"
}
},
"node_modules/@types/topojson-client": {
"version": "3.1.5",
"resolved": "https://registry.npmjs.org/@types/topojson-client/-/topojson-client-3.1.5.tgz",
"integrity": "sha512-C79rySTyPxnQNNguTZNI1Ct4D7IXgvyAs3p9HPecnl6mNrJ5+UhvGNYcZfpROYV2lMHI48kJPxwR+F9C6c7nmw==",
"dev": true,
"license": "MIT",
"dependencies": {
"@types/geojson": "*",
"@types/topojson-specification": "*"
}
},
"node_modules/@types/topojson-specification": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/@types/topojson-specification/-/topojson-specification-1.0.5.tgz",
"integrity": "sha512-C7KvcQh+C2nr6Y2Ub4YfgvWvWCgP2nOQMtfhlnwsRL4pYmmwzBS7HclGiS87eQfDOU/DLQpX6GEscviaz4yLIQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"@types/geojson": "*"
}
},
"node_modules/@types/unist": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
@@ -5799,16 +5629,6 @@
"lodash": "^4.17.15"
}
},
"node_modules/date-fns": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.4.0.tgz",
"integrity": "sha512-+1UMbeh68lH1SegH83CGWwpb6OHHbpSgr3+s5Eww5M4CAgswBpoWS0AjTOfEJ33HiYKz1hdj/KTFprzXHmq/6w==",
"license": "MIT",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/kossnocorp"
}
},
"node_modules/debounce-fn": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/debounce-fn/-/debounce-fn-4.0.0.tgz",
@@ -6045,34 +5865,6 @@
"dev": true,
"license": "ISC"
},
"node_modules/embla-carousel": {
"version": "8.6.0",
"resolved": "https://registry.npmjs.org/embla-carousel/-/embla-carousel-8.6.0.tgz",
"integrity": "sha512-SjWyZBHJPbqxHOzckOfo8lHisEaJWmwd23XppYFYVh10bU66/Pn5tkVkbkCMZVdbUE5eTCI2nD8OyIP4Z+uwkA==",
"license": "MIT"
},
"node_modules/embla-carousel-react": {
"version": "8.6.0",
"resolved": "https://registry.npmjs.org/embla-carousel-react/-/embla-carousel-react-8.6.0.tgz",
"integrity": "sha512-0/PjqU7geVmo6F734pmPqpyHqiM99olvyecY7zdweCw+6tKEXnrE90pBiBbMMU8s5tICemzpQ3hi5EpxzGW+JA==",
"license": "MIT",
"dependencies": {
"embla-carousel": "8.6.0",
"embla-carousel-reactive-utils": "8.6.0"
},
"peerDependencies": {
"react": "^16.8.0 || ^17.0.1 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
}
},
"node_modules/embla-carousel-reactive-utils": {
"version": "8.6.0",
"resolved": "https://registry.npmjs.org/embla-carousel-reactive-utils/-/embla-carousel-reactive-utils-8.6.0.tgz",
"integrity": "sha512-fMVUDUEx0/uIEDM0Mz3dHznDhfX+znCCDCeIophYb1QGVM7YThSWX+wz11zlYwWFOr74b4QLGg0hrGPJeG2s4A==",
"license": "MIT",
"peerDependencies": {
"embla-carousel": "8.6.0"
}
},
"node_modules/emoji-regex": {
"version": "10.6.0",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
@@ -6966,16 +6758,6 @@
"integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
"license": "MIT"
},
"node_modules/input-otp": {
"version": "1.4.2",
"resolved": "https://registry.npmjs.org/input-otp/-/input-otp-1.4.2.tgz",
"integrity": "sha512-l3jWwYNvrEa6NTCt7BECfCm48GvwuZzkoeG3gBL2w4CHeOXW3eKFmf9UNYkNfYc3mxMrthMnxjIE07MT0zLBQA==",
"license": "MIT",
"peerDependencies": {
"react": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc",
"react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0.0 || ^19.0.0-rc"
}
},
"node_modules/internmap": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
@@ -9608,32 +9390,6 @@
"node": ">=0.10.0"
}
},
"node_modules/react-day-picker": {
"version": "10.0.1",
"resolved": "https://registry.npmjs.org/react-day-picker/-/react-day-picker-10.0.1.tgz",
"integrity": "sha512-eNh6BlwcYInWaJtRv18mXQ06Ys/H6rdTZAnTaSdOYJuTpwP1JMCHNd1FDRadA+gbeinq+psdULN5Xnowy9mV8w==",
"license": "MIT",
"dependencies": {
"@date-fns/tz": "^1.4.1",
"date-fns": "^4.1.0"
},
"engines": {
"node": ">=18"
},
"funding": {
"type": "individual",
"url": "https://github.com/sponsors/gpbl"
},
"peerDependencies": {
"@types/react": ">=16.8.0",
"react": ">=16.8.0"
},
"peerDependenciesMeta": {
"@types/react": {
"optional": true
}
}
},
"node_modules/react-dom": {
"version": "19.2.7",
"resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz",
@@ -9646,22 +9402,6 @@
"react": "^19.2.7"
}
},
"node_modules/react-hook-form": {
"version": "7.80.0",
"resolved": "https://registry.npmjs.org/react-hook-form/-/react-hook-form-7.80.0.tgz",
"integrity": "sha512-4P+fk6oXsxY+6xSj7Euhc2sumQD8zQqCuVHoJwoyp9EchP+IUW9OESB7uHFJOKsIBQ4MQqYE84INJFqUCYNoOg==",
"license": "MIT",
"engines": {
"node": ">=18.0.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/react-hook-form"
},
"peerDependencies": {
"react": "^16.8.0 || ^17 || ^18 || ^19"
}
},
"node_modules/react-is": {
"version": "19.2.7",
"resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.7.tgz",
@@ -10360,25 +10100,6 @@
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/simple-icons": {
"version": "16.24.1",
"resolved": "https://registry.npmjs.org/simple-icons/-/simple-icons-16.24.1.tgz",
"integrity": "sha512-AnDQPrZAVzYSym7cBVIrnbhLk9auWGgkl+9hKvkbTqGEfH6TU7WKgumEXYYaJuM1Ib87+cnzr881UZniCM7t+A==",
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/simple-icons"
},
{
"type": "github",
"url": "https://github.com/sponsors/simple-icons"
}
],
"license": "CC0-1.0",
"engines": {
"node": ">=0.12.18"
}
},
"node_modules/simple-swizzle": {
"version": "0.2.4",
"resolved": "https://registry.npmjs.org/simple-swizzle/-/simple-swizzle-0.2.4.tgz",
@@ -10696,28 +10417,6 @@
"url": "https://opencollective.com/webpack"
}
},
"node_modules/temporal-polyfill": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/temporal-polyfill/-/temporal-polyfill-1.0.1.tgz",
"integrity": "sha512-N2SoI9olnW7BUsU8RosDphZQl9s+WJ8O7PoJMFCr/e5/1rFkVI4GNOWaSeySG+UoP04foPYsnLWbJmbXOiShZg==",
"license": "MIT",
"dependencies": {
"temporal-spec": "1.0.0",
"temporal-utils": "1.0.1"
}
},
"node_modules/temporal-spec": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/temporal-spec/-/temporal-spec-1.0.0.tgz",
"integrity": "sha512-00Ahj1e1ifaERTMOIIGpOCdOo9IEk2m6GGSMedsn9a2SIsGLdOTbmME1Htv6IM82b6VHrzSUTIVc7YHy6hdhFQ==",
"license": "Apache-2.0"
},
"node_modules/temporal-utils": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/temporal-utils/-/temporal-utils-1.0.1.tgz",
"integrity": "sha512-HAixuesxFQIUaQk3ptX2jhfO/FsOkgVkDDMawvp6n/fkB1q6BKfs3lURw9I+pK/2e2e/q/vrLrxmeqauBoyGMQ==",
"license": "MIT"
},
"node_modules/text-segmentation": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/text-segmentation/-/text-segmentation-1.0.3.tgz",
@@ -10766,26 +10465,6 @@
"node": ">=0.6"
}
},
"node_modules/topojson-client": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/topojson-client/-/topojson-client-3.1.0.tgz",
"integrity": "sha512-605uxS6bcYxGXw9qi62XyrV6Q3xwbndjachmNxu8HWTtVPxZfEJN9fd/SZS1Q54Sn2y0TMyMxFj/cJINqGHrKw==",
"license": "ISC",
"dependencies": {
"commander": "2"
},
"bin": {
"topo2geo": "bin/topo2geo",
"topomerge": "bin/topomerge",
"topoquantize": "bin/topoquantize"
}
},
"node_modules/topojson-client/node_modules/commander": {
"version": "2.20.3",
"resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
"integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
"license": "MIT"
},
"node_modules/trim-lines": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
@@ -11417,6 +11096,7 @@
"version": "4.4.3",
"resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
"integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
"dev": true,
"license": "MIT",
"funding": {
"url": "https://github.com/sponsors/colinhacks"
+1 -19
View File
@@ -16,7 +16,7 @@
"test:polling": "node --test scripts/polling.test.mjs",
"test:replay": "node --test scripts/replay.test.mjs",
"test:upload": "node --test scripts/upload.test.mjs",
"test:i18n": "node scripts/check-i18n.mjs"
"test:i18n": "node scripts/check-i18n.mjs && node --test scripts/i18n.test.mjs"
},
"lint-staged": {
"*.{js,ts,jsx,tsx}": [
@@ -27,51 +27,33 @@
"@antv/g6": "^5.1.1",
"@base-ui/react": "^1.6.0",
"@dnd-kit/core": "^6.3.1",
"@dnd-kit/modifiers": "^9.0.0",
"@dnd-kit/sortable": "^10.0.0",
"@fullcalendar/react": "^7.0.0",
"@hookform/resolvers": "^5.4.0",
"@shadcn/react": "^0.1.0",
"@tanstack/react-table": "^8.21.3",
"@xyflow/react": "^12.3.0",
"class-variance-authority": "^0.7.1",
"clsx": "^2.1.1",
"cmdk": "^1.1.1",
"d3-geo": "^3.1.1",
"date-fns": "^4.4.0",
"embla-carousel-react": "^8.6.0",
"geist": "^1.7.2",
"input-otp": "^1.4.2",
"lucide-react": "^1.22.0",
"next": "^16.4.6",
"next-themes": "^0.4.6",
"radix-ui": "^1.6.0",
"react": "^19.2.7",
"react-day-picker": "^10.0.1",
"react-dom": "^19.2.7",
"react-hook-form": "^7.80.0",
"react-is": "^19.2.7",
"react-markdown": "^10.1.0",
"react-resizable-panels": "^4.12.0",
"recharts": "^3.8.0",
"remark-gfm": "^4.0.1",
"simple-icons": "^16.24.1",
"sonner": "^2.0.7",
"tailwind-merge": "^3.6.0",
"temporal-polyfill": "^1.0.1",
"topojson-client": "^3.1.0",
"vaul": "^1.1.2",
"zod": "^4.4.3",
"zustand": "^5.0.14"
},
"devDependencies": {
"@biomejs/biome": "^2.5.1",
"@tailwindcss/postcss": "^4.3.2",
"@types/d3-geo": "^3.1.0",
"@types/node": "^22.20.0",
"@types/react": "^19.2.17",
"@types/react-dom": "^19.2.3",
"@types/topojson-client": "^3.1.5",
"babel-plugin-react-compiler": "^1.0.0",
"husky": "^9.1.7",
"lint-staged": "^16.4.0",
+27 -30
View File
@@ -2,11 +2,14 @@ import { readFileSync, readdirSync, statSync } from "node:fs";
import { dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
// Every literal t("...") / t('...') key must exist in the locale dictionary
// with the same {placeholders}. Dynamic keys (variables, template literals
// with ${}) are skipped: there is nothing to compare them against.
// English source text is the key. Check every shipped dictionary, including
// dynamic entries, while retaining the existing literal-call coverage check.
const root = join(dirname(fileURLToPath(import.meta.url)), "..");
const dict = JSON.parse(readFileSync(join(root, "src/i18n/locales/tr.json"), "utf8"));
const localeDir = join(root, "src/i18n/locales");
const dictionaries = readdirSync(localeDir)
.filter((name) => name.endsWith(".json"))
.sort()
.map((name) => [name, JSON.parse(readFileSync(join(localeDir, name), "utf8"))]);
const files = [];
function walk(dir) {
@@ -19,7 +22,7 @@ function walk(dir) {
}
walk(join(root, "src"));
const calls = new Map(); // key -> first file that uses it
const calls = new Map();
const literalCall = /(?:^|[^\w$.])t\(\s*(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)')/gm;
for (const file of files) {
const src = readFileSync(file, "utf8");
@@ -31,34 +34,28 @@ for (const file of files) {
}
function placeholders(s) {
return [...s.matchAll(/\{(\w+)\}/g)]
.map((m) => m[1])
.sort()
.join(",");
return [...s.matchAll(/\{(\w+)\}/g)].map((m) => m[1]).sort().join(",");
}
const missing = [];
const mismatch = [];
for (const [key, file] of calls) {
if (!Object.prototype.hasOwnProperty.call(dict, key)) {
missing.push(`${file}: ${JSON.stringify(key)}`);
continue;
}
if (placeholders(dict[key]) !== placeholders(key)) {
mismatch.push(`${JSON.stringify(key)}: source {${placeholders(key)}} dict {${placeholders(dict[key])}}`);
const allKeys = new Set(dictionaries.flatMap(([, dict]) => Object.keys(dict)));
const errors = [];
if (!dictionaries.length) errors.push("No locale dictionaries found");
for (const [name, dict] of dictionaries) {
for (const key of new Set([...allKeys, ...calls.keys()])) {
if (!Object.prototype.hasOwnProperty.call(dict, key)) {
errors.push(`${name}: missing ${JSON.stringify(key)} (${calls.get(key) ?? "dictionary parity"})`);
continue;
}
const value = dict[key];
if (typeof value !== "string" || !value.trim()) {
errors.push(`${name}: empty or non-string value for ${JSON.stringify(key)}`);
} else if (placeholders(value) !== placeholders(key)) {
errors.push(`${name}: placeholder mismatch for ${JSON.stringify(key)}`);
}
}
console.log(`i18n: ${calls.size} literal keys checked against ${Object.keys(dict).length} ${name} entries`);
}
if (missing.length || mismatch.length) {
if (missing.length) {
console.error(`Missing tr.json entries (${missing.length}):\n${missing.join("\n")}`);
}
if (mismatch.length) {
console.error(`Placeholder mismatches (${mismatch.length}):\n${mismatch.join("\n")}`);
}
if (errors.length) {
console.error(errors.join("\n"));
process.exit(1);
}
console.log(
`i18n: ${calls.size} literal keys checked against ${Object.keys(dict).length} tr.json entries`,
);
+93
View File
@@ -0,0 +1,93 @@
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { createRequire } from "node:module";
import test from "node:test";
import vm from "node:vm";
import ts from "typescript";
const sourceURL = new URL("../src/i18n/index.ts", import.meta.url);
const require = createRequire(sourceURL);
const code = ts.transpileModule(readFileSync(sourceURL, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, esModuleInterop: true },
}).outputText;
function load({ saved = null, languages = ["en-US"], language = "en-US", blocked = false, server = false } = {}) {
const writes = [];
let reloads = 0;
const context = { exports: {}, require };
if (!server) {
context.document = { documentElement: { lang: "en" } };
context.window = {
localStorage: {
getItem(key) {
assert.equal(key, "artex.locale");
if (blocked) throw new Error("Storage blocked");
return saved;
},
setItem(key, value) {
if (blocked) throw new Error("Storage blocked");
writes.push([key, value]);
},
},
navigator: { languages, language },
location: { reload: () => { reloads++; } },
};
}
vm.runInNewContext(code, context, { filename: "i18n/index.js" });
return { api: context.exports, document: context.document, writes, reloads: () => reloads };
}
test("static export remains English and unknown keys fall back safely", () => {
const { api } = load({ server: true });
assert.equal(api.locale, "en");
assert.equal(api.intlLocale, "en-US");
assert.equal(api.t("Unknown {value}", { value: 3 }), "Unknown 3");
});
test("saved Chinese preference wins and sets the document and Intl locale", () => {
const { api, document } = load({ saved: "zh-CN", languages: ["tr-TR"] });
assert.equal(api.locale, "zh-CN");
assert.equal(api.intlLocale, "zh-CN");
assert.equal(document.documentElement.lang, "zh-CN");
assert.equal(api.t("Language"), "语言");
assert.equal(api.t("{count} tasks", { count: 3 }), "3 个任务");
assert.equal(api.t("Task #{id}"), "任务 #{id}");
assert.equal(api.t("constructor"), "constructor");
assert.equal(api.t("toString"), "toString");
assert.equal(api.t("__proto__"), "__proto__");
assert.equal(api.t("{count} tasks", Object.create({ count: 3 })), "{count} 个任务");
});
test("Chinese browser tags, fallback languages, invalid preferences and blocked storage", () => {
for (const tag of ["zh", "zh-CN", "zh-SG", "zh-Hans-CN", "ZH-cn"]) {
assert.equal(load({ languages: [tag] }).api.locale, "zh-CN");
}
assert.equal(load({ saved: "invalid", languages: ["fr-FR", "zh-CN"] }).api.locale, "zh-CN");
assert.equal(load({ blocked: true, languages: ["zh-CN"] }).api.locale, "zh-CN");
assert.equal(load({ languages: null, language: "zh-CN" }).api.locale, "zh-CN");
assert.equal(load({ languages: [], language: "zh-CN" }).api.locale, "en");
assert.equal(load({ languages: ["fr-FR"] }).api.locale, "en");
});
test("existing English and Turkish preferences and formatting are preserved", () => {
const english = load({ saved: "en", languages: ["zh-CN"] }).api;
const turkish = load({ saved: "tr", languages: ["zh-CN"] }).api;
assert.equal(english.locale, "en");
assert.equal(english.t("Language"), "Language");
assert.equal(turkish.locale, "tr");
assert.equal(turkish.intlLocale, "tr-TR");
assert.equal(turkish.t("Language"), "Dil");
assert.equal(load({ languages: ["tr-TR"] }).api.locale, "tr");
});
test("switching persists the existing storage key and reloads once", () => {
const state = load();
state.api.setLocale("en");
assert.equal(state.reloads(), 0);
state.api.setLocale("zh-CN");
assert.deepEqual(state.writes, [["artex.locale", "zh-CN"]]);
assert.equal(state.reloads(), 1);
const blocked = load({ blocked: true });
assert.doesNotThrow(() => blocked.api.setLocale("zh-CN"));
assert.equal(blocked.reloads(), 1);
});
@@ -20,7 +20,6 @@ import { usePreferencesStore } from "@/stores/preferences/preferences-provider";
import { NavMain } from "./nav-main";
import { NavUser } from "./nav-user";
import { SidebarSupportCard } from "./sidebar-support-card";
export function AppSidebar({ ...props }: React.ComponentProps<typeof Sidebar>) {
@@ -1,84 +0,0 @@
"use client";
import { Ellipsis, Folder, Forward, type LucideIcon, Trash2 } from "lucide-react";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu";
import {
SidebarGroup,
SidebarGroupLabel,
SidebarMenu,
SidebarMenuAction,
SidebarMenuButton,
SidebarMenuItem,
useSidebar,
} from "@/components/ui/sidebar";
import { t } from "@/i18n";
export function NavDocuments({
items,
}: {
readonly items: readonly {
readonly name: string;
readonly url: string;
readonly icon: LucideIcon;
}[];
}) {
const { isMobile } = useSidebar();
return (
<SidebarGroup className="group-data-[collapsible=icon]:hidden">
<SidebarGroupLabel>{t("Documents")}</SidebarGroupLabel>
<SidebarMenu>
{items.map((item) => (
<SidebarMenuItem key={item.name}>
<SidebarMenuButton asChild>
<a href={item.url}>
<item.icon />
<span>{item.name}</span>
</a>
</SidebarMenuButton>
<DropdownMenu>
<DropdownMenuTrigger asChild>
<SidebarMenuAction showOnHover className="rounded-sm data-[state=open]:bg-accent">
<Ellipsis />
<span className="sr-only">{t("More")}</span>
</SidebarMenuAction>
</DropdownMenuTrigger>
<DropdownMenuContent
className="w-24 rounded-lg"
side={isMobile ? "bottom" : "right"}
align={isMobile ? "end" : "start"}
>
<DropdownMenuItem>
<Folder />
<span>{t("Open")}</span>
</DropdownMenuItem>
<DropdownMenuItem>
<Forward />
<span>{t("Share")}</span>
</DropdownMenuItem>
<DropdownMenuSeparator />
<DropdownMenuItem variant="destructive">
<Trash2 />
<span>{t("Delete")}</span>
</DropdownMenuItem>
</DropdownMenuContent>
</DropdownMenu>
</SidebarMenuItem>
))}
<SidebarMenuItem>
<SidebarMenuButton className="text-sidebar-foreground/70">
<Ellipsis className="text-sidebar-foreground/70" />
<span>{t("More")}</span>
</SidebarMenuButton>
</SidebarMenuItem>
</SidebarMenu>
</SidebarGroup>
);
}
@@ -4,10 +4,9 @@ import * as React from "react";
import Link from "next/link";
import { usePathname } from "next/navigation";
import { ChevronRight, MailIcon, PlusCircleIcon } from "lucide-react";
import { ChevronRight } from "lucide-react";
import { api } from "@/lib/api";
import { Button } from "@/components/ui/button";
import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible";
import {
DropdownMenu,
@@ -1,43 +0,0 @@
"use client";
import type * as React from "react";
import type { LucideIcon } from "lucide-react";
import {
SidebarGroup,
SidebarGroupContent,
SidebarMenu,
SidebarMenuButton,
SidebarMenuItem,
} from "@/components/ui/sidebar";
export function NavSecondary({
items,
...props
}: {
items: {
title: string;
url: string;
icon: LucideIcon;
}[];
} & React.ComponentPropsWithoutRef<typeof SidebarGroup>) {
return (
<SidebarGroup {...props}>
<SidebarGroupContent>
<SidebarMenu>
{items.map((item) => (
<SidebarMenuItem key={item.title}>
<SidebarMenuButton asChild>
<a href={item.url}>
<item.icon />
<span>{item.title}</span>
</a>
</SidebarMenuButton>
</SidebarMenuItem>
))}
</SidebarMenu>
</SidebarGroupContent>
</SidebarGroup>
);
}
@@ -1,32 +0,0 @@
import Link from "next/link";
import { siX } from "simple-icons";
import { SimpleIcon } from "@/components/simple-icon";
import { Card, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
import { t } from "@/i18n";
export function SidebarSupportCard() {
// The X link sits inside the sentence through a placeholder so the word order can follow the locale.
const [before, after = ""] = t("Open an issue or do reach out to me on {x}.").split("{x}");
return (
<Card size="sm" className="overflow-hidden shadow-none group-data-[collapsible=icon]:hidden">
<CardHeader className="min-w-0 px-4">
<CardTitle className="truncate text-sm">{t("Looking for something more?")}</CardTitle>
<CardDescription className="line-clamp-2">
{before.trimEnd()}&nbsp;
<Link
href="https://x.com/arhamkhnz"
target="_blank"
rel="noreferrer"
aria-label={t("Reach out on X")}
className="inline-flex items-center text-foreground"
>
<SimpleIcon icon={siX} aria-hidden className="size-3 fill-current" />
</Link>
{after}
</CardDescription>
</CardHeader>
</Card>
);
}
+2 -2
View File
@@ -14,11 +14,11 @@ import {
TargetIcon,
ZapIcon,
} from "lucide-react";
import { Bar, BarChart, CartesianGrid, Tooltip as RechartsTooltip, XAxis, YAxis } from "recharts";
import { Bar, BarChart, CartesianGrid, XAxis, YAxis } from "recharts";
import { StatusBadge } from "@/components/status-badge";
import { Badge } from "@/components/ui/badge";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Card, CardContent, CardHeader } from "@/components/ui/card";
import { type ChartConfig, ChartContainer, ChartTooltip, ChartTooltipContent } from "@/components/ui/chart";
import { Progress } from "@/components/ui/progress";
import { api } from "@/lib/api";
+1
View File
@@ -4,6 +4,7 @@
/* Theme preset styles: these override CSS variables based on the selected data-theme-preset */
@import "../styles/presets/brutalist.css";
@import "../styles/presets/neon.css";
@import "../styles/presets/soft-pop.css";
@import "../styles/presets/tangerine.css";
+1 -1
View File
@@ -2,7 +2,7 @@
import * as React from "react";
import { toast } from "sonner";
import { EyeIcon, GitCompareIcon, InfoIcon, PencilIcon, RotateCcwIcon, SaveIcon, Trash2Icon, XIcon } from "lucide-react";
import { EyeIcon, GitCompareIcon, PencilIcon, RotateCcwIcon, SaveIcon, Trash2Icon, XIcon } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Badge } from "@/components/ui/badge";
@@ -1,7 +1,5 @@
"use client";
import * as React from "react";
import { PlusIcon, Trash2Icon } from "lucide-react";
import { Button } from "@/components/ui/button";

Some files were not shown because too many files have changed in this diff Show More