fix(provider): stop meta credentials crossing endpoints

Author: TheGreatAxios

packages/first-class-providers/src/index.ts

@@ -1,5 +1,6 @@
 export {
   FIRST_CLASS_PROVIDERS,
+  META_API_KEY_PROVIDER_ID,
   OPENAI_API_BASE_URL,
   OPENAI_API_MAX_COMPLETION_TOKENS_MODELS,
   firstClassPathAsProvider,

packages/first-class-providers/src/providers.test.ts

@@ -112,7 +112,7 @@ describe("FIRST_CLASS_PROVIDERS", () => {
 
     const api = meta?.paths?.find((p) => p.id === "api");
     expect(api?.auth).toBe("api-key");
-    expect(api?.providerId).toBe("meta");
+    expect(api?.providerId).toBe("meta-api");
     expect(api?.baseURL).toBe("https://api.meta.ai/v1");
     expect(api?.defaultModel).toBe("muse-spark-1.3");
     expect((api?.models ?? []).length).toBeGreaterThan(0);

packages/first-class-providers/src/providers.ts

@@ -16,6 +16,9 @@ import {
 import { META_BASE_URL, META_DEFAULT_MODELS } from "@corbits/meta-provider";
 import type { FirstClassProviderDef } from "./types.js";
 
+/** Settings id for a pasted Meta API key. OAuth profiles stay under `meta/<slug>`. */
+export const META_API_KEY_PROVIDER_ID = "meta-api";
+
 const OPENAI_API_MODELS = [
   "gpt-6-astra",
   "gpt-5.4",
@@ -109,7 +112,7 @@ export const FIRST_CLASS_PROVIDERS: readonly FirstClassProviderDef[] = [
         models: META_DEFAULT_MODELS,
         defaultModel: "muse-spark-1.3",
         authHint: "Paste your Meta API key (LLM|...)",
-        providerId: "meta",
+        providerId: META_API_KEY_PROVIDER_ID,
       },
     ],
   },

src/auth/meta/login.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { startMetaLogin } from "./login.js";
 import { loadMetaProfile } from "../../config/oauth-stores.js";
+import { REJECTED_META_VERIFICATION_URI } from "./verification-uri.js";
 
 const AUTH_URL = "https://auth.meta.com/oidc/device/authorization/";
 const TOKEN_URL = "https://auth.meta.com/oidc/device/token/";
@@ -91,6 +92,38 @@ describe("startMetaLogin (device flow)", () => {
     });
   });
 
+  test("does not forward an http or non-Meta verification URI", async () => {
+    const fetchImpl = (async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url === AUTH_URL) {
+        return jsonResponse({
+          device_code: "dc-1",
+          user_code: "ABCD-1234",
+          verification_uri_complete: "http://evil.example/device?code=ABCD",
+          interval: 1,
+          expires_in: 1800,
+        });
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    }) as unknown as typeof fetch;
+
+    let notified = false;
+    const controller = new AbortController();
+    const handle = startMetaLogin({
+      profile: "work",
+      signal: controller.signal,
+      fetchImpl,
+      sleep: noopSleep,
+      notify: () => {
+        notified = true;
+      },
+    });
+    await expect(handle.completed).rejects.toThrow(
+      REJECTED_META_VERIFICATION_URI,
+    );
+    expect(notified).toBe(false);
+  });
+
   test("abort rejects with the cancelled-login message", async () => {
     const fetchImpl = (async (input: RequestInfo | URL, init?: RequestInit) => {
       const url = String(input);

src/auth/meta/login.ts

@@ -2,6 +2,10 @@ import { metaDeviceLogin, type MetaOAuthTokens } from "@corbits/meta-provider";
 
 import type { AuthProfile } from "../store.js";
 import { saveMetaProfile } from "../../config/oauth-stores.js";
+import {
+  isPinnedMetaVerificationUri,
+  REJECTED_META_VERIFICATION_URI,
+} from "./verification-uri.js";
 
 export type MetaLoginHandle = {
   authorizeUrl: string;
@@ -44,13 +48,15 @@ export function startMetaLogin(opts: StartMetaLoginOptions): MetaLoginHandle {
       ...(opts.sleep !== undefined ? { sleep: opts.sleep } : {}),
       ...(opts.now !== undefined ? { now: opts.now } : {}),
       notify: (event) => {
-        if (event.type === "device_code") {
-          opts.notify?.({
-            type: "device_code",
-            verificationUri: event.verificationUri,
-            userCode: event.userCode,
-          });
+        if (event.type !== "device_code") return;
+        if (!isPinnedMetaVerificationUri(event.verificationUri)) {
+          throw new Error(REJECTED_META_VERIFICATION_URI);
         }
+        opts.notify?.({
+          type: "device_code",
+          verificationUri: event.verificationUri,
+          userCode: event.userCode,
+        });
       },
     });
     const profile: AuthProfile<MetaOAuthTokens> = {

src/auth/meta/verification-uri.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+
+import { isPinnedMetaVerificationUri } from "./verification-uri.js";
+
+describe("isPinnedMetaVerificationUri", () => {
+  test("accepts https on Meta's auth host", () => {
+    expect(
+      isPinnedMetaVerificationUri(
+        "https://auth.meta.com/device?code=ABCD-1234",
+      ),
+    ).toBe(true);
+  });
+
+  test("rejects http and non-Meta hosts", () => {
+    expect(
+      isPinnedMetaVerificationUri("http://auth.meta.com/device?code=ABCD"),
+    ).toBe(false);
+    expect(
+      isPinnedMetaVerificationUri("https://evil.example/device?code=ABCD"),
+    ).toBe(false);
+    expect(
+      isPinnedMetaVerificationUri("https://auth.meta.com.evil.example/device"),
+    ).toBe(false);
+    expect(isPinnedMetaVerificationUri("not a url")).toBe(false);
+  });
+});

src/auth/meta/verification-uri.ts

@@ -0,0 +1,15 @@
+import { META_AUTH_HOST } from "@corbits/meta-provider";
+
+const META_AUTH_HOSTNAME = new URL(META_AUTH_HOST).hostname;
+
+export const REJECTED_META_VERIFICATION_URI = "rejected verification url";
+
+/** https on Meta's auth host only. The device-flow package allows any http(s) URL. */
+export function isPinnedMetaVerificationUri(uri: string): boolean {
+  try {
+    const url = new URL(uri);
+    return url.protocol === "https:" && url.hostname === META_AUTH_HOSTNAME;
+  } catch {
+    return false;
+  }
+}

src/auth/remove-provider.test.ts

@@ -7,6 +7,9 @@ import {
   listCodexProfiles,
   loadCodexProfile,
   saveCodexProfile,
+  listMetaProfiles,
+  loadMetaProfile,
+  saveMetaProfile,
 } from "../config/oauth-stores.js";
 import {
   listXaiProfiles,
@@ -128,4 +131,24 @@ describe("oauthStoreForProvider", () => {
       expect(await codex?.removeProfile(codex.profile, home)).toEqual([]);
     });
   });
+
+  test("removing an OAuth-backed meta row deletes that auth-store profile", async () => {
+    await withHome(async (home) => {
+      const tokens = { access: "LLM|a", refresh: "id", expiresAt: 10_000_000 };
+      await saveMetaProfile({ name: "default", createdAt: 0, tokens }, home);
+      await saveMetaProfile({ name: "work", createdAt: 0, tokens }, home);
+      const target = oauthStoreForProvider({
+        name: "meta/default",
+        metaProfile: "default",
+      });
+      expect(await target?.removeProfile(target.profile, home)).toEqual([
+        "default",
+      ]);
+      expect(await loadMetaProfile("default", home)).toBeUndefined();
+      expect(
+        (await listMetaProfiles(home)).map((profile) => profile.name),
+      ).toEqual(["work"]);
+      expect(oauthStoreForProvider({ name: "meta-api/default" })).toBeNull();
+    });
+  });
 });

src/config/index.ts

@@ -54,6 +54,7 @@ import {
   metaProfilesToCatalogEntries,
   metaProvidersAsSettings,
 } from "./meta-providers.js";
+import { separateCollidingMetaApiKeys } from "./meta-api-key.js";
 import { fetchBifrostModels } from "./bifrost.js";
 import { customReasoningSettings } from "./providers.js";
 
@@ -108,6 +109,7 @@ import {
   resolveLocalSettingsPath,
   normalizeOpenAICompatibleBaseURL,
   resolveProvider,
+  saveGlobalSettings,
   hasMcpTransport,
   isExaMCPPreset,
   type MCPServerSettingsEntry,
@@ -459,6 +461,7 @@ export function buildMetaSource(fields: {
 export function buildMetaApiKeySource(fields: {
   id: string;
   apiKey?: string;
+  baseURL?: string;
   model: string;
   sessionId: string;
   reasoningEffort?: ReasoningEffort;
@@ -467,10 +470,14 @@ export function buildMetaApiKeySource(fields: {
   if (fields.reasoningEffort !== undefined)
     providerOptions[META_REASONING_EFFORT_OPTION] = fields.reasoningEffort;
   registerSourceSecret(fields.id, fields.apiKey);
+  const configured = fields.baseURL?.trim() ?? "";
   return {
     id: fields.id,
     provider: META_PROVIDER,
-    baseURL: META_BASE_URL,
+    baseURL:
+      configured.length > 0
+        ? normalizeOpenAICompatibleBaseURL(configured)
+        : META_BASE_URL,
     credentialId: fields.id,
     model: fields.model,
     defaults: { maxTokens: SOURCE_MAX_TOKENS, providerOptions },
@@ -1104,7 +1111,7 @@ export async function loadConfig(
     ...xaiProvidersAsSettings(xaiProfiles),
     ...metaProvidersAsSettings(metaProfiles),
   };
-  const settings =
+  let settings =
     configPath !== undefined
       ? await loadSettingsRecoveringClobberedOAuthSelection(
           configPath,
@@ -1122,6 +1129,25 @@ export async function loadConfig(
           projectedOAuthProviders,
           { persist: true },
         );
+  const separatedMeta = separateCollidingMetaApiKeys(
+    settings,
+    metaProfiles.map((profile) => profile.name),
+  );
+  if (
+    separatedMeta.changed &&
+    separatedMeta.settings !== null &&
+    configPath === undefined &&
+    useOAuthProfiles
+  ) {
+    try {
+      await saveGlobalSettings(effectiveSettingsPath, separatedMeta.settings);
+    } catch {
+      process.stderr.write(
+        `settings: failed to persist Meta API-key separation for ${effectiveSettingsPath}; continuing with in-memory settings.\n`,
+      );
+    }
+  }
+  settings = separatedMeta.settings;
 
   // True when the value came from settings, not this invocation's
   // --dangerously-skip-permissions flag (Config.skipPermissionsFromSettings).
@@ -1388,30 +1414,39 @@ export function mergeOAuthCatalog(
   xaiProfiles: readonly XaiProfile[],
   metaProfiles: readonly MetaProfile[],
 ): ProviderCatalogEntry[] {
+  const separated = separateCollidingMetaApiKeys(
+    settings,
+    metaProfiles.map((profile) => profile.name),
+  ).settings;
   const codexEntries = codexProfilesToCatalogEntries(codexProfiles);
   const xaiEntries = xaiProfilesToCatalogEntries(xaiProfiles);
   const metaEntries = metaProfilesToCatalogEntries(metaProfiles);
+  const bareMeta = separated?.providers["meta"];
+  const bareMetaHasApiKey =
+    typeof bareMeta?.apiKey === "string" && bareMeta.apiKey.length > 0;
   // Legacy bare `codex`/`xai` row (the original single-instance connect key)
   // next to live credential-backed `<kind>/<profile>` entries reads as a
   // second provider. Drop it once that family has a live profile; when
   // nothing is connected the bare row is the only ChatGPT/Grok access and
   // stays. A bare row at a different endpoint is a distinct provider (see
-  // sameEndpoint), so it stays too.
+  // sameEndpoint), so it stays too. A bare `meta` row with its own API key
+  // is not a legacy placeholder and stays beside OAuth profiles.
   const dropBare = new Set([
     ...(codexEntries.length > 0 &&
-    sameEndpoint(settings?.providers["codex"]?.baseURL, CODEX_BASE_URL)
+    sameEndpoint(separated?.providers["codex"]?.baseURL, CODEX_BASE_URL)
       ? ["codex"]
       : []),
     ...(xaiEntries.length > 0 &&
-    sameEndpoint(settings?.providers["xai"]?.baseURL, XAI_BASE_URL)
+    sameEndpoint(separated?.providers["xai"]?.baseURL, XAI_BASE_URL)
       ? ["xai"]
       : []),
     ...(metaEntries.length > 0 &&
-    sameEndpoint(settings?.providers["meta"]?.baseURL, META_BASE_URL)
+    !bareMetaHasApiKey &&
+    sameEndpoint(bareMeta?.baseURL, META_BASE_URL)
       ? ["meta"]
       : []),
   ]);
-  const settingsRows = buildProviderCatalog(settings, resolved);
+  const settingsRows = buildProviderCatalog(separated, resolved);
   // A hand-named codex/<slug> or xai/<slug> API-key row is explicit config,
   // not an OAuth placeholder (see isHandNamedProviderEntry): keep it and skip
   // the colliding live profile projection. buildProviderCatalog
@@ -1420,7 +1455,7 @@ export function mergeOAuthCatalog(
   // profile marker — treating it as hand-named would eject the real marked
   // entry for a stale token snapshot.
   const handNamed = new Set(
-    Object.entries(settings?.providers ?? {})
+    Object.entries(separated?.providers ?? {})
       .filter(
         ([name, provider]) =>
           (isCodexProviderName(name) ||

src/config/inference-sources.test.ts

@@ -229,6 +229,31 @@ describe("source credential provenance", () => {
     });
   });
 
+  test("a meta row with a non-Meta base URL keeps that URL and its key", () => {
+    const source = buildInferenceSourceForRef(
+      { provider: "meta", model: "muse-spark-1.3" },
+      {
+        sessionId: "sess-meta-gateway",
+        catalog: [
+          {
+            name: "meta",
+            baseURL: "https://gateway.corp.example/v1",
+            apiKey: "sk-corp",
+            models: ["muse-spark-1.3"],
+          },
+        ],
+      },
+      undefined,
+    );
+
+    if (source === null) throw new Error("expected Meta API-key source");
+    expect(source.baseURL).toBe("https://gateway.corp.example/v1");
+    expect(source.baseURL).not.toBe("https://api.meta.ai/v1");
+    expect(
+      readSourceCredentialRecord(source.credentialId).material.secret,
+    ).toBe("sk-corp");
+  });
+
   test("namespaced API-key rows are not inferred as OAuth", () => {
     const source = buildInferenceSourceForRef(
       { provider: "codex/shadow", model: "relay-model" },