axauth 1.0.0 → 1.2.0

package/dist/auth/agents/{claude-code.js → claude.js}

@@ -3,9 +3,11 @@
  *
  * Supports OAuth via keychain (macOS) or file, and API key via env var.
  */
+import path from "node:path";
 import { isMacOS } from "../keychain.js";
-import { deleteFileCreds, deleteKeychainCreds, getDefaultCredsFilePath, loadFileCreds, loadKeychainCreds, saveFileCreds, saveKeychainCreds, } from "./claude-code-storage.js";
-const AGENT_ID = "claude";
+import { resolveCustomDirectory } from "../validate-directories.js";
+import { AGENT_ID, checkAuth, deleteFileCreds, deleteKeychainCreds, extractRawCredentials, getDefaultCredsFilePath, saveFileCreds, saveKeychainCreds, } from "./claude-storage.js";
+const CREDS_FILE_NAME = ".credentials.json";
 /** Claude Code authentication adapter */
 const claudeCodeAdapter = {
     agentId: AGENT_ID,
@@ -16,60 +18,20 @@ const claudeCodeAdapter = {
         installApiKey: false,
     },
     checkAuth() {
-        if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
-            return { agentId: AGENT_ID, authenticated: true, method: "OAuth (env)" };
-        }
-        const keychainCreds = loadKeychainCreds();
-        if (keychainCreds) {
-            const subType = keychainCreds.subscriptionType;
-            return {
-                agentId: AGENT_ID,
-                authenticated: true,
-                method: `OAuth (${subType ?? "keychain"})`,
-            };
-        }
-        if (loadFileCreds()) {
-            return { agentId: AGENT_ID, authenticated: true, method: "OAuth (file)" };
-        }
-        if (process.env.ANTHROPIC_API_KEY) {
-            return { agentId: AGENT_ID, authenticated: true, method: "API key" };
-        }
-        return { agentId: AGENT_ID, authenticated: false };
+        const result = checkAuth();
+        return { agentId: AGENT_ID, ...result };
     },
     extractRawCredentials() {
-        if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
-            return {
-                agent: AGENT_ID,
-                type: "oauth",
-                data: { accessToken: process.env.CLAUDE_CODE_OAUTH_TOKEN },
-            };
-        }
-        const keychainCreds = loadKeychainCreds();
-        if (keychainCreds) {
-            return {
-                agent: AGENT_ID,
-                type: "oauth",
-                data: { ...keychainCreds, _source: "keychain" },
-            };
-        }
-        const fileCreds = loadFileCreds();
-        if (fileCreds) {
-            return {
-                agent: AGENT_ID,
-                type: "oauth",
-                data: { ...fileCreds, _source: "file" },
-            };
-        }
-        if (process.env.ANTHROPIC_API_KEY) {
-            return {
-                agent: AGENT_ID,
-                type: "api-key",
-                data: { apiKey: process.env.ANTHROPIC_API_KEY },
-            };
-        }
-        return undefined;
+        const result = extractRawCredentials();
+        if (!result)
+            return undefined;
+        return { agent: AGENT_ID, ...result };
     },
     installCredentials(creds, options) {
+        // Resolve custom directory with validation
+        const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+        if (!resolved.ok)
+            return resolved.error;
         if (creds.type === "api-key") {
             return {
                 ok: false,
@@ -77,17 +39,18 @@ const claudeCodeAdapter = {
             };
         }
         const { _source, ...oauthData } = creds.data;
-        // Custom path forces file storage (keychain only for default location)
-        if (options?.path) {
-            if (saveFileCreds(oauthData, options.path)) {
+        // Custom directory forces file storage (keychain only for default location)
+        if (resolved.customDir) {
+            const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+            if (saveFileCreds(oauthData, targetPath)) {
                 return {
                     ok: true,
-                    message: `Installed credentials to ${options.path}`,
+                    message: `Installed credentials to ${targetPath}`,
                 };
             }
             return {
                 ok: false,
-                message: `Failed to install credentials to ${options.path}`,
+                message: `Failed to install credentials to ${targetPath}`,
             };
         }
         // Default location: use storage option or _source marker
@@ -114,10 +77,15 @@ const claudeCodeAdapter = {
         };
     },
     removeCredentials(options) {
-        // Custom path: only remove that specific file (no keychain)
-        if (options?.path) {
-            if (deleteFileCreds(options.path)) {
-                return { ok: true, message: `Removed ${options.path}` };
+        // Resolve custom directory with validation
+        const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+        if (!resolved.ok)
+            return resolved.error;
+        // Custom directory: only remove that specific file (no keychain)
+        if (resolved.customDir) {
+            const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+            if (deleteFileCreds(targetPath)) {
+                return { ok: true, message: `Removed ${targetPath}` };
             }
             return {
                 ok: true,

package/dist/auth/agents/codex-config.js

@@ -8,7 +8,7 @@ import { codexConfigReader } from "axconfig";
 import { getResolvedConfigDirectory } from "../resolve-config-directory.js";
 /** Get the codex home directory */
 function getCodexHome() {
-    return getResolvedConfigDirectory(codexConfigReader);
+    return getResolvedConfigDirectory("codex");
 }
 /** Get auth file path */
 function getAuthFilePath() {

package/dist/auth/agents/codex.js

@@ -6,10 +6,12 @@
 import path from "node:path";
 import { ensureDirectory } from "../file-storage.js";
 import { isMacOS } from "../keychain.js";
+import { resolveCustomDirectory } from "../validate-directories.js";
 import { checkAuth, extractRawCredentials } from "./codex-auth-check.js";
 import { getAuthFilePath, getCodexHome, updateConfigStorage, } from "./codex-config.js";
 import { buildAuthContent, deleteFileCreds, deleteKeychainCreds, saveFileCreds, saveKeychainCreds, } from "./codex-storage.js";
 const AGENT_ID = "codex";
+const CREDS_FILE_NAME = "auth.json";
 /** Codex authentication adapter */
 const codexAdapter = {
     agentId: AGENT_ID,
@@ -22,25 +24,29 @@ const codexAdapter = {
     checkAuth,
     extractRawCredentials,
     installCredentials(creds, options) {
+        // Resolve custom directory with validation
+        const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+        if (!resolved.ok)
+            return resolved.error;
         const authContent = buildAuthContent(creds.type, creds.data);
-        // Custom path forces file storage (keychain only for default location)
-        if (options?.path) {
-            const parentDirectory = path.dirname(options.path);
-            if (!ensureDirectory(parentDirectory)) {
+        // Custom directory forces file storage (keychain only for default location)
+        if (resolved.customDir) {
+            if (!ensureDirectory(resolved.customDir)) {
                 return {
                     ok: false,
-                    message: `Failed to create directory ${parentDirectory}`,
+                    message: `Failed to create directory ${resolved.customDir}`,
                 };
             }
-            if (saveFileCreds(authContent, options.path)) {
+            const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+            if (saveFileCreds(authContent, targetPath)) {
                 return {
                     ok: true,
-                    message: `Installed credentials to ${options.path}`,
+                    message: `Installed credentials to ${targetPath}`,
                 };
             }
             return {
                 ok: false,
-                message: `Failed to install credentials to ${options.path}`,
+                message: `Failed to install credentials to ${targetPath}`,
             };
         }
         // Default location: use storage option or _source marker
@@ -72,10 +78,15 @@ const codexAdapter = {
         return { ok: false, message: "Failed to install credentials to file" };
     },
     removeCredentials(options) {
-        // Custom path: only remove that specific file (no keychain)
-        if (options?.path) {
-            if (deleteFileCreds(options.path)) {
-                return { ok: true, message: `Removed ${options.path}` };
+        // Resolve custom directory with validation
+        const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+        if (!resolved.ok)
+            return resolved.error;
+        // Custom directory: only remove that specific file (no keychain)
+        if (resolved.customDir) {
+            const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+            if (deleteFileCreds(targetPath)) {
+                return { ok: true, message: `Removed ${targetPath}` };
             }
             return {
                 ok: true,

package/dist/auth/agents/copilot-storage.js

@@ -7,7 +7,6 @@
  */
 import { existsSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { copilotConfigReader } from "axconfig";
 import { ensureDirectory, loadJsonFile, saveJsonFile, } from "../file-storage.js";
 import { deleteFromKeychain, isMacOS, loadFromKeychain, saveToKeychain, } from "../keychain.js";
 import { getResolvedConfigDirectory } from "../resolve-config-directory.js";
@@ -15,7 +14,7 @@ const KEYCHAIN_SERVICE = "copilot-cli";
 const DEFAULT_HOST = "https://github.com";
 /** Get the copilot config directory */
 function getConfigDirectory() {
-    return getResolvedConfigDirectory(copilotConfigReader);
+    return getResolvedConfigDirectory("copilot");
 }
 /** Get the default config file path */
 function getConfigFilePath() {

package/dist/auth/agents/copilot.js

@@ -4,11 +4,14 @@
  * Supports OAuth via keychain (macOS) or file, and GitHub token via env var.
  * Also supports GitHub CLI (`gh auth login`) as a fallback.
  */
+import path from "node:path";
 import { ensureDirectory } from "../file-storage.js";
 import { isMacOS } from "../keychain.js";
+import { resolveCustomDirectory } from "../validate-directories.js";
 import { findFirstAvailableToken } from "./copilot-auth-check.js";
 import { deleteFileToken, deleteKeychainToken, deleteTokenFromPath, getConfigDirectory, getConfigFilePath, saveFileToken, saveKeychainToken, saveTokenToPath, } from "./copilot-storage.js";
 const AGENT_ID = "copilot";
+const CREDS_FILE_NAME = "token.json";
 /** Copilot CLI authentication adapter */
 const copilotAdapter = {
     agentId: AGENT_ID,
@@ -46,6 +49,10 @@ const copilotAdapter = {
         };
     },
     installCredentials(creds, options) {
+        // Resolve custom directory with validation
+        const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+        if (!resolved.ok)
+            return resolved.error;
         if (creds.type === "api-key") {
             return {
                 ok: false,
@@ -58,17 +65,18 @@ const copilotAdapter = {
         if (!token) {
             return { ok: false, message: "No access token found in credentials" };
         }
-        // Custom path forces file storage
-        if (options?.path) {
-            if (saveTokenToPath(token, options.path)) {
+        // Custom directory forces file storage
+        if (resolved.customDir) {
+            const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+            if (saveTokenToPath(token, targetPath)) {
                 return {
                     ok: true,
-                    message: `Installed credentials to ${options.path}`,
+                    message: `Installed credentials to ${targetPath}`,
                 };
             }
             return {
                 ok: false,
-                message: `Failed to install credentials to ${options.path}`,
+                message: `Failed to install credentials to ${targetPath}`,
             };
         }
         // Default location: use storage option or _source marker
@@ -102,10 +110,15 @@ const copilotAdapter = {
         return { ok: false, message: "Failed to install credentials to file" };
     },
     removeCredentials(options) {
-        // Custom path: only remove that specific file
-        if (options?.path) {
-            if (deleteTokenFromPath(options.path)) {
-                return { ok: true, message: `Removed ${options.path}` };
+        // Resolve custom directory with validation
+        const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+        if (!resolved.ok)
+            return resolved.error;
+        // Custom directory: only remove that specific file
+        if (resolved.customDir) {
+            const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+            if (deleteTokenFromPath(targetPath)) {
+                return { ok: true, message: `Removed ${targetPath}` };
             }
             return {
                 ok: true,

package/dist/auth/agents/gemini-auth-check.d.ts

@@ -1,16 +1,16 @@
 /**
  * Gemini CLI authentication checking.
  *
- * Determines auth status based on configured auth type and available credentials.
+ * Uses priority-ordered credential discovery: env → keychain → file.
  */
 /** Credential source for auth method display */
-type CredentialSource = "keychain" | "file" | "api-key" | "vertex-ai" | "adc";
+type CredentialSource = "keychain" | "file" | "api-key" | "vertex-ai";
 /** Result of finding available credentials */
 interface CredentialResult {
     source: CredentialSource;
     method: string;
     data?: Record<string, unknown>;
 }
-/** Find credentials based on configured auth type */
+/** Find credentials using priority-ordered discovery: env → keychain → file */
 declare function findCredentials(): CredentialResult | undefined;
 export { findCredentials };

package/dist/auth/agents/gemini-auth-check.js

@@ -1,51 +1,25 @@
 /**
  * Gemini CLI authentication checking.
  *
- * Determines auth status based on configured auth type and available credentials.
+ * Uses priority-ordered credential discovery: env → keychain → file.
  */
 import { existsSync } from "node:fs";
-import { getAuthType, getDefaultOAuthPath, loadKeychainCreds, loadOAuthCreds, } from "./gemini-storage.js";
-/** Check OAuth credentials (keychain first, then file) */
-function checkOAuthCredentials() {
-    const keychainCreds = loadKeychainCreds();
-    if (keychainCreds) {
-        return {
-            source: "keychain",
-            method: "Google OAuth (keychain)",
-            data: keychainCreds,
-        };
-    }
-    if (existsSync(getDefaultOAuthPath())) {
-        const fileCreds = loadOAuthCreds();
-        if (fileCreds) {
-            return {
-                source: "file",
-                method: "Google OAuth (file)",
-                data: fileCreds,
-            };
-        }
-    }
-    return undefined;
-}
-/** Check API key credentials */
-function checkApiKeyCredentials() {
+import { getDefaultOAuthPath, loadKeychainCreds, loadOAuthCreds, } from "./gemini-storage.js";
+/** Check environment variable credentials (API key and Vertex AI) */
+function checkEnvironmentAuth() {
     if (process.env.GEMINI_API_KEY) {
         return {
             source: "api-key",
-            method: "API key",
+            method: "API key (env)",
             data: { apiKey: process.env.GEMINI_API_KEY },
         };
     }
-    return undefined;
-}
-/** Check Vertex AI credentials */
-function checkVertexAiCredentials() {
     const hasVertexEnvironment = (process.env.GOOGLE_CLOUD_PROJECT && process.env.GOOGLE_CLOUD_LOCATION) ||
         process.env.GOOGLE_API_KEY;
     if (hasVertexEnvironment) {
         return {
             source: "vertex-ai",
-            method: "Vertex AI",
+            method: "Vertex AI (env)",
             data: process.env.GOOGLE_API_KEY
                 ? { apiKey: process.env.GOOGLE_API_KEY }
                 : undefined,
@@ -53,21 +27,34 @@ function checkVertexAiCredentials() {
     }
     return undefined;
 }
-/** Find credentials based on configured auth type */
-function findCredentials() {
-    const authType = getAuthType();
-    if (authType === "oauth-personal") {
-        return checkOAuthCredentials();
-    }
-    if (authType === "gemini-api-key") {
-        return checkApiKeyCredentials();
-    }
-    if (authType === "vertex-ai") {
-        return checkVertexAiCredentials();
+/** Check keychain for OAuth credentials */
+function checkKeychainAuth() {
+    const keychainCreds = loadKeychainCreds();
+    if (keychainCreds) {
+        return {
+            source: "keychain",
+            method: "Google OAuth (keychain)",
+            data: keychainCreds,
+        };
     }
-    if (authType === "compute-default-credentials") {
-        return { source: "adc", method: "Compute ADC" };
+    return undefined;
+}
+/** Check file for OAuth credentials */
+function checkFileAuth() {
+    if (existsSync(getDefaultOAuthPath())) {
+        const fileCreds = loadOAuthCreds();
+        if (fileCreds) {
+            return {
+                source: "file",
+                method: "Google OAuth (file)",
+                data: fileCreds,
+            };
+        }
     }
     return undefined;
 }
+/** Find credentials using priority-ordered discovery: env → keychain → file */
+function findCredentials() {
+    return checkEnvironmentAuth() ?? checkKeychainAuth() ?? checkFileAuth();
+}
 export { findCredentials };

package/dist/auth/agents/gemini-install.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gemini credential installation operations.
+ *
+ * Extracted from gemini.ts to reduce file complexity.
+ */
+import type { InstallOptions, OperationResult, RemoveOptions } from "../adapter.js";
+/** Install OAuth credentials to storage */
+declare function installOAuthCredentials(oauthData: Record<string, unknown>, source: string | undefined, options?: InstallOptions): OperationResult;
+/** Remove credentials from storage */
+declare function removeGeminiCredentials(options?: RemoveOptions): OperationResult;
+export { installOAuthCredentials, removeGeminiCredentials };

package/dist/auth/agents/gemini-install.js

@@ -0,0 +1,115 @@
+/**
+ * Gemini credential installation operations.
+ *
+ * Extracted from gemini.ts to reduce file complexity.
+ */
+import path from "node:path";
+import { ensureDirectory } from "../file-storage.js";
+import { isMacOS } from "../keychain.js";
+import { resolveCustomDirectory } from "../validate-directories.js";
+import { clearAuthTypeFromSettings, deleteKeychainCreds, deleteOAuthCreds, getDefaultOAuthPath, saveKeychainCreds, saveOAuthCreds, setAuthTypeInSettings, } from "./gemini-storage.js";
+const AGENT_ID = "gemini";
+const CREDS_FILE_NAME = "oauth_creds.json";
+/** Install OAuth credentials to storage */
+function installOAuthCredentials(oauthData, source, options) {
+    // Resolve custom directory with validation
+    const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+    if (!resolved.ok)
+        return resolved.error;
+    // Custom directory forces file storage
+    if (resolved.customDir) {
+        return installToCustomDirectory(oauthData, resolved.customDir);
+    }
+    // Default location: use storage option or _source marker
+    const targetStorage = options?.storage ?? (source === "keychain" ? "keychain" : "file");
+    if (targetStorage === "keychain") {
+        return installToKeychain(oauthData);
+    }
+    return installToDefaultFile(oauthData);
+}
+/** Install to custom directory */
+function installToCustomDirectory(oauthData, customDirectory) {
+    if (!ensureDirectory(customDirectory)) {
+        return {
+            ok: false,
+            message: `Failed to create directory ${customDirectory}`,
+        };
+    }
+    const targetPath = path.join(customDirectory, CREDS_FILE_NAME);
+    if (!saveOAuthCreds(oauthData, targetPath)) {
+        return {
+            ok: false,
+            message: `Failed to install credentials to ${targetPath}`,
+        };
+    }
+    if (!setAuthTypeInSettings("oauth-personal", customDirectory)) {
+        return { ok: false, message: "Failed to update settings" };
+    }
+    return { ok: true, message: `Installed credentials to ${targetPath}` };
+}
+/** Install to macOS Keychain */
+function installToKeychain(oauthData) {
+    if (!isMacOS()) {
+        return {
+            ok: false,
+            message: "Keychain storage is only available on macOS",
+        };
+    }
+    if (!saveKeychainCreds(oauthData)) {
+        return { ok: false, message: "Failed to save to macOS Keychain" };
+    }
+    if (!setAuthTypeInSettings("oauth-personal")) {
+        return { ok: false, message: "Failed to update settings" };
+    }
+    return { ok: true, message: "Installed credentials to macOS Keychain" };
+}
+/** Install to default file location */
+function installToDefaultFile(oauthData) {
+    const targetPath = getDefaultOAuthPath();
+    const targetDirectory = path.dirname(targetPath);
+    if (!ensureDirectory(targetDirectory)) {
+        return {
+            ok: false,
+            message: `Failed to create directory ${targetDirectory}`,
+        };
+    }
+    if (!saveOAuthCreds(oauthData, targetPath)) {
+        return { ok: false, message: "Failed to write OAuth credentials" };
+    }
+    if (!setAuthTypeInSettings("oauth-personal")) {
+        return { ok: false, message: "Failed to update settings" };
+    }
+    return { ok: true, message: `Installed credentials to ${targetPath}` };
+}
+/** Remove credentials from storage */
+function removeGeminiCredentials(options) {
+    // Resolve custom directory with validation
+    const resolved = resolveCustomDirectory(AGENT_ID, options?.configDir, options?.dataDir);
+    if (!resolved.ok)
+        return resolved.error;
+    // Custom directory: only remove that specific file
+    if (resolved.customDir) {
+        const targetPath = path.join(resolved.customDir, CREDS_FILE_NAME);
+        if (deleteOAuthCreds(targetPath)) {
+            return { ok: true, message: `Removed ${targetPath}` };
+        }
+        return { ok: true, message: "No credentials file found at specified path" };
+    }
+    // Default location: remove from keychain, file, and clear settings
+    const removedFrom = [];
+    if (deleteKeychainCreds()) {
+        removedFrom.push("macOS Keychain");
+    }
+    if (deleteOAuthCreds()) {
+        removedFrom.push(getDefaultOAuthPath());
+    }
+    // Always clear auth type setting to avoid stale configuration
+    if (clearAuthTypeFromSettings()) {
+        removedFrom.push("auth type from settings");
+    }
+    if (removedFrom.length === 0) {
+        return { ok: true, message: "No credentials found" };
+    }
+    return { ok: true, message: `Removed from ${removedFrom.join(" and ")}` };
+}
+export { installOAuthCredentials, removeGeminiCredentials };

package/dist/auth/agents/gemini-storage.d.ts

@@ -3,12 +3,10 @@
  */
 /** Get default OAuth credentials file path */
 declare function getDefaultOAuthPath(): string;
-/** Get current auth type from settings */
-declare function getAuthType(): string | undefined;
 /** Clear auth type from settings */
 declare function clearAuthTypeFromSettings(): boolean;
 /** Set auth type in settings */
-declare function setAuthTypeInSettings(authType: string): boolean;
+declare function setAuthTypeInSettings(authType: string, configDirectory?: string): boolean;
 /** Load OAuth credentials from file */
 declare function loadOAuthCreds(): Record<string, unknown> | undefined;
 /** Load OAuth credentials from keychain */
@@ -21,4 +19,4 @@ declare function deleteKeychainCreds(): boolean;
 declare function saveOAuthCreds(data: Record<string, unknown>, filePath?: string): boolean;
 /** Delete OAuth credentials file */
 declare function deleteOAuthCreds(filePath?: string): boolean;
-export { clearAuthTypeFromSettings, deleteKeychainCreds, deleteOAuthCreds, getAuthType, getDefaultOAuthPath, loadKeychainCreds, loadOAuthCreds, saveKeychainCreds, saveOAuthCreds, setAuthTypeInSettings, };
+export { clearAuthTypeFromSettings, deleteKeychainCreds, deleteOAuthCreds, getDefaultOAuthPath, loadKeychainCreds, loadOAuthCreds, saveKeychainCreds, saveOAuthCreds, setAuthTypeInSettings, };

package/dist/auth/agents/gemini-storage.js

@@ -10,28 +10,20 @@ const KEYCHAIN_SERVICE = "gemini-cli-oauth";
 const KEYCHAIN_ACCOUNT = "main-account";
 /** Get the Gemini config directory */
 function getConfigDirectory() {
-    return getResolvedConfigDirectory(geminiConfigReader);
+    return getResolvedConfigDirectory("gemini");
 }
 /** Get default OAuth credentials file path */
 function getDefaultOAuthPath() {
     return path.join(getConfigDirectory(), "oauth_creds.json");
 }
-/** Get current auth type from settings */
-function getAuthType() {
-    const result = geminiConfigReader.readRaw(getConfigDirectory(), "security.auth.selectedType");
-    if (result.ok && typeof result.value === "string") {
-        return result.value;
-    }
-    return undefined;
-}
 /** Clear auth type from settings */
 function clearAuthTypeFromSettings() {
     const result = geminiConfigReader.deleteRaw(getConfigDirectory(), "security.auth.selectedType");
     return result.ok && result.deleted;
 }
 /** Set auth type in settings */
-function setAuthTypeInSettings(authType) {
-    const result = geminiConfigReader.writeRaw(getConfigDirectory(), "security.auth.selectedType", authType);
+function setAuthTypeInSettings(authType, configDirectory) {
+    const result = geminiConfigReader.writeRaw(configDirectory ?? getConfigDirectory(), "security.auth.selectedType", authType);
     return result.ok;
 }
 /** Load OAuth credentials from file */
@@ -66,4 +58,4 @@ function saveOAuthCreds(data, filePath) {
 function deleteOAuthCreds(filePath) {
     return deleteFile(filePath ?? getDefaultOAuthPath());
 }
-export { clearAuthTypeFromSettings, deleteKeychainCreds, deleteOAuthCreds, getAuthType, getDefaultOAuthPath, loadKeychainCreds, loadOAuthCreds, saveKeychainCreds, saveOAuthCreds, setAuthTypeInSettings, };
+export { clearAuthTypeFromSettings, deleteKeychainCreds, deleteOAuthCreds, getDefaultOAuthPath, loadKeychainCreds, loadOAuthCreds, saveKeychainCreds, saveOAuthCreds, setAuthTypeInSettings, };