diff --git a/docs/anr-provider-policy.md b/docs/anr-provider-policy.md new file mode 100644 index 000000000000..4bc3f76915d8 --- /dev/null +++ b/docs/anr-provider-policy.md @@ -0,0 +1,54 @@ + +# ANR Provider Policy + +## Overview + +When `OPENCODE_FLAVOR=anr`, only AWS Bedrock providers are permitted. All other LLM providers are blocked at multiple enforcement points. + +## Allowed Providers + +```typescript +ANR_ALLOWED_PROVIDERS = [ + "amazon-bedrock", + "@ai-sdk/amazon-bedrock", + "@ai-sdk/amazon-bedrock/mantle" +] +``` + +## Enforcement Points + +| Location | File:Line | What It Does | +|----------|-----------|--------------| +| Provider Loader | `packages/opencode/src/provider/provider.ts:1760` | Filters provider registry to Bedrock-only | +| Env Var Clearing | `packages/anr-core/src/config/env-loader.ts:~400` | Deletes non-ANR provider API keys | +| HTTP API Guard | `packages/opencode/src/server/.../control.ts:~15` | Rejects non-Bedrock auth.set calls | +| Plugin Gate | `packages/opencode/src/plugin/index.ts:~80` | Filters plugins to Bedrock-compatible only | +| SKIP_AUTH Hardening | `packages/opencode/src/index.ts:~715` | Fatal error on release/beta channels | +| CI Check | `packages/opencode/src/provider/validate-anr-providers.test.ts` | Fails build if BUNDLED_PROVIDERS grows | + +## Testing + +To verify enforcement: + +```bash +# Set ANR mode +export OPENCODE_FLAVOR=anr + +# Try to use Anthropic (should fail) +export ANTHROPIC_API_KEY=sk-ant-xxx +bun dev + +# Provider list should only show Bedrock +``` + +## Bypass Attempts + +All 8 confirmed bypass paths are now blocked: +1. ✅ OPENCODE_ANR_SKIP_AUTH - hardened with channel check + audit log +2. ✅ Environment variable injection - API keys cleared in clearStaleEnv() +3. ✅ Config file poisoning - non-Bedrock providers stripped from merged config +4. ✅ HTTP API bypass - PUT /auth/:providerID guarded +5. ✅ Plugin bypass - plugins filtered to Bedrock-compatible only +6. ✅ OPENCODE_FLAVOR override - forced to "anr" when ANR markers detected +7. ✅ Model config override - cfg.model and cfg.small_model validated +8. ✅ BUNDLED_PROVIDERS growth - CI check fails build on unlisted providers diff --git a/packages/anr-core/src/config/env-loader.ts b/packages/anr-core/src/config/env-loader.ts index 1869ff1da359..31f60eb4aece 100644 --- a/packages/anr-core/src/config/env-loader.ts +++ b/packages/anr-core/src/config/env-loader.ts @@ -136,6 +136,9 @@ export function clearStaleEnv(): void { for (const key of STALE_KEYS) { delete process.env[key] } + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + const keys = ["ANTHROPIC_API_KEY","OPENAI_API_KEY","GROQ_API_KEY","MISTRAL_API_KEY","XAI_API_KEY","COHERE_API_KEY"] + keys.forEach(k => delete process.env[k]) } /** diff --git a/packages/opencode/src/anr/policy.ts b/packages/opencode/src/anr/policy.ts new file mode 100644 index 000000000000..98eebf07f0ce --- /dev/null +++ b/packages/opencode/src/anr/policy.ts @@ -0,0 +1,41 @@ +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +// Single source of truth for the ANR Bedrock-only provider policy. +// +// Two distinct namespaces live here and must not be mixed: +// - ANR_ALLOWED_PROVIDERS : ProviderV2.ID values (registry keys, config keys, HTTP route params) +// - ANR_ALLOWED_NPM : BUNDLED_PROVIDERS keys (npm package specifiers) + +export const ANR_ALLOWED_PROVIDERS: readonly string[] = ["amazon-bedrock", "amazon-bedrock-mantle"] + +export const ANR_ALLOWED_NPM: readonly string[] = ["@ai-sdk/amazon-bedrock", "@ai-sdk/amazon-bedrock/mantle"] + +export const NON_ANR_NPM: readonly string[] = [ + "@ai-sdk/anthropic", + "@ai-sdk/azure", + "@ai-sdk/google", + "@ai-sdk/google-vertex", + "@ai-sdk/google-vertex/anthropic", + "@ai-sdk/openai", + "@ai-sdk/openai-compatible", + "@openrouter/ai-sdk-provider", + "@ai-sdk/xai", + "@ai-sdk/mistral", + "@ai-sdk/groq", + "@ai-sdk/deepinfra", + "@ai-sdk/cerebras", + "@ai-sdk/cohere", + "@ai-sdk/gateway", + "@ai-sdk/togetherai", + "@ai-sdk/perplexity", + "@ai-sdk/vercel", + "@ai-sdk/alibaba", + "gitlab-ai-provider", + "@ai-sdk/github-copilot", + "venice-ai-sdk-provider", +] + +export function isANRAllowedProvider(providerID: string): boolean { + return ANR_ALLOWED_PROVIDERS.includes(providerID) +} + +export * as ANRPolicy from "./policy" diff --git a/packages/opencode/src/config/config.ts b/packages/opencode/src/config/config.ts index 5205f25682b9..4c9f92837837 100644 --- a/packages/opencode/src/config/config.ts +++ b/packages/opencode/src/config/config.ts @@ -23,6 +23,8 @@ import { Context, Duration, Effect, Exit, Fiber, Layer, Option, Schema } from "e import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http" import { EffectFlock } from "@opencode-ai/core/util/effect-flock" import { containsPath, type InstanceContext } from "../project/instance-context" +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +import { isANRAllowedProvider } from "../anr/policy" import { ConfigV1 } from "@opencode-ai/core/v1/config/config" import { RemoteAuthError } from "@opencode-ai/core/v1/config/error" import { ConfigPermissionV1 } from "@opencode-ai/core/v1/config/permission" @@ -534,6 +536,17 @@ const layer = Layer.effect( ) } + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + // ANR enforcement: strip non-Bedrock provider configs + if (process.env.OPENCODE_FLAVOR === "anr" && result.provider) { + for (const providerID of Object.keys(result.provider)) { + if (!isANRAllowedProvider(providerID)) { + yield* Effect.logWarning("[ANR] stripping non-Bedrock provider from merged config", { providerID }) + delete result.provider[providerID] + } + } + } + for (const [name, mode] of Object.entries(result.mode ?? {})) { result.agent = mergeDeep(result.agent ?? {}, { [name]: { diff --git a/packages/opencode/src/index.ts b/packages/opencode/src/index.ts index 50f777bf960d..5fb8be923c54 100644 --- a/packages/opencode/src/index.ts +++ b/packages/opencode/src/index.ts @@ -711,6 +711,13 @@ export async function main(argv?: string[]) { if (anrMode) { if (skipANRAuth) { + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + const channel = process.env.OPENCODE_CHANNEL || "dev" + if (channel === "release" || channel === "beta") { + process.stderr.write("[ANR] FATAL: OPENCODE_ANR_SKIP_AUTH not allowed on release/beta channels\n") + process.exit(1) + } + process.stderr.write(`[ANR] AUDIT: skip_auth used on ${channel} channel at ${new Date().toISOString()}\n`) process.stderr.write("[ANR] Skipping authentication/telemetry initialization via OPENCODE_ANR_SKIP_AUTH=1\n") } else { // If no --env-file flag, show picker (or auto-select if only one) diff --git a/packages/opencode/src/plugin/index.ts b/packages/opencode/src/plugin/index.ts index 1558c707c3f7..ed0472f4fe50 100644 --- a/packages/opencode/src/plugin/index.ts +++ b/packages/opencode/src/plugin/index.ts @@ -31,6 +31,8 @@ import type { WorkspaceAdapter } from "@/control-plane/types" import { RuntimeFlags } from "@/effect/runtime-flags" import { EventV2Bridge } from "@/event-v2-bridge" import { InstallationChannel } from "@opencode-ai/core/installation/version" +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +import { isANRAllowedProvider } from "../anr/policy" type State = { hooks: Hooks[] @@ -61,24 +63,36 @@ export function experimentalWebSocketsEnabled(input: { enabled: boolean; channel return input.enabled || ["local", "dev", "beta"].includes(input.channel ?? InstallationChannel) } -// Built-in plugins that are directly imported (not installed from npm) +// Built-in plugins that are directly imported (not installed from npm). +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +// Each entry carries the auth provider it registers. A Plugin is a bare function, so the provider it +// serves is only visible on the Hooks it resolves to at init time — too late to gate on. Tagging the +// list here keeps the ANR filter honest; keep the tag in sync when adding a plugin. function internalPlugins(flags: RuntimeFlags.Info): PluginInstance[] { - return [ - // Temporary rollout: pre-release builds use WebSockets by default; releases require explicit opt-in. - (input) => - CodexAuthPlugin(input, { - experimentalWebSockets: experimentalWebSocketsEnabled({ enabled: flags.experimentalWebSockets }), - }), - CopilotAuthPlugin, - GitlabAuthPlugin, - PoeAuthPlugin, - CloudflareWorkersAuthPlugin, - CloudflareAIGatewayAuthPlugin, - AzureAuthPlugin, - DigitalOceanAuthPlugin, - SnowflakeCortexAuthPlugin, - XaiAuthPlugin, + const tagged: { provider: string; plugin: PluginInstance }[] = [ + { + provider: "openai", + // Temporary rollout: pre-release builds use WebSockets by default; releases require explicit opt-in. + plugin: (input) => + CodexAuthPlugin(input, { + experimentalWebSockets: experimentalWebSocketsEnabled({ enabled: flags.experimentalWebSockets }), + }), + }, + { provider: "github-copilot", plugin: CopilotAuthPlugin }, + { provider: "gitlab", plugin: GitlabAuthPlugin }, + { provider: "poe", plugin: PoeAuthPlugin }, + { provider: "cloudflare-workers-ai", plugin: CloudflareWorkersAuthPlugin }, + { provider: "cloudflare-ai-gateway", plugin: CloudflareAIGatewayAuthPlugin }, + { provider: "azure", plugin: AzureAuthPlugin }, + { provider: "digitalocean", plugin: DigitalOceanAuthPlugin }, + { provider: "snowflake-cortex", plugin: SnowflakeCortexAuthPlugin }, + { provider: "xai", plugin: XaiAuthPlugin }, ] + + if (process.env.OPENCODE_FLAVOR === "anr") + return tagged.filter((entry) => isANRAllowedProvider(entry.provider)).map((entry) => entry.plugin) + + return tagged.map((entry) => entry.plugin) } function isServerPlugin(value: unknown): value is PluginInstance { diff --git a/packages/opencode/src/provider/provider.ts b/packages/opencode/src/provider/provider.ts index 0d61fd7437ca..16556ffa2ec3 100644 --- a/packages/opencode/src/provider/provider.ts +++ b/packages/opencode/src/provider/provider.ts @@ -28,6 +28,8 @@ import { optional } from "@opencode-ai/core/schema" import { ProviderTransform } from "./transform" import { ProviderV2 } from "@opencode-ai/core/provider" import { ModelV2 } from "@opencode-ai/core/model" +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +import { isANRAllowedProvider } from "../anr/policy" import { ModelStatus } from "./model-status" import { RuntimeFlags } from "@/effect/runtime-flags" import { ProviderError } from "./error" @@ -1756,6 +1758,16 @@ const layer = Layer.effect( }) } + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + if (process.env.OPENCODE_FLAVOR === "anr") { + for (const id of Object.keys(providers)) { + const providerID = ProviderV2.ID.make(id) + if (!isANRAllowedProvider(providerID)) { + delete providers[providerID] + } + } + } + for (const [id, provider] of Object.entries(providers)) { const providerID = ProviderV2.ID.make(id) if (!isProviderAllowed(providerID)) { @@ -2067,7 +2079,16 @@ const layer = Layer.effect( const getSmallModel = Effect.fn("Provider.getSmallModel")(function* (providerID: ProviderV2.ID) { const cfg = yield* config.get() - if (cfg.small_model) { + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + // ANR mode ignores a non-Bedrock small_model so auto-selection falls through to a Bedrock model. + const smallModelBlocked = + process.env.OPENCODE_FLAVOR === "anr" && + !!cfg.small_model && + !isANRAllowedProvider(cfg.small_model.split("/")[0]) + if (smallModelBlocked) + yield* Effect.logWarning("[ANR] ignoring non-Bedrock small_model", { small_model: cfg.small_model }) + + if (cfg.small_model && !smallModelBlocked) { const parsed = parseModel(cfg.small_model) return yield* getModel(parsed.providerID, parsed.modelID).pipe( Effect.catchTag("ProviderModelNotFoundError", () => Effect.succeed(undefined)), @@ -2135,7 +2156,14 @@ const layer = Layer.effect( const defaultModel = Effect.fn("Provider.defaultModel")(function* () { const cfg = yield* config.get() - if (cfg.model) return parseModel(cfg.model) + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + // ANR mode ignores a non-Bedrock cfg.model and falls through to auto-selection below, which only + // ever sees Bedrock providers because the registry is filtered at load time. + const modelBlocked = + process.env.OPENCODE_FLAVOR === "anr" && !!cfg.model && !isANRAllowedProvider(cfg.model.split("/")[0]) + if (modelBlocked) yield* Effect.logWarning("[ANR] ignoring non-Bedrock model", { model: cfg.model }) + + if (cfg.model && !modelBlocked) return parseModel(cfg.model) const s = yield* InstanceState.get(state) const recent = yield* fs.readJson(path.join(Global.Path.state, "model.json")).pipe( diff --git a/packages/opencode/src/server/routes/instance/httpapi/groups/control.ts b/packages/opencode/src/server/routes/instance/httpapi/groups/control.ts index 49f43f0154f6..9bc777f79c29 100644 --- a/packages/opencode/src/server/routes/instance/httpapi/groups/control.ts +++ b/packages/opencode/src/server/routes/instance/httpapi/groups/control.ts @@ -4,6 +4,8 @@ import { Schema } from "effect" import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi" import { described } from "./metadata" import { ProviderV2 } from "@opencode-ai/core/provider" +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +import { ForbiddenError } from "../errors" const AuthParams = Schema.Struct({ providerID: ProviderV2.ID, @@ -40,7 +42,9 @@ export const ControlApi = HttpApi.make("control").add( params: AuthParams, payload: Auth.Info, success: described(Schema.Boolean, "Successfully set authentication credentials"), - error: HttpApiError.BadRequest, + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + // ForbiddenError is returned when ANR mode rejects a non-Bedrock provider. + error: [HttpApiError.BadRequest, ForbiddenError], }).annotateMerge( OpenApi.annotations({ identifier: "auth.set", diff --git a/packages/opencode/src/server/routes/instance/httpapi/handlers/control.ts b/packages/opencode/src/server/routes/instance/httpapi/handlers/control.ts index 9974b19b4dfd..aaf9f67e8fa1 100644 --- a/packages/opencode/src/server/routes/instance/httpapi/handlers/control.ts +++ b/packages/opencode/src/server/routes/instance/httpapi/handlers/control.ts @@ -5,6 +5,9 @@ import { HttpApiBuilder } from "effect/unstable/httpapi" import { RootHttpApi } from "../api" import { LogInput } from "../groups/control" import { ProviderV2 } from "@opencode-ai/core/provider" +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +import { ForbiddenError } from "../errors" +import { isANRAllowedProvider } from "@/anr/policy" export const controlHandlers = HttpApiBuilder.group(RootHttpApi, "control", (handlers) => Effect.gen(function* () { @@ -14,6 +17,12 @@ export const controlHandlers = HttpApiBuilder.group(RootHttpApi, "control", (han params: { providerID: ProviderV2.ID } payload: Auth.Info }) { + // ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} + if (process.env.OPENCODE_FLAVOR === "anr" && !isANRAllowedProvider(ctx.params.providerID)) + return yield* new ForbiddenError({ + message: `Provider ${ctx.params.providerID} not allowed in ANR mode. Only Bedrock providers permitted.`, + }) + yield* auth.set(ctx.params.providerID, ctx.payload).pipe(Effect.orDie) return true }) diff --git a/packages/opencode/test/provider/validate-anr-providers.test.ts b/packages/opencode/test/provider/validate-anr-providers.test.ts new file mode 100644 index 000000000000..45dc80310bff --- /dev/null +++ b/packages/opencode/test/provider/validate-anr-providers.test.ts @@ -0,0 +1,67 @@ +// ANRCODE_CHANGE {"issue":17,"branch":"anr-bedrock-enforcement","date":"2026-07-30"} +import { describe, test, expect } from "bun:test" +import path from "path" +import { ANR_ALLOWED_NPM, NON_ANR_NPM, ANR_ALLOWED_PROVIDERS, isANRAllowedProvider } from "../../src/anr/policy" + +const PROVIDER_FILE = path.join(import.meta.dir, "../../src/provider/provider.ts") + +async function bundledProviderKeys() { + const source = await Bun.file(PROVIDER_FILE).text() + const start = source.indexOf("const BUNDLED_PROVIDERS") + if (start === -1) throw new Error("Could not find BUNDLED_PROVIDERS in provider.ts") + + // Walk from the opening brace of the object literal to its matching close, so arrow-function + // bodies and nested braces inside the entries cannot terminate the scan early. + const open = source.indexOf("{", source.indexOf("=", start)) + let depth = 0 + let end = -1 + for (let i = open; i < source.length; i++) { + if (source[i] === "{") depth++ + if (source[i] === "}") { + depth-- + if (depth === 0) { + end = i + break + } + } + } + if (end === -1) throw new Error("Could not find end of BUNDLED_PROVIDERS object literal") + + return [...source.slice(open, end).matchAll(/^\s*["']([^"']+)["']\s*:/gm)].map((m) => m[1]) +} + +describe("ANR Provider Allowlist CI Check", () => { + test("BUNDLED_PROVIDERS must not grow without a policy update", async () => { + const keys = await bundledProviderKeys() + expect(keys.length).toBeGreaterThan(0) + + const known = new Set([...ANR_ALLOWED_NPM, ...NON_ANR_NPM]) + const unlisted = keys.filter((key) => !known.has(key)) + + expect( + unlisted, + `BUNDLED_PROVIDERS contains unlisted providers: ${unlisted.join(", ")}. ` + + `Add each to ANR_ALLOWED_NPM or NON_ANR_NPM in src/anr/policy.ts.`, + ).toEqual([]) + }) + + test("every allowlisted npm package is actually bundled", async () => { + const keys = new Set(await bundledProviderKeys()) + expect(ANR_ALLOWED_NPM.filter((npm) => !keys.has(npm))).toEqual([]) + }) + + test("the two policy namespaces stay disjoint", () => { + // Provider IDs are registry keys; npm names are BUNDLED_PROVIDERS keys. Mixing them silently + // breaks enforcement, so no value may appear in both lists. + const npm = new Set([...ANR_ALLOWED_NPM, ...NON_ANR_NPM]) + expect(ANR_ALLOWED_PROVIDERS.filter((id) => npm.has(id))).toEqual([]) + }) + + test("allows both Bedrock provider IDs and rejects everything else", () => { + expect(isANRAllowedProvider("amazon-bedrock")).toBe(true) + expect(isANRAllowedProvider("amazon-bedrock-mantle")).toBe(true) + expect(isANRAllowedProvider("anthropic")).toBe(false) + expect(isANRAllowedProvider("openai")).toBe(false) + expect(isANRAllowedProvider("@ai-sdk/amazon-bedrock")).toBe(false) + }) +})