Download src/app/api/cli-tools/codex-settings/route.ts from shimen/shinroute: direct link, hf CLI and curl.
- Browser
- Download file 8.89 kB
-
https://huggingface.co/spaces/shimen/shinroute/resolve/main/src/app/api/cli-tools/codex-settings/route.ts
- Command line
-
hf download hf://spaces/shimen/shinroute/src/app/api/cli-tools/codex-settings/route.ts
-
curl -L -o route.ts https://huggingface.co/spaces/shimen/shinroute/resolve/main/src/app/api/cli-tools/codex-settings/route.ts
8.89 kB
| "use server"; | |
| import { NextResponse } from "next/server"; | |
| import fs from "fs/promises"; | |
| import path from "path"; | |
| import { | |
| ensureCliConfigWriteAllowed, | |
| getCliConfigPaths, | |
| getCliRuntimeStatus, | |
| } from "@/shared/services/cliRuntime"; | |
| import { createMultiBackup } from "@/shared/services/backupService"; | |
| import { saveCliToolLastConfigured, deleteCliToolLastConfigured } from "@/lib/db/cliToolState"; | |
| const getCodexConfigPath = () => getCliConfigPaths("codex").config; | |
| const getCodexAuthPath = () => getCliConfigPaths("codex").auth; | |
| const getCodexDir = () => path.dirname(getCodexConfigPath()); | |
| // Parse TOML config to object (simple parser for codex config) | |
| const parseToml = (content: string) => { | |
| const result: Record<string, any> = { _root: {}, _sections: {} }; | |
| let currentSection = "_root"; | |
| content.split("\n").forEach((line) => { | |
| const trimmed = line.trim(); | |
| if (!trimmed || trimmed.startsWith("#")) return; | |
| // Section header like [model_providers.omniroute] | |
| const sectionMatch = trimmed.match(/^\[(.+)\]$/); | |
| if (sectionMatch) { | |
| currentSection = sectionMatch[1]; | |
| result._sections[currentSection] = {}; | |
| return; | |
| } | |
| // Key = value | |
| const kvMatch = trimmed.match(/^([^=]+)\s*=\s*(.+)$/); | |
| if (kvMatch) { | |
| const key = kvMatch[1].trim(); | |
| let value = kvMatch[2].trim(); | |
| // Remove quotes | |
| if ( | |
| (value.startsWith('"') && value.endsWith('"')) || | |
| (value.startsWith("'") && value.endsWith("'")) | |
| ) { | |
| value = value.slice(1, -1); | |
| } | |
| if (currentSection === "_root") { | |
| result._root[key] = value; | |
| } else { | |
| result._sections[currentSection][key] = value; | |
| } | |
| } | |
| }); | |
| return result; | |
| }; | |
| // Convert parsed object back to TOML string | |
| const toToml = (parsed: Record<string, any>) => { | |
| let lines: string[] = []; | |
| // Root level keys | |
| Object.entries(parsed._root).forEach(([key, value]) => { | |
| lines.push(`${key} = "${value}"`); | |
| }); | |
| // Sections | |
| Object.entries(parsed._sections).forEach(([section, values]) => { | |
| lines.push(""); | |
| lines.push(`[${section}]`); | |
| Object.entries(values).forEach(([key, value]) => { | |
| lines.push(`${key} = "${value}"`); | |
| }); | |
| }); | |
| return lines.join("\n") + "\n"; | |
| }; | |
| // Read current config.toml | |
| const readConfig = async () => { | |
| try { | |
| const configPath = getCodexConfigPath(); | |
| const content = await fs.readFile(configPath, "utf-8"); | |
| return content; | |
| } catch (error: any) { | |
| if (error.code === "ENOENT") return null; | |
| throw error; | |
| } | |
| }; | |
| // Check if config has OmniRoute settings | |
| const hasOmniRouteConfig = (config: string | null) => { | |
| if (!config) return false; | |
| return ( | |
| config.includes('model_provider = "omniroute"') || | |
| config.includes("[model_providers.omniroute]") | |
| ); | |
| }; | |
| // GET - Check codex CLI and read current settings | |
| export async function GET() { | |
| try { | |
| const runtime = await getCliRuntimeStatus("codex"); | |
| if (!runtime.installed || !runtime.runnable) { | |
| return NextResponse.json({ | |
| installed: runtime.installed, | |
| runnable: runtime.runnable, | |
| command: runtime.command, | |
| commandPath: runtime.commandPath, | |
| runtimeMode: runtime.runtimeMode, | |
| reason: runtime.reason, | |
| config: null, | |
| message: | |
| runtime.installed && !runtime.runnable | |
| ? "Codex CLI is installed but not runnable" | |
| : "Codex CLI is not installed", | |
| }); | |
| } | |
| const config = await readConfig(); | |
| return NextResponse.json({ | |
| installed: runtime.installed, | |
| runnable: runtime.runnable, | |
| command: runtime.command, | |
| commandPath: runtime.commandPath, | |
| runtimeMode: runtime.runtimeMode, | |
| reason: runtime.reason, | |
| config, | |
| hasOmniRoute: hasOmniRouteConfig(config), | |
| configPath: getCodexConfigPath(), | |
| }); | |
| } catch (error) { | |
| console.log("Error checking codex settings:", error); | |
| return NextResponse.json({ error: "Failed to check codex settings" }, { status: 500 }); | |
| } | |
| } | |
| // POST - Update OmniRoute settings (merge with existing config) | |
| export async function POST(request: Request) { | |
| try { | |
| const writeGuard = ensureCliConfigWriteAllowed(); | |
| if (writeGuard) { | |
| return NextResponse.json({ error: writeGuard }, { status: 403 }); | |
| } | |
| const { baseUrl, apiKey, model } = await request.json(); | |
| if (!baseUrl || !apiKey || !model) { | |
| return NextResponse.json( | |
| { error: "baseUrl, apiKey and model are required" }, | |
| { status: 400 } | |
| ); | |
| } | |
| const codexDir = getCodexDir(); | |
| const configPath = getCodexConfigPath(); | |
| const authPath = getCodexAuthPath(); | |
| // Ensure directory exists | |
| await fs.mkdir(codexDir, { recursive: true }); | |
| // Backup current configs before modifying | |
| await createMultiBackup("codex", [configPath, authPath]); | |
| // Read and parse existing config | |
| let parsed: Record<string, any> = { _root: {}, _sections: {} }; | |
| try { | |
| const existingConfig = await fs.readFile(configPath, "utf-8"); | |
| parsed = parseToml(existingConfig); | |
| } catch { | |
| /* No existing config */ | |
| } | |
| // Update only OmniRoute related fields (api_key goes to auth.json, not config.toml) | |
| parsed._root.model = model; | |
| parsed._root.model_provider = "omniroute"; | |
| // Update or create omniroute provider section (no api_key - Codex reads from auth.json) | |
| // Ensure /v1 suffix is added only once | |
| const normalizedBaseUrl = baseUrl.endsWith("/v1") ? baseUrl : `${baseUrl}/v1`; | |
| parsed._sections["model_providers.omniroute"] = { | |
| name: "OmniRoute", | |
| base_url: normalizedBaseUrl, | |
| wire_api: "responses", | |
| }; | |
| // Write merged config | |
| const configContent = toToml(parsed); | |
| await fs.writeFile(configPath, configContent); | |
| // Update auth.json with OPENAI_API_KEY (Codex reads this first) | |
| let authData: Record<string, any> = {}; | |
| try { | |
| const existingAuth = await fs.readFile(authPath, "utf-8"); | |
| authData = JSON.parse(existingAuth); | |
| } catch { | |
| /* No existing auth */ | |
| } | |
| authData.OPENAI_API_KEY = apiKey; | |
| await fs.writeFile(authPath, JSON.stringify(authData, null, 2)); | |
| // Persist last-configured timestamp | |
| try { | |
| saveCliToolLastConfigured("codex"); | |
| } catch { | |
| /* non-critical */ | |
| } | |
| return NextResponse.json({ | |
| success: true, | |
| message: "Codex settings applied successfully!", | |
| configPath, | |
| }); | |
| } catch (error) { | |
| console.log("Error updating codex settings:", error); | |
| return NextResponse.json({ error: "Failed to update codex settings" }, { status: 500 }); | |
| } | |
| } | |
| // DELETE - Remove OmniRoute settings only (keep other settings) | |
| export async function DELETE() { | |
| try { | |
| const writeGuard = ensureCliConfigWriteAllowed(); | |
| if (writeGuard) { | |
| return NextResponse.json({ error: writeGuard }, { status: 403 }); | |
| } | |
| const configPath = getCodexConfigPath(); | |
| // Backup current configs before resetting | |
| await createMultiBackup("codex", [configPath, getCodexAuthPath()]); | |
| // Read and parse existing config | |
| let parsed: Record<string, any> = { _root: {}, _sections: {} }; | |
| try { | |
| const existingConfig = await fs.readFile(configPath, "utf-8"); | |
| parsed = parseToml(existingConfig); | |
| } catch (error: any) { | |
| if (error.code === "ENOENT") { | |
| return NextResponse.json({ | |
| success: true, | |
| message: "No config file to reset", | |
| }); | |
| } | |
| throw error; | |
| } | |
| // Remove OmniRoute related root fields only if they point to omniroute | |
| if (parsed._root.model_provider === "omniroute") { | |
| delete parsed._root.model; | |
| delete parsed._root.model_provider; | |
| } | |
| // Remove omniroute provider section | |
| delete parsed._sections["model_providers.omniroute"]; | |
| // Write updated config | |
| const configContent = toToml(parsed); | |
| await fs.writeFile(configPath, configContent); | |
| // Remove OPENAI_API_KEY from auth.json | |
| const authPath = getCodexAuthPath(); | |
| try { | |
| const existingAuth = await fs.readFile(authPath, "utf-8"); | |
| const authData = JSON.parse(existingAuth); | |
| delete authData.OPENAI_API_KEY; | |
| // Write back or delete if empty | |
| if (Object.keys(authData).length === 0) { | |
| await fs.unlink(authPath); | |
| } else { | |
| await fs.writeFile(authPath, JSON.stringify(authData, null, 2)); | |
| } | |
| } catch { | |
| /* No auth file */ | |
| } | |
| // Clear last-configured timestamp | |
| try { | |
| deleteCliToolLastConfigured("codex"); | |
| } catch { | |
| /* non-critical */ | |
| } | |
| return NextResponse.json({ | |
| success: true, | |
| message: "OmniRoute settings removed successfully", | |
| }); | |
| } catch (error) { | |
| console.log("Error resetting codex settings:", error); | |
| return NextResponse.json({ error: "Failed to reset codex settings" }, { status: 500 }); | |
| } | |
| } | |