Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
launch: codex app integration (#16120)
Parth Sareenac7295ccabdc
diff --git a/app/store/database.go b/app/store/database.goindex bb81bdad6..6c6767c52 100644--- a/app/store/database.go+++ b/app/store/database.go@@ -1201,15 +1201,16 @@ func (db *database) getSettings() (Settings, error) {func (db *database) setSettings(s Settings) error {lastHomeView := strings.ToLower(strings.TrimSpace(s.LastHomeView))validLaunchView := map[string]struct{}{- "launch": {},- "openclaw": {},- "claude": {},- "hermes": {},- "codex": {},- "copilot": {},- "opencode": {},- "droid": {},- "pi": {},+ "launch": {},+ "openclaw": {},+ "claude": {},+ "hermes": {},+ "codex": {},+ "codex-app": {},+ "copilot": {},+ "opencode": {},+ "droid": {},+ "pi": {},}if lastHomeView != "chat" {if _, ok := validLaunchView[lastHomeView]; !ok {diff --git a/app/store/store_test.go b/app/store/store_test.goindex 90bfda0dd..d4a08a8ad 100644--- a/app/store/store_test.go+++ b/app/store/store_test.go@@ -122,6 +122,21 @@ func TestStore(t *testing.T) {}})+ t.Run("settings codex app home view is accepted", func(t *testing.T) {+ if err := s.SetSettings(Settings{LastHomeView: "codex-app"}); err != nil {+ t.Fatal(err)+ }++ loaded, err := s.Settings()+ if err != nil {+ t.Fatal(err)+ }++ if loaded.LastHomeView != "codex-app" {+ t.Fatalf("expected codex-app LastHomeView to be preserved, got %q", loaded.LastHomeView)+ }+ })+t.Run("window size", func(t *testing.T) {if err := s.SetWindowSize(1024, 768); err != nil {t.Fatal(err)diff --git a/app/ui/app/public/launch-icons/codex-app.png b/app/ui/app/public/launch-icons/codex-app.pngnew file mode 100644index 000000000..72e9baf76Binary files /dev/null and b/app/ui/app/public/launch-icons/codex-app.png differdiff --git a/app/ui/app/src/components/LaunchCommands.tsx b/app/ui/app/src/components/LaunchCommands.tsxindex b3f0e438c..f2b50cf5e 100644--- a/app/ui/app/src/components/LaunchCommands.tsx+++ b/app/ui/app/src/components/LaunchCommands.tsx@@ -22,11 +22,12 @@ const LAUNCH_COMMANDS: LaunchCommand[] = [iconClassName: "h-7 w-7",},{- id: "openclaw",- name: "OpenClaw",- command: "ollama launch openclaw",- description: "Personal AI with 100+ skills",- icon: "/launch-icons/openclaw.svg",+ id: "codex-app",+ name: "Codex App",+ command: "ollama launch codex-app",+ description: "OpenAI's desktop coding agent",+ icon: "/launch-icons/codex-app.png",+ iconClassName: "h-full w-full",},{id: "hermes",@@ -36,6 +37,13 @@ const LAUNCH_COMMANDS: LaunchCommand[] = [icon: "/launch-icons/hermes-agent.svg",iconClassName: "h-7 w-7",},+ {+ id: "openclaw",+ name: "OpenClaw",+ command: "ollama launch openclaw",+ description: "Personal AI with 100+ skills",+ icon: "/launch-icons/openclaw.svg",+ },{id: "opencode",name: "OpenCode",diff --git a/cmd/cmd.go b/cmd/cmd.goindex e238b5bd3..d63393fda 100644--- a/cmd/cmd.go+++ b/cmd/cmd.go@@ -2231,7 +2231,7 @@ func runLauncherAction(cmd *cobra.Command, action tui.TUIAction, deps launcherDefunc launcherActionExitsLoop(integration string) bool {switch integration {- case "vscode":+ case "codex-app", "vscode":return truedefault:return falsediff --git a/cmd/cmd_launcher_test.go b/cmd/cmd_launcher_test.goindex 9e5f6dbb0..3a766f4ab 100644--- a/cmd/cmd_launcher_test.go+++ b/cmd/cmd_launcher_test.go@@ -249,7 +249,7 @@ func TestRunLauncherAction_GUIAppsExitTUILoop(t *testing.T) {cmd := &cobra.Command{}cmd.SetContext(context.Background())- for _, integration := range []string{"vscode"} {+ for _, integration := range []string{"codex-app", "vscode"} {continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: integration}, launcherDeps{resolveRunModel: unexpectedRunModelResolution(t),launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {diff --git a/cmd/launch/codex.go b/cmd/launch/codex.goindex 4ac24deb9..7bd03e54c 100644--- a/cmd/launch/codex.go+++ b/cmd/launch/codex.go@@ -7,7 +7,9 @@ import ("path/filepath""strings"+ "github.com/ollama/ollama/cmd/internal/fileutil""github.com/ollama/ollama/envconfig"+ "github.com/pelletier/go-toml/v2""golang.org/x/mod/semver")@@ -16,7 +18,15 @@ type Codex struct{}func (c *Codex) String() string { return "Codex" }-const codexProfileName = "ollama-launch"+const (+ codexProfileName = "ollama-launch"+ codexProviderName = "Ollama"++ codexRootProfileKey = "profile"+ codexRootModelKey = "model"+ codexRootModelProviderKey = "model_provider"+ codexRootModelCatalogJSONKey = "model_catalog_json"+)func (c *Codex) args(model string, extra []string) []string {args := []string{"--profile", codexProfileName}@@ -49,76 +59,483 @@ func (c *Codex) Run(model string, args []string) error {// ensureCodexConfig writes a [profiles.ollama-launch] section to ~/.codex/config.toml// with openai_base_url pointing to the local Ollama server.func ensureCodexConfig() error {- home, err := os.UserHomeDir()+ configPath, err := codexConfigPath()if err != nil {return err}- codexDir := filepath.Join(home, ".codex")- if err := os.MkdirAll(codexDir, 0o755); err != nil {+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {return err}-- configPath := filepath.Join(codexDir, "config.toml")return writeCodexProfile(configPath)}+func codexConfigPath() (string, error) {+ home, err := os.UserHomeDir()+ if err != nil {+ return "", err+ }+ return filepath.Join(home, ".codex", "config.toml"), nil+}+// writeCodexProfile ensures ~/.codex/config.toml has the ollama-launch profile// and model provider sections with the correct base URL.func writeCodexProfile(configPath string) error {- baseURL := envconfig.Host().String() + "/v1/"+ return writeCodexLaunchProfile(configPath, codexLaunchProfileOptions{+ forceAPIAuth: true,+ })+}++type codexLaunchProfileOptions struct {+ activate bool+ profileName string+ forceAPIAuth bool+ setRootModelConfig bool+ model string+ modelCatalogPath string+ backupIntegration string+}++func writeCodexLaunchProfile(configPath string, opts codexLaunchProfileOptions) error {+ baseURL := codexBaseURL()+ profileName := codexLaunchProfileName(opts)+ profileHeader := codexProfileHeaderFor(profileName)+ providerHeader := codexProviderHeaderFor(profileName)++ content, readErr := os.ReadFile(configPath)+ text := ""+ if readErr == nil {+ text = string(content)+ } else if !os.IsNotExist(readErr) {+ return readErr+ }+ parsed, err := codexParseConfig(text)+ if err != nil {+ return err+ }++ model := strings.TrimSpace(opts.model)+ if model == "" {+ model = parsed.ProfileString(profileName, codexRootModelKey)+ }+ modelCatalogPath := strings.TrimSpace(opts.modelCatalogPath)+ if modelCatalogPath == "" {+ modelCatalogPath = parsed.ProfileString(profileName, codexRootModelCatalogJSONKey)+ }++ profileLines := []string{}+ if model != "" {+ profileLines = append(profileLines, fmt.Sprintf("%s = %q", codexRootModelKey, model))+ }+ profileLines = append(profileLines,+ fmt.Sprintf("openai_base_url = %q", baseURL),+ fmt.Sprintf("%s = %q", codexRootModelProviderKey, profileName),+ )+ if opts.forceAPIAuth {+ profileLines = append(profileLines, `forced_login_method = "api"`)+ }+ if modelCatalogPath != "" {+ profileLines = append(profileLines, fmt.Sprintf("%s = %q", codexRootModelCatalogJSONKey, modelCatalogPath))+ }sections := []struct {header stringlines []string}{{- header: fmt.Sprintf("[profiles.%s]", codexProfileName),- lines: []string{- fmt.Sprintf("openai_base_url = %q", baseURL),- `forced_login_method = "api"`,- fmt.Sprintf("model_provider = %q", codexProfileName),- },+ header: profileHeader,+ lines: profileLines,},{- header: fmt.Sprintf("[model_providers.%s]", codexProfileName),+ header: providerHeader,lines: []string{- `name = "Ollama"`,+ fmt.Sprintf("name = %q", codexProviderName),fmt.Sprintf("base_url = %q", baseURL),+ `wire_api = "responses"`,},},}- content, readErr := os.ReadFile(configPath)- text := ""- if readErr == nil {- text = string(content)+ if opts.activate {+ text = codexSetRootStringValue(text, codexRootProfileKey, profileName)+ }+ if opts.setRootModelConfig {+ if model != "" {+ text = codexSetRootStringValue(text, codexRootModelKey, model)+ }+ text = codexSetRootStringValue(text, codexRootModelProviderKey, profileName)+ if modelCatalogPath != "" {+ text = codexSetRootStringValue(text, codexRootModelCatalogJSONKey, modelCatalogPath)+ }}for _, s := range sections {- block := strings.Join(append([]string{s.header}, s.lines...), "\n") + "\n"+ text = codexUpsertSection(text, s.header, s.lines)+ }+ parsed, err = codexParseConfig(text)+ if err != nil {+ return err+ }+ if err := codexValidateLaunchProfileText(parsed, profileName, opts, model, modelCatalogPath, baseURL); err != nil {+ return err+ }- if idx := strings.Index(text, s.header); idx >= 0 {- // Replace the existing section up to the next section header.- rest := text[idx+len(s.header):]- if endIdx := strings.Index(rest, "\n["); endIdx >= 0 {- text = text[:idx] + block + rest[endIdx+1:]- } else {- text = text[:idx] + block+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ return err+ }+ return fileutil.WriteWithBackup(configPath, []byte(text), opts.backupIntegration)+}++func codexLaunchProfileName(opts codexLaunchProfileOptions) string {+ if name := strings.TrimSpace(opts.profileName); name != "" {+ return name+ }+ return codexProfileName+}++func codexBaseURL() string {+ return strings.TrimRight(envconfig.ConnectableHost().String(), "/") + "/v1/"+}++func codexProfileHeader() string {+ return codexProfileHeaderFor(codexProfileName)+}++func codexProviderHeader() string {+ return codexProviderHeaderFor(codexProfileName)+}++func codexProfileHeaderFor(profileName string) string {+ return fmt.Sprintf("[profiles.%s]", profileName)+}++func codexProviderHeaderFor(profileName string) string {+ return fmt.Sprintf("[model_providers.%s]", profileName)+}++func codexValidateLaunchProfileText(config codexParsedConfig, profileName string, opts codexLaunchProfileOptions, model, modelCatalogPath, baseURL string) error {+ for _, check := range []struct {+ path []string+ want string+ }{+ {[]string{"profiles", profileName, "openai_base_url"}, baseURL},+ {[]string{"profiles", profileName, codexRootModelProviderKey}, profileName},+ {[]string{"model_providers", profileName, "name"}, codexProviderName},+ {[]string{"model_providers", profileName, "base_url"}, baseURL},+ {[]string{"model_providers", profileName, "wire_api"}, "responses"},+ } {+ if got, ok := config.String(check.path...); !ok || got != check.want {+ return fmt.Errorf("generated Codex config missing %s = %q", strings.Join(check.path, "."), check.want)+ }+ }+ if opts.forceAPIAuth {+ if got, ok := config.String("profiles", profileName, "forced_login_method"); !ok || got != "api" {+ return fmt.Errorf("generated Codex config missing profiles.%s.forced_login_method = %q", profileName, "api")+ }+ }+ if model != "" {+ if got, ok := config.String("profiles", profileName, codexRootModelKey); !ok || got != model {+ return fmt.Errorf("generated Codex config missing profiles.%s.model = %q", profileName, model)+ }+ }+ if modelCatalogPath != "" {+ if got, ok := config.String("profiles", profileName, codexRootModelCatalogJSONKey); !ok || got != modelCatalogPath {+ return fmt.Errorf("generated Codex config missing profiles.%s.model_catalog_json = %q", profileName, modelCatalogPath)+ }+ }+ if opts.activate {+ if got := config.RootString(codexRootProfileKey); got != profileName {+ return fmt.Errorf("generated Codex config missing profile = %q", profileName)+ }+ }+ if opts.setRootModelConfig {+ if model != "" {+ if got := config.RootString(codexRootModelKey); got != model {+ return fmt.Errorf("generated Codex config missing model = %q", model)}- } else {- // Append the section.- if text != "" && !strings.HasSuffix(text, "\n") {- text += "\n"+ }+ if got := config.RootString(codexRootModelProviderKey); got != profileName {+ return fmt.Errorf("generated Codex config missing model_provider = %q", profileName)+ }+ if modelCatalogPath != "" {+ if got := config.RootString(codexRootModelCatalogJSONKey); got != modelCatalogPath {+ return fmt.Errorf("generated Codex config missing model_catalog_json = %q", modelCatalogPath)}- if text != "" {- text += "\n"+ }+ }+ return nil+}++func codexUpsertSection(text, header string, lines []string) string {+ block := strings.Join(append([]string{header}, lines...), "\n") + "\n"++ if targetPath, ok := codexTableHeaderPath(header); ok {+ if start, end, found := codexSectionRange(text, targetPath); found {+ return text[:start] + block + text[end:]+ }+ }++ if text != "" && !strings.HasSuffix(text, "\n") {+ text += "\n"+ }+ if text != "" {+ text += "\n"+ }+ return text + block+}++func codexRemoveSection(text, header string) string {+ targetPath, ok := codexTableHeaderPath(header)+ if !ok {+ return text+ }+ start, end, found := codexSectionRange(text, targetPath)+ if !found {+ return text+ }+ return text[:start] + text[end:]+}++type codexParsedConfig struct {+ values map[string]any+}++func (c codexParsedConfig) String(path ...string) (string, bool) {+ if len(path) == 0 {+ return "", false+ }+ var current any = c.values+ for _, part := range path {+ table, ok := current.(map[string]any)+ if !ok {+ return "", false+ }+ current, ok = table[part]+ if !ok {+ return "", false+ }+ }+ value, ok := current.(string)+ if !ok {+ return "", false+ }+ return value, true+}++func (c codexParsedConfig) RootString(key string) string {+ value, _ := c.RootStringOK(key)+ return value+}++func (c codexParsedConfig) RootStringOK(key string) (string, bool) {+ return c.String(key)+}++func (c codexParsedConfig) ProfileString(profileName, key string) string {+ value, _ := c.String("profiles", profileName, key)+ return value+}++func (c codexParsedConfig) ProviderString(profileName, key string) string {+ value, _ := c.String("model_providers", profileName, key)+ return value+}++func codexRootStringValue(text, key string) string {+ config, err := codexParseConfig(text)+ if err != nil {+ return ""+ }+ return config.RootString(key)+}++func codexRootStringValueOK(text, key string) (string, bool) {+ config, err := codexParseConfig(text)+ if err != nil {+ return "", false+ }+ return config.RootStringOK(key)+}++func codexStringValue(text string, path ...string) (string, bool) {+ config, err := codexParseConfig(text)+ if err != nil {+ return "", false+ }+ return config.String(path...)+}++func codexSectionStringValue(text, header, key string) string {+ path, ok := codexTableHeaderPath(header)+ if !ok {+ return ""+ }+ value, _ := codexStringValue(text, append(path, key)...)+ return value+}++func codexParseConfig(text string) (codexParsedConfig, error) {+ values, err := codexParseConfigText(text)+ if err != nil {+ return codexParsedConfig{}, err+ }+ return codexParsedConfig{values: values}, nil+}++func codexParseConfigText(text string) (map[string]any, error) {+ cfg := map[string]any{}+ if strings.TrimSpace(text) == "" {+ return cfg, nil+ }+ if err := toml.Unmarshal([]byte(text), &cfg); err != nil {+ return nil, fmt.Errorf("invalid Codex config TOML: %w", err)+ }+ return cfg, nil+}++func codexValidateConfigText(text string) error {+ _, err := codexParseConfig(text)+ return err+}++func codexSectionRange(text string, targetPath []string) (int, int, bool) {+ lines := strings.SplitAfter(text, "\n")+ offset := 0+ start := -1+ for _, line := range lines {+ trimmed := strings.TrimSpace(line)+ if !strings.HasPrefix(trimmed, "[") || strings.HasPrefix(trimmed, "#") {+ offset += len(line)+ continue+ }+ if start >= 0 {+ return start, offset, true+ }+ if path, ok := codexTableHeaderPath(trimmed); ok && codexSamePath(path, targetPath) {+ start = offset+ }+ offset += len(line)+ }+ if start >= 0 {+ return start, len(text), true+ }+ return 0, 0, false+}++func codexTableHeaderPath(header string) ([]string, bool) {+ trimmed := strings.TrimSpace(header)+ if !strings.HasPrefix(trimmed, "[") || strings.HasPrefix(trimmed, "[[") {+ return nil, false+ }++ const probeKey = "__ollama_launch_probe"+ cfg := map[string]any{}+ if err := toml.Unmarshal([]byte(trimmed+"\n"+probeKey+" = true\n"), &cfg); err != nil {+ return nil, false+ }+ return codexFindProbePath(cfg, probeKey, nil)+}++func codexFindProbePath(value any, probeKey string, path []string) ([]string, bool) {+ table, ok := value.(map[string]any)+ if !ok {+ return nil, false+ }+ if probe, ok := table[probeKey].(bool); ok && probe {+ return path, true+ }+ for key, child := range table {+ if key == probeKey {+ continue+ }+ if childPath, ok := codexFindProbePath(child, probeKey, append(path, key)); ok {+ return childPath, true+ }+ }+ return nil, false+}++func codexSamePath(a, b []string) bool {+ if len(a) != len(b) {+ return false+ }+ for i := range a {+ if a[i] != b[i] {+ return false+ }+ }+ return true+}++func codexSetRootStringValue(text, key, value string) string {+ lines := strings.SplitAfter(text, "\n")+ rootEnd := len(lines)+ for i, line := range lines {+ if strings.HasPrefix(strings.TrimSpace(line), "[") {+ rootEnd = i+ break+ }+ }++ assignment := fmt.Sprintf("%s = %q", key, value)+ for i := range rootEnd {+ line := lines[i]+ trimmed := strings.TrimSpace(line)+ if trimmed == "" || strings.HasPrefix(trimmed, "#") {+ continue+ }+ if codexRootLineHasKey(trimmed, key) {+ if strings.HasSuffix(line, "\n") {+ lines[i] = assignment + "\n"+ } else {+ lines[i] = assignment+ }+ return strings.Join(lines, "")+ }+ }++ insert := assignment + "\n"+ root := strings.Join(lines[:rootEnd], "")+ rest := strings.Join(lines[rootEnd:], "")+ if root != "" && !strings.HasSuffix(root, "\n") {+ root += "\n"+ }+ if rest != "" && !strings.HasSuffix(insert, "\n\n") {+ insert += "\n"+ }+ return root + insert + rest+}++func codexRemoveRootValue(text, key string) string {+ lines := strings.SplitAfter(text, "\n")+ rootEnd := len(lines)+ for i, line := range lines {+ if strings.HasPrefix(strings.TrimSpace(line), "[") {+ rootEnd = i+ break+ }+ }++ out := make([]string, 0, len(lines))+ for i, line := range lines {+ if i < rootEnd {+ trimmed := strings.TrimSpace(line)+ if trimmed != "" && !strings.HasPrefix(trimmed, "#") && codexRootLineHasKey(trimmed, key) {+ continue}- text += block}+ out = append(out, line)}+ return strings.Join(out, "")+}- return os.WriteFile(configPath, []byte(text), 0o644)+func codexRootLineHasKey(line, key string) bool {+ cfg := map[string]any{}+ if err := toml.Unmarshal([]byte(line+"\n"), &cfg); err != nil {+ return false+ }+ _, ok := cfg[key]+ return ok}func checkCodexVersion() error {diff --git a/cmd/launch/codex_app.go b/cmd/launch/codex_app.gonew file mode 100644index 000000000..454fe90d6--- /dev/null+++ b/cmd/launch/codex_app.go@@ -0,0 +1,989 @@+package launch++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "os"+ "os/exec"+ "path/filepath"+ "runtime"+ "slices"+ "strconv"+ "strings"+ "time"++ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/cmd/config"+ "github.com/ollama/ollama/cmd/internal/fileutil"+ "github.com/ollama/ollama/envconfig"+ modelpkg "github.com/ollama/ollama/types/model"+)++const (+ codexAppIntegrationName = "codex-app"+ codexAppProfileName = "ollama-launch-codex-app"+ codexAppBundleID = "com.openai.codex"+ codexAppModelCatalogFilename = "ollama-launch-models.json"+ codexAppRestoreHint = "To restore your usual Codex profile, run: ollama launch codex-app --restore"+ codexAppConfigurationSuccess = "Codex App profile changed to Ollama."+ codexAppRestoreSuccess = "Codex App restored to your usual profile."+)++var (+ codexAppGOOS = runtime.GOOS+ codexAppStat = os.Stat+ codexAppGlob = filepath.Glob+ codexAppOpenApp = defaultCodexAppOpenApp+ codexAppOpenPath = defaultCodexAppOpenAppPath+ codexAppOpenStart = defaultCodexAppOpenStartAppID+ codexAppQuitApp = defaultCodexAppQuitApp+ codexAppIsRunning = defaultCodexAppIsRunning+ codexAppRunPath = defaultCodexAppRunningAppPath+ codexAppStartID = defaultCodexAppStartAppID+ codexAppCanOpenID = defaultCodexAppCanOpenBundleID+ codexAppSleep = time.Sleep+)++// CodexApp configures the desktop Codex app with one launch-selected default+// model while leaving model discovery and switching to Codex's Ollama provider.+type CodexApp struct{}++func (c *CodexApp) String() string { return "Codex App" }++func (c *CodexApp) Supported() error { return codexAppSupported() }++func (c *CodexApp) Paths() []string {+ configPath, err := codexConfigPath()+ if err != nil {+ return nil+ }+ return []string{configPath}+}++func (c *CodexApp) Configure(model string) error {+ return c.ConfigureWithModels(model, []string{model})+}++func (c *CodexApp) ConfigureWithModels(primary string, models []string) error {+ primary = strings.TrimSpace(primary)+ if primary == "" {+ return fmt.Errorf("codex-app requires a model")+ }++ configPath, err := codexConfigPath()+ if err != nil {+ return err+ }+ if err := saveCodexAppRestoreState(configPath); err != nil {+ return err+ }+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ return err+ }+ if err := writeCodexAppModelCatalog(catalogPath, primary, codexAppCatalogModelNames(primary, models)); err != nil {+ return err+ }+ return writeCodexLaunchProfile(configPath, codexLaunchProfileOptions{+ activate: true,+ profileName: codexAppProfileName,+ setRootModelConfig: true,+ model: primary,+ modelCatalogPath: catalogPath,+ backupIntegration: codexAppIntegrationName,+ })+}++func (c *CodexApp) CurrentModel() string {+ configPath, err := codexConfigPath()+ if err != nil {+ return ""+ }+ data, err := os.ReadFile(configPath)+ if err != nil {+ return ""+ }+ text := string(data)+ parsed, err := codexParseConfig(text)+ if err != nil {+ return ""+ }+ for _, profileName := range codexAppManagedProfileNames() {+ if parsed.RootString(codexRootModelProviderKey) == profileName {+ baseURL := parsed.ProviderString(profileName, "base_url")+ if codexNormalizeURL(baseURL) == codexNormalizeURL(codexBaseURL()) && codexAppCatalogHealthy(parsed, profileName) {+ return strings.TrimSpace(parsed.RootString(codexRootModelKey))+ }+ }+ }++ profileName := parsed.RootString(codexRootProfileKey)+ if !codexAppIsManagedProfileName(profileName) {+ return ""+ }+ if parsed.ProfileString(profileName, codexRootModelProviderKey) != profileName {+ return ""+ }+ baseURL := parsed.ProviderString(profileName, "base_url")+ if codexNormalizeURL(baseURL) != codexNormalizeURL(codexBaseURL()) {+ return ""+ }+ if !codexAppCatalogHealthy(parsed, profileName) {+ return ""+ }+ return strings.TrimSpace(parsed.ProfileString(profileName, codexRootModelKey))+}++func codexAppManagedProfileNames() []string {+ return []string{codexAppProfileName, codexProfileName}+}++func codexAppIsManagedProfileName(profileName string) bool {+ for _, candidate := range codexAppManagedProfileNames() {+ if profileName == candidate {+ return true+ }+ }+ return false+}++func codexAppIsOwnedProfileName(profileName string) bool {+ return profileName == codexAppProfileName+}++func codexAppCatalogHealthy(config codexParsedConfig, profileName string) bool {+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ return false+ }+ if config.RootString(codexRootModelCatalogJSONKey) != catalogPath {+ return false+ }+ if config.ProfileString(profileName, codexRootModelCatalogJSONKey) != catalogPath {+ return false+ }+ data, err := os.ReadFile(catalogPath)+ if err != nil {+ return false+ }+ var catalog struct {+ Models []json.RawMessage `json:"models"`+ }+ if err := json.Unmarshal(data, &catalog); err != nil {+ return false+ }+ return len(catalog.Models) > 0+}++func (c *CodexApp) Onboard() error {+ return config.MarkIntegrationOnboarded(codexAppIntegrationName)+}++func (c *CodexApp) RequiresInteractiveOnboarding() bool {+ return false+}++func (c *CodexApp) RestoreHint() string {+ return codexAppRestoreHint+}++func (c *CodexApp) ConfigurationSuccessMessage() string {+ return codexAppConfigurationSuccess + "\n" + codexAppRestoreHint+}++func (c *CodexApp) RestoreSuccessMessage() string {+ return codexAppRestoreSuccess+}++func (c *CodexApp) Run(_ string, args []string) error {+ if err := codexAppSupported(); err != nil {+ return err+ }+ if len(args) > 0 {+ return fmt.Errorf("codex-app does not accept extra arguments")+ }+ return codexAppLaunchOrRestart("Restart Codex to use Ollama?")+}++func (c *CodexApp) Restore() error {+ if err := codexAppSupported(); err != nil {+ return err+ }+ configPath, err := codexConfigPath()+ if err != nil {+ return err+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ if os.IsNotExist(err) {+ if err := removeCodexAppRestoreState(); err != nil {+ return codexAppRestoreFailure(configPath, err)+ }+ return codexAppLaunchOrRestart("Restart Codex to use your usual profile?")+ }+ return codexAppRestoreFailure(configPath, err)+ }+ text := string(data)+ if err := codexValidateConfigText(text); err != nil {+ return codexAppRestoreFailure(configPath, err)+ }++ state, stateErr := loadCodexAppRestoreState()+ if stateErr == nil {+ text = codexAppRestoreRootValues(text, state)+ } else if os.IsNotExist(stateErr) {+ text = codexAppRemoveOwnedRootValues(text)+ } else {+ return codexAppRestoreFailure(configPath, stateErr)+ }+ if !codexAppRootReferencesOwnedConfig(text) {+ text = codexAppRemoveOwnedSections(text)+ }++ if err := codexValidateConfigText(text); err != nil {+ return codexAppRestoreFailure(configPath, err)+ }+ if err := fileutil.WriteWithBackup(configPath, []byte(text), codexAppIntegrationName); err != nil {+ return codexAppRestoreFailure(configPath, err)+ }+ if err := codexAppRemoveOwnedCatalogIfUnused(text); err != nil {+ return codexAppRestoreFailure(configPath, err)+ }+ if err := removeCodexAppRestoreState(); err != nil {+ return codexAppRestoreFailure(configPath, err)+ }+ return codexAppLaunchOrRestart("Restart Codex to use your usual profile?")+}++func codexAppRestoreFailure(configPath string, err error) error {+ return fmt.Errorf("restore Codex App config: %w\n\nRestore did not complete. Check these files before retrying:\n Codex config: %s\n Restore state: %s\n Model catalog: %s\n Backups: %s",+ err,+ configPath,+ codexAppRestoreStatePath(),+ codexAppModelCatalogPathForConfig(configPath),+ filepath.Join(fileutil.BackupDir(), codexAppIntegrationName),+ )+}++func codexAppSupported() error {+ switch codexAppGOOS {+ case "darwin", "windows":+ return nil+ default:+ return fmt.Errorf("Codex App launch is only supported on macOS and Windows")+ }+}++func codexAppInstalled() bool {+ if codexAppAppPath() != "" {+ return true+ }+ switch codexAppGOOS {+ case "darwin":+ return codexAppCanOpenID()+ case "windows":+ return codexAppIsRunning() || codexAppStartID() != ""+ default:+ return false+ }+}++func codexAppModelCatalogPath() (string, error) {+ configPath, err := codexConfigPath()+ if err != nil {+ return "", err+ }+ return codexAppModelCatalogPathForConfig(configPath), nil+}++func codexAppModelCatalogPathForConfig(configPath string) string {+ return filepath.Join(filepath.Dir(configPath), codexAppModelCatalogFilename)+}++func writeCodexAppModelCatalog(path, primary string, models []string) error {+ if len(models) == 0 {+ return fmt.Errorf("codex-app model catalog cannot be empty")+ }+ client := api.NewClient(envconfig.ConnectableHost(), http.DefaultClient)+ ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)+ defer cancel()++ baseInstructions := codexAppBaseInstructions()+ primaryMetadata := codexAppSelectedModelMetadata(ctx, client, primary)+ entries := make([]map[string]any, 0, len(models))+ for i, model := range models {+ metadata := codexAppDefaultModelMetadata()+ if model == primary {+ metadata = primaryMetadata+ }+ entries = append(entries, codexAppCatalogEntry(model, metadata, i, baseInstructions))+ }++ data, err := json.MarshalIndent(map[string]any{"models": entries}, "", " ")+ if err != nil {+ return err+ }+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ return err+ }+ return fileutil.WriteWithBackup(path, append(data, '\n'), codexAppIntegrationName)+}++func codexAppCatalogModelNames(primary string, fallback []string) []string {+ models := codexAppTagModelNames()+ if len(models) == 0 {+ models = fallback+ }+ return dedupeModelList(append([]string{primary}, models...))+}++func codexAppTagModelNames() []string {+ client := api.NewClient(envconfig.ConnectableHost(), http.DefaultClient)+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)+ defer cancel()++ resp, err := client.List(ctx)+ if err != nil {+ return nil+ }++ models := make([]string, 0, len(resp.Models))+ for _, model := range resp.Models {+ name := strings.TrimSpace(model.Name)+ if name != "" {+ models = append(models, name)+ }+ }+ return models+}++type codexAppModelMetadata struct {+ contextWindow int+ inputModalities []string+}++func codexAppDefaultModelMetadata() codexAppModelMetadata {+ return codexAppModelMetadata{+ contextWindow: 272_000,+ inputModalities: []string{"text"},+ }+}++func codexAppSelectedModelMetadata(ctx context.Context, client *api.Client, model string) codexAppModelMetadata {+ metadata := codexAppDefaultModelMetadata()+ resp, err := client.Show(ctx, &api.ShowRequest{Model: model})+ if err != nil {+ return metadata+ }+ if n, ok := modelInfoContextLength(resp.ModelInfo); ok {+ metadata.contextWindow = n+ }+ if slices.Contains(resp.Capabilities, modelpkg.CapabilityVision) {+ metadata.inputModalities = []string{"text", "image"}+ }+ return metadata+}++func codexAppCatalogEntry(model string, metadata codexAppModelMetadata, priority int, baseInstructions string) map[string]any {+ return map[string]any{+ "slug": model,+ "display_name": model,+ "description": "Ollama local model",+ "default_reasoning_level": nil,+ "supported_reasoning_levels": []any{},+ "shell_type": "default",+ "visibility": "list",+ "supported_in_api": true,+ "priority": priority,+ "additional_speed_tiers": []any{},+ "availability_nux": nil,+ "upgrade": nil,+ "base_instructions": baseInstructions,+ "model_messages": nil,+ "supports_reasoning_summaries": false,+ "default_reasoning_summary": "auto",+ "support_verbosity": false,+ "default_verbosity": nil,+ "apply_patch_tool_type": nil,+ "web_search_tool_type": "text",+ "truncation_policy": map[string]any{"mode": "bytes", "limit": 10_000},+ "supports_parallel_tool_calls": false,+ "supports_image_detail_original": false,+ "context_window": metadata.contextWindow,+ "max_context_window": metadata.contextWindow,+ "auto_compact_token_limit": nil,+ "effective_context_window_percent": 95,+ "experimental_supported_tools": []any{},+ "input_modalities": metadata.inputModalities,+ "supports_search_tool": false,+ }+}++func codexAppBaseInstructions() string {+ path, err := codexModelCachePath()+ if err == nil {+ var cached struct {+ Models []struct {+ BaseInstructions string `json:"base_instructions"`+ } `json:"models"`+ }+ if data, readErr := os.ReadFile(path); readErr == nil {+ if json.Unmarshal(data, &cached) == nil {+ for _, model := range cached.Models {+ if strings.TrimSpace(model.BaseInstructions) != "" {+ return model.BaseInstructions+ }+ }+ }+ }+ }+ return "You are Codex, a coding agent. You and the user share the same workspace and collaborate to achieve the user's goals."+}++func codexModelCachePath() (string, error) {+ home, err := os.UserHomeDir()+ if err != nil {+ return "", err+ }+ return filepath.Join(home, ".codex", "models_cache.json"), nil+}++func codexAppAppPath() string {+ var candidates []string+ switch codexAppGOOS {+ case "darwin":+ candidates = codexAppDarwinAppCandidates()+ case "windows":+ candidates = codexAppWindowsAppCandidates()+ default:+ return ""+ }+ for _, candidate := range candidates {+ if info, err := codexAppStat(candidate); err == nil {+ if codexAppGOOS == "darwin" && !info.IsDir() {+ continue+ }+ if codexAppGOOS == "windows" && info.IsDir() {+ continue+ }+ return candidate+ }+ }+ return ""+}++func codexAppDarwinAppCandidates() []string {+ candidates := []string{"/Applications/Codex.app"}+ if home, err := os.UserHomeDir(); err == nil {+ candidates = append(candidates, filepath.Join(home, "Applications", "Codex.app"))+ }+ return candidates+}++func codexAppWindowsAppCandidates() []string {+ local, err := codexAppLocalAppData()+ if err != nil {+ return nil+ }++ candidates := []string{+ filepath.Join(local, "Programs", "Codex", "Codex.exe"),+ filepath.Join(local, "Programs", "OpenAI Codex", "Codex.exe"),+ filepath.Join(local, "Codex", "Codex.exe"),+ filepath.Join(local, "OpenAI Codex", "Codex.exe"),+ filepath.Join(local, "OpenAI", "Codex", "Codex.exe"),+ filepath.Join(local, "openai-codex-electron", "Codex.exe"),+ }+ for _, pattern := range []string{+ filepath.Join(local, "Programs", "Codex", "app-*", "Codex.exe"),+ filepath.Join(local, "Programs", "OpenAI Codex", "app-*", "Codex.exe"),+ filepath.Join(local, "Codex", "app-*", "Codex.exe"),+ filepath.Join(local, "OpenAI Codex", "app-*", "Codex.exe"),+ filepath.Join(local, "OpenAI", "Codex", "app-*", "Codex.exe"),+ filepath.Join(local, "openai-codex-electron", "app-*", "Codex.exe"),+ } {+ matches, _ := codexAppGlob(pattern)+ candidates = append(candidates, matches...)+ }+ return codexAppDedupePaths(candidates)+}++func codexAppDedupePaths(paths []string) []string {+ out := make([]string, 0, len(paths))+ seen := make(map[string]bool, len(paths))+ for _, path := range paths {+ if strings.TrimSpace(path) == "" {+ continue+ }+ key := strings.ToLower(path)+ if seen[key] {+ continue+ }+ seen[key] = true+ out = append(out, path)+ }+ return out+}++func codexAppLocalAppData() (string, error) {+ if local := strings.TrimSpace(os.Getenv("LOCALAPPDATA")); local != "" {+ return local, nil+ }+ if home := strings.TrimSpace(os.Getenv("USERPROFILE")); home != "" {+ return filepath.Join(home, "AppData", "Local"), nil+ }+ home, err := os.UserHomeDir()+ if err != nil {+ return "", err+ }+ return filepath.Join(home, "AppData", "Local"), nil+}++func codexAppLaunchOrRestart(prompt string) error {+ if !codexAppIsRunning() {+ return codexAppOpenApp()+ }+ restartAppID := ""+ restartAppPath := ""+ if codexAppGOOS == "windows" {+ restartAppID = codexAppStartID()+ if restartAppID == "" {+ restartAppPath = codexAppRunPath()+ }+ }++ restart, err := ConfirmPrompt(prompt)+ if err != nil {+ return err+ }+ if !restart {+ fmt.Fprintln(os.Stderr, "\nQuit and reopen Codex when you're ready for the profile change to take effect.")+ return nil+ }++ if err := codexAppQuitApp(); err != nil {+ return fmt.Errorf("quit Codex: %w", err)+ }+ if err := waitForCodexAppExit(30 * time.Second); err != nil {+ return err+ }+ if restartAppID != "" {+ return codexAppOpenStart(restartAppID)+ }+ if restartAppPath != "" {+ return codexAppOpenPath(restartAppPath)+ }+ return codexAppOpenApp()+}++func waitForCodexAppExit(timeout time.Duration) error {+ deadline := time.Now().Add(timeout)+ for time.Now().Before(deadline) {+ if !codexAppIsRunning() {+ return nil+ }+ codexAppSleep(200 * time.Millisecond)+ }+ return fmt.Errorf("Codex did not quit; quit it manually and re-run the command")+}++func defaultCodexAppOpenApp() error {+ switch codexAppGOOS {+ case "windows":+ if path := codexAppAppPath(); path != "" {+ return codexAppOpenPath(path)+ }+ if path := codexAppRunPath(); path != "" {+ return codexAppOpenPath(path)+ }+ if appID := codexAppStartID(); appID != "" {+ return codexAppOpenStart(appID)+ }+ return fmt.Errorf("Codex executable was not found; open Codex manually once and re-run 'ollama launch codex-app'")+ case "darwin":+ if path := codexAppAppPath(); path != "" {+ cmd := exec.Command("open", path)+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ return cmd.Run()+ }+ cmd := exec.Command("open", "-b", codexAppBundleID)+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ return cmd.Run()+ default:+ return codexAppSupported()+ }+}++func defaultCodexAppOpenAppPath(path string) error {+ switch codexAppGOOS {+ case "windows":+ return exec.Command("powershell.exe", "-NoProfile", "-Command", "Start-Process -FilePath "+quotePowerShellString(path)).Run()+ case "darwin":+ cmd := exec.Command("open", path)+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ return cmd.Run()+ default:+ return codexAppSupported()+ }+}++func defaultCodexAppOpenStartAppID(appID string) error {+ return exec.Command("powershell.exe", "-NoProfile", "-Command", "Start-Process "+quotePowerShellString(`shell:AppsFolder\`+appID)).Run()+}++func defaultCodexAppQuitApp() error {+ if codexAppGOOS == "windows" {+ script := `Get-Process Codex -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowHandle -ne 0 } | ForEach-Object { [void]$_.CloseMainWindow() }`+ return exec.Command("powershell.exe", "-NoProfile", "-Command", script).Run()+ }++ scriptErr := exec.Command("osascript", "-e", `tell application "Codex" to quit`).Run()+ if scriptErr != nil {+ scriptErr = exec.Command("osascript", "-e", `tell application id "`+codexAppBundleID+`" to quit`).Run()+ }+ return scriptErr+}++func defaultCodexAppIsRunning() bool {+ switch codexAppGOOS {+ case "windows":+ return len(codexAppMatchingProcessIDs()) > 0+ case "darwin":+ out, err := exec.Command("osascript", "-e", `tell application "System Events" to exists process "Codex"`).Output()+ if err == nil && strings.TrimSpace(string(out)) == "true" {+ return true+ }+ return len(codexAppMatchingProcessIDs()) > 0+ default:+ return false+ }+}++func codexAppMatchingProcessIDs() []int {+ if codexAppGOOS == "windows" {+ return codexAppWindowsMatchingProcessIDs()+ }++ out, err := exec.Command("ps", "-axo", "pid=,command=").Output()+ if err != nil {+ return nil+ }+ var pids []int+ for _, line := range strings.Split(string(out), "\n") {+ line = strings.TrimSpace(line)+ if line == "" {+ continue+ }+ fields := strings.Fields(line)+ if len(fields) < 2 {+ continue+ }+ pid, err := strconv.Atoi(fields[0])+ if err != nil || pid == os.Getpid() {+ continue+ }+ command := strings.TrimSpace(strings.TrimPrefix(line, fields[0]))+ if codexAppProcessMatches(command) {+ pids = append(pids, pid)+ }+ }+ return pids+}++func codexAppWindowsMatchingProcessIDs() []int {+ script := fmt.Sprintf(`$current = %d; Get-CimInstance Win32_Process -Filter "Name = 'Codex.exe' OR Name = 'codex.exe'" | Where-Object { $_.ProcessId -ne $current -and ((($_.Name -ieq 'Codex.exe') -and (($null -eq $_.CommandLine) -or ($_.CommandLine -notlike '* --type=*'))) -or (($_.Name -ieq 'codex.exe') -and ($_.CommandLine -like '*app-server*'))) } | Select-Object -ExpandProperty ProcessId`, os.Getpid())+ out, err := exec.Command("powershell.exe", "-NoProfile", "-Command", script).Output()+ if err != nil {+ return nil+ }++ var pids []int+ for _, line := range strings.Split(string(out), "\n") {+ pid, err := strconv.Atoi(strings.TrimSpace(line))+ if err == nil && pid != os.Getpid() {+ pids = append(pids, pid)+ }+ }+ return pids+}++func defaultCodexAppRunningAppPath() string {+ if codexAppGOOS != "windows" {+ return ""+ }+ script := `(Get-Process Codex -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowHandle -ne 0 -and $_.Path } | Select-Object -First 1 -ExpandProperty Path)`+ out, err := exec.Command("powershell.exe", "-NoProfile", "-Command", script).Output()+ if err != nil {+ return ""+ }+ return strings.TrimSpace(string(out))+}++func defaultCodexAppStartAppID() string {+ if codexAppGOOS != "windows" {+ return ""+ }+ script := `(Get-StartApps Codex | Where-Object { $_.Name -eq 'Codex' -or $_.Name -like 'Codex*' } | Select-Object -First 1 -ExpandProperty AppID)`+ out, err := exec.Command("powershell.exe", "-NoProfile", "-Command", script).Output()+ if err != nil {+ return ""+ }+ return strings.TrimSpace(string(out))+}++func defaultCodexAppCanOpenBundleID() bool {+ if codexAppGOOS != "darwin" {+ return false+ }+ query := fmt.Sprintf("kMDItemCFBundleIdentifier == %q", codexAppBundleID)+ out, err := exec.Command("mdfind", query).Output()+ return err == nil && strings.TrimSpace(string(out)) != ""+}++func codexAppProcessMatches(command string) bool {+ if strings.Contains(command, `\Codex.exe`) && strings.Contains(command, " --type=") {+ return false+ }+ for _, pattern := range codexAppProcessPatterns() {+ if strings.Contains(command, pattern) {+ return true+ }+ }+ return false+}++func codexAppProcessPatterns() []string {+ return []string{+ "Codex.app/Contents/MacOS/Codex",+ "Codex.app/Contents/Resources/codex app-server",+ `\Codex.exe`,+ `resources\codex.exe app-server`,+ `resources\codex.exe" app-server`,+ `resources\codex.exe" "app-server`,+ }+}++func codexNormalizeURL(raw string) string {+ return strings.TrimRight(strings.TrimSpace(raw), "/")+}++func codexAppRootStillManaged(text string) bool {+ config, err := codexParseConfig(text)+ if err != nil {+ return false+ }+ return codexAppIsOwnedProfileName(config.RootString(codexRootProfileKey)) ||+ codexAppIsOwnedProfileName(config.RootString(codexRootModelProviderKey))+}++func codexAppRootReferencesOwnedConfig(text string) bool {+ config, err := codexParseConfig(text)+ if err != nil {+ return false+ }+ return config.RootString(codexRootProfileKey) == codexAppProfileName ||+ config.RootString(codexRootModelProviderKey) == codexAppProfileName+}++func codexAppRootReferencesCatalog(text string) bool {+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ return false+ }+ config, err := codexParseConfig(text)+ if err != nil {+ return false+ }+ return config.RootString(codexRootModelCatalogJSONKey) == catalogPath+}++func codexAppRemoveOwnedSections(text string) string {+ text = codexRemoveSection(text, codexProfileHeaderFor(codexAppProfileName))+ text = codexRemoveSection(text, codexProviderHeaderFor(codexAppProfileName))+ return text+}++func codexAppRemoveOwnedCatalogIfUnused(text string) error {+ if codexAppRootReferencesCatalog(text) {+ return nil+ }+ if catalogPath, err := codexAppModelCatalogPath(); err == nil {+ if err := os.Remove(catalogPath); err != nil && !os.IsNotExist(err) {+ return err+ }+ } else {+ return err+ }+ return nil+}++func codexAppRemoveOwnedRootValues(text string) string {+ config, err := codexParseConfig(text)+ if err != nil {+ return text+ }+ modelProvider := config.RootString(codexRootModelProviderKey)+ modelCatalogJSON := config.RootString(codexRootModelCatalogJSONKey)+ if !codexAppIsOwnedProfileName(config.RootString(codexRootProfileKey)) && !codexAppIsOwnedProfileName(modelProvider) {+ return text+ }+ text = codexRemoveRootValue(text, codexRootProfileKey)+ text = codexRemoveRootValue(text, codexRootModelKey)+ if codexAppIsOwnedProfileName(modelProvider) {+ text = codexRemoveRootValue(text, codexRootModelProviderKey)+ }+ if catalogPath, err := codexAppModelCatalogPath(); err == nil && modelCatalogJSON == catalogPath {+ text = codexRemoveRootValue(text, codexRootModelCatalogJSONKey)+ }+ return text+}++func codexAppRestoreRootValues(text string, state codexAppRestoreState) string {+ if !codexAppRootStillManaged(text) {+ return text+ }+ text = codexRestoreRootStringValue(text, codexRootProfileKey, state.HadProfile, state.Profile)+ text = codexRestoreRootStringValue(text, codexRootModelKey, state.HadModel, state.Model)+ text = codexRestoreRootStringValue(text, codexRootModelProviderKey, state.HadModelProvider, state.ModelProvider)+ text = codexRestoreRootStringValue(text, codexRootModelCatalogJSONKey, state.HadModelCatalogJSON, state.ModelCatalogJSON)+ return text+}++type codexAppRestoreState struct {+ HadProfile bool `json:"had_profile"`+ Profile string `json:"profile,omitempty"`+ HadModel bool `json:"had_model"`+ Model string `json:"model,omitempty"`+ HadModelProvider bool `json:"had_model_provider"`+ ModelProvider string `json:"model_provider,omitempty"`+ HadModelCatalogJSON bool `json:"had_model_catalog_json"`+ ModelCatalogJSON string `json:"model_catalog_json,omitempty"`+}++func saveCodexAppRestoreState(configPath string) error {+ configText := ""+ configExists := false+ if configData, err := os.ReadFile(configPath); err == nil {+ configText = string(configData)+ if err := codexValidateConfigText(configText); err != nil {+ return err+ }+ configExists = true+ } else if !os.IsNotExist(err) {+ return err+ }++ if !configExists {+ return writeCodexAppRestoreState(codexAppRestoreState{})+ }++ statePath := codexAppRestoreStatePath()+ if stateData, err := os.ReadFile(statePath); err == nil {+ hasRootConfig, err := codexAppRestoreStateHasRootConfig(stateData)+ if err != nil {+ return err+ }+ if hasRootConfig {+ if configExists && !codexAppRootStillManaged(configText) {+ return writeCodexAppRestoreState(codexAppRestoreStateFromText(configText))+ }+ return nil+ }+ var existing codexAppRestoreState+ if err := json.Unmarshal(stateData, &existing); err != nil {+ return err+ }+ upgraded := codexAppRestoreStateFromText(configText)+ upgraded.HadProfile = existing.HadProfile+ upgraded.Profile = existing.Profile+ return writeCodexAppRestoreState(upgraded)+ } else if !os.IsNotExist(err) {+ return err+ }++ return writeCodexAppRestoreState(codexAppRestoreStateFromText(configText))+}++func codexAppRestoreStateHasRootConfig(data []byte) (bool, error) {+ var raw map[string]json.RawMessage+ if err := json.Unmarshal(data, &raw); err != nil {+ return false, err+ }+ _, hasModel := raw["had_model"]+ _, hasModelProvider := raw["had_model_provider"]+ _, hasModelCatalogJSON := raw["had_model_catalog_json"]+ return hasModel && hasModelProvider && hasModelCatalogJSON, nil+}++func codexAppRestoreStateFromText(text string) codexAppRestoreState {+ config, err := codexParseConfig(text)+ if err != nil {+ return codexAppRestoreState{}+ }+ profile, hadProfile := config.RootStringOK(codexRootProfileKey)+ model, hadModel := config.RootStringOK(codexRootModelKey)+ modelProvider, hadModelProvider := config.RootStringOK(codexRootModelProviderKey)+ modelCatalogJSON, hadModelCatalogJSON := config.RootStringOK(codexRootModelCatalogJSONKey)+ return codexAppRestoreState{+ HadProfile: hadProfile,+ Profile: profile,+ HadModel: hadModel,+ Model: model,+ HadModelProvider: hadModelProvider,+ ModelProvider: modelProvider,+ HadModelCatalogJSON: hadModelCatalogJSON,+ ModelCatalogJSON: modelCatalogJSON,+ }+}++func codexRestoreRootStringValue(text, key string, hadValue bool, value string) string {+ if hadValue {+ return codexSetRootStringValue(text, key, value)+ }+ return codexRemoveRootValue(text, key)+}++func writeCodexAppRestoreState(state codexAppRestoreState) error {+ path := codexAppRestoreStatePath()+ if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {+ return err+ }+ data, err := json.MarshalIndent(state, "", " ")+ if err != nil {+ return err+ }+ return fileutil.WriteWithBackup(path, data, codexAppIntegrationName)+}++func loadCodexAppRestoreState() (codexAppRestoreState, error) {+ data, err := os.ReadFile(codexAppRestoreStatePath())+ if err != nil {+ return codexAppRestoreState{}, err+ }+ var state codexAppRestoreState+ if err := json.Unmarshal(data, &state); err != nil {+ return codexAppRestoreState{}, err+ }+ return state, nil+}++func removeCodexAppRestoreState() error {+ if err := os.Remove(codexAppRestoreStatePath()); err != nil && !os.IsNotExist(err) {+ return err+ }+ return nil+}++func codexAppRestoreStatePath() string {+ home, err := os.UserHomeDir()+ if err != nil {+ return filepath.Join(os.TempDir(), "ollama-codex-app-restore.json")+ }+ return filepath.Join(home, ".ollama", "launch", "codex-app-restore.json")+}diff --git a/cmd/launch/codex_app_test.go b/cmd/launch/codex_app_test.gonew file mode 100644index 000000000..d1f1f85f4--- /dev/null+++ b/cmd/launch/codex_app_test.go@@ -0,0 +1,1318 @@+package launch++import (+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "os"+ "path/filepath"+ "strings"+ "testing"+ "time"++ "github.com/ollama/ollama/cmd/internal/fileutil"+)++func withCodexAppPlatform(t *testing.T, goos string) {+ t.Helper()+ old := codexAppGOOS+ codexAppGOOS = goos+ t.Cleanup(func() {+ codexAppGOOS = old+ })+}++func withCodexAppProcessHooks(t *testing.T, isRunning func() bool, quit func() error, open func() error) {+ t.Helper()+ oldIsRunning := codexAppIsRunning+ oldQuit := codexAppQuitApp+ oldOpen := codexAppOpenApp+ oldOpenPath := codexAppOpenPath+ oldOpenStart := codexAppOpenStart+ oldRunPath := codexAppRunPath+ oldStartID := codexAppStartID+ oldCanOpenID := codexAppCanOpenID+ codexAppIsRunning = isRunning+ codexAppQuitApp = quit+ codexAppOpenApp = open+ t.Cleanup(func() {+ codexAppIsRunning = oldIsRunning+ codexAppQuitApp = oldQuit+ codexAppOpenApp = oldOpen+ codexAppOpenPath = oldOpenPath+ codexAppOpenStart = oldOpenStart+ codexAppRunPath = oldRunPath+ codexAppStartID = oldStartID+ codexAppCanOpenID = oldCanOpenID+ })+}++func TestCodexAppIntegration(t *testing.T) {+ c := &CodexApp{}++ t.Run("implements runner", func(t *testing.T) {+ var _ Runner = c+ })+ t.Run("implements supported integration", func(t *testing.T) {+ var _ SupportedIntegration = c+ })+ t.Run("implements managed single model", func(t *testing.T) {+ var _ ManagedSingleModel = c+ })+ t.Run("receives model list", func(t *testing.T) {+ var _ ManagedModelListConfigurer = c+ })+ t.Run("onboarding is noninteractive", func(t *testing.T) {+ var _ ManagedInteractiveOnboarding = c+ if c.RequiresInteractiveOnboarding() {+ t.Fatal("Codex App onboarding should only mark launch config")+ }+ })+ t.Run("implements restore", func(t *testing.T) {+ var _ RestorableIntegration = c+ var _ RestoreHintIntegration = c+ var _ ConfigurationSuccessIntegration = c+ var _ RestoreSuccessIntegration = c+ })+}++func TestCodexAppSupportedPlatforms(t *testing.T) {+ for _, goos := range []string{"darwin", "windows"} {+ t.Run(goos, func(t *testing.T) {+ withCodexAppPlatform(t, goos)+ if err := codexAppSupported(); err != nil {+ t.Fatalf("codexAppSupported returned error: %v", err)+ }+ })+ }++ t.Run("linux unsupported", func(t *testing.T) {+ withCodexAppPlatform(t, "linux")+ err := codexAppSupported()+ if err == nil || !strings.Contains(err.Error(), "macOS and Windows") {+ t.Fatalf("codexAppSupported error = %v, want platform message", err)+ }+ })+}++func TestCodexAppWindowsAppPathCandidates(t *testing.T) {+ withCodexAppPlatform(t, "windows")+ local := filepath.Join(t.TempDir(), "LocalAppData")+ t.Setenv("LOCALAPPDATA", local)++ exe := filepath.Join(local, "Codex", "app-26.429.30905", "Codex.exe")+ if err := os.MkdirAll(filepath.Dir(exe), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(exe, []byte{}, 0o644); err != nil {+ t.Fatal(err)+ }++ if got := codexAppAppPath(); got != exe {+ t.Fatalf("codexAppAppPath = %q, want %q", got, exe)+ }+}++func TestCodexAppInstalledUsesWindowsStartMenuFallback(t *testing.T) {+ withCodexAppPlatform(t, "windows")+ t.Setenv("LOCALAPPDATA", filepath.Join(t.TempDir(), "LocalAppData"))++ oldStartID := codexAppStartID+ oldIsRunning := codexAppIsRunning+ codexAppStartID = func() string { return "OpenAI.Codex_12345!App" }+ codexAppIsRunning = func() bool { return false }+ t.Cleanup(func() {+ codexAppStartID = oldStartID+ codexAppIsRunning = oldIsRunning+ })++ if !codexAppInstalled() {+ t.Fatal("expected Windows Start menu app id to count as installed")+ }+}++func TestCodexAppInstalledUsesMacBundleIDFallback(t *testing.T) {+ withCodexAppPlatform(t, "darwin")++ oldCanOpenID := codexAppCanOpenID+ oldStat := codexAppStat+ codexAppCanOpenID = func() bool { return true }+ codexAppStat = func(string) (os.FileInfo, error) { return nil, os.ErrNotExist }+ t.Cleanup(func() {+ codexAppCanOpenID = oldCanOpenID+ codexAppStat = oldStat+ })++ if !codexAppInstalled() {+ t.Fatal("expected macOS LaunchServices bundle id fallback to count as installed")+ }+}++func TestCodexAppConfigureActivatesOllamaProfile(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:9999")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ "profile = \"default\"\n" ++ "model = \"gpt-5.5\"\n\n" ++ "[profiles.default]\n" ++ "model = \"gpt-5.5\"\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ c := &CodexApp{}+ if err := c.ConfigureWithModels("llama3.2", []string{"llama3.2", "qwen3:8b"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ content := string(data)+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ t.Fatal(err)+ }++ for _, want := range []string{+ fmt.Sprintf(`profile = %q`, codexAppProfileName),+ `model = "llama3.2"`,+ fmt.Sprintf(`model_provider = %q`, codexAppProfileName),+ fmt.Sprintf(`model_catalog_json = %q`, catalogPath),+ codexProfileHeaderFor(codexAppProfileName),+ `model = "llama3.2"`,+ `openai_base_url = "http://127.0.0.1:9999/v1/"`,+ fmt.Sprintf(`model_provider = %q`, codexAppProfileName),+ `model_catalog_json = "`,+ codexProviderHeaderFor(codexAppProfileName),+ `name = "Ollama"`,+ `base_url = "http://127.0.0.1:9999/v1/"`,+ `wire_api = "responses"`,+ `[profiles.default]`,+ } {+ if !strings.Contains(content, want) {+ t.Fatalf("expected config to contain %q, got:\n%s", want, content)+ }+ }+ if got := c.CurrentModel(); got != "llama3.2" {+ t.Fatalf("CurrentModel = %q, want llama3.2", got)+ }++ restoreData, err := os.ReadFile(codexAppRestoreStatePath())+ if err != nil {+ t.Fatalf("expected restore state: %v", err)+ }+ if !strings.Contains(string(restoreData), `"profile": "default"`) {+ t.Fatalf("expected restore state to remember default profile, got %s", restoreData)+ }+ catalogData, err := os.ReadFile(catalogPath)+ if err != nil {+ t.Fatalf("expected model catalog: %v", err)+ }+ var catalog struct {+ Models []map[string]any `json:"models"`+ }+ if err := json.Unmarshal(catalogData, &catalog); err != nil {+ t.Fatalf("catalog should be valid JSON: %v", err)+ }+ if got := catalogSlugs(catalog.Models); strings.Join(got, ",") != "llama3.2,qwen3:8b" {+ t.Fatalf("catalog slugs = %v, want fallback models", got)+ }+}++func TestCodexAppConfigureUsesAppSpecificProfileWithoutTouchingCLIProfile(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:9999")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ `profile = "default"` + "\n\n" ++ "[profiles.ollama-launch]\n" ++ `model = "cli-model"` + "\n" ++ `openai_base_url = "http://cli.invalid/v1/"` + "\n" ++ `model_provider = "ollama-launch"` + "\n\n" ++ "[model_providers.ollama-launch]\n" ++ `name = "CLI Ollama"` + "\n" ++ `base_url = "http://cli.invalid/v1/"` + "\n" ++ `wire_api = "responses"` + "\n\n" ++ "[profiles.default]\n" ++ `model = "gpt-5.5"` + "\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ content := string(data)+ if got := codexRootStringValue(content, "profile"); got != codexAppProfileName {+ t.Fatalf("root profile = %q, want %q", got, codexAppProfileName)+ }+ if got := codexSectionStringValue(content, codexProfileHeader(), "openai_base_url"); got != "http://cli.invalid/v1/" {+ t.Fatalf("CLI profile base URL = %q, want preserved CLI URL in:\n%s", got, content)+ }+ if got := codexSectionStringValue(content, codexProviderHeader(), "name"); got != "CLI Ollama" {+ t.Fatalf("CLI provider name = %q, want preserved CLI provider in:\n%s", got, content)+ }+ if got := codexSectionStringValue(content, codexProfileHeaderFor(codexAppProfileName), "model"); got != "llama3.2" {+ t.Fatalf("app profile model = %q, want llama3.2", got)+ }+ if got := codexSectionStringValue(content, codexProviderHeaderFor(codexAppProfileName), "base_url"); got != "http://127.0.0.1:9999/v1/" {+ t.Fatalf("app provider base URL = %q", got)+ }+ assertBackupContains(t, filepath.Join(fileutil.BackupDir(), codexAppIntegrationName, "config.toml.*"), `profile = "default"`)+}++func TestCodexAppConfigureUsesConnectableHostForUnspecifiedBindAddress(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://0.0.0.0:11434")++ if err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ content := string(data)+ if strings.Contains(content, "0.0.0.0") {+ t.Fatalf("config should not write bind-only host, got:\n%s", content)+ }+ if got := codexSectionStringValue(content, codexProfileHeaderFor(codexAppProfileName), "openai_base_url"); got != "http://127.0.0.1:11434/v1/" {+ t.Fatalf("app profile openai_base_url = %q, want connectable loopback URL", got)+ }+ if got := codexSectionStringValue(content, codexProviderHeaderFor(codexAppProfileName), "base_url"); got != "http://127.0.0.1:11434/v1/" {+ t.Fatalf("app provider base_url = %q, want connectable loopback URL", got)+ }+ if got := codexRootStringValue(content, "model_provider"); got != codexAppProfileName {+ t.Fatalf("root model_provider = %q, want %q", got, codexAppProfileName)+ }+}++func TestCodexAppConfigureRejectsMalformedTomlBeforeSideEffects(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "profile = \n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"})+ if err == nil || !strings.Contains(err.Error(), "invalid Codex config TOML") {+ t.Fatalf("ConfigureWithModels error = %v, want invalid TOML", err)+ }+ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ if string(data) != existing {+ t.Fatalf("malformed config should be left untouched, got:\n%s", data)+ }+ if _, err := os.Stat(codexAppRestoreStatePath()); !os.IsNotExist(err) {+ t.Fatalf("restore state should not be written before config validation, err=%v", err)+ }+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ t.Fatal(err)+ }+ if _, err := os.Stat(catalogPath); !os.IsNotExist(err) {+ t.Fatalf("model catalog should not be written before config validation, err=%v", err)+ }+}++func TestCodexAppConfigureRejectsMalformedTomlEvenWithExistingRestoreState(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "[profiles.ollama-launch\nmodel = \"llama3.2\"\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ restoreState := `{"had_profile":true,"profile":"default","had_model":true,"model":"gpt-5.5","had_model_provider":true,"model_provider":"openai","had_model_catalog_json":false}`+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(restoreState), 0o644); err != nil {+ t.Fatal(err)+ }++ err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"})+ if err == nil || !strings.Contains(err.Error(), "invalid Codex config TOML") {+ t.Fatalf("ConfigureWithModels error = %v, want invalid TOML", err)+ }+ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ if string(data) != existing {+ t.Fatalf("malformed config should be left untouched, got:\n%s", data)+ }+ stateData, err := os.ReadFile(codexAppRestoreStatePath())+ if err != nil {+ t.Fatal(err)+ }+ if string(stateData) != restoreState {+ t.Fatalf("restore state should be left untouched, got:\n%s", stateData)+ }+}++func TestCodexAppCurrentModelRequiresManagedActiveProfile(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:11434")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ content := "" ++ "profile = \"default\"\n\n" ++ codexProfileHeaderFor(codexAppProfileName) + "\n" ++ "model = \"llama3.2\"\n" ++ fmt.Sprintf("model_provider = %q\n\n", codexAppProfileName) ++ codexProviderHeaderFor(codexAppProfileName) + "\n" ++ "base_url = \"http://127.0.0.1:11434/v1/\"\n"+ if err := os.WriteFile(configPath, []byte(content), 0o644); err != nil {+ t.Fatal(err)+ }++ if got := (&CodexApp{}).CurrentModel(); got != "" {+ t.Fatalf("CurrentModel = %q, want empty when active profile is not managed", got)+ }+}++func TestCodexAppCurrentModelReadsManagedRootConfig(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:11434")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ content := "" ++ `model = "qwen3:8b"` + "\n" ++ fmt.Sprintf(`model_provider = %q`, codexAppProfileName) + "\n\n" ++ fmt.Sprintf(`model_catalog_json = %q`, mustWriteCodexAppTestCatalog(t, "qwen3:8b")) + "\n\n" ++ codexProfileHeaderFor(codexAppProfileName) + "\n" ++ fmt.Sprintf(`model_provider = %q`, codexAppProfileName) + "\n" ++ fmt.Sprintf(`model_catalog_json = %q`, mustCodexAppModelCatalogPath(t)) + "\n\n" ++ codexProviderHeaderFor(codexAppProfileName) + "\n" ++ `base_url = "http://127.0.0.1:11434/v1/"` + "\n"+ if err := os.WriteFile(configPath, []byte(content), 0o644); err != nil {+ t.Fatal(err)+ }++ if got := (&CodexApp{}).CurrentModel(); got != "qwen3:8b" {+ t.Fatalf("CurrentModel = %q, want qwen3:8b", got)+ }+}++func TestCodexAppCurrentModelRequiresHealthyCatalog(t *testing.T) {+ for _, tt := range []struct {+ name string+ rootCatalog bool+ profileCatalog bool+ writeCatalog bool+ catalogData string+ }{+ {+ name: "missing catalog reference",+ rootCatalog: false,+ profileCatalog: true,+ writeCatalog: true,+ catalogData: `{"models":[{"slug":"llama3.2"}]}`,+ },+ {+ name: "deleted catalog file",+ rootCatalog: true,+ profileCatalog: true,+ writeCatalog: false,+ catalogData: `{"models":[{"slug":"llama3.2"}]}`,+ },+ {+ name: "missing profile catalog reference",+ rootCatalog: true,+ profileCatalog: false,+ writeCatalog: true,+ catalogData: `{"models":[{"slug":"llama3.2"}]}`,+ },+ {+ name: "corrupt catalog file",+ rootCatalog: true,+ profileCatalog: true,+ writeCatalog: true,+ catalogData: `{"models":`,+ },+ {+ name: "empty catalog",+ rootCatalog: true,+ profileCatalog: true,+ writeCatalog: true,+ catalogData: `{"models":[]}`,+ },+ } {+ t.Run(tt.name, func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:11434")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ catalogPath := mustCodexAppModelCatalogPath(t)+ if tt.writeCatalog {+ if err := os.WriteFile(catalogPath, []byte(tt.catalogData), 0o644); err != nil {+ t.Fatal(err)+ }+ }+ var rootCatalogLine, profileCatalogLine string+ if tt.rootCatalog {+ rootCatalogLine = fmt.Sprintf(`model_catalog_json = %q`, catalogPath) + "\n"+ }+ if tt.profileCatalog {+ profileCatalogLine = fmt.Sprintf(`model_catalog_json = %q`, catalogPath) + "\n"+ }+ content := "" ++ `model = "llama3.2"` + "\n" ++ fmt.Sprintf(`model_provider = %q`, codexAppProfileName) + "\n" ++ rootCatalogLine + "\n" ++ codexProfileHeaderFor(codexAppProfileName) + "\n" ++ fmt.Sprintf(`model_provider = %q`, codexAppProfileName) + "\n" ++ profileCatalogLine + "\n" ++ codexProviderHeaderFor(codexAppProfileName) + "\n" ++ `base_url = "http://127.0.0.1:11434/v1/"` + "\n"+ if err := os.WriteFile(configPath, []byte(content), 0o644); err != nil {+ t.Fatal(err)+ }++ if got := (&CodexApp{}).CurrentModel(); got != "" {+ t.Fatalf("CurrentModel = %q, want empty when catalog is unhealthy", got)+ }+ })+ }+}++func TestCodexAppConfigurePopulatesCatalogFromTagsAndShow(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)++ showCalls := make(map[string]int)+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch r.URL.Path {+ case "/api/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"},{"name":"qwen3:8b"},{"name":"llama3.2"}]}`)+ case "/api/show":+ var req struct {+ Model string `json:"model"`+ }+ if err := json.NewDecoder(r.Body).Decode(&req); err != nil {+ t.Fatalf("decode show request: %v", err)+ }+ showCalls[req.Model]+++ fmt.Fprintf(w, `{"model_info":{"general.context_length":%d},"capabilities":["vision"]}`, 65536+len(req.Model))+ default:+ http.NotFound(w, r)+ }+ }))+ defer srv.Close()+ t.Setenv("OLLAMA_HOST", srv.URL)++ if err := (&CodexApp{}).ConfigureWithModels("gemma4", []string{"fallback"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ t.Fatal(err)+ }+ data, err := os.ReadFile(catalogPath)+ if err != nil {+ t.Fatal(err)+ }+ var catalog struct {+ Models []map[string]any `json:"models"`+ }+ if err := json.Unmarshal(data, &catalog); err != nil {+ t.Fatalf("catalog should be valid JSON: %v", err)+ }++ if got := catalogSlugs(catalog.Models); strings.Join(got, ",") != "gemma4,qwen3:8b,llama3.2" {+ t.Fatalf("catalog slugs = %v, want /api/tags models", got)+ }+ for _, model := range catalog.Models {+ slug, _ := model["slug"].(string)+ if model["display_name"] != slug {+ t.Fatalf("display_name should match slug for %q: %v", slug, model["display_name"])+ }+ if model["visibility"] != "list" {+ t.Fatalf("visibility for %q = %v, want list", slug, model["visibility"])+ }+ if model["default_reasoning_level"] != nil {+ t.Fatalf("default_reasoning_level for %q = %v, want nil", slug, model["default_reasoning_level"])+ }+ levels, ok := model["supported_reasoning_levels"].([]any)+ if !ok || len(levels) != 0 {+ t.Fatalf("supported_reasoning_levels for %q = %v, want empty list", slug, model["supported_reasoning_levels"])+ }+ wantContext := float64(272000)+ wantModalities := []string{"text"}+ wantShowCalls := 0+ if slug == "gemma4" {+ wantContext = float64(65536 + len(slug))+ wantModalities = []string{"text", "image"}+ wantShowCalls = 1+ }+ if model["context_window"] != wantContext {+ t.Fatalf("context_window for %q = %v, want %v", slug, model["context_window"], wantContext)+ }+ if got := catalogInputModalities(model); strings.Join(got, ",") != strings.Join(wantModalities, ",") {+ t.Fatalf("input_modalities for %q = %v, want %v", slug, got, wantModalities)+ }+ if showCalls[slug] != wantShowCalls {+ t.Fatalf("show calls for %q = %d, want %d", slug, showCalls[slug], wantShowCalls)+ }+ }+}++func TestCodexAppConfigureUpgradesLegacyRestoreState(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:9999")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ `model = "gpt-5.5"` + "\n" ++ `model_provider = "odc-resp-dev"` + "\n\n" ++ "[model_providers.odc-resp-dev]\n" ++ `base_url = "https://example.invalid/v1/"` + "\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(`{"had_profile":false}`), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ state, err := loadCodexAppRestoreState()+ if err != nil {+ t.Fatal(err)+ }+ if state.HadProfile {+ t.Fatalf("HadProfile = true, want legacy false")+ }+ if !state.HadModel || state.Model != "gpt-5.5" {+ t.Fatalf("model restore state = (%v, %q), want previous root model", state.HadModel, state.Model)+ }+ if !state.HadModelProvider || state.ModelProvider != "odc-resp-dev" {+ t.Fatalf("model provider restore state = (%v, %q), want previous root provider", state.HadModelProvider, state.ModelProvider)+ }+}++func TestCodexAppRestoreRestoresPreviousProfile(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withCodexAppPlatform(t, "darwin")++ var openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error {+ openCalls+++ return nil+ },+ )++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ "profile = \"default\"\n" ++ "model = \"gpt-5.5\"\n" ++ "model_provider = \"openai\"\n" ++ "model_catalog_json = \"/tmp/original-catalog.json\"\n\n" ++ "[profiles.default]\n" ++ "model = \"gpt-5.5\"\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ c := &CodexApp{}+ if err := c.ConfigureWithModels("llama3.2", []string{"llama3.2"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }+ if err := c.Restore(); err != nil {+ t.Fatalf("Restore returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ if !strings.Contains(string(data), `profile = "default"`) || strings.Contains(string(data), fmt.Sprintf(`profile = %q`, codexAppProfileName)) {+ t.Fatalf("restore should restore previous active profile, got:\n%s", data)+ }+ restored := string(data)+ if strings.Contains(restored, codexProfileHeaderFor(codexAppProfileName)) || strings.Contains(restored, codexProviderHeaderFor(codexAppProfileName)) {+ t.Fatalf("restore should remove owned app sections, got:\n%s", restored)+ }+ for key, want := range map[string]string{+ "profile": "default",+ "model": "gpt-5.5",+ "model_provider": "openai",+ "model_catalog_json": "/tmp/original-catalog.json",+ } {+ if got := codexRootStringValue(restored, key); got != want {+ t.Fatalf("root %s = %q, want %q in:\n%s", key, got, want, restored)+ }+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }+ if _, err := os.Stat(codexAppRestoreStatePath()); !os.IsNotExist(err) {+ t.Fatalf("restore state should be removed, got err=%v", err)+ }+}++func TestCodexAppRestoreMissingConfigRemovesRestoreState(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withCodexAppPlatform(t, "darwin")++ var openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error {+ openCalls+++ return nil+ },+ )++ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ restoreState := `{"had_profile":true,"profile":"stale","had_model":true,"model":"old","had_model_provider":true,"model_provider":"openai","had_model_catalog_json":false}`+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(restoreState), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).Restore(); err != nil {+ t.Fatalf("Restore returned error: %v", err)+ }++ if _, err := os.Stat(codexAppRestoreStatePath()); !os.IsNotExist(err) {+ t.Fatalf("restore state should be removed when config is missing, got err=%v", err)+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }+}++func TestCodexAppConfigureMissingConfigReplacesStaleRestoreState(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:9999")++ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ restoreState := `{"had_profile":true,"profile":"stale","had_model":true,"model":"old","had_model_provider":true,"model_provider":"openai","had_model_catalog_json":false}`+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(restoreState), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"}); err != nil {+ t.Fatalf("ConfigureWithModels returned error: %v", err)+ }++ state, err := loadCodexAppRestoreState()+ if err != nil {+ t.Fatal(err)+ }+ if state.HadProfile || state.HadModel || state.HadModelProvider || state.HadModelCatalogJSON {+ t.Fatalf("restore state = %+v, want empty snapshot when config was missing", state)+ }+}++func TestCodexAppConfigureRefreshesRestoreStateAfterManualProfileSwitch(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:9999")+ withCodexAppPlatform(t, "darwin")++ var openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error {+ openCalls+++ return nil+ },+ )++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ initial := "" ++ `profile = "default"` + "\n" ++ `model = "gpt-5.5"` + "\n" ++ `model_provider = "openai"` + "\n\n" ++ "[profiles.default]\n" ++ `model = "gpt-5.5"` + "\n"+ if err := os.WriteFile(configPath, []byte(initial), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).ConfigureWithModels("llama3.2", []string{"llama3.2"}); err != nil {+ t.Fatalf("first ConfigureWithModels returned error: %v", err)+ }++ manual := "" ++ `profile = "manual"` + "\n" ++ `model = "manual-model"` + "\n" ++ `model_provider = "openai"` + "\n\n" ++ "[profiles.manual]\n" ++ `model = "manual-model"` + "\n"+ if err := os.WriteFile(configPath, []byte(manual), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).ConfigureWithModels("qwen3:8b", []string{"qwen3:8b"}); err != nil {+ t.Fatalf("second ConfigureWithModels returned error: %v", err)+ }+ if err := (&CodexApp{}).Restore(); err != nil {+ t.Fatalf("Restore returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ restored := string(data)+ for key, want := range map[string]string{+ "profile": "manual",+ "model": "manual-model",+ "model_provider": "openai",+ } {+ if got := codexRootStringValue(restored, key); got != want {+ t.Fatalf("root %s = %q, want %q in:\n%s", key, got, want, restored)+ }+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }+}++func TestCodexAppRestoreRejectsMalformedTomlWithoutWriting(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withCodexAppPlatform(t, "darwin")++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "model = \"unterminated\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(`{"had_profile":false,"had_model":false,"had_model_provider":false,"had_model_catalog_json":false}`), 0o644); err != nil {+ t.Fatal(err)+ }++ err := (&CodexApp{}).Restore()+ if err == nil || !strings.Contains(err.Error(), "invalid Codex config TOML") {+ t.Fatalf("Restore error = %v, want invalid TOML", err)+ }+ catalogPath, pathErr := codexAppModelCatalogPath()+ if pathErr != nil {+ t.Fatal(pathErr)+ }+ for _, want := range []string{+ "Restore did not complete",+ "Codex config: " + configPath,+ "Restore state: " + codexAppRestoreStatePath(),+ "Model catalog: " + catalogPath,+ "Backups: " + filepath.Join(fileutil.BackupDir(), codexAppIntegrationName),+ } {+ if !strings.Contains(err.Error(), want) {+ t.Fatalf("Restore error missing %q:\n%v", want, err)+ }+ }+ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ if string(data) != existing {+ t.Fatalf("malformed config should be left untouched, got:\n%s", data)+ }+ if _, err := os.Stat(codexAppRestoreStatePath()); err != nil {+ t.Fatalf("restore state should remain after failed restore: %v", err)+ }+}++func TestCodexAppRestoreWithoutStateRemovesManagedRootModel(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withCodexAppPlatform(t, "darwin")++ var openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error {+ openCalls+++ return nil+ },+ )++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ t.Fatal(err)+ }+ existing := "" ++ fmt.Sprintf(`profile = %q`, codexAppProfileName) + "\n" ++ `model = "llama3.2"` + "\n" ++ fmt.Sprintf(`model_provider = %q`, codexAppProfileName) + "\n" ++ fmt.Sprintf(`model_catalog_json = %q`, catalogPath) + "\n\n" ++ codexProfileHeaderFor(codexAppProfileName) + "\n" ++ `model = "llama3.2"` + "\n" ++ fmt.Sprintf(`model_provider = %q`, codexAppProfileName) + "\n\n" ++ codexProviderHeaderFor(codexAppProfileName) + "\n" ++ `base_url = "http://127.0.0.1:11434/v1/"` + "\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(catalogPath), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(catalogPath, []byte(`{"models":[]}`), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).Restore(); err != nil {+ t.Fatalf("Restore returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ content := string(data)+ for _, key := range []string{"profile", "model", "model_provider", "model_catalog_json"} {+ if got, ok := codexRootStringValueOK(content, key); ok {+ t.Fatalf("root %s should be removed, got %q in:\n%s", key, got, content)+ }+ }+ if strings.Contains(content, codexProfileHeaderFor(codexAppProfileName)) || strings.Contains(content, codexProviderHeaderFor(codexAppProfileName)) {+ t.Fatalf("owned app sections should be removed, got:\n%s", content)+ }+ if _, err := os.Stat(catalogPath); !os.IsNotExist(err) {+ t.Fatalf("owned catalog should be removed when unused, err=%v", err)+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }+}++func TestCodexAppRestoreDoesNotStompUserChangedRootConfig(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withCodexAppPlatform(t, "darwin")++ var openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error {+ openCalls+++ return nil+ },+ )++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ t.Fatal(err)+ }+ existing := "" ++ `profile = "manual"` + "\n" ++ `model = "gpt-5.5"` + "\n" ++ `model_provider = "openai"` + "\n\n" ++ codexProfileHeaderFor(codexAppProfileName) + "\n" ++ `model = "llama3.2"` + "\n" ++ fmt.Sprintf(`model_catalog_json = %q`, catalogPath) + "\n\n" ++ codexProviderHeaderFor(codexAppProfileName) + "\n" ++ `base_url = "http://127.0.0.1:11434/v1/"` + "\n\n" ++ "[profiles.manual]\n" ++ `model = "gpt-5.5"` + "\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(catalogPath), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(catalogPath, []byte(`{"models":[]}`), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ restoreState := `{"had_profile":true,"profile":"default","had_model":true,"model":"old","had_model_provider":true,"model_provider":"old-provider","had_model_catalog_json":false}`+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(restoreState), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).Restore(); err != nil {+ t.Fatalf("Restore returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ content := string(data)+ for key, want := range map[string]string{+ "profile": "manual",+ "model": "gpt-5.5",+ "model_provider": "openai",+ } {+ if got := codexRootStringValue(content, key); got != want {+ t.Fatalf("root %s = %q, want %q in:\n%s", key, got, want, content)+ }+ }+ if strings.Contains(content, codexProfileHeaderFor(codexAppProfileName)) || strings.Contains(content, codexProviderHeaderFor(codexAppProfileName)) {+ t.Fatalf("owned app sections should be removed when no longer active, got:\n%s", content)+ }+ if _, err := os.Stat(catalogPath); !os.IsNotExist(err) {+ t.Fatalf("owned catalog should be removed when unused, err=%v", err)+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }+}++func TestCodexAppRestoreDoesNotTreatCLIProfileAsOwned(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withCodexAppPlatform(t, "darwin")++ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error { return nil },+ )++ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ `profile = "ollama-launch"` + "\n" ++ `model = "cli-model"` + "\n" ++ `model_provider = "ollama-launch"` + "\n\n" ++ "[profiles.ollama-launch]\n" ++ `model = "cli-model"` + "\n" ++ `openai_base_url = "http://cli.invalid/v1/"` + "\n" ++ `model_provider = "ollama-launch"` + "\n\n" ++ "[model_providers.ollama-launch]\n" ++ `name = "CLI Ollama"` + "\n" ++ `base_url = "http://cli.invalid/v1/"` + "\n" ++ `wire_api = "responses"` + "\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }+ if err := os.MkdirAll(filepath.Dir(codexAppRestoreStatePath()), 0o755); err != nil {+ t.Fatal(err)+ }+ restoreState := `{"had_profile":true,"profile":"default","had_model":true,"model":"gpt-5.5","had_model_provider":true,"model_provider":"openai","had_model_catalog_json":false}`+ if err := os.WriteFile(codexAppRestoreStatePath(), []byte(restoreState), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := (&CodexApp{}).Restore(); err != nil {+ t.Fatalf("Restore returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }+ if string(data) != existing {+ t.Fatalf("CLI Codex profile should be left untouched, got:\n%s", data)+ }+}++func TestCodexAppRunRestartsRunningAppWhenConfirmed(t *testing.T) {+ withCodexAppPlatform(t, "darwin")+ restoreConfirm := withLaunchConfirmPolicy(launchConfirmPolicy{yes: true})+ defer restoreConfirm()++ running := true+ var quitCalls, openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return running },+ func() error {+ quitCalls+++ running = false+ return nil+ },+ func() error {+ openCalls+++ return nil+ },+ )++ if err := (&CodexApp{}).Run("qwen3.5", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }+ if quitCalls != 1 || openCalls != 1 {+ t.Fatalf("quit/open calls = %d/%d, want 1/1", quitCalls, openCalls)+ }+}++func TestCodexAppRunWaitsForGracefulExitBeforeReopening(t *testing.T) {+ withCodexAppPlatform(t, "darwin")+ restoreConfirm := withLaunchConfirmPolicy(launchConfirmPolicy{yes: true})+ defer restoreConfirm()++ oldSleep := codexAppSleep+ t.Cleanup(func() {+ codexAppSleep = oldSleep+ })++ running := true+ var quitCalls, openCalls, sleepCalls int+ codexAppSleep = func(time.Duration) {+ sleepCalls+++ if sleepCalls == 2 {+ running = false+ }+ }+ withCodexAppProcessHooks(t,+ func() bool { return running },+ func() error {+ quitCalls+++ return nil+ },+ func() error {+ openCalls+++ return nil+ },+ )++ if err := (&CodexApp{}).Run("qwen3.5", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }+ if quitCalls != 1 || openCalls != 1 {+ t.Fatalf("quit/open calls = %d/%d, want 1/1", quitCalls, openCalls)+ }+ if sleepCalls == 0 {+ t.Fatal("expected restart to wait for Codex to exit before reopening")+ }+}++func TestCodexAppRunOpensOnWindowsWhenNotRunning(t *testing.T) {+ withCodexAppPlatform(t, "windows")++ var openCalls int+ withCodexAppProcessHooks(t,+ func() bool { return false },+ func() error { return nil },+ func() error {+ openCalls+++ return nil+ },+ )++ if err := (&CodexApp{}).Run("qwen3.5", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }+ if openCalls != 1 {+ t.Fatalf("open calls = %d, want 1", openCalls)+ }+}++func TestCodexAppRunRestartsWindowsStartAppID(t *testing.T) {+ withCodexAppPlatform(t, "windows")+ restoreConfirm := withLaunchConfirmPolicy(launchConfirmPolicy{yes: true})+ defer restoreConfirm()++ running := true+ var quitCalls int+ withCodexAppProcessHooks(t,+ func() bool { return running },+ func() error {+ quitCalls+++ running = false+ return nil+ },+ func() error {+ t.Fatal("open app fallback should not be used")+ return nil+ },+ )++ codexAppStartID = func() string { return "OpenAI.Codex_2p2nqsd0c76g0!App" }+ codexAppRunPath = func() string {+ return `C:\Program Files\WindowsApps\OpenAI.Codex_26.429.8261.0_x64__2p2nqsd0c76g0\app\Codex.exe`+ }+ var openedStartID, openedPath string+ codexAppOpenStart = func(appID string) error {+ openedStartID = appID+ return nil+ }+ codexAppOpenPath = func(path string) error {+ openedPath = path+ return nil+ }++ if err := (&CodexApp{}).Run("qwen3.5", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }+ if quitCalls != 1 {+ t.Fatalf("quit calls = %d, want 1", quitCalls)+ }+ if openedStartID != "OpenAI.Codex_2p2nqsd0c76g0!App" {+ t.Fatalf("opened Start AppID = %q", openedStartID)+ }+ if openedPath != "" {+ t.Fatalf("opened path = %q, want Start AppID path only", openedPath)+ }+}++func TestCodexAppRunRejectsExtraArgs(t *testing.T) {+ withCodexAppPlatform(t, "darwin")+ err := (&CodexApp{}).Run("qwen3.5", []string{"--foo"})+ if err == nil || !strings.Contains(err.Error(), "does not accept extra arguments") {+ t.Fatalf("Run error = %v, want extra args rejection", err)+ }+}++func TestCodexAppProcessMatchesMainAndAppServer(t *testing.T) {+ for _, command := range []string{+ "/Applications/Codex.app/Contents/MacOS/Codex",+ "/Applications/Codex.app/Contents/Resources/codex app-server --analytics-default-enabled",+ `C:\Users\parth\AppData\Local\Programs\Codex\Codex.exe`,+ `"C:\Users\parth\AppData\Local\Codex\app-26.429.30905\resources\codex.exe" app-server --analytics-default-enabled`,+ `"C:\Users\parth\AppData\Local\openai-codex-electron\resources\codex.exe" "app-server"`,+ } {+ if !codexAppProcessMatches(command) {+ t.Fatalf("expected command to match Codex App process: %s", command)+ }+ }++ for _, command := range []string{+ "/Applications/Codex.app/Contents/Frameworks/Codex Helper.app/Contents/MacOS/Codex Helper",+ "/Applications/Codex.app/Contents/Frameworks/Electron Framework.framework/Helpers/chrome_crashpad_handler",+ `"C:\Program Files\WindowsApps\OpenAI.Codex_26.429.8261.0_x64__2p2nqsd0c76g0\app\Codex.exe" --type=renderer --user-data-dir="C:\Users\parth\AppData\Roaming\Codex"`,+ `"C:\Program Files\WindowsApps\OpenAI.Codex_26.429.8261.0_x64__2p2nqsd0c76g0\app\Codex.exe" --type=crashpad-handler`,+ } {+ if codexAppProcessMatches(command) {+ t.Fatalf("expected helper command not to match Codex App process: %s", command)+ }+ }+}++func catalogSlugs(models []map[string]any) []string {+ slugs := make([]string, 0, len(models))+ for _, model := range models {+ if slug, _ := model["slug"].(string); slug != "" {+ slugs = append(slugs, slug)+ }+ }+ return slugs+}++func catalogInputModalities(entry map[string]any) []string {+ raw, _ := entry["input_modalities"].([]any)+ modalities := make([]string, 0, len(raw))+ for _, item := range raw {+ if modality, _ := item.(string); modality != "" {+ modalities = append(modalities, modality)+ }+ }+ return modalities+}++func mustCodexAppModelCatalogPath(t *testing.T) string {+ t.Helper()+ catalogPath, err := codexAppModelCatalogPath()+ if err != nil {+ t.Fatal(err)+ }+ return catalogPath+}++func mustWriteCodexAppTestCatalog(t *testing.T, slugs ...string) string {+ t.Helper()+ catalogPath := mustCodexAppModelCatalogPath(t)+ if err := os.MkdirAll(filepath.Dir(catalogPath), 0o755); err != nil {+ t.Fatal(err)+ }+ models := make([]map[string]string, 0, len(slugs))+ for _, slug := range slugs {+ models = append(models, map[string]string{"slug": slug})+ }+ data, err := json.Marshal(map[string]any{"models": models})+ if err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(catalogPath, data, 0o644); err != nil {+ t.Fatal(err)+ }+ return catalogPath+}diff --git a/cmd/launch/codex_test.go b/cmd/launch/codex_test.goindex c19e24d1e..5c1cc573b 100644--- a/cmd/launch/codex_test.go+++ b/cmd/launch/codex_test.go@@ -6,6 +6,8 @@ import ("slices""strings""testing"++ "github.com/ollama/ollama/cmd/internal/fileutil")func TestCodexArgs(t *testing.T) {@@ -69,6 +71,9 @@ func TestWriteCodexProfile(t *testing.T) {if !strings.Contains(content, `name = "Ollama"`) {t.Error("missing model provider name")}+ if err := codexValidateConfigText(content); err != nil {+ t.Fatalf("generated config should be valid TOML: %v\n%s", err, content)+ }})t.Run("appends profile to existing file without profile", func(t *testing.T) {@@ -114,6 +119,150 @@ func TestWriteCodexProfile(t *testing.T) {if strings.Count(content, "[model_providers.ollama-launch]") != 1 {t.Errorf("expected exactly one [model_providers.ollama-launch] section, got %d", strings.Count(content, "[model_providers.ollama-launch]"))}+ if err := codexValidateConfigText(content); err != nil {+ t.Fatalf("generated config should be valid TOML: %v\n%s", err, content)+ }+ })++ t.Run("replaces equivalent quoted profile table", func(t *testing.T) {+ tmpDir := t.TempDir()+ configPath := filepath.Join(tmpDir, "config.toml")+ existing := "" ++ `profile = "default"` + "\n\n" ++ `[profiles."ollama-launch"]` + "\n" ++ `openai_base_url = "http://old:1234/v1/"` + "\n\n" ++ `[model_providers."ollama-launch"]` + "\n" ++ `name = "Old"` + "\n" ++ `base_url = "http://old:1234/v1/"` + "\n\n" ++ `[profiles.default]` + "\n" ++ `model = "gpt-5.5"` + "\n"+ os.WriteFile(configPath, []byte(existing), 0o644)++ if err := writeCodexProfile(configPath); err != nil {+ t.Fatal(err)+ }++ data, _ := os.ReadFile(configPath)+ content := string(data)++ if strings.Contains(content, `profiles."ollama-launch"`) {+ t.Fatalf("quoted profile table should be replaced, got:\n%s", content)+ }+ if strings.Contains(content, "old:1234") {+ t.Fatalf("old URL was not replaced, got:\n%s", content)+ }+ if got := codexSectionStringValue(content, codexProfileHeader(), "model_provider"); got != codexProfileName {+ t.Fatalf("profile model_provider = %q, want %q", got, codexProfileName)+ }+ if got := codexSectionStringValue(content, codexProviderHeader(), "base_url"); !strings.Contains(got, "/v1/") {+ t.Fatalf("provider base_url = %q, want /v1/ URL", got)+ }+ if err := codexValidateConfigText(content); err != nil {+ t.Fatalf("generated config should be valid TOML: %v\n%s", err, content)+ }+ })++ t.Run("rejects invalid existing toml without writing", func(t *testing.T) {+ tmpDir := t.TempDir()+ configPath := filepath.Join(tmpDir, "config.toml")+ existing := "profile = \n"+ os.WriteFile(configPath, []byte(existing), 0o644)++ err := writeCodexProfile(configPath)+ if err == nil || !strings.Contains(err.Error(), "invalid Codex config TOML") {+ t.Fatalf("writeCodexProfile error = %v, want invalid TOML", err)+ }++ data, _ := os.ReadFile(configPath)+ if string(data) != existing {+ t.Fatalf("invalid config should be left untouched, got:\n%s", data)+ }+ })++ t.Run("rejects malformed existing toml variants without writing", func(t *testing.T) {+ tests := map[string]string{+ "duplicate root key": "profile = \"default\"\nprofile = \"other\"\n",+ "unterminated string": "model = \"gpt-5.5\n",+ "bad table": "[profiles.ollama-launch\nmodel = \"llama3.2\"\n",+ "duplicate table key": "[profiles.ollama-launch]\nmodel = \"a\"\nmodel = \"b\"\n",+ }+ for name, existing := range tests {+ t.Run(name, func(t *testing.T) {+ tmpDir := t.TempDir()+ configPath := filepath.Join(tmpDir, "config.toml")+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ err := writeCodexProfile(configPath)+ if err == nil || !strings.Contains(err.Error(), "invalid Codex config TOML") {+ t.Fatalf("writeCodexProfile error = %v, want invalid TOML", err)+ }++ data, _ := os.ReadFile(configPath)+ if string(data) != existing {+ t.Fatalf("invalid config should be left untouched, got:\n%s", data)+ }+ })+ }+ })++ t.Run("backs up previous config before overwrite", func(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ configPath := filepath.Join(tmpDir, ".codex", "config.toml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "# original-codex-backup-marker\n[profiles.default]\nmodel = \"gpt-5.5\"\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ if err := writeCodexProfile(configPath); err != nil {+ t.Fatal(err)+ }++ assertBackupContains(t, filepath.Join(fileutil.BackupDir(), "config.toml.*"), "original-codex-backup-marker")+ })++ t.Run("updates equivalent quoted root keys", func(t *testing.T) {+ tmpDir := t.TempDir()+ configPath := filepath.Join(tmpDir, "config.toml")+ existing := "" ++ `"profile" = "default"` + "\n" ++ `"model" = "gpt-5.5"` + "\n" ++ `"model_provider" = "openai"` + "\n\n" ++ `[profiles.default]` + "\n" ++ `model = "gpt-5.5"` + "\n"+ os.WriteFile(configPath, []byte(existing), 0o644)++ err := writeCodexLaunchProfile(configPath, codexLaunchProfileOptions{+ activate: true,+ setRootModelConfig: true,+ model: "llama3.2",+ })+ if err != nil {+ t.Fatal(err)+ }++ data, _ := os.ReadFile(configPath)+ content := string(data)+ for key, want := range map[string]string{+ "profile": codexProfileName,+ "model": "llama3.2",+ "model_provider": codexProfileName,+ } {+ if got := codexRootStringValue(content, key); got != want {+ t.Fatalf("root %s = %q, want %q in:\n%s", key, got, want, content)+ }+ }+ if strings.Contains(content, `"profile"`) || strings.Contains(content, `"model_provider"`) {+ t.Fatalf("quoted root keys should be rewritten once, got:\n%s", content)+ }+ if err := codexValidateConfigText(content); err != nil {+ t.Fatalf("generated config should be valid TOML: %v\n%s", err, content)+ }})t.Run("replaces profile while preserving following sections", func(t *testing.T) {@@ -178,6 +327,26 @@ func TestWriteCodexProfile(t *testing.T) {t.Errorf("expected custom host in URL, got:\n%s", content)}})++ t.Run("uses connectable host for unspecified bind address", func(t *testing.T) {+ t.Setenv("OLLAMA_HOST", "http://0.0.0.0:11434")+ tmpDir := t.TempDir()+ configPath := filepath.Join(tmpDir, "config.toml")++ if err := writeCodexProfile(configPath); err != nil {+ t.Fatal(err)+ }++ data, _ := os.ReadFile(configPath)+ content := string(data)++ if strings.Contains(content, "0.0.0.0") {+ t.Fatalf("config should not write bind-only host, got:\n%s", content)+ }+ if !strings.Contains(content, "127.0.0.1:11434/v1/") {+ t.Fatalf("expected connectable loopback URL, got:\n%s", content)+ }+ })}func TestEnsureCodexConfig(t *testing.T) {@@ -227,3 +396,21 @@ func TestEnsureCodexConfig(t *testing.T) {}})}++func assertBackupContains(t *testing.T, pattern, marker string) {+ t.Helper()+ backups, err := filepath.Glob(pattern)+ if err != nil {+ t.Fatal(err)+ }+ for _, backupPath := range backups {+ data, err := os.ReadFile(backupPath)+ if err != nil {+ t.Fatal(err)+ }+ if strings.Contains(string(data), marker) {+ return+ }+ }+ t.Fatalf("backup matching %q with marker %q not found", pattern, marker)+}diff --git a/cmd/launch/integrations_test.go b/cmd/launch/integrations_test.goindex da406b4c5..8a842eea5 100644--- a/cmd/launch/integrations_test.go+++ b/cmd/launch/integrations_test.go@@ -58,6 +58,9 @@ func TestIntegrationLookup(t *testing.T) {{"claude desktop", "claude-desktop", true, "Claude Desktop"},{"claude desktop alias", "claude-app", true, "Claude Desktop"},{"codex", "codex", true, "Codex"},+ {"codex app", "codex-app", true, "Codex App"},+ {"codex app desktop alias", "codex-desktop", true, "Codex App"},+ {"codex app gui alias", "codex-gui", true, "Codex App"},{"kimi", "kimi", true, "Kimi Code CLI"},{"droid", "droid", true, "Droid"},{"opencode", "opencode", true, "OpenCode"},@@ -80,7 +83,7 @@ func TestIntegrationLookup(t *testing.T) {}func TestIntegrationRegistry(t *testing.T) {- expectedIntegrations := []string{"claude", "claude-desktop", "codex", "kimi", "droid", "opencode", "hermes", "pool"}+ expectedIntegrations := []string{"claude", "claude-desktop", "codex", "codex-app", "kimi", "droid", "opencode", "hermes", "pool"}for _, name := range expectedIntegrations {t.Run(name, func(t *testing.T) {r, ok := integrations[name]@@ -1813,11 +1816,38 @@ func TestListIntegrationInfos(t *testing.T) {}want = filtered}+ if codexAppSupported() != nil {+ filtered := make([]string, 0, len(want))+ for _, name := range want {+ if name != "codex-app" {+ filtered = append(filtered, name)+ }+ }+ want = filtered+ }+if diff := compareStrings(got, want); diff != "" {t.Fatalf("launcher integration order mismatch: %s", diff)}})+ t.Run("prioritizes primary launcher integrations", func(t *testing.T) {+ got := make([]string, 0, len(infos))+ for _, info := range infos {+ got = append(got, info.Name)+ }+ wantPrefix := []string{"claude", "codex-app", "hermes", "openclaw"}+ if codexAppSupported() != nil {+ wantPrefix = []string{"claude", "hermes", "openclaw", "opencode"}+ }+ if len(got) < len(wantPrefix) {+ t.Fatalf("expected at least %d integrations, got %v", len(wantPrefix), got)+ }+ if diff := compareStrings(got[:len(wantPrefix)], wantPrefix); diff != "" {+ t.Fatalf("unexpected primary launcher order: %s", diff)+ }+ })+t.Run("all fields populated", func(t *testing.T) {for _, info := range infos {if info.Name == "" {@@ -1831,6 +1861,9 @@ func TestListIntegrationInfos(t *testing.T) {t.Run("includes known integrations", func(t *testing.T) {known := map[string]bool{"claude": false, "codex": false, "opencode": false}+ if codexAppSupported() == nil {+ known["codex-app"] = false+ }if poolsideGOOS != "windows" {known["pool"] = false}diff --git a/cmd/launch/launch.go b/cmd/launch/launch.goindex 39ce0c4ce..0cb81c14e 100644--- a/cmd/launch/launch.go+++ b/cmd/launch/launch.go@@ -285,22 +285,25 @@ Flags and extra arguments require an integration name.Supported integrations:claude Claude Code- cline Cline+ codex-app Codex App (aliases: codex-desktop, codex-gui)+ hermes Hermes Agent+ openclaw OpenClaw (aliases: clawdbot, moltbot)+ opencode OpenCodecodex Codexcopilot Copilot CLI (aliases: copilot-cli)droid Droid- hermes Hermes Agentkimi Kimi Code CLI- opencode OpenCode- openclaw OpenClaw (aliases: clawdbot, moltbot)pi Pipool Pool+ cline Clinevscode VS Code (aliases: code)Examples:ollama launchollama launch claudeollama launch claude --model <model>+ ollama launch codex-app+ ollama launch codex-app --restoreollama launch hermesollama launch droid --config (does not auto-launch)ollama launch codex -- -p myprofile (pass extra args to integration)@@ -769,7 +772,13 @@ func (c *launcherClient) launchManagedSingleIntegration(ctx context.Context, namreturn nil}- if needsConfigure || req.ModelOverride != "" || (current != "" && target != current) || !savedMatchesModels(saved, []string{target}) {+ // current is the live managed app config; target may come from saved launch+ // state. Rewrite when the live config is missing or has drifted so the app+ // config converges with the model which launch is about to use.+ liveConfigMissing := current == ""+ liveConfigDrifted := current != "" && target != current+ configured := false+ if needsConfigure || req.ModelOverride != "" || liveConfigMissing || liveConfigDrifted || !savedMatchesModels(saved, []string{target}) {configureModels, err := c.managedSingleConfigureModels(ctx, managed, target)if err != nil {return err@@ -782,6 +791,7 @@ func (c *launcherClient) launchManagedSingleIntegration(ctx context.Context, namreturn err}}+ configured = true}if !managedIntegrationOnboarded(saved, managed) {@@ -793,6 +803,12 @@ func (c *launcherClient) launchManagedSingleIntegration(ctx context.Context, nam}}+ if configured {+ if !printConfigurationSuccess(managed) {+ printRestoreHint(managed)+ }+ }+if req.ConfigureOnly {return nil}@@ -941,7 +957,7 @@ func (c *launcherClient) resolveSingleIntegrationTarget(ctx context.Context, run}}- if needsConfigure {+ if needsConfigure && req.ModelOverride == "" {selected, err := c.selectSingleModelWithSelectorReady(ctx, fmt.Sprintf("Select model for %s:", runner), target, DefaultSingleSelector, !skipReadiness)if err != nil {return "", false, errdiff --git a/cmd/launch/launch_test.go b/cmd/launch/launch_test.goindex 8333c89ca..c0903aaf9 100644--- a/cmd/launch/launch_test.go+++ b/cmd/launch/launch_test.go@@ -68,15 +68,18 @@ func (r *launcherRestorableRunner) RestoreSuccessMessage() string {}type launcherManagedRunner struct {- paths []string- currentModel string- configured []string- ranModel string- onboarded bool- onboardCalls int- onboardingComplete bool- refreshCalls int- refreshErr error+ paths []string+ currentModel string+ configured []string+ ranModel string+ onboarded bool+ onboardCalls int+ onboardingComplete bool+ refreshCalls int+ refreshErr error+ restoreHint string+ configSuccessMessage string+ skipModelReadiness bool}func (r *launcherManagedRunner) Run(model string, args []string) error {@@ -110,6 +113,14 @@ func (r *launcherManagedRunner) RefreshRuntimeAfterConfigure() error {return r.refreshErr}+func (r *launcherManagedRunner) RestoreHint() string { return r.restoreHint }++func (r *launcherManagedRunner) ConfigurationSuccessMessage() string {+ return r.configSuccessMessage+}++func (r *launcherManagedRunner) SkipModelReadiness() bool { return r.skipModelReadiness }+type launcherHeadlessManagedRunner struct {launcherManagedRunner}@@ -480,6 +491,116 @@ func TestLaunchIntegration_ManagedSingleIntegrationConfigOnlySkipsFinalRun(t *te}}+func TestLaunchIntegration_ManagedSingleIntegrationPrintsConfigurationSuccessAfterConfigure(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)+ withInteractiveSession(t, true)+ withLauncherHooks(t)++ runner := &launcherManagedRunner{+ configSuccessMessage: "configured successfully\nrestore via success message",+ restoreHint: "run restore command",+ skipModelReadiness: true,+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ stderr := captureStderr(t, func() {+ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ModelOverride: "gemma4",+ ForceConfigure: true,+ ConfigureOnly: true,+ }); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }+ })++ if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {+ t.Fatalf("configured models mismatch: %s", diff)+ }+ if !strings.Contains(stderr, "configured successfully") {+ t.Fatalf("expected configuration success in stderr, got %q", stderr)+ }+ if !strings.Contains(stderr, "restore via success message") {+ t.Fatalf("expected restore guidance in configuration success, got %q", stderr)+ }+ if strings.Contains(stderr, "run restore command") {+ t.Fatalf("restore hint should not print separately after configure, got %q", stderr)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationDoesNotPrintRestoreHintWhenUnchanged(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)+ withInteractiveSession(t, true)+ withLauncherHooks(t)++ runner := &launcherManagedRunner{+ currentModel: "gemma4",+ onboardingComplete: true,+ configSuccessMessage: "configured successfully",+ restoreHint: "run restore command",+ skipModelReadiness: true,+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ if err := config.SaveIntegration("stubmanaged", []string{"gemma4"}); err != nil {+ t.Fatalf("failed to save managed integration config: %v", err)+ }+ if err := config.MarkIntegrationOnboarded("stubmanaged"); err != nil {+ t.Fatalf("failed to mark integration onboarded: %v", err)+ }++ stderr := captureStderr(t, func() {+ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }+ })++ if len(runner.configured) != 0 {+ t.Fatalf("expected Configure to be skipped when saved matches, got %v", runner.configured)+ }+ if strings.Contains(stderr, "configured successfully") {+ t.Fatalf("configuration success should not print when config is unchanged, got %q", stderr)+ }+ if strings.Contains(stderr, "run restore command") {+ t.Fatalf("restore hint should not print when config is unchanged, got %q", stderr)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationForceConfigureUsesModelOverride(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)+ withInteractiveSession(t, true)+ withLauncherHooks(t)++ runner := &launcherManagedRunner{+ paths: nil,+ skipModelReadiness: true,+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ DefaultSingleSelector = func(title string, items []SelectionItem, current string) (string, error) {+ return "", fmt.Errorf("selector should not run with an explicit model override")+ }++ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ModelOverride: "gemma4",+ ForceConfigure: true,+ ConfigureOnly: true,+ }); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }++ if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {+ t.Fatalf("configured models mismatch: %s", diff)+ }+ if runner.ranModel != "" {+ t.Fatalf("expected configure-only flow to skip final launch, got %q", runner.ranModel)+ }+}+func TestLaunchIntegration_ManagedSingleIntegrationSkipsRewriteWhenSavedMatches(t *testing.T) {tmpDir := t.TempDir()setLaunchTestHome(t, tmpDir)@@ -505,7 +626,9 @@ func TestLaunchIntegration_ManagedSingleIntegrationSkipsRewriteWhenSavedMatches(t.Fatalf("failed to save managed integration config: %v", err)}- runner := &launcherManagedRunner{}+ runner := &launcherManagedRunner{+ currentModel: "gemma4",+ }withIntegrationOverride(t, "stubmanaged", runner)DefaultSingleSelector = func(title string, items []SelectionItem, current string) (string, error) {@@ -532,6 +655,53 @@ func TestLaunchIntegration_ManagedSingleIntegrationSkipsRewriteWhenSavedMatches(}}+func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedMatchesButLiveConfigMissing(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)+ withInteractiveSession(t, true)+ withLauncherHooks(t)++ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch r.URL.Path {+ case "/api/show":+ fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)+ default:+ http.NotFound(w, r)+ }+ }))+ defer srv.Close()+ t.Setenv("OLLAMA_HOST", srv.URL)++ if err := config.SaveIntegration("stubmanaged", []string{"gemma4"}); err != nil {+ t.Fatalf("failed to save managed integration config: %v", err)+ }++ runner := &launcherManagedRunner{}+ withIntegrationOverride(t, "stubmanaged", runner)++ DefaultSingleSelector = func(title string, items []SelectionItem, current string) (string, error) {+ t.Fatal("selector should not be called when saved model is usable")+ return "", nil+ }+ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ return true, nil+ }++ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }++ if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {+ t.Fatalf("expected Configure to rewrite missing live config: %s", diff)+ }+ if runner.refreshCalls != 1 {+ t.Fatalf("expected runtime refresh once after rewrite, got %d", runner.refreshCalls)+ }+ if runner.ranModel != "gemma4" {+ t.Fatalf("expected launch to run saved model, got %q", runner.ranModel)+ }+}+func TestLaunchIntegration_ManagedSingleIntegrationRewritesWhenSavedDiffers(t *testing.T) {tmpDir := t.TempDir()setLaunchTestHome(t, tmpDir)diff --git a/cmd/launch/registry.go b/cmd/launch/registry.goindex 0d9407e4d..968d7b4bf 100644--- a/cmd/launch/registry.go+++ b/cmd/launch/registry.go@@ -33,7 +33,7 @@ type IntegrationInfo struct {Description string}-var launcherIntegrationOrder = []string{"claude", "openclaw", "hermes", "opencode", "codex", "copilot", "droid", "pi", "pool"}+var launcherIntegrationOrder = []string{"claude", "codex-app", "hermes", "openclaw", "opencode", "codex", "copilot", "droid", "pi", "pool"}var integrationSpecs = []*IntegrationSpec{{@@ -87,6 +87,18 @@ var integrationSpecs = []*IntegrationSpec{Command: []string{"npm", "install", "-g", "@openai/codex"},},},+ {+ Name: "codex-app",+ Runner: &CodexApp{},+ Aliases: []string{"codex-desktop", "codex-gui"},+ Description: "OpenAI's desktop coding agent",+ Install: IntegrationInstallSpec{+ CheckInstalled: func() bool {+ return codexAppInstalled()+ },+ URL: "https://developers.openai.com/codex/app/overview/",+ },+ },{Name: "kimi",Runner: &Kimi{},diff --git a/cmd/tui/tui_test.go b/cmd/tui/tui_test.goindex b385fe741..7f2504616 100644--- a/cmd/tui/tui_test.go+++ b/cmd/tui/tui_test.go@@ -29,6 +29,13 @@ func launcherTestState() *launch.LauncherState {Selectable: true,Changeable: true,},+ "codex-app": {+ Name: "codex-app",+ DisplayName: "Codex App",+ Description: "OpenAI's desktop coding agent",+ Selectable: true,+ Changeable: true,+ },"openclaw": {Name: "openclaw",DisplayName: "OpenClaw",@@ -122,12 +129,25 @@ func expectedExpandedSequence(state *launch.LauncherState) []string {func TestMenuRendersPinnedItemsAndMore(t *testing.T) {state := launcherTestState()menu := newModel(state)+ wantPrefix := []string{"run", "claude", "codex-app", "hermes", "openclaw"}+ if findMenuCursorByIntegration(menu.items, "codex-app") == -1 {+ wantPrefix = []string{"run", "claude", "hermes", "openclaw", "opencode"}+ }+ if got := integrationSequence(menu.items); len(got) < len(wantPrefix) {+ t.Fatalf("expected at least %d menu items, got %v", len(wantPrefix), got)+ } else if diff := compareStrings(got[:len(wantPrefix)], wantPrefix); diff != "" {+ t.Fatalf("unexpected primary TUI order: %s", diff)+ }+view := menu.View()- for _, want := range []string{"Chat with a model", "Launch Claude Code", "Launch OpenClaw", "Launch Hermes Agent", "More..."} {+ for _, want := range []string{"Chat with a model", "Launch Claude Code", "Launch Hermes Agent", "Launch OpenClaw", "More..."} {if !strings.Contains(view, want) {t.Fatalf("expected menu view to contain %q\n%s", want, view)}}+ if findMenuCursorByIntegration(menu.items, "codex-app") != -1 && !strings.Contains(view, "Launch Codex App") {+ t.Fatalf("expected menu view to contain Codex App\n%s", view)+ }if strings.Contains(view, "Launch Claude Desktop") {t.Fatalf("expected hidden Claude Desktop to be absent\n%s", view)}diff --git a/docs/docs.json b/docs/docs.jsonindex 79db465d6..32eb68120 100644--- a/docs/docs.json+++ b/docs/docs.json@@ -124,6 +124,7 @@"pages": ["/integrations/claude-code","/integrations/codex",+ "/integrations/codex-app","/integrations/copilot-cli","/integrations/opencode","/integrations/droid",diff --git a/docs/integrations/codex-app.mdx b/docs/integrations/codex-app.mdxnew file mode 100644index 000000000..f93bdbadc--- /dev/null+++ b/docs/integrations/codex-app.mdx@@ -0,0 +1,39 @@+---+title: Codex App+---++## Install++Install the [Codex App](https://developers.openai.com/codex/app/overview/) for macOS or Windows.++## Usage with Ollama++<Note>Codex works best with a larger context window. It is recommended to use a context window of at least 64k tokens.</Note>++### Quick setup++```shell+ollama launch codex-app+```++To choose a model:++```shell+ollama launch codex-app --model gpt-oss:120b+```++To configure without launching:++```shell+ollama launch codex-app --config+```++To restore your usual Codex profile:++```shell+ollama launch codex-app --restore+```++## Backups++Before overwriting Codex App config files, Ollama Launch saves backups under `~/.ollama/backup/codex-app/`. On Windows, `~` resolves to your user profile directory.diff --git a/docs/integrations/codex.mdx b/docs/integrations/codex.mdxindex 1888809b5..3bde7aa7f 100644--- a/docs/integrations/codex.mdx+++ b/docs/integrations/codex.mdx@@ -1,11 +1,11 @@----title: Codex+title: Codex CLI---## Install-Install the [Codex CLI](https://developers.openai.com/codex/cli/):+Install the [Codex CLI](https://developers.openai.com/codex/cli/). For the desktop app, see [Codex App](/integrations/codex-app).```npm install -g @openai/codexdiff --git a/docs/integrations/index.mdx b/docs/integrations/index.mdxindex 83f2417d0..00a550643 100644--- a/docs/integrations/index.mdx+++ b/docs/integrations/index.mdx@@ -9,7 +9,8 @@ Ollama integrates with a wide range of tools.Coding assistants that can read, modify, and execute code in your projects.- [Claude Code](/integrations/claude-code)-- [Codex](/integrations/codex)+- [Codex CLI](/integrations/codex)+- [Codex App](/integrations/codex-app)- [Copilot CLI](/integrations/copilot-cli)- [OpenCode](/integrations/opencode)- [Droid](/integrations/droid)diff --git a/go.mod b/go.modindex ce433674b..d5dd28ed1 100644--- a/go.mod+++ b/go.mod@@ -30,6 +30,7 @@ require (github.com/mattn/go-runewidth v0.0.16github.com/nlpodyssey/gopickle v0.3.0github.com/pdevine/tensor v0.0.0-20240510204454-f88f4562727c+ github.com/pelletier/go-toml/v2 v2.2.2github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141cgithub.com/tkrajina/typescriptify-golang-structs v0.2.0github.com/tree-sitter/go-tree-sitter v0.25.0@@ -95,7 +96,6 @@ require (github.com/mattn/go-isatty v0.0.20 // indirectgithub.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirectgithub.com/modern-go/reflect2 v1.0.2 // indirect- github.com/pelletier/go-toml/v2 v2.2.2 // indirectgithub.com/spf13/pflag v1.0.5 // indirectgithub.com/twitchyliquid64/golang-asm v0.15.1 // indirectgithub.com/ugorji/go/codec v1.2.12 // indirect