Compare commits

...
Author SHA1 Message Date
BaaRai b27ac66009 security(server): block SSRF in POST /api/llm/models (GHSA-7w8h) 2026-11-20 02:35:39 +01:00
BaaRai 0a22c9583f Merge pull request #389 from BaaRai/security/intercept-default-tools
fix(intercept): gate ExecuteExtraTool and Monitor by default
2026-11-20 02:01:35 +01:00
BaaRai 29edd24285 Merge pull request #388 from BaaRai/security/asset-dsl-or-scope
fix(db): parenthesise a top-level OR in asset DSL queries
2026-11-20 01:53:07 +01:00
BaaRai 46751cfb9e fix(intercept): gate ExecuteExtraTool and Monitor by default
The default intercept-enabled set left out ExecuteExtraTool (the dispatcher for MCP and deferred tools) and Monitor (background commands), so calls through them bypassed every rule unless the operator had saved their own enabled-tools list.

A malformed intercept_enabled_tools value also produced an empty set, which turned the rule system off; it now falls back to the defaults, and GetEnabledTools reports the parse error instead of pretending nothing is gated.
2026-11-20 01:48:50 +01:00
BaaRai 4677c1b6f6 Merge pull request #387 from BaaRai/security/workspace-platform-deny
fix(server): keep the capture CA and index out of the workspace file API
2026-11-20 01:37:49 +01:00
BaaRai 4d4b42586e Merge pull request #386 from BaaRai/security/mcp-sse-origin
fix(mcp): keep the legacy SSE message endpoint on the configured origin
2026-11-20 01:37:43 +01:00
BaaRai 84a623bf2d fix(db): parenthesise a top-level OR in asset DSL queries
QueryDSLInScope builds the DSL clause and then appends the task-scope clause with AND. An OR node joined its children without wrapping the whole group, so '(a) OR (b) AND id IN (scope)' let the first branch return assets outside the task scope. Wrap the whole disjunction; the children are already parenthesised.

Tests: the pure builder shape, and a PostgreSQL case where the bare-text branch matches both an in-scope and an out-of-scope asset (fails before the fix).
2026-11-20 01:34:28 +01:00
BaaRai 43f1c893c4 Merge pull request #385 from BaaRai/security/denylist-git-cmake
fix(intercept): deny always-allow for git, cmake, ctest and cpack
2026-11-20 01:34:21 +01:00
BaaRai 4a29dbfd6d Merge pull request #384 from BaaRai/fix/llm-rotate-context
fix(server): attach the rotated LLM profile pin after execContextFor
2026-11-20 01:28:50 +01:00
BaaRai 7cd9faf1f9 fix(mcp): keep the legacy SSE message endpoint on the configured origin
readSSEEndpoint accepted any absolute URL, and legacyRoundTrip copied every
configured header (Authorization included) to it. Resolve the announced
endpoint against the configured SSE URL, refuse a different scheme, host or
effective port, refuse userinfo, and apply the same origin check to every
redirect hop for both the legacy SSE and Streamable HTTP clients.
2026-11-20 01:23:48 +01:00
BaaRai 02a67bf9c5 fix(intercept): deny always-allow for git, cmake, ctest and cpack
The argv allow denylist is the only gate that stops an always-allow rule
from naming a program whose flags can run arbitrary commands. git (aliases,
hooks, -c), cmake (-P), ctest and cpack run commands from user-controlled
files, so an allow prefix for them is never safe. Also key the arity table
by the normalised program name so a path-qualified binary derives the same
prefix length as the bare name.
2026-11-20 01:23:45 +01:00
BaaRai b3c9708bf3 fix(server): attach rotated LLM profile pin after execContextFor (#376) 2026-11-20 01:01:08 +01:00
22 changed files with 1913 additions and 75 deletions
+6
View File
@@ -43,6 +43,12 @@ The enforced trust boundary for asset insertion is `insert_assets`, which runs e
Accepted gap: when a task has no allow-list, there is no allow rule to apply (block rules still run), and any host carried on an in-scope event that is not blocked enters the graph as an asset. Operators who rely on the scanner's scope rules alone should configure an allow-list per task, or review `output.json` before feeding it to ARTEX. Cross-checking ingested events against ARTEX's own rule set would change what existing scanner configurations mean for those operators, so it is treated as a deliberate design question (see #317), not an accepted vulnerability.
## Outbound Model Listing (`POST /api/llm/models`)
`POST /api/llm/models` fetches model lists from the provider endpoint and optional HTTP proxy supplied in the request. By default, ARTEX allows only `http` and `https` URLs whose hosts resolve exclusively to public IP addresses (blocking loopback, RFC1918 private networks, IPv6 unique-local `fc00::/7`, link-local/cloud metadata such as `169.254.169.254`, unspecified, and multicast addresses), and enforces the same checks on redirects and at dial time. The built-in local Ollama default (`http://127.0.0.1:11434/v1`) is permitted only when the request leaves `base_url` empty for the `ollama` provider.
Operators running self-hosted LLM gateways or Ollama on a LAN or Docker bridge can allow specific endpoints with `ARTEX_LLM_PRIVATE_ENDPOINTS`, a comma-separated list of exact `host:port` entries (for example, `127.0.0.1:11434,host.docker.internal:11434,192.168.1.10:11434`). A URL whose `host:port` matches an entry may resolve to a loopback or private address while scheme restrictions, link-local/cloud-metadata blocks, and redirect validation still apply; everything else stays refused. Leaving `ARTEX_LLM_PRIVATE_ENDPOINTS` unset or empty keeps the strict public-only policy.
## What to Expect
This is an open-source project maintained on a best-effort basis. We aim to acknowledge a report within about a week and keep you updated, but we cannot guarantee specific response or fix timeframes.
+5 -1
View File
@@ -302,7 +302,11 @@ func (b *whereBuilder) build(node *astNode) (string, error) {
}
parts = append(parts, "("+clause+")")
}
return strings.Join(parts, " OR "), nil
// The whole disjunction must be parenthesised: callers append their own
// clauses with AND (the task scope in QueryDSLInScope, the type filter),
// and AND binds tighter than OR, so "(a) OR (b) AND scope" would let the
// first branch escape the scope.
return "(" + strings.Join(parts, " OR ") + ")", nil
case "leaf":
return b.buildLeaf(*node.expr)
}
+86
View File
@@ -0,0 +1,86 @@
package db
import (
"fmt"
"strings"
"testing"
"time"
)
// A top-level OR must be parenthesised as a whole. QueryDSLInScope appends the
// task-scope clause with AND, and AND binds tighter than OR, so an unparenthesised
// disjunction lets the first branch return rows from outside the task scope.
func TestBuildDSLWhereWrapsOr(t *testing.T) {
node, err := ParseDSL("domain=alpha OR domain=beta")
if err != nil {
t.Fatal(err)
}
where, _, err := buildDSLWhereBase(node, 0)
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(where, "((") || !strings.HasSuffix(where, "))") {
t.Fatalf("compiled to %q: the whole OR group must be parenthesised", where)
}
}
// TestQueryDSLInScopeOrDoesNotEscape is the behavioural form: an OR query whose
// first branch matches every row must not return an asset outside the task scope.
func TestQueryDSLInScopeOrDoesNotEscape(t *testing.T) {
d, assets, _ := testSetup(t)
t.Cleanup(func() { d.Close() })
task, err := d.CreateTask("or scope", "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
stamp := time.Now().UnixNano()
root := fmt.Sprintf("in%d.invalid", stamp)
out := fmt.Sprintf("x%d.invalid", stamp)
marker := fmt.Sprintf("or%d", stamp)
if err := assets.upsertTaskScope(TaskScope{TaskID: task.ID, Kind: "root_domain", Domain: root}); err != nil {
t.Fatalf("seed scope: %v", err)
}
var inID, outID int64
for _, r := range []struct {
domain, root string
id *int64
}{
{"a." + root, root, &inID},
{out, out, &outID},
} {
if err := d.QueryRow(`INSERT INTO assets(type,domain,root_domain,page_title,last_seen)
VALUES ('subdomain',$1,$2,$3,now()) RETURNING id`, r.domain, r.root, marker).Scan(r.id); err != nil {
t.Fatalf("insert %s: %v", r.domain, err)
}
}
t.Cleanup(func() {
cleanupExec(t, d, `DELETE FROM assets WHERE id=ANY($1::bigint[])`, []int64{inID, outID})
})
// The bare marker matches both rows; the second branch names the out-of-scope
// host. Only the in-scope row may come back.
got, err := assets.QueryDSLInScope(marker+" OR domain="+out, "", task.ID, 50, 0)
if err != nil {
t.Fatal(err)
}
var sawIn, sawOut bool
for _, a := range got {
switch a.ID {
case inID:
sawIn = true
case outID:
sawOut = true
}
}
if !sawIn {
t.Fatalf("in-scope asset %d missing from %+v", inID, got)
}
if sawOut {
t.Fatalf("out-of-scope asset %d leaked through an OR query", outID)
}
}
+4 -4
View File
@@ -15,12 +15,12 @@ import (
func TestArgvAllowKeepsDenyAndTargetGate(t *testing.T) {
ic := intercept.New(nil)
ic.SetRulesForTest([]db.InterceptRule{
{ID: 1, Name: "no force push", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "string",
{ID: 1, Name: "no force flag", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "string",
Pattern: "--force", Action: "deny", Message: "force push is forbidden"},
{ID: 2, Name: "argv allow curl", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["curl"]`, Action: "allow"},
{ID: 3, Name: "argv allow git push", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["git","push"]`, Action: "allow"},
{ID: 3, Name: "argv allow nmap", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["nmap"]`, Action: "allow"},
})
g := NewWithInterceptor(ic)
gate := &fakeGate{t: t, check: unpinnedOnce, request: func(int, []intercept.TargetRequest, *intercept.Decision) intercept.TargetResult {
@@ -29,7 +29,7 @@ func TestArgvAllowKeepsDenyAndTargetGate(t *testing.T) {
g.gate = gate
ctx := gateOn(context.Background(), "7", time.Minute)
if block, msg := pre(g, ctx, "Bash", `{"command":"git push --force origin"}`); !block || !strings.Contains(msg, "force push is forbidden") {
if block, msg := pre(g, ctx, "Bash", `{"command":"nmap --force 10.0.0.1"}`); !block || !strings.Contains(msg, "force push is forbidden") {
t.Fatalf("deny over argv allow: block=%v msg=%q", block, msg)
}
if gate.checks != 0 {
+3 -1
View File
@@ -530,7 +530,9 @@ func TestGateOffLeavesEveryBranchUnchanged(t *testing.T) {
for name, ctx := range off {
before := len(g.rows())
// 1. A tool outside the enabled set: passes, nothing is written.
for _, c := range []struct{ tool, input string }{{"Monitor", curl(deny)}, {"mcp__scan__run", `{"target":"203.0.113.7","note":"` + deny + `"}`}} {
// Monitor and ExecuteExtraTool are in the default set now, so use read-only
// tools and an MCP name (inner names are not in the set).
for _, c := range []struct{ tool, input string }{{"list_assets", curl(deny)}, {"mcp__scan__run", `{"target":"203.0.113.7","note":"` + deny + `"}`}} {
if block, msg := pre(guard, ctx, c.tool, c.input); block {
t.Fatalf("%s: %s blocked: %s", name, c.tool, msg)
}
+2
View File
@@ -27,6 +27,8 @@ var alwaysAllowDenylist = func() map[string]bool {
// package managers and build tools: run package scripts and hooks
"npm npx pnpm yarn bunx corepack pip pipx uv uvx poetry conda composer gem bundle bundler rake cargo go " +
"mvn gradle dotnet apt apt-get dpkg dnf yum rpm pacman apk brew snap flatpak",
// version control and build generators: run hooks, aliases and script files
"git cmake ctest cpack",
// orchestration: run images, playbooks and plans
"docker docker-compose podman nerdctl kubectl helm ansible ansible-playbook terraform pulumi vagrant",
// destructive
+27 -7
View File
@@ -13,12 +13,13 @@ func TestArgvAllowDenylist(t *testing.T) {
"python", "python3", "python3.11", "/usr/bin/python3.11", "php8.2", "ruby3.2", "perl5", "pip3",
"env", "/usr/bin/env", "bash", "/bin/sh", "find", "rm", "mkfs", "mkfs.ext4", "/sbin/mkfs.xfs",
"docker", "kubectl", "npm", "sudo", "xargs", "Rscript", ".",
"git", "/usr/bin/git", "cmake", "cmake3", "/usr/bin/cmake", "ctest", "cpack",
} {
if !ArgvAllowDenied(prog) {
t.Errorf("%q is not denied", prog)
}
}
for _, prog := range []string{"nmap", "git", "/usr/bin/git", "curl", "ls", "gh", "x", "7z", "pythonic"} {
for _, prog := range []string{"nmap", "curl", "ls", "gh", "x", "7z", "pythonic"} {
if ArgvAllowDenied(prog) {
t.Errorf("%q is denied, want allowable", prog)
}
@@ -30,8 +31,8 @@ func TestAlwaysAllowPrefix(t *testing.T) {
b, _ := json.Marshal(map[string]string{"command": cmd})
return b
}
if got, err := AlwaysAllowPrefix("Bash", bash("git push --force origin main")); err != nil || !slices.Equal(got, []string{"git", "push"}) {
t.Fatalf("git push: %q %v", got, err)
if got, err := AlwaysAllowPrefix("Bash", bash("gh pr list --limit 5")); err != nil || !slices.Equal(got, []string{"gh", "pr", "list"}) {
t.Fatalf("gh pr list: %q %v", got, err)
}
if got, err := AlwaysAllowPrefix("Bash", bash("nmap -p 80 10.0.0.1")); err != nil || !slices.Equal(got, []string{"nmap"}) {
t.Fatalf("nmap: %q %v", got, err)
@@ -40,10 +41,10 @@ func TestAlwaysAllowPrefix(t *testing.T) {
tool string
input []byte
}{
"not Bash": {"shell_open", bash("git push")},
"compound": {"Bash", bash("git push; id")},
"substitution": {"Bash", bash("git push $(id)")},
"redirection": {"Bash", bash("git push > out")},
"not Bash": {"shell_open", bash("gh pr list")},
"compound": {"Bash", bash("gh pr list; id")},
"substitution": {"Bash", bash("gh pr list $(id)")},
"redirection": {"Bash", bash("gh pr list > out")},
"empty": {"Bash", bash("")},
"no command": {"Bash", []byte(`{}`)},
"not json": {"Bash", []byte(`not json`)},
@@ -52,6 +53,11 @@ func TestAlwaysAllowPrefix(t *testing.T) {
"find": {"Bash", bash("find . -exec sh -c id ;")},
"rm": {"Bash", bash("rm -rf /")},
"docker": {"Bash", bash("docker run --privileged x")},
"git": {"Bash", bash("git status")},
"path to git": {"Bash", bash("/usr/bin/git status")},
"git config": {"Bash", bash("git config user.name x")},
"cmake": {"Bash", bash("cmake --version")},
"ctest": {"Bash", bash("ctest -N")},
} {
if got, err := AlwaysAllowPrefix(c.tool, c.input); err == nil {
t.Errorf("%s: prefix %q, want a refusal", name, got)
@@ -59,6 +65,20 @@ func TestAlwaysAllowPrefix(t *testing.T) {
}
}
// The arity table is keyed by program name, so a path-qualified binary derives
// the same prefix length as the bare name.
func TestArgvPrefixLenUsesBasename(t *testing.T) {
if got := argvPrefixLen([]string{"/usr/bin/gh", "pr", "list"}); got != 3 {
t.Errorf("path-qualified gh prefix length = %d, want 3", got)
}
if got := argvPrefixLen([]string{"/usr/bin/git", "status"}); got != 2 {
t.Errorf("path-qualified git prefix length = %d, want 2", got)
}
if got, err := ArgvPrefix("/usr/bin/gh pr list"); err != nil || !slices.Equal(got, []string{"/usr/bin/gh", "pr", "list"}) {
t.Errorf("path-qualified gh prefix = %q, %v", got, err)
}
}
// The denylist neutralises argv allow rules at matching time (a rule created
// before the denylist, or written straight into the database), and only them:
// an argv deny or ask rule for the same program still matches.
+9 -1
View File
@@ -25,9 +25,17 @@ var argvArity = map[string]int{
}
// argvPrefixLen returns the number of leading tokens that form the prefix.
// The arity table is keyed by program name, so a path-qualified binary
// (/usr/bin/git) uses the same arity as the bare name.
func argvPrefixLen(tokens []string) int {
if len(tokens) == 0 {
return 0
}
key := make([]string, len(tokens))
copy(key, tokens)
key[0] = argvProgramName(tokens[0])
for n := len(tokens); n > 0; n-- {
if a, ok := argvArity[strings.Join(tokens[:n], " ")]; ok {
if a, ok := argvArity[strings.Join(key[:n], " ")]; ok {
return min(a, len(tokens))
}
}
+8 -8
View File
@@ -214,20 +214,20 @@ func TestParseArgvPattern(t *testing.T) {
func TestArgvAllowBelowDeny(t *testing.T) {
ic := New(nil)
ic.SetRulesForTest([]db.InterceptRule{
{ID: 1, Name: "no force push", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "regex",
{ID: 1, Name: "no force flag", Enabled: true, Priority: 50, MatchTarget: "tool_input", MatchType: "regex",
Pattern: `--force`, Action: "deny"},
{ID: 2, Name: "argv allow git push", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["git","push"]`, Action: "allow"},
{ID: 2, Name: "argv allow nmap", Enabled: true, Priority: -1000, MatchTarget: "tool_input", MatchType: "argv",
Pattern: `["nmap"]`, Action: "allow"},
})
dec, ok := ic.Match("Bash", []byte(`{"command":"git push --force"}`))
dec, ok := ic.Match("Bash", []byte(`{"command":"nmap --force 10.0.0.1"}`))
if !ok || dec.Action != "deny" || dec.RuleID != 1 {
t.Fatalf("force push: %+v %v, want the deny rule", dec, ok)
t.Fatalf("force flag: %+v %v, want the deny rule", dec, ok)
}
dec, ok = ic.Match("Bash", []byte(`{"command":"git push origin"}`))
dec, ok = ic.Match("Bash", []byte(`{"command":"nmap 10.0.0.1"}`))
if !ok || dec.Action != "allow" || dec.RuleID != 2 {
t.Fatalf("push: %+v %v, want the argv allow", dec, ok)
t.Fatalf("nmap: %+v %v, want the argv allow", dec, ok)
}
if _, ok := ic.Match("Bash", []byte(`{"command":"git push; id"}`)); ok {
if _, ok := ic.Match("Bash", []byte(`{"command":"nmap 10.0.0.1; id"}`)); ok {
t.Fatal("a compound command matched the argv rule")
}
if _, ok := compileRule(db.InterceptRule{MatchType: "argv", Pattern: `["-x"]`}); ok {
+48
View File
@@ -0,0 +1,48 @@
package intercept
import "testing"
// TestDefaultEnabledToolsCoverExecutors pins the tools that must be gated when no
// intercept_enabled_tools setting has been saved. ExecuteExtraTool and Monitor
// dispatch MCP / deferred tools and background commands, so leaving them out let
// those calls bypass every rule.
func TestDefaultEnabledToolsCoverExecutors(t *testing.T) {
got := map[string]bool{}
for _, name := range defaultEnabledTools {
got[name] = true
}
for _, want := range []string{"Bash", "Write", "Edit", "MultiEdit", "ExecuteExtraTool", "Monitor"} {
if !got[want] {
t.Errorf("defaultEnabledTools must include %q", want)
}
}
for _, readOnly := range []string{"list_assets", "traffic_search", "Read"} {
if got[readOnly] {
t.Errorf("defaultEnabledTools must not gate the read-only tool %q by default", readOnly)
}
}
}
// TestEnabledToolsFromSettingNeverDisablesTheGate: an unset or malformed setting
// must keep the defaults, not turn the rule system off.
func TestEnabledToolsFromSettingNeverDisablesTheGate(t *testing.T) {
for _, tc := range []struct {
name string
val string
ok bool
}{
{"unset", "", false},
{"malformed", "{not json", true},
{"wrong shape", `"Bash"`, true},
} {
got := enabledToolsFromSetting(tc.val, tc.ok)
if !got["Bash"] || !got["ExecuteExtraTool"] || !got["Monitor"] {
t.Errorf("%s: enabled tools %v, want the defaults", tc.name, got)
}
}
// A valid explicit list replaces the defaults.
got := enabledToolsFromSetting(`["Bash"]`, true)
if !got["Bash"] || got["WebFetch"] {
t.Fatalf("explicit list: %v, want only Bash", got)
}
}
+28 -19
View File
@@ -266,6 +266,10 @@ var defaultEnabledTools = []string{
"Bash", "WebFetch", "web_search",
"shell_open", "shell_send",
"Write", "Edit", "MultiEdit",
// ExecuteExtraTool dispatches MCP and deferred tools, and Monitor starts a
// background command; both execute third-party or shell commands, so they
// belong in the default gate with the rest.
"ExecuteExtraTool", "Monitor",
}
// New creates an Interceptor backed by d. The rule cache is lazy-loaded on
@@ -305,27 +309,32 @@ func (i *Interceptor) loadLocked() error {
// Load enabled-tools set from settings, falling back to hard-coded defaults.
val, ok, _ := i.db.GetSetting("intercept_enabled_tools")
if !ok {
m := make(map[string]bool, len(defaultEnabledTools))
for _, n := range defaultEnabledTools {
m[n] = true
}
i.enabledTools = m
} else {
var names []string
if json.Unmarshal([]byte(val), &names) != nil {
i.enabledTools = map[string]bool{}
} else {
m := make(map[string]bool, len(names))
for _, n := range names {
m[n] = true
}
i.enabledTools = m
}
}
i.enabledTools = enabledToolsFromSetting(val, ok)
return nil
}
// enabledToolsFromSetting maps the stored intercept_enabled_tools value to the
// gate's set. A malformed value must not silently disable the gate, so it falls
// back to the same defaults as an unset setting.
func enabledToolsFromSetting(val string, ok bool) map[string]bool {
m := make(map[string]bool, len(defaultEnabledTools))
for _, n := range defaultEnabledTools {
m[n] = true
}
if !ok {
return m
}
var names []string
if json.Unmarshal([]byte(val), &names) != nil {
return m
}
m = make(map[string]bool, len(names))
for _, n := range names {
m[n] = true
}
return m
}
func (i *Interceptor) rules() ([]compiledRule, error) {
i.mu.RLock()
if i.cached != nil {
@@ -381,7 +390,7 @@ func (i *Interceptor) GetEnabledTools() ([]string, error) {
}
var names []string
if err := json.Unmarshal([]byte(val), &names); err != nil {
return []string{}, nil
return nil, fmt.Errorf("intercept_enabled_tools is not valid JSON: %w", err)
}
return names, nil
}
+13 -2
View File
@@ -165,6 +165,18 @@ func (i *Interceptor) loadExemptions() (exemptions, error) {
return ex, nil
}
// IsNonPublicAddr reports whether addr is private (RFC1918, fc00::/7 unique
// local), loopback, link-local (including 169.254.169.254 and fe80::/10),
// unspecified, multicast, or a known instance-metadata address.
// Invalid addresses are treated as non-public (fail closed).
func IsNonPublicAddr(addr netip.Addr) bool {
if !addr.IsValid() {
return true
}
addr = addr.Unmap().WithZone("")
return addr.IsPrivate() || ValidateExemptionHost(addr.String()) != nil
}
// voidsExemption reports whether one resolved address voids a stored
// exemption on a name: a private address (10/8, 172.16/12, 192.168/16, the
// unique local range fc00::/7), or one that is never exempt as a literal
@@ -175,6 +187,5 @@ func voidsExemption(ip string) bool {
if err != nil {
return true
}
a = a.Unmap().WithZone("")
return a.IsPrivate() || ValidateExemptionHost(a.String()) != nil
return IsNonPublicAddr(a)
}
+87 -11
View File
@@ -17,6 +17,7 @@ import (
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"strings"
@@ -101,6 +102,66 @@ func normalizeHeaders(headers map[string]string) (map[string]string, error) {
return out, nil
}
// originKey returns the scheme, host and effective port of u, in a form two
// URLs can be compared with. Empty means u is not an absolute http(s) URL with
// a host.
func originKey(u *url.URL) string {
if u == nil {
return ""
}
scheme := strings.ToLower(u.Scheme)
var port string
switch scheme {
case "http":
port = "80"
case "https":
port = "443"
default:
return ""
}
host := strings.ToLower(u.Hostname())
if host == "" {
return ""
}
if p := u.Port(); p != "" {
port = p
}
return scheme + "://" + net.JoinHostPort(host, port)
}
// sameOrigin reports whether u has the same scheme, host and effective port as
// base.
func sameOrigin(base, u *url.URL) bool {
key := originKey(base)
return key != "" && key == originKey(u)
}
// redirectPolicy refuses a redirect that leaves the origin of the configured
// endpoint, so a remote MCP server cannot retarget authenticated requests.
func redirectPolicy(base *url.URL) func(*http.Request, []*http.Request) error {
return func(req *http.Request, via []*http.Request) error {
if len(via) >= 10 {
return errors.New("mcp: stopped after 10 redirects")
}
if !sameOrigin(base, req.URL) {
return fmt.Errorf("mcp: refusing a redirect to another origin: %s", req.URL.Redacted())
}
return nil
}
}
// parseMCPURL parses and validates a configured MCP endpoint URL.
func parseMCPURL(raw string) (*url.URL, error) {
u, err := url.Parse(raw)
if err != nil {
return nil, fmt.Errorf("mcp url: %w", err)
}
if originKey(u) == "" {
return nil, fmt.Errorf("mcp url must be an absolute http or https URL with a host: %q", raw)
}
return u, nil
}
// New connects to a remote MCP endpoint and performs the initialize handshake.
// headers are sent on every request (Authorization, custom API keys, …).
// When insecure is true, TLS certificate verification is skipped so servers that
@@ -117,7 +178,11 @@ func New(ctx context.Context, server, url string, headers map[string]string, ins
if timeoutSeconds > 0 {
timeout = time.Duration(timeoutSeconds) * time.Second
}
hc := &http.Client{Timeout: timeout}
base, err := parseMCPURL(url)
if err != nil {
return nil, err
}
hc := &http.Client{Timeout: timeout, CheckRedirect: redirectPolicy(base)}
if insecure {
hc.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
}
@@ -142,7 +207,11 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
if err != nil {
return nil, err
}
hc := &http.Client{} // the SSE stream is intentionally long-lived.
base, err := parseMCPURL(sseURL)
if err != nil {
return nil, err
}
hc := &http.Client{CheckRedirect: redirectPolicy(base)} // the SSE stream is intentionally long-lived.
if insecure {
hc.Transport = &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
}
@@ -167,7 +236,7 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
return nil, fmt.Errorf("mcp sse http %d: %s", resp.StatusCode, readSnippet(resp.Body))
}
reader := bufio.NewReader(resp.Body)
endpoint, err := readSSEEndpoint(reader, sseURL)
endpoint, err := readSSEEndpoint(reader, base)
if err != nil {
resp.Body.Close()
cancel()
@@ -195,7 +264,11 @@ func NewSSE(ctx context.Context, server, sseURL string, headers map[string]strin
return c, nil
}
func readSSEEndpoint(r *bufio.Reader, base string) (string, error) {
// readSSEEndpoint reads the message endpoint announced by the SSE stream. The
// endpoint must stay on the origin of the configured SSE URL: the POSTs that
// follow carry the operator's headers, and a remote server must not be able to
// retarget them.
func readSSEEndpoint(r *bufio.Reader, base *url.URL) (string, error) {
for {
line, err := r.ReadString('\n')
if err != nil {
@@ -213,14 +286,17 @@ func readSSEEndpoint(r *bufio.Reader, base string) (string, error) {
if err != nil {
return "", fmt.Errorf("mcp sse endpoint URL: %w", err)
}
if !u.IsAbs() {
b, err := url.Parse(base)
if err != nil {
return "", err
}
candidate = b.ResolveReference(u).String()
if u.User != nil {
return "", errors.New("mcp sse endpoint must not carry userinfo")
}
return candidate, nil
abs := u
if !u.IsAbs() {
abs = base.ResolveReference(u)
}
if !sameOrigin(base, abs) {
return "", fmt.Errorf("mcp sse endpoint %q is not on the configured origin", abs.Redacted())
}
return abs.String(), nil
}
}
+133
View File
@@ -1,11 +1,13 @@
package mcphttp
import (
"bufio"
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync"
"testing"
@@ -105,3 +107,134 @@ func TestLegacySSEClientDiscoverAndCall(t *testing.T) {
t.Fatalf("Call() = %q, %v", got, err)
}
}
func TestReadSSEEndpointSameOrigin(t *testing.T) {
base, err := url.Parse("https://mcp.example.com:8443/sse")
if err != nil {
t.Fatal(err)
}
read := func(line string) (string, error) {
stream := "event: endpoint\ndata: " + line + "\n\n"
return readSSEEndpoint(bufio.NewReader(strings.NewReader(stream)), base)
}
for _, line := range []string{
"/message?sessionId=1",
"https://mcp.example.com:8443/message",
"HTTPS://MCP.EXAMPLE.COM:8443/message",
"//mcp.example.com:8443/message",
} {
got, err := read(line)
if err != nil {
t.Errorf("%q: %v", line, err)
continue
}
u, err := url.Parse(got)
if err != nil || !sameOrigin(base, u) {
t.Errorf("%q: resolved to %q, not the configured origin", line, got)
}
}
for _, line := range []string{
"https://evil.example/message",
"http://mcp.example.com:8443/message",
"https://mcp.example.com:444/message",
"//evil.example/message",
"http://user:pass@mcp.example.com:8443/message",
"ftp://mcp.example.com/message",
} {
if got, err := read(line); err == nil {
t.Errorf("%q: accepted as %q, want a refusal", line, got)
}
}
}
func TestReadSSEEndpointDefaultPort(t *testing.T) {
base, err := url.Parse("https://mcp.example.com/sse")
if err != nil {
t.Fatal(err)
}
stream := "data: https://mcp.example.com:443/message\n\n"
if _, err := readSSEEndpoint(bufio.NewReader(strings.NewReader(stream)), base); err != nil {
t.Fatalf("explicit default port refused: %v", err)
}
}
func TestParseMCPURL(t *testing.T) {
for _, raw := range []string{"ftp://x/y", "not-a-url", "http:///nohost", ""} {
if _, err := parseMCPURL(raw); err == nil {
t.Errorf("%q accepted, want a refusal", raw)
}
}
for _, raw := range []string{"http://x/y", "https://x:8443/y"} {
if _, err := parseMCPURL(raw); err != nil {
t.Errorf("%q refused: %v", raw, err)
}
}
}
func TestLegacySSERefusesCrossOriginEndpoint(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
fmt.Fprint(w, "event: endpoint\ndata: http://evil.invalid/message\n\n")
w.(http.Flusher).Flush()
<-r.Context().Done()
}))
defer srv.Close()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if _, err := NewSSE(ctx, "test", srv.URL+"/sse", nil, false); err == nil {
t.Fatal("cross-origin SSE endpoint accepted")
}
}
func TestMCPClientRefusesCrossOriginRedirect(t *testing.T) {
var hits int
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hits++
}))
defer target.Close()
src := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, target.URL+"/steal", http.StatusFound)
}))
defer src.Close()
base, err := url.Parse(src.URL + "/sse")
if err != nil {
t.Fatal(err)
}
hc := &http.Client{CheckRedirect: redirectPolicy(base)}
resp, err := hc.Get(src.URL + "/sse")
if err == nil {
resp.Body.Close()
t.Fatal("cross-origin redirect accepted")
}
if hits != 0 {
t.Fatalf("redirect target was reached %d times", hits)
}
}
func TestMCPClientAllowsSameOriginRedirect(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/sse", func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/sse2", http.StatusFound)
})
mux.HandleFunc("/sse2", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
srv := httptest.NewServer(mux)
defer srv.Close()
base, err := url.Parse(srv.URL + "/sse")
if err != nil {
t.Fatal(err)
}
hc := &http.Client{CheckRedirect: redirectPolicy(base)}
resp, err := hc.Get(srv.URL + "/sse")
if err != nil {
t.Fatalf("same-origin redirect refused: %v", err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("status %d", resp.StatusCode)
}
}
+23 -10
View File
@@ -1182,6 +1182,27 @@ func (e *Engine) runWorkerStep(ctx context.Context, t *Task, name string, worker
return e.runIntent(ctx, t, name, worker, intent, token, "", "")
}
// intentWorkContext resolves the cached per-task exec context and returns a
// per-intent child context with the rotated LLM profile pin attached (#85,
// #376). Attaching the pin after execContextFor ensures a cached e.execCtx
// does not drop it; attaching it after the paused/deleting check ensures a
// rolled-back claim never advances the rotation counter.
func (e *Engine) intentWorkContext(ctx context.Context, t *Task) (ectx, workCtx context.Context, workCancel context.CancelCauseFunc, ok bool) {
ectx = e.clockCtx(e.execContextFor(ctx, t.ID), t, false) // cancellable by Pause; carries the task deadline
if ectx.Err() != nil || e.IsDeleting(t.ID) {
return ectx, nil, nil, false
}
// per-work child context so the planner's kill_work can stop just this work.
workCtx, workCancel = context.WithCancelCause(ectx)
// Per-intent LLM rotation (#85): each claimed worker intent runs on the
// next chain head. The pin travels through the run context into the
// provider resolver; non-worker roles and failover keep the active head.
if head, pinned := t.nextRotatedProfile(); pinned {
workCtx = withLLMProfilePin(workCtx, head)
}
return ectx, workCtx, workCancel, true
}
// runIntent executes and fully settles one already-claimed (state=running) intent.
// Both the pool worker loop (via runWorkerStep) and the human-message handler (via
// runDetachedIntent, a dedicated goroutine outside the worker pool) call it, so the
@@ -1194,25 +1215,17 @@ func (e *Engine) runWorkerStep(ctx context.Context, t *Task, name string, worker
// while the worker is busy, and every intent state write below is fenced on it,
// so a worker whose claim was taken over cannot overwrite the new claimer.
func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *agent.Worker, intent *db.Node, token, requestID, message string) bool {
// Per-intent LLM rotation (#85): each claimed worker intent runs on the
// next chain head. The pin travels through the run context into the
// provider resolver; non-worker roles and failover keep the active head.
if head, ok := t.nextRotatedProfile(); ok {
ctx = withLLMProfilePin(ctx, head)
}
hasChatMessage := message != ""
e.stampFirstRun(t) // first real execution → stamp first_run_at + compute the deadline (only for tasks with a timeout)
e.touch(t.ID)
emit := func(r db.Activity) { e.emitActivity(t, r) }
ectx := e.clockCtx(e.execContextFor(ctx, t.ID), t, false) // cancellable by Pause; carries the task deadline
if ectx.Err() != nil || e.IsDeleting(t.ID) {
ectx, workCtx, workCancel, ok := e.intentWorkContext(ctx, t)
if !ok {
if err := t.Store.SettleIntentClaim(intent.ID, token, "open"); err != nil {
log.Printf("[worker %s] task %s intent #%d claim rollback failed: %v", name, t.ID, intent.ID, err)
}
return true
}
// per-work child context so the planner's kill_work can stop just this work.
workCtx, workCancel := context.WithCancelCause(ectx)
e.registerWork(intent.ID, workCancel)
stopHeartbeat := startClaimHeartbeat(t.Store, db.IntentClaimHeartbeatInterval, name, intent.ID, token, workCancel)
// wrap the guard hooks so steer_work can inject a mid-run course-correction
+4 -4
View File
@@ -7,7 +7,7 @@ import (
)
func TestValidateArgvRuleReq(t *testing.T) {
base := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: `["git","push"]`, Action: "allow"}
base := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: `["nmap"]`, Action: "allow"}
if err := validateInterceptRuleReq(base); err != nil {
t.Fatalf("valid argv rule refused: %v", err)
}
@@ -15,7 +15,7 @@ func TestValidateArgvRuleReq(t *testing.T) {
"tool_name target": func(r *interceptRuleReq) { r.MatchTarget = "tool_name" },
"empty pattern": func(r *interceptRuleReq) { r.Pattern = "" },
"empty token": func(r *interceptRuleReq) { r.Pattern = `["git",""]` },
"flag token": func(r *interceptRuleReq) { r.Pattern = `["git","-C"]` },
"flag token": func(r *interceptRuleReq) { r.Pattern = `["nmap","-C"]` },
"metacharacter": func(r *interceptRuleReq) { r.Pattern = `["nmap;id"]` },
"nine tokens": func(r *interceptRuleReq) { r.Pattern = `["a","b","c","d","e","f","g","h","i"]` },
"not an array": func(r *interceptRuleReq) { r.Pattern = `git push` },
@@ -31,7 +31,7 @@ func TestValidateArgvRuleReq(t *testing.T) {
// The manual rule form refuses an argv allow rule for a denylisted program,
// with the message of the "always allow" endpoint; deny and ask stay creatable.
func TestValidateArgvAllowDenylist(t *testing.T) {
for _, pattern := range []string{`["python"]`, `["python3.11"]`, `["/usr/bin/env"]`, `["find"]`, `["docker","run"]`} {
for _, pattern := range []string{`["python"]`, `["python3.11"]`, `["/usr/bin/env"]`, `["find"]`, `["docker","run"]`, `["git","push"]`, `["cmake"]`} {
req := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: pattern, Action: "allow"}
tokens, _ := intercept.ParseArgvPattern(pattern)
want := intercept.CheckArgvAllow(tokens)
@@ -45,7 +45,7 @@ func TestValidateArgvAllowDenylist(t *testing.T) {
}
}
}
for _, pattern := range []string{`["nmap"]`, `["git","push"]`} {
for _, pattern := range []string{`["nmap"]`, `["curl"]`} {
req := interceptRuleReq{Name: "r", MatchTarget: "tool_input", MatchType: "argv", Pattern: pattern, Action: "allow"}
if err := validateInterceptRuleReq(req); err != nil {
t.Errorf("allow %s refused: %v", pattern, err)
+1
View File
@@ -130,6 +130,7 @@ func TestStoredProfileKeyOnlyForStoredEndpoint(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
s.allowLoopbackModels = true
s.cfgMu.Lock()
s.llmCfg = agent.Config{} // no global key to fall back on
s.cfgMu.Unlock()
+920
View File
@@ -0,0 +1,920 @@
package server
import (
"context"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/tls"
"crypto/x509"
"crypto/x509/pkix"
"math/big"
"net"
"net/http"
"net/http/httptest"
"net/netip"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/agent"
)
func dialTestServerForHosts(routes map[string]string, fallback func(ctx context.Context, network, addr string) (net.Conn, error)) func(ctx context.Context, network, addr string) (net.Conn, error) {
return func(ctx context.Context, network, addr string) (net.Conn, error) {
if target, ok := routes[strings.ToLower(addr)]; ok {
return (&net.Dialer{}).DialContext(ctx, network, target)
}
host, _, err := net.SplitHostPort(addr)
if err == nil {
if target, ok := routes[strings.ToLower(host)]; ok {
return (&net.Dialer{}).DialContext(ctx, network, target)
}
}
return fallback(ctx, network, addr)
}
}
// newTestTLSServer starts an HTTPS httptest server with a leaf certificate
// valid for dnsNames and returns the server and a CertPool trusting it.
func newTestTLSServer(t *testing.T, dnsNames []string, h http.Handler) (*httptest.Server, *x509.CertPool) {
t.Helper()
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
t.Fatal(err)
}
tmpl := &x509.Certificate{
SerialNumber: big.NewInt(1),
Subject: pkix.Name{CommonName: dnsNames[0]},
NotBefore: time.Now().Add(-time.Hour),
NotAfter: time.Now().Add(time.Hour),
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
DNSNames: dnsNames,
}
der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
if err != nil {
t.Fatal(err)
}
cert, err := x509.ParseCertificate(der)
if err != nil {
t.Fatal(err)
}
pool := x509.NewCertPool()
pool.AddCert(cert)
srv := httptest.NewUnstartedServer(h)
srv.TLS = &tls.Config{
Certificates: []tls.Certificate{{
Certificate: [][]byte{der},
PrivateKey: key,
}},
}
srv.StartTLS()
t.Cleanup(srv.Close)
return srv, pool
}
func TestLLMModelsRefusesLoopbackBeforeRequest(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
var hits atomic.Int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hits.Add(1)
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte("internal secret body"))
}))
t.Cleanup(srv.Close)
// Strict production default: no test seams set.
s := &Server{}
for _, tc := range []struct {
name string
provider string
apiKey string
}{
{"openai", "openai", "sk-test"},
{"anthropic", "anthropic", "sk-test"},
{"ollama_keyless", "ollama", ""},
} {
t.Run(tc.name, func(t *testing.T) {
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": tc.provider,
"base_url": srv.URL,
"api_key": tc.apiKey,
})
if hits.Load() != 0 {
t.Fatalf("loopback server was contacted (%d hits)", hits.Load())
}
if resp["ok"] != false {
t.Fatalf("expected ok=false, got %v", resp)
}
errMsg, _ := resp["error"].(string)
if errMsg == "" {
t.Fatalf("expected non-empty refusal error, got %v", resp)
}
if strings.Contains(errMsg, "127.0.0.1") || strings.Contains(errMsg, "internal secret") {
t.Fatalf("error leaked address or body: %q", errMsg)
}
})
}
}
func TestLLMModelsDefaultOllamaAllowedWithoutSeam(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
// 1. Caller-supplied DefaultOllamaBaseURL ("http://127.0.0.1:11434/v1") must
// still be refused with no test seams and no allow-list entry.
bare := &Server{}
supplied := postJSON(t, bare.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": agent.DefaultOllamaBaseURL,
"api_key": "",
})
if supplied["ok"] != false {
t.Fatalf("caller-supplied %s must be refused, got %v", agent.DefaultOllamaBaseURL, supplied)
}
if errMsg, _ := supplied["error"].(string); !strings.Contains(errMsg, "not allowed") || strings.Contains(errMsg, "127.0.0.1") {
t.Fatalf("unexpected refusal for caller-supplied ollama URL: %q", errMsg)
}
// 2. Empty base_url with provider="ollama" uses the code-owned default and
// must NOT be refused by URL validation or dial control even with no test seam.
var ollamaHits atomic.Int32
fakeOllama := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ollamaHits.Add(1)
if r.URL.Path != "/v1/models" {
w.WriteHeader(http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"llama3.2"}]}`))
}))
t.Cleanup(fakeOllama.Close)
// Verify the production guard allows dialing only 127.0.0.1:11434 (not other loopback ports).
s := &Server{}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"127.0.0.1:11434": fakeOllama.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": "",
"api_key": "",
})
if ollamaHits.Load() != 1 {
t.Fatalf("expected default ollama endpoint to be contacted once, got %d", ollamaHits.Load())
}
if resp["ok"] != true {
t.Fatalf("expected ok=true for default ollama without allowLoopbackModels, got %v", resp)
}
rawModels, _ := resp["models"].([]any)
if len(rawModels) != 1 || rawModels[0] != "llama3.2" {
t.Fatalf("unexpected models: %v", rawModels)
}
// Also verify a completely bare Server (zero seams at all) does not refuse
// {"provider":"ollama","base_url":""} at validation or dial Control.
bareResp := postJSON(t, bare.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": "",
"api_key": "",
})
if bareResp["ok"] == false {
errMsg, _ := bareResp["error"].(string)
if strings.Contains(errMsg, "not allowed") {
t.Fatalf("bare Server refused code-owned default Ollama URL: %q", errMsg)
}
}
}
func TestLLMModelsPrivateEndpointsAllowList(t *testing.T) {
var allowedHits atomic.Int32
allowedSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
allowedHits.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"local-llama"}]}`))
}))
t.Cleanup(allowedSrv.Close)
var otherPortHits atomic.Int32
otherPortSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
otherPortHits.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"wrong-port"}]}`))
}))
t.Cleanup(otherPortSrv.Close)
// 1. No allow-list entry -> refused with bare Server (zero test seams).
t.Setenv(LLMPrivateEndpointsEnv, "")
bare := &Server{}
noEntry := postJSON(t, bare.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": allowedSrv.URL,
"api_key": "",
})
if allowedHits.Load() != 0 || noEntry["ok"] != false {
t.Fatalf("expected refusal with empty %s, hits=%d resp=%v", LLMPrivateEndpointsEnv, allowedHits.Load(), noEntry)
}
// 2. Allow-listed exact host:port works end-to-end with bare Server (real production dialer + guard).
t.Setenv(LLMPrivateEndpointsEnv, allowedSrv.Listener.Addr().String()+",host.docker.internal:11434")
okResp := postJSON(t, bare.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": allowedSrv.URL,
"api_key": "",
})
if allowedHits.Load() != 1 || okResp["ok"] != true {
t.Fatalf("allow-listed endpoint should work, hits=%d resp=%v", allowedHits.Load(), okResp)
}
rawModels, _ := okResp["models"].([]any)
if len(rawModels) != 1 || rawModels[0] != "local-llama" {
t.Fatalf("unexpected models from allow-listed endpoint: %v", rawModels)
}
// 3. Same host on a different port stays refused.
diffPort := postJSON(t, bare.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": otherPortSrv.URL,
"api_key": "",
})
if otherPortHits.Load() != 0 || diffPort["ok"] != false {
t.Fatalf("same host on another port must be refused, hits=%d resp=%v", otherPortHits.Load(), diffPort)
}
// 4. Allow-listed hostname resolving to RFC1918 works on its exact port,
// stays refused on another port, and still validates scheme & redirects.
var dockerHits atomic.Int32
dockerSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
dockerHits.Add(1)
if r.URL.Path == "/redirect/v1/models" {
http.Redirect(w, r, otherPortSrv.URL+"/secret", http.StatusFound)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"docker-qwen"}]}`))
}))
t.Cleanup(dockerSrv.Close)
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "host.docker.internal" {
return []netip.Addr{netip.MustParseAddr("192.168.65.254")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"host.docker.internal:11434": dockerSrv.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
dockerOK := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": "http://host.docker.internal:11434",
"api_key": "",
})
if dockerHits.Load() != 1 || dockerOK["ok"] != true {
t.Fatalf("allow-listed docker host should work, hits=%d resp=%v", dockerHits.Load(), dockerOK)
}
dockerWrongPort := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": "http://host.docker.internal:8080",
"api_key": "",
})
if dockerWrongPort["ok"] != false {
t.Fatalf("docker host on wrong port must be refused: %v", dockerWrongPort)
}
dockerBadScheme := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": "ftp://host.docker.internal:11434",
"api_key": "",
})
if dockerBadScheme["ok"] != false {
t.Fatalf("disallowed scheme on allow-listed host must be refused: %v", dockerBadScheme)
}
dockerBadRedirect := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "ollama",
"base_url": "http://host.docker.internal:11434/redirect",
"api_key": "",
})
if otherPortHits.Load() != 0 || dockerBadRedirect["ok"] != false {
t.Fatalf("redirect from allow-listed host to non-listed loopback port must be refused, hits=%d resp=%v", otherPortHits.Load(), dockerBadRedirect)
}
// 5. Cloud metadata remains refused even if mistakenly added to the env var.
t.Setenv(LLMPrivateEndpointsEnv, "169.254.169.254:80,[fd00:ec2::254]:80")
for _, metaURL := range []string{"http://169.254.169.254/latest/meta-data/", "http://[fd00:ec2::254]/latest/meta-data/"} {
metaResp := postJSON(t, bare.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": metaURL,
"api_key": "sk-test",
})
if metaResp["ok"] != false {
t.Fatalf("metadata URL %s must stay refused even if listed: %v", metaURL, metaResp)
}
}
}
func TestLLMModelsRefusesMetadataAndRestrictedAddresses(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
s := &Server{}
for _, tc := range []struct {
name string
baseURL string
noLeak string
}{
{"aws_metadata", "http://169.254.169.254/latest/meta-data/", "169.254.169.254"},
{"rfc1918_10", "http://10.0.0.1/v1", "10.0.0.1"},
{"rfc1918_172", "http://172.16.0.1/v1", "172.16.0.1"},
{"rfc1918_192", "http://192.168.1.1/v1", "192.168.1.1"},
{"unique_local_v6", "http://[fc00::1]/v1", "fc00::1"},
{"unique_local_fd", "http://[fd12:3456::1]/v1", "fd12:3456::1"},
{"unspecified_v4", "http://0.0.0.0/v1", "0.0.0.0"},
{"unspecified_v6", "http://[::]/v1", "::"},
{"loopback_v6", "http://[::1]:8080/v1", "::1"},
{"link_local_v6", "http://[fe80::1]/v1", "fe80::1"},
{"v4_mapped_loopback", "http://[::ffff:127.0.0.1]/v1", "127.0.0.1"},
{"v4_mapped_metadata", "http://[::ffff:169.254.169.254]/v1", "169.254.169.254"},
{"aws_imds_v6", "http://[fd00:ec2::254]/latest/meta-data/", "fd00:ec2::254"},
{"alibaba_metadata", "http://100.100.100.200/latest/meta-data/", "100.100.100.200"},
{"decimal_loopback", "http://2130706433/v1", "127.0.0.1"},
{"hex_metadata", "http://0xa9.254.0xa9fe/latest/meta-data/", "169.254.169.254"},
{"localhost", "http://localhost:8080/v1", "127.0.0.1"},
} {
t.Run(tc.name, func(t *testing.T) {
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": tc.baseURL,
"api_key": "sk-test",
})
if resp["ok"] != false {
t.Fatalf("expected ok=false for %s, got %v", tc.baseURL, resp)
}
errMsg, _ := resp["error"].(string)
if errMsg == "" {
t.Fatalf("expected error message for %s", tc.baseURL)
}
if tc.noLeak != "" && strings.Contains(errMsg, tc.noLeak) {
t.Fatalf("error leaked address %q: %q", tc.noLeak, errMsg)
}
})
}
// Resolved DNS addresses must be checked and must never leak into the error.
for _, tc := range []struct {
name string
addrs []netip.Addr
noLeak string
}{
{"dns_private", []netip.Addr{netip.MustParseAddr("10.23.45.67")}, "10.23.45.67"},
{"dns_metadata", []netip.Addr{netip.MustParseAddr("169.254.169.254")}, "169.254.169.254"},
{"dns_unique_local", []netip.Addr{netip.MustParseAddr("fd00::42")}, "fd00::42"},
{"dns_mixed_public_and_loopback", []netip.Addr{netip.MustParseAddr("93.184.216.34"), netip.MustParseAddr("127.0.0.1")}, "127.0.0.1"},
} {
t.Run(tc.name, func(t *testing.T) {
rs := &Server{
modelLookupIP: func(_ context.Context, _ string) ([]netip.Addr, error) {
return tc.addrs, nil
},
}
resp := postJSON(t, rs.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://internal.example/v1",
"api_key": "sk-test",
})
if resp["ok"] != false {
t.Fatalf("expected ok=false, got %v", resp)
}
errMsg, _ := resp["error"].(string)
if errMsg == "" || strings.Contains(errMsg, tc.noLeak) {
t.Fatalf("unexpected error %q (must be non-empty and not contain %q)", errMsg, tc.noLeak)
}
})
}
}
func TestLLMModelsRefusesDisallowedSchemes(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
s := &Server{}
for _, raw := range []string{
"file:///etc/passwd",
"ftp://api.example.com/v1",
"gopher://api.example.com:70/1",
"javascript:alert(1)",
} {
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": raw,
"api_key": "sk-test",
})
if resp["ok"] != false {
t.Fatalf("scheme %q was not refused: %v", raw, resp)
}
if errMsg, _ := resp["error"].(string); !strings.Contains(errMsg, "http or https") {
t.Fatalf("scheme %q: expected http/https refusal, got %q", raw, errMsg)
}
}
}
func TestLLMModelsRefusesRestrictedProxyAndTargetThroughProxy(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
var proxyHits atomic.Int32
proxySrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
proxyHits.Add(1)
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":[{"id":"proxied"}]}`))
}))
t.Cleanup(proxySrv.Close)
// 1. Loopback proxy is refused before any request is sent.
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "api.public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}
if host == "private-proxy.example" {
return []netip.Addr{netip.MustParseAddr("10.99.0.1")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
for _, tc := range []struct {
name string
proxy string
noLeak string
}{
{"loopback_proxy", proxySrv.URL, "127.0.0.1"},
{"metadata_proxy", "http://169.254.169.254:80", "169.254.169.254"},
{"socks5_proxy", "socks5://api.public.example:1080", ""},
{"dns_private_proxy", "http://private-proxy.example:3128", "10.99.0.1"},
} {
t.Run(tc.name, func(t *testing.T) {
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://api.public.example/v1",
"proxy": tc.proxy,
"api_key": "sk-test",
})
if proxyHits.Load() != 0 {
t.Fatalf("proxy was contacted (%d hits)", proxyHits.Load())
}
if resp["ok"] != false {
t.Fatalf("expected ok=false, got %v", resp)
}
errMsg, _ := resp["error"].(string)
if errMsg == "" || (tc.noLeak != "" && strings.Contains(errMsg, tc.noLeak)) {
t.Fatalf("unexpected error %q (must not leak %q)", errMsg, tc.noLeak)
}
})
}
// 2. Valid public proxy + refused target: target must be rejected before the proxy is contacted.
s2 := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "proxy.public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.35")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s2.modelDialContext = dialTestServerForHosts(
map[string]string{"proxy.public.example": proxySrv.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s2).blockDial}).DialContext,
)
resp := postJSON(t, s2.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://169.254.169.254/latest/meta-data/",
"proxy": "http://proxy.public.example:8080",
"api_key": "sk-test",
})
if proxyHits.Load() != 0 {
t.Fatalf("proxy was contacted for refused target (%d hits)", proxyHits.Load())
}
if resp["ok"] != false {
t.Fatalf("expected ok=false, got %v", resp)
}
if errMsg, _ := resp["error"].(string); strings.Contains(errMsg, "169.254.169.254") {
t.Fatalf("error leaked metadata address: %q", errMsg)
}
// 3. Valid public proxy + public target that returns 302 to 127.0.0.1:
// the proxy must see the first request only, never the redirect target.
var proxyReqs []string
redirProxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
proxyReqs = append(proxyReqs, r.URL.String())
http.Redirect(w, r, "http://127.0.0.1:9999/secret", http.StatusFound)
}))
t.Cleanup(redirProxy.Close)
s3 := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
switch host {
case "proxy.public.example":
return []netip.Addr{netip.MustParseAddr("93.184.216.35")}, nil
case "api.public.example":
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
default:
return nil, &net.DNSError{Err: "no such host", Name: host}
}
},
}
s3.modelDialContext = dialTestServerForHosts(
map[string]string{"proxy.public.example": redirProxy.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s3).blockDial}).DialContext,
)
resp3 := postJSON(t, s3.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://api.public.example/v1",
"proxy": "http://proxy.public.example:8080",
"api_key": "sk-test",
})
if len(proxyReqs) != 1 || proxyReqs[0] != "http://api.public.example/v1/models" {
t.Fatalf("proxy received unexpected requests: %v", proxyReqs)
}
if resp3["ok"] != false {
t.Fatalf("expected ok=false for proxied redirect to loopback, got %v", resp3)
}
if errMsg, _ := resp3["error"].(string); errMsg == "" || strings.Contains(errMsg, "127.0.0.1") {
t.Fatalf("unexpected error %q (must not leak 127.0.0.1)", errMsg)
}
}
func TestLLMModelsRefusesRedirectToLoopbackAndRestrictedHost(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
var targetHits atomic.Int32
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
targetHits.Add(1)
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte("loopback secret"))
}))
t.Cleanup(target.Close)
for _, tc := range []struct {
name string
location string
noLeak string
}{
{"redirect_to_loopback", target.URL + "/secret", "127.0.0.1"},
{"redirect_to_metadata", "http://169.254.169.254/latest/meta-data/", "169.254.169.254"},
{"redirect_to_private_dns", "http://internal.example/secret", "10.44.55.66"},
} {
t.Run(tc.name, func(t *testing.T) {
targetHits.Store(0)
var redirHits atomic.Int32
redirector := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
redirHits.Add(1)
http.Redirect(w, r, tc.location, http.StatusFound)
}))
t.Cleanup(redirector.Close)
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
switch host {
case "public.example":
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
case "internal.example":
return []netip.Addr{netip.MustParseAddr("10.44.55.66")}, nil
default:
return nil, &net.DNSError{Err: "no such host", Name: host}
}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"public.example": redirector.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://public.example/v1",
"api_key": "sk-test",
})
if redirHits.Load() != 1 {
t.Fatalf("expected redirector to be hit once, got %d", redirHits.Load())
}
if targetHits.Load() != 0 {
t.Fatalf("redirect target on loopback was contacted (%d hits)", targetHits.Load())
}
if resp["ok"] != false {
t.Fatalf("expected ok=false, got %v", resp)
}
errMsg, _ := resp["error"].(string)
if errMsg == "" {
t.Fatalf("expected refusal error, got %v", resp)
}
if strings.Contains(errMsg, tc.noLeak) || strings.Contains(errMsg, "loopback secret") {
t.Fatalf("error leaked address or body: %q", errMsg)
}
})
}
}
func TestLLMModelsRedirectSchemePolicyAndCap(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
t.Run("http_to_https_same_host_allowed", func(t *testing.T) {
httpsSrv, pool := newTestTLSServer(t, []string{"public.example"}, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"upgraded-model"}]}`))
}))
httpSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "https://public.example/v1/models", http.StatusFound)
}))
t.Cleanup(httpSrv.Close)
s := &Server{
modelRootCAs: pool,
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{
"public.example:80": httpSrv.Listener.Addr().String(),
"public.example:443": httpsSrv.Listener.Addr().String(),
},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://public.example/v1",
"api_key": "sk-test",
})
if resp["ok"] != true {
t.Fatalf("expected same-host http->https upgrade to succeed, got %v", resp)
}
rawModels, _ := resp["models"].([]any)
if len(rawModels) != 1 || rawModels[0] != "upgraded-model" {
t.Fatalf("unexpected models after upgrade: %v", rawModels)
}
})
t.Run("https_to_http_downgrade_refused", func(t *testing.T) {
var httpHits atomic.Int32
httpSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
httpHits.Add(1)
_, _ = w.Write([]byte(`{"data":[{"id":"downgraded"}]}`))
}))
t.Cleanup(httpSrv.Close)
httpsSrv, pool := newTestTLSServer(t, []string{"public.example"}, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "http://public.example/v1/models", http.StatusFound)
}))
s := &Server{
modelRootCAs: pool,
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{
"public.example:80": httpSrv.Listener.Addr().String(),
"public.example:443": httpsSrv.Listener.Addr().String(),
},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "https://public.example/v1",
"api_key": "sk-test",
})
if httpHits.Load() != 0 {
t.Fatalf("downgraded HTTP endpoint was contacted (%d hits)", httpHits.Load())
}
if resp["ok"] != false {
t.Fatalf("expected ok=false on https->http downgrade, got %v", resp)
}
if errMsg, _ := resp["error"].(string); !strings.Contains(errMsg, "scheme") {
t.Fatalf("expected scheme refusal error, got %q", errMsg)
}
})
t.Run("http_to_https_cross_host_refused", func(t *testing.T) {
var otherHits atomic.Int32
httpsOther, pool := newTestTLSServer(t, []string{"other.public.example"}, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
otherHits.Add(1)
_, _ = w.Write([]byte(`{"data":[{"id":"other"}]}`))
}))
httpSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "https://other.public.example/v1/models", http.StatusFound)
}))
t.Cleanup(httpSrv.Close)
s := &Server{
modelRootCAs: pool,
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
switch host {
case "public.example":
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
case "other.public.example":
return []netip.Addr{netip.MustParseAddr("93.184.216.35")}, nil
default:
return nil, &net.DNSError{Err: "no such host", Name: host}
}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{
"public.example:80": httpSrv.Listener.Addr().String(),
"other.public.example:443": httpsOther.Listener.Addr().String(),
},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://public.example/v1",
"api_key": "sk-test",
})
if otherHits.Load() != 0 {
t.Fatalf("cross-host HTTPS redirect target was contacted (%d hits)", otherHits.Load())
}
if resp["ok"] != false {
t.Fatalf("expected ok=false on cross-host scheme change, got %v", resp)
}
if errMsg, _ := resp["error"].(string); !strings.Contains(errMsg, "scheme") {
t.Fatalf("expected scheme refusal error, got %q", errMsg)
}
})
t.Run("http_to_file_refused", func(t *testing.T) {
httpSrv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "file:///etc/passwd", http.StatusFound)
}))
t.Cleanup(httpSrv.Close)
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"public.example": httpSrv.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://public.example/v1",
"api_key": "sk-test",
})
if resp["ok"] != false {
t.Fatalf("expected ok=false on file:// redirect, got %v", resp)
}
if errMsg, _ := resp["error"].(string); !strings.Contains(errMsg, "scheme") {
t.Fatalf("expected scheme refusal error, got %q", errMsg)
}
})
t.Run("too_many_redirects", func(t *testing.T) {
var hops atomic.Int32
looper := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
n := hops.Add(1)
http.Redirect(w, r, "/v1/models?hop="+string(rune('0'+n)), http.StatusFound)
}))
t.Cleanup(looper.Close)
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"public.example": looper.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://public.example/v1",
"api_key": "sk-test",
})
if resp["ok"] != false {
t.Fatalf("expected ok=false on redirect loop, got %v", resp)
}
if errMsg, _ := resp["error"].(string); !strings.Contains(errMsg, "too many redirects") {
t.Fatalf("expected too many redirects error, got %q", errMsg)
}
if hops.Load() > int32(maxModelRedirects) {
t.Fatalf("followed %d redirects, cap is %d", hops.Load(), maxModelRedirects)
}
})
}
func TestLLMModelsChecksEveryCandidateURL(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
var flip atomic.Bool
var seenPaths []string
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
seenPaths = append(seenPaths, r.URL.Path)
if r.URL.Path == "/anthropic/v1/models" {
// Flip DNS to a private address before candidate 2 is tried.
flip.Store(true)
w.WriteHeader(http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"should-not-reach"}]}`))
}))
t.Cleanup(upstream.Close)
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host != "rebind.example" {
return nil, &net.DNSError{Err: "no such host", Name: host}
}
if flip.Load() {
return []netip.Addr{netip.MustParseAddr("10.77.88.99")}, nil
}
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"rebind.example": upstream.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "anthropic",
"base_url": "http://rebind.example/anthropic",
"api_key": "sk-test",
})
if resp["ok"] != false {
t.Fatalf("expected ok=false when second candidate resolves to private IP, got %v", resp)
}
if len(seenPaths) != 1 || seenPaths[0] != "/anthropic/v1/models" {
t.Fatalf("expected only first candidate to be sent, got %v", seenPaths)
}
if errMsg, _ := resp["error"].(string); errMsg == "" || strings.Contains(errMsg, "10.77.88.99") {
t.Fatalf("unexpected error %q (must not leak resolved IP)", errMsg)
}
}
func TestLLMModelsPublicEndpointWorks(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/v1/models" {
// Also verify a safe same-scheme redirect to a public host succeeds.
http.Redirect(w, r, "http://api.public.example/v2/models", http.StatusFound)
return
}
if r.URL.Path != "/v2/models" {
w.WriteHeader(http.StatusNotFound)
return
}
if r.Header.Get("Authorization") != "Bearer sk-public" {
w.WriteHeader(http.StatusUnauthorized)
return
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"gpt-4o"},{"id":"o3"}]}`))
}))
t.Cleanup(upstream.Close)
s := &Server{
modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
if host == "api.public.example" {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}
return nil, &net.DNSError{Err: "no such host", Name: host}
},
}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"api.public.example": upstream.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai",
"base_url": "http://api.public.example/v1",
"api_key": "sk-public",
})
if resp["ok"] != true {
t.Fatalf("expected ok=true for normal public endpoint, got %v", resp)
}
rawModels, _ := resp["models"].([]any)
if len(rawModels) != 2 || rawModels[0] != "gpt-4o" || rawModels[1] != "o3" {
t.Fatalf("unexpected models: %v", rawModels)
}
}
+1
View File
@@ -202,6 +202,7 @@ func TestOllamaListModels(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
s.allowLoopbackModels = true
call := func(baseURL string) (bool, []string) {
body, _ := json.Marshal(map[string]any{"provider": "ollama", "base_url": baseURL, "api_key": ""})
+9
View File
@@ -2,6 +2,7 @@ package server
import (
"context"
"crypto/x509"
"encoding/base64"
"encoding/json"
"errors"
@@ -65,6 +66,14 @@ type Server struct {
authHashKey string
authVersionKey string
// Test-only seams for pgListModels SSRF checks. All remain zero/nil in
// production (strict public-only default; only exact host:port entries in
// ARTEX_LLM_PRIVATE_ENDPOINTS may resolve to private addresses).
allowLoopbackModels bool
modelLookupIP func(ctx context.Context, host string) ([]netip.Addr, error)
modelDialContext func(ctx context.Context, network, addr string) (net.Conn, error)
modelRootCAs *x509.CertPool
loginLimit *loginLimiter // per-IP attempt limit on POST /api/auth/login
pwdLimit *loginLimiter // attempt limit on POST /api/auth/change-password (IP + session token)
trustedProxies []netip.Prefix // ARTEX_TRUSTED_PROXIES; see clientIP
+317 -7
View File
@@ -4,13 +4,16 @@ import (
"archive/zip"
"bytes"
"context"
"crypto/tls"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"mime"
"net"
"net/http"
"net/netip"
"net/url"
"os"
"path"
@@ -18,6 +21,8 @@ import (
"regexp"
"strconv"
"strings"
"sync"
"syscall"
"text/template"
"text/template/parse"
"time"
@@ -26,6 +31,7 @@ import (
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/intercept"
"github.com/Autumn-27/artex/notify"
"github.com/Autumn-27/norma/llm"
"github.com/Autumn-27/norma/skill"
@@ -2306,6 +2312,224 @@ func (s *Server) pgLLMPoolReset(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, s.llmPoolStatus())
}
const maxModelRedirects = 5
// LLMPrivateEndpointsEnv is an opt-in comma-separated allow-list of exact
// host:port entries (for example "127.0.0.1:11434,host.docker.internal:11434")
// that POST /api/llm/models may contact on loopback or private addresses.
// Unset or empty enforces the strict public-only policy.
const LLMPrivateEndpointsEnv = "ARTEX_LLM_PRIVATE_ENDPOINTS"
type modelURLRefusalError struct {
msg string
}
func (e *modelURLRefusalError) Error() string { return e.msg }
func normalizeModelHost(host string) (kind, normalized string, ok bool) {
host = strings.TrimSpace(host)
if host == "" {
return "", "", false
}
if addr, err := netip.ParseAddr(host); err == nil {
return intercept.TargetIP, addr.Unmap().WithZone("").String(), true
}
t, ok := intercept.NormalizeTarget(host)
if !ok || t.Kind == intercept.TargetCIDR || t.Host == "" {
return "", "", false
}
return t.Kind, t.Host, true
}
func urlEffectivePort(u *url.URL) (int, bool) {
if p := u.Port(); p != "" {
n, err := strconv.Atoi(p)
if err != nil || n < 1 || n > 65535 {
return 0, false
}
return n, true
}
switch strings.ToLower(u.Scheme) {
case "http":
return 80, true
case "https":
return 443, true
default:
return 0, false
}
}
func parsePrivateModelEndpoints(raw string) map[string]bool {
out := map[string]bool{}
for _, entry := range strings.Split(raw, ",") {
entry = strings.TrimSpace(entry)
if entry == "" {
continue
}
host, portStr, err := net.SplitHostPort(entry)
if err != nil {
continue
}
port, err := strconv.Atoi(portStr)
if err != nil || port < 1 || port > 65535 {
continue
}
_, normHost, ok := normalizeModelHost(host)
if !ok {
continue
}
out[net.JoinHostPort(normHost, strconv.Itoa(port))] = true
}
return out
}
func sameRedirectHost(a, b *url.URL) bool {
ha := strings.TrimSuffix(strings.ToLower(strings.TrimSpace(a.Hostname())), ".")
hb := strings.TrimSuffix(strings.ToLower(strings.TrimSpace(b.Hostname())), ".")
return ha != "" && ha == hb
}
func (s *Server) isBlockedModelAddr(addr netip.Addr, allowPrivate bool) bool {
if !addr.IsValid() {
return true
}
addr = addr.Unmap().WithZone("")
if s != nil && s.allowLoopbackModels && addr.IsLoopback() {
return false
}
if !intercept.IsNonPublicAddr(addr) {
return false
}
if allowPrivate {
// Allow-listed self-hosted endpoints may resolve to loopback or RFC1918 /
// unique-local private addresses, but never link-local, unspecified,
// multicast, or instance-metadata addresses (such as 169.254.169.254 or
// fd00:ec2::254).
if addr.IsLoopback() {
return false
}
if addr.IsPrivate() && intercept.ValidateExemptionHost(addr.String()) == nil {
return false
}
}
return true
}
func (s *Server) lookupModelIPs(ctx context.Context, host string) ([]netip.Addr, error) {
if s != nil && s.modelLookupIP != nil {
return s.modelLookupIP(ctx, host)
}
return net.DefaultResolver.LookupNetIP(ctx, "ip", host)
}
type modelURLGuard struct {
s *Server
privateEndpoints map[string]bool
mu sync.Mutex
allowedDialAddrs map[string]bool
}
func newModelURLGuard(s *Server) *modelURLGuard {
return &modelURLGuard{
s: s,
privateEndpoints: parsePrivateModelEndpoints(os.Getenv(LLMPrivateEndpointsEnv)),
}
}
func (g *modelURLGuard) allowDialAddr(addr netip.Addr, port int) {
if !addr.IsValid() || port < 1 || port > 65535 {
return
}
key := net.JoinHostPort(addr.Unmap().WithZone("").String(), strconv.Itoa(port))
g.mu.Lock()
if g.allowedDialAddrs == nil {
g.allowedDialAddrs = map[string]bool{}
}
g.allowedDialAddrs[key] = true
g.mu.Unlock()
}
func (g *modelURLGuard) isAllowedDialAddr(addr netip.Addr, port string) bool {
key := net.JoinHostPort(addr.Unmap().WithZone("").String(), port)
g.mu.Lock()
ok := g.allowedDialAddrs[key]
g.mu.Unlock()
return ok
}
func (g *modelURLGuard) blockDial(_, address string, _ syscall.RawConn) error {
host, port, err := net.SplitHostPort(address)
if err != nil {
return &modelURLRefusalError{msg: "target address is not allowed"}
}
addr, err := netip.ParseAddr(host)
if err != nil {
return &modelURLRefusalError{msg: "target address is not allowed"}
}
allowPrivate := g.isAllowedDialAddr(addr, port)
if g.s.isBlockedModelAddr(addr, allowPrivate) {
return &modelURLRefusalError{msg: "target address is not allowed"}
}
return nil
}
// validateURL validates a base_url candidate, proxy URL, or redirect target for
// POST /api/llm/models. Only http and https URLs are permitted; hosts must
// resolve strictly to public addresses unless their exact host:port is listed
// in ARTEX_LLM_PRIVATE_ENDPOINTS. Errors never include resolved IP addresses.
func (g *modelURLGuard) validateURL(ctx context.Context, rawURL, role string) (*url.URL, error) {
u, err := url.Parse(strings.TrimSpace(rawURL))
if err != nil {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("invalid %s URL", role)}
}
scheme := strings.ToLower(u.Scheme)
if scheme != "http" && scheme != "https" {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("%s URL must use http or https", role)}
}
if u.Opaque != "" {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("invalid %s URL", role)}
}
port, ok := urlEffectivePort(u)
if !ok {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("invalid %s URL", role)}
}
kind, normHost, ok := normalizeModelHost(u.Hostname())
if !ok {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("invalid %s URL host", role)}
}
hostPort := net.JoinHostPort(normHost, strconv.Itoa(port))
allowPrivate := g.privateEndpoints[hostPort]
if kind == intercept.TargetIP {
addr, err := netip.ParseAddr(normHost)
if err != nil || g.s.isBlockedModelAddr(addr, allowPrivate) {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("%s URL host is not allowed", role)}
}
if allowPrivate {
g.allowDialAddr(addr, port)
}
return u, nil
}
if !allowPrivate && !(g.s != nil && g.s.allowLoopbackModels) && (normHost == "localhost" || strings.HasSuffix(normHost, ".localhost")) {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("%s URL host is not allowed", role)}
}
addrs, err := g.s.lookupModelIPs(ctx, normHost)
if err != nil || len(addrs) == 0 {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("failed to resolve %s host", role)}
}
for _, addr := range addrs {
if g.s.isBlockedModelAddr(addr, allowPrivate) {
return nil, &modelURLRefusalError{msg: fmt.Sprintf("%s URL host is not allowed", role)}
}
}
if allowPrivate {
for _, addr := range addrs {
g.allowDialAddr(addr, port)
}
}
return u, nil
}
// pgListModels fetches available models from the provider's API endpoint.
// Supports OpenAI-format (GET /models), Anthropic-format (GET /v1/models) and
// Ollama (keyless OpenAI-compatible GET /v1/models on the local server); for
@@ -2355,7 +2579,9 @@ func (s *Server) pgListModels(w http.ResponseWriter, r *http.Request) {
return
}
baseURL := strings.TrimRight(strings.TrimSpace(req.BaseURL), "/")
rawBaseURL := strings.TrimSpace(req.BaseURL)
baseURL := strings.TrimRight(rawBaseURL, "/")
defaultOllama := provider == "ollama" && rawBaseURL == ""
// Candidate endpoints to try in order. Some Anthropic-compatible providers
// (e.g. DeepSeek) implement /v1/messages under an /anthropic path but expose
@@ -2419,19 +2645,98 @@ func (s *Server) pgListModels(w http.ResponseWriter, r *http.Request) {
}
}
// Build HTTP client with optional proxy.
transport := &http.Transport{}
// Validate proxy and every candidate URL before sending any request.
// Pre-request validation is required in addition to the dial-time guard
// because a caller-supplied HTTP proxy fetches the target URL itself.
guard := newModelURLGuard(s)
var proxyURL *url.URL
if p := strings.TrimSpace(req.Proxy); p != "" {
if pu, err := url.Parse(p); err == nil {
transport.Proxy = http.ProxyURL(pu)
var err error
proxyURL, err = guard.validateURL(r.Context(), p, "proxy")
if err != nil {
writeJSON(w, 200, map[string]any{"ok": false, "error": err.Error()})
return
}
}
client := &http.Client{Transport: transport, Timeout: 30 * time.Second}
if defaultOllama {
// The built-in Ollama default is code-owned, not caller input: allow
// dialing its exact host:port without relaxing caller-supplied URLs.
if du, err := url.Parse(agent.DefaultOllamaBaseURL); err == nil {
if addr, err := netip.ParseAddr(du.Hostname()); err == nil {
if port, ok := urlEffectivePort(du); ok {
guard.allowDialAddr(addr, port)
}
}
}
} else {
for _, c := range candidates {
if _, err := guard.validateURL(r.Context(), c.url, "endpoint"); err != nil {
writeJSON(w, 200, map[string]any{"ok": false, "error": err.Error()})
return
}
}
}
// Build HTTP client with strict dial guard, redirect validation, and optional proxy.
var transport *http.Transport
if base, ok := http.DefaultTransport.(*http.Transport); ok {
transport = base.Clone()
} else {
transport = &http.Transport{}
}
transport.Proxy = nil
if proxyURL != nil {
transport.Proxy = http.ProxyURL(proxyURL)
}
if s.modelRootCAs != nil {
if transport.TLSClientConfig == nil {
transport.TLSClientConfig = &tls.Config{}
} else {
transport.TLSClientConfig = transport.TLSClientConfig.Clone()
}
transport.TLSClientConfig.RootCAs = s.modelRootCAs
}
dialCtx := (&net.Dialer{Timeout: 10 * time.Second, Control: guard.blockDial}).DialContext
if s.modelDialContext != nil {
dialCtx = s.modelDialContext
}
transport.DialContext = dialCtx
defer transport.CloseIdleConnections()
client := &http.Client{
Transport: transport,
Timeout: 30 * time.Second,
CheckRedirect: func(req *http.Request, via []*http.Request) error {
if len(via) >= maxModelRedirects {
return &modelURLRefusalError{msg: "too many redirects"}
}
if len(via) > 0 {
prev := via[len(via)-1].URL
prevScheme := strings.ToLower(prev.Scheme)
nextScheme := strings.ToLower(req.URL.Scheme)
if nextScheme != prevScheme {
if !(prevScheme == "http" && nextScheme == "https" && sameRedirectHost(prev, req.URL)) {
return &modelURLRefusalError{msg: "redirect scheme change is not allowed"}
}
}
}
if _, err := guard.validateURL(req.Context(), req.URL.String(), "redirect"); err != nil {
return err
}
return nil
},
}
// Try each candidate; return the first that yields a non-empty model list.
var lastErr string
emptyOK := false
for _, c := range candidates {
for i, c := range candidates {
if i > 0 && !defaultOllama {
if _, err := guard.validateURL(r.Context(), c.url, "endpoint"); err != nil {
writeJSON(w, 200, map[string]any{"ok": false, "error": err.Error()})
return
}
}
httpReq, err := http.NewRequestWithContext(r.Context(), http.MethodGet, c.url, nil)
if err != nil {
lastErr = "failed to build request: " + err.Error()
@@ -2440,6 +2745,11 @@ func (s *Server) pgListModels(w http.ResponseWriter, r *http.Request) {
httpReq.Header = c.hdr
resp, err := client.Do(httpReq)
if err != nil {
var refusal *modelURLRefusalError
if errors.As(err, &refusal) {
writeJSON(w, 200, map[string]any{"ok": false, "error": refusal.Error()})
return
}
lastErr = "request failed: " + err.Error()
continue
}
+179
View File
@@ -3,12 +3,14 @@ package server
import (
"context"
"fmt"
"iter"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/norma/llm"
)
@@ -211,3 +213,180 @@ func TestNextRotatedProfileRoundRobin(t *testing.T) {
t.Fatal("disabled rotation must not assign a pin")
}
}
type pinCapture struct {
id int64
ok bool
}
type pinCaptureProvider struct {
mu sync.Mutex
seen []pinCapture
}
func (p *pinCaptureProvider) record(ctx context.Context) {
id, ok := llmProfilePinFrom(ctx)
p.mu.Lock()
p.seen = append(p.seen, pinCapture{id: id, ok: ok})
p.mu.Unlock()
}
func (p *pinCaptureProvider) Stream(ctx context.Context, _ llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
p.record(ctx)
return func(yield func(llm.StreamEvent, error) bool) {
if !yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "done"}, nil) {
return
}
if !yield(llm.StreamEvent{Type: llm.SEMessageDelta, StopReason: "end_turn"}, nil) {
return
}
yield(llm.StreamEvent{Type: llm.SEMessageStop}, nil)
}
}
func (p *pinCaptureProvider) Complete(ctx context.Context, _ llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
p.record(ctx)
return llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{llm.TextBlock("done")}}, "end_turn", llm.Usage{}, nil
}
// Regression test for #376 (DB-free): warming e.execContextFor first (as the
// planner does) must not drop the per-intent LLM profile pin on subsequent
// worker intents, and a paused/deleting rollback must not advance rotation.
func TestIntentWorkContextRotatesWithCachedExecCtx(t *testing.T) {
const (
taskID = "77"
profileA = int64(101)
profileB = int64(202)
)
e := NewEngine(nil)
tk := &Task{ID: taskID, LLMProfileIDs: []int64{profileA, profileB}, LLMRotate: true}
// Warm the per-task cached execCtx, simulating the planner running first.
warm := e.execContextFor(context.Background(), taskID)
if warm == nil || warm.Err() != nil {
t.Fatalf("warm execContextFor returned invalid ctx: %v", warm)
}
// A paused task must roll back without advancing the rotation counter.
e.Pause(taskID, agent.AbortPausedByUser)
if _, _, _, ok := e.intentWorkContext(context.Background(), tk); ok {
t.Fatal("paused task unexpectedly yielded a work context")
}
e.Resume(tk)
// Re-warm cached execCtx after resume (again simulating planner before worker).
_ = e.execContextFor(context.Background(), taskID)
// A deleting task must also roll back without advancing the rotation counter.
e.BeginDelete(taskID)
if _, _, _, ok := e.intentWorkContext(context.Background(), tk); ok {
t.Fatal("deleting task unexpectedly yielded a work context")
}
e.AbortDelete(taskID, false)
// Two consecutive claimed intents must carry distinct rotated pins (A then B).
_, workA, cancelA, ok := e.intentWorkContext(context.Background(), tk)
if !ok {
t.Fatal("first intentWorkContext failed")
}
defer cancelA(nil)
gotA, okA := llmProfilePinFrom(workA)
if !okA || gotA != profileA {
t.Fatalf("first workCtx pin = (%d, %v), want (%d, true)", gotA, okA, profileA)
}
_, workB, cancelB, ok := e.intentWorkContext(context.Background(), tk)
if !ok {
t.Fatal("second intentWorkContext failed")
}
defer cancelB(nil)
gotB, okB := llmProfilePinFrom(workB)
if !okB || gotB != profileB {
t.Fatalf("second workCtx pin = (%d, %v), want (%d, true)", gotB, okB, profileB)
}
if gotA == gotB {
t.Fatalf("expected distinct pinned profile IDs, both were %d", gotA)
}
}
// Regression test for #376 (end-to-end through runIntent): warm execContextFor
// first (simulating the planner running before workers), then run two intents
// through runIntent and assert the two work contexts carry distinct pinned
// profile IDs (A then B).
func TestRunIntentRotatesPinnedProfileWithCachedExecCtx(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Skipf("postgres unavailable: %v", err)
}
defer m.Close()
ids := make([]int64, 0, 2)
for i := 0; i < 2; i++ {
id, err := m.pg.SaveProfile(&db.LLMProfile{
Name: fmt.Sprintf("runintent-rotate-%d-%d", time.Now().UnixNano(), i),
Format: "openai",
BaseURL: "http://127.0.0.1:1/v1",
Model: "test",
APIKey: "test-key",
})
if err != nil {
t.Fatal(err)
}
ids = append(ids, id)
defer m.pg.DeleteProfile(id)
}
on := true
task, err := m.CreateTaskWithOptions("runIntent rotation", "verify pin survives cached execCtx", db.TaskCreateOptions{
LLMProfileIDs: ids,
LLMRotate: &on,
})
if err != nil {
t.Fatal(err)
}
defer m.DeleteTask(task.ID, DeleteTaskOptions{})
e := NewEngine(m)
// Warm the per-task cached execCtx before any worker intent runs.
_ = e.execContextFor(context.Background(), task.ID)
// Verify paused rollback through runIntent does not advance rotation.
if _, err := task.Store.AddIntent(map[string]any{"summary": "rolled back while paused"}, 1, nil, "planner"); err != nil {
t.Fatal(err)
}
pausedIntent, pausedToken := e.claimNext(task, "work#0")
if pausedIntent == nil {
t.Fatal("failed to claim intent for paused rollback check")
}
e.Pause(task.ID, agent.AbortPausedByUser)
probe := &pinCaptureProvider{}
worker := agent.NewWorker(probe, "test-model", m.dir, nil, 0, 2)
e.runIntent(context.Background(), task, "work#0", worker, pausedIntent, pausedToken, "", "")
if len(probe.seen) != 0 {
t.Fatalf("paused runIntent called provider %d times, want 0", len(probe.seen))
}
e.Resume(task)
// Re-warm cached execCtx after resume (simulating planner before workers).
_ = e.execContextFor(context.Background(), task.ID)
// Run two intents through runIntent and assert distinct pins: ids[0] then ids[1].
if _, err := task.Store.AddIntent(map[string]any{"summary": "rotate intent 2"}, 1, nil, "planner"); err != nil {
t.Fatal(err)
}
for i, wantID := range ids {
name := fmt.Sprintf("work#%d", i+1)
intent, token := e.claimNext(task, name)
if intent == nil {
t.Fatalf("intent %d not claimed", i+1)
}
p := &pinCaptureProvider{}
w := agent.NewWorker(p, "test-model", m.dir, nil, 0, 2)
e.runIntent(context.Background(), task, name, w, intent, token, "", "")
if len(p.seen) == 0 {
t.Fatalf("intent %d: provider was not called", i+1)
}
got := p.seen[0]
if !got.ok || got.id != wantID {
t.Fatalf("intent %d: workCtx pin = (%d, %v), want (%d, true)", i+1, got.id, got.ok, wantID)
}
}
}