AppConfig Feature Flags: Kill Switches for Agent Tools Without Redeploy

// ❌ Kill switch buried in Lambda env — requires redeploy
const ENABLED = (process.env.ENABLED_TOOLS ?? "")
 .split(",")
 .filter(Boolean);

export function isToolEnabled(name: string): boolean {
 return ENABLED.includes(name); // stale until next deploy
}

{
 "tools": {
 "shell_exec": { "enabled": false, "reason": "incident-2026-09-19" },
 "read_file": { "enabled": true },
 "apply_patch": { "enabled": true, "maxBytes": 65536 }
 },
 "agent": { "maxDepth": 2, "modelId": "anthropic.claude-sonnet-4-20250514-v1:0" },
 "failClosed": true
}

// ✅ AppConfig agent extension / GetLatestConfiguration pattern
import {
 AppConfigDataClient,
 StartConfigurationSessionCommand,
 GetLatestConfigurationCommand,
} from "@aws-sdk/client-appconfigdata";

const client = new AppConfigDataClient({});
let token: string | undefined;
let cached: AgentPolicy | null = null;
let fetchedAt = 0;
const POLL_MS = 30_000; // ✅ short for kill switches; not 5 minutes

type AgentPolicy = {
 tools: Record<string, { enabled: boolean; maxBytes?: number }>;
 agent: { maxDepth: number; modelId: string };
 failClosed: boolean;
};

async function refreshPolicy(): Promise<AgentPolicy | null> {
 if (!token) {
 const start = await client.send(
 new StartConfigurationSessionCommand({
 ApplicationIdentifier: process.env.APPCONFIG_APP!,
 EnvironmentIdentifier: process.env.APPCONFIG_ENV!,
 ConfigurationProfileIdentifier: process.env.APPCONFIG_PROFILE!,
 RequiredMinimumPollIntervalInSeconds: 15,
 })
 );
 token = start.InitialConfigurationToken!;
 }
 const out = await client.send(
 new GetLatestConfigurationCommand({ ConfigurationToken: token })
 );
 token = out.NextPollConfigurationToken ?? token;
 if (out.Configuration && out.Configuration.byteLength > 0) {
 cached = JSON.parse(Buffer.from(out.Configuration).toString("utf8"));
 fetchedAt = Date.now();
 }
 return cached;
}

export async function getPolicy(): Promise<AgentPolicy> {
 const stale = Date.now() - fetchedAt > POLL_MS;
 if (!cached || stale) {
 try {
 const p = await refreshPolicy();
 if (p) return p;
 } catch (err) {
 // fall through to fail-closed
 console.error("appconfig_unreachable", err);
 }
 }
 if (cached) return cached;
 // ❌ Do NOT default to "all tools on" when AppConfig is down
 return {
 tools: {},
 agent: { maxDepth: 0, modelId: process.env.SAFE_MODEL_ID! },
 failClosed: true,
 };
}

// ✅ Prefer the Lambda extension HTTP endpoint when available
export async function getPolicyViaExtension(): Promise<AgentPolicy> {
 const app = process.env.AWS_APPCONFIG_APPLICATION!;
 const env = process.env.AWS_APPCONFIG_ENVIRONMENT!;
 const profile = process.env.AWS_APPCONFIG_CONFIGURATION_PROFILE!;
 const url =
 `http://localhost:2772/applications/${app}/environments/${env}` +
 `/configurations/${profile}`;
 try {
 const res = await fetch(url, { signal: AbortSignal.timeout(800) });
 if (!res.ok) throw new Error(`appconfig_http_${res.status}`);
 return (await res.json()) as AgentPolicy;
 } catch {
 // fail closed — empty allowlist
 return {
 tools: {},
 agent: { maxDepth: 0, modelId: process.env.SAFE_MODEL_ID! },
 failClosed: true,
 };
 }
}

// ✅ Tool gate that fails closed
export async function assertToolAllowed(
 toolName: string,
 depth: number
): Promise<{ ok: true } | { ok: false; error: string }> {
 const policy = await getPolicy();
 if (policy.failClosed && Object.keys(policy.tools).length === 0) {
 return { ok: false, error: "agent_policy_unavailable" };
 }
 const t = policy.tools[toolName];
 if (!t?.enabled) {
 return { ok: false, error: "tool_disabled_by_flag" };
 }
 if (depth > policy.agent.maxDepth) {
 return { ok: false, error: "maxDepth_flag_exceeded" };
 }
 return { ok: true };
}