Scheduling infrastructure for absolutely everyone.
fix: oauth flow for safari extension (companion) (#26795)
Carina Wollendorferbb9581d0d91f
diff --git a/companion/extension/entrypoints/background/index.ts b/companion/extension/entrypoints/background/index.tsindex a8db6627405..08b342c4975 100644--- a/companion/extension/entrypoints/background/index.ts+++ b/companion/extension/entrypoints/background/index.ts@@ -242,6 +242,15 @@ function getBrowserDisplayName(): string {* These provide unified access to browser extension APIs across Chrome, Firefox, Safari, and Edge*/+/**+ * Extended browser API interface that includes browserAction (Manifest V2)+ * Safari uses browserAction instead of action+ */+interface BrowserAPIWithLegacyAction {+ action?: typeof chrome.action;+ browserAction?: typeof chrome.action;+}+// Get the appropriate browser API namespacefunction getBrowserAPI(): typeof chrome {if (typeof browser !== "undefined" && browser?.runtime) {@@ -278,8 +287,8 @@ function getTabsAPI(): typeof chrome.tabs | null {function getActionAPI(): typeof chrome.action | null {const api = getBrowserAPI();// Safari uses browserAction (Manifest V2), Chrome uses action (Manifest V3)- // biome-ignore lint/suspicious/noExplicitAny: Safari's browserAction API is not in Chrome types- return api?.action || (api as any)?.browserAction || null;+ const apiWithLegacyAction = api as unknown as BrowserAPIWithLegacyAction;+ return api?.action || apiWithLegacyAction?.browserAction || null;}// Check if the URL is a restricted page where content scripts can't run@@ -363,16 +372,24 @@ export default defineBackground(() => {const authUrl = message.authUrl as string;const state = new URL(authUrl).searchParams.get("state");- if (state && storageAPI?.local) {- storageAPI.local.set({ oauth_state: state }, () => {- const runtime = getRuntimeAPI();- if (runtime?.lastError) {- devLog.warn("Failed to store OAuth state:", runtime.lastError.message);- }- });- }+ // Store state before starting OAuth to prevent race conditions+ const storeState = async () => {+ if (!state) {+ throw new Error("No state parameter in auth URL");+ }+ if (!storageAPI?.local) {+ throw new Error("Storage API not available");+ }+ try {+ await storageAPI.local.set({ oauth_state: state });+ } catch (error) {+ devLog.error("Failed to store OAuth state:", error);+ throw new Error("Failed to initialize OAuth flow - cannot store state");+ }+ };- handleExtensionOAuth(authUrl)+ storeState()+ .then(() => handleExtensionOAuth(authUrl)).then((responseUrl) => sendResponse({ success: true, responseUrl })).catch((error) => sendResponse({ success: false, error: error.message }));return true;@@ -493,9 +510,15 @@ export default defineBackground(() => {});async function handleExtensionOAuth(authUrl: string): Promise<string> {- const identityAPI = getIdentityAPI();const browserType = detectBrowser();+ // Safari uses tabs-based OAuth flow+ if (browserType === BrowserType.Safari) {+ return handleSafariTabsOAuth(authUrl);+ }++ const identityAPI = getIdentityAPI();+if (!identityAPI) {throw new Error(`Identity API not available in ${getBrowserDisplayName()}`);}@@ -521,8 +544,8 @@ async function handleExtensionOAuth(authUrl: string): Promise<string> {}return new Promise((resolve, reject) => {- // Firefox and Safari use Promise-based API- if (browserType === BrowserType.Firefox || browserType === BrowserType.Safari) {+ // Firefox uses Promise-based API+ if (browserType === BrowserType.Firefox) {try {const result = identityAPI.launchWebAuthFlow({url: authUrl,@@ -568,6 +591,168 @@ async function handleExtensionOAuth(authUrl: string): Promise<string> {});}+/**+ * Handle Safari OAuth using tabs-based flow+ * Opens OAuth in a new tab and captures the redirect callback+ */+async function handleSafariTabsOAuth(authUrl: string): Promise<string> {+ // Extract the redirect URI to know what to watch for+ const redirectUri = new URL(authUrl).searchParams.get("redirect_uri");+ if (!redirectUri) {+ throw new Error("redirect_uri not found in auth URL");+ }++ const redirectUrlObj = new URL(redirectUri);+ const redirectOrigin = redirectUrlObj.origin; // scheme + host + port+ const redirectPath = redirectUrlObj.pathname;++ return new Promise((resolve, reject) => {+ const tabsAPI = getTabsAPI();+ if (!tabsAPI) {+ reject(new Error("Tabs API not available"));+ return;+ }++ let oauthTabId: number | null = null;+ let isResolved = false;++ const timeoutId = setTimeout(+ () => {+ if (!isResolved) {+ cleanup();+ reject(new Error("OAuth flow timed out after 5 minutes"));+ }+ },+ 5 * 60 * 1000+ );++ const tabUpdateListener = (tabId: number, _changeInfo: unknown, tab: chrome.tabs.Tab) => {+ // Only process updates for our OAuth tab+ if (tabId !== oauthTabId) return;++ // Check if the tab navigated to the redirect URI+ if (tab.url) {+ try {+ const tabUrl = new URL(tab.url);++ // Check if this is our OAuth callback URL - exact origin and path match+ if (tabUrl.origin === redirectOrigin && tabUrl.pathname === redirectPath) {+ if (!isResolved) {+ const error = tabUrl.searchParams.get("error");+ if (error) {+ isResolved = true;+ cleanup();+ const errorDescription = tabUrl.searchParams.get("error_description") || error;++ // Close the tab after capturing error+ if (oauthTabId !== null) {+ tabsAPI.remove(oauthTabId).catch(() => {+ // Ignore errors when closing tab+ });+ }++ reject(new Error(`OAuth error: ${errorDescription}`));+ return;+ }++ const code = tabUrl.searchParams.get("code");+ if (!code) {+ // No code yet, keep listening (might be an intermediate redirect)+ return;+ }++ const state = tabUrl.searchParams.get("state");+ if (!state) {+ isResolved = true;+ cleanup();++ // Close the tab+ if (oauthTabId !== null) {+ tabsAPI.remove(oauthTabId).catch(() => {+ // Ignore errors when closing tab+ });+ }++ reject(new Error("No state parameter in OAuth callback"));+ return;+ }++ // State validation - only close tab after validation succeeds+ isResolved = true;+ cleanup();++ validateOAuthStateWithoutCleanup(state)+ .then(() => {+ // State is valid, close the tab and resolve+ // Note: State is NOT cleaned up here, token exchange will clean it up+ if (oauthTabId !== null) {+ tabsAPI.remove(oauthTabId).catch(() => {+ // Ignore errors when closing tab+ });+ }+ if (!tab.url) {+ reject(new Error("Tab URL is undefined"));+ return;+ }+ resolve(tab.url);+ })+ .catch((error) => {+ // State validation failed, close the tab and reject+ if (oauthTabId !== null) {+ tabsAPI.remove(oauthTabId).catch(() => {+ // Ignore errors when closing tab+ });+ }+ reject(error);+ });+ }+ }+ } catch (_error) {+ // Invalid URL, ignore+ }+ }+ };++ // Listen for tab removal (user closed the OAuth tab)+ const tabRemovedListener = (tabId: number) => {+ if (tabId === oauthTabId && !isResolved) {+ isResolved = true;+ cleanup();+ reject(new Error("OAuth cancelled by user"));+ }+ };++ const cleanup = () => {+ clearTimeout(timeoutId);+ tabsAPI.onUpdated.removeListener(tabUpdateListener);+ tabsAPI.onRemoved.removeListener(tabRemovedListener);+ };++ // Register listeners+ tabsAPI.onUpdated.addListener(tabUpdateListener);+ tabsAPI.onRemoved.addListener(tabRemovedListener);++ // Open OAuth URL in a new tab+ tabsAPI+ .create({+ url: authUrl,+ active: true,+ })+ .then((tab) => {+ if (tab.id) {+ oauthTabId = tab.id;+ } else {+ cleanup();+ reject(new Error("Failed to create OAuth tab"));+ }+ })+ .catch((error) => {+ cleanup();+ reject(new Error(`Failed to open OAuth tab: ${error.message}`));+ });+ });+}+async function handleTokenExchange(tokenRequest: Record<string, string>,tokenEndpoint: string,@@ -617,31 +802,61 @@ async function handleTokenExchange(return tokens;}+/**+ * Validates OAuth state without cleaning it up (for Safari flow)+ * Token exchange will clean up the state after successful validation+ */+async function validateOAuthStateWithoutCleanup(state: string): Promise<void> {+ const storageAPI = getStorageAPI();+ if (!storageAPI?.local) {+ // Fail closed: if we can't access storage, we can't validate state+ throw new Error("Storage API not available - cannot validate OAuth state");+ }++ const result = await storageAPI.local.get(["oauth_state"]);+ const storedState = result.oauth_state as string | undefined;++ if (!storedState) {+ throw new Error("No stored OAuth state found - possible CSRF attack");+ }++ if (storedState !== state) {+ devLog.error("State parameter mismatch - possible CSRF attack");+ throw new Error("Invalid state parameter - possible CSRF attack");+ }+}+async function validateOAuthState(state: string): Promise<void> {const storageAPI = getStorageAPI();if (!storageAPI?.local) {- devLog.warn("Storage API not available for state validation");- return;+ // Fail closed: if we can't access storage, we can't validate state+ throw new Error("Storage API not available - cannot validate OAuth state");}try {const result = await storageAPI.local.get(["oauth_state"]);const storedState = result.oauth_state as string | undefined;- if (storedState && storedState !== state) {+ // Fail closed: state must exist and match exactly+ if (!storedState) {+ throw new Error("No stored OAuth state found");+ }++ if (storedState !== state) {await storageAPI.local.remove("oauth_state");devLog.error("State parameter mismatch - possible CSRF attack");throw new Error("Invalid state parameter - possible CSRF attack");}- if (storedState === state) {- await storageAPI.local.remove("oauth_state");- }+ await storageAPI.local.remove("oauth_state");} catch (error) {- if (error instanceof Error && error.message.includes("Invalid state parameter")) {- throw error;+ // Clean up on any error+ try {+ await storageAPI.local.remove("oauth_state");+ } catch {+ // Ignore cleanup errors}- devLog.warn("State validation warning:", error);+ throw error;}}