fix(home-assistant): respect OOMOL_CONNECT_ALLOW_PRIVATE_NETWORK

Home Assistant instances on a LAN (e.g. 10.0.0.5) were rejected by the SSRF
egress guard even when the deployment set OOMOL_CONNECT_ALLOW_PRIVATE_NETWORK,
because the provider's executor definition never passed allowPrivateNetwork to
defineProviderExecutors. Without that opt-in the runtime falls back to the
shared public-only providerFetch, so the deployment flag had no effect for
Home Assistant.

Pass allowPrivateNetwork: isPrivateNetworkAccessAllowed, matching the 26 other
providers that already wire it.

Default behavior is unchanged: with the flag unset, private targets stay
blocked. Loopback, link-local, and cloud-metadata targets remain blocked in
both states.

Cover the opt-in beside the shared module in provider-runtime.test.ts, per
AGENTS.md ("Keep open-source-only shared-infrastructure tests beside the
shared module rather than inside a provider directory").

Author: reopenpilot

src/providers/home_assistant/executors.ts

@@ -1,6 +1,7 @@
 import type { CredentialValidators, ExecutionContext, ProviderExecutors } from "../../core/types.ts";
 import type { HomeAssistantActionContext } from "./runtime.ts";
 
+import { isPrivateNetworkAccessAllowed } from "../../core/request.ts";
 import { defineProviderExecutors, requireApiKeyCredential } from "../provider-runtime.ts";
 import {
   homeAssistantActionHandlers,
@@ -13,6 +14,7 @@ const service = "home_assistant";
 export const executors: ProviderExecutors = defineProviderExecutors<HomeAssistantActionContext>({
   service,
   handlers: homeAssistantActionHandlers,
+  allowPrivateNetwork: isPrivateNetworkAccessAllowed,
   async createContext(context: ExecutionContext, fetcher: typeof fetch): Promise<HomeAssistantActionContext> {
     const credential = await requireApiKeyCredential(context, service);
     return {

src/providers/provider-runtime.test.ts

@@ -1,7 +1,7 @@
 import type { ExecutionContext, ResolvedCredential } from "../core/types.ts";
 
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { setPrivateNetworkAccessAllowed } from "../core/request.ts";
+import { isPrivateNetworkAccessAllowed, setPrivateNetworkAccessAllowed } from "../core/request.ts";
 import {
   createProviderTimeout,
   defineProviderExecutors,
@@ -136,6 +136,68 @@ describe("provider egress SSRF guard", () => {
     expect(response.status).toBe(302);
     expect(calls).toHaveLength(1);
   });
+
+  it("blocks private targets for executors that do not opt in", async () => {
+    const calls = stubFetchSequence([new Response("{}", { status: 200 })]);
+    const executors = defineProviderExecutors<{ fetcher: typeof fetch }>({
+      service: "test_service",
+      handlers: {
+        async probe(_input, context) {
+          return { status: (await context.fetcher("http://10.0.0.5:8123/api/")).status };
+        },
+      },
+      createContext: (_context, fetcher) => ({ fetcher }),
+    });
+    setPrivateNetworkAccessAllowed(true);
+
+    const result = await executors["test_service.probe"]!({}, executionContext);
+
+    expect(result.ok).toBe(false);
+    expect(result.error?.message).toContain("must not target private or reserved IP addresses");
+    expect(calls).toHaveLength(0);
+  });
+
+  it("reaches private targets for opted-in executors once the deployment enables the flag", async () => {
+    const calls = stubFetchSequence([new Response("{}", { status: 200 })]);
+    const executors = defineProviderExecutors<{ fetcher: typeof fetch }>({
+      service: "test_service",
+      handlers: {
+        async probe(_input, context) {
+          return { status: (await context.fetcher("http://10.0.0.5:8123/api/")).status };
+        },
+      },
+      createContext: (_context, fetcher) => ({ fetcher }),
+      allowPrivateNetwork: isPrivateNetworkAccessAllowed,
+    });
+    setPrivateNetworkAccessAllowed(true);
+
+    const result = await executors["test_service.probe"]!({}, executionContext);
+
+    expect(result.ok).toBe(true);
+    expect(calls.map((call) => call.url)).toEqual(["http://10.0.0.5:8123/api/"]);
+  });
+
+  it("keeps the opt-in gated on the deployment flag and never unblocks loopback", async () => {
+    const executors = defineProviderExecutors<{ fetcher: typeof fetch }>({
+      service: "test_service",
+      handlers: {
+        async probe(_input, context) {
+          return { status: (await context.fetcher(_input.url as string)).status };
+        },
+      },
+      createContext: (_context, fetcher) => ({ fetcher }),
+      allowPrivateNetwork: isPrivateNetworkAccessAllowed,
+    });
+
+    const calls = stubFetchSequence([]);
+    const disabled = await executors["test_service.probe"]!({ url: "http://10.0.0.5:8123/api/" }, executionContext);
+    setPrivateNetworkAccessAllowed(true);
+    const loopback = await executors["test_service.probe"]!({ url: "http://127.0.0.1:8123/api/" }, executionContext);
+
+    expect(disabled.ok).toBe(false);
+    expect(loopback.ok).toBe(false);
+    expect(calls).toHaveLength(0);
+  });
 });
 
 describe("provider runtime fetch", () => {