package agentstatus import ( "context" "os/exec" "path/filepath" "runtime" "strings" "sync" "github.com/tutti-os/tutti/packages/agent/daemon/runtimecmd" ) // codexRuntimeCandidateSource records how a launcher entered a discovery // snapshot. A logical installation can have more than one source when, for // example, its launcher is both on PATH and returned by `bun pm bin -g`. type codexRuntimeCandidateSource string const ( codexRuntimeCandidateSourcePath codexRuntimeCandidateSource = "path" codexRuntimeCandidateSourceBunGlobal codexRuntimeCandidateSource = "bun_global" codexRuntimeCandidateSourcePNPMGlobal codexRuntimeCandidateSource = "pnpm_global" codexRuntimeCandidateSourceNPMGlobal codexRuntimeCandidateSource = "npm_global" codexRuntimeCandidateSourceHomebrew codexRuntimeCandidateSource = "homebrew" ) // codexRuntimeCandidate is discovery evidence only. Phase two adds version // and app-server validation; phase one must not use these candidates to alter // selection or launch behavior. type codexRuntimeCandidate struct { LauncherPath string RealPath string PackageRoot string Sources []codexRuntimeCandidateSource } // discoverCodexRuntimeCandidates enumerates every known Codex launcher source // instead of stopping at the first PATH match. It intentionally does not // perform version or app-server probes and is not connected to runtime // selection yet. func (s Service) discoverCodexRuntimeCandidates(ctx context.Context, spec ProviderSpec) []codexRuntimeCandidate { if !isCodexStatusSpec(spec) { return nil } resolver := s.commandResolver() env := resolver.Env(spec.AdapterEnv) result := codexRuntimeCandidateCollector{} result.addAll(resolveCodexLaunchers(resolver, env), codexRuntimeCandidateSourcePath) if path := resolver.ResolveBinary([]string{"codex"}, spec.AdapterEnv); path != "" { result.add(path, codexRuntimeCandidateSourcePath) } globalBins := s.discoverCodexGlobalBins(ctx, resolver, spec.AdapterEnv) for _, discovery := range []struct { binDir string source codexRuntimeCandidateSource }{ {globalBins.bun, codexRuntimeCandidateSourceBunGlobal}, {globalBins.pnpm, codexRuntimeCandidateSourcePNPMGlobal}, {globalBins.npm, codexRuntimeCandidateSourceNPMGlobal}, {globalBins.homebrew, codexRuntimeCandidateSourceHomebrew}, } { if discovery.binDir != "" { result.addAll(resolveCodexLaunchersInDir(resolver, discovery.binDir), discovery.source) } } return result.candidates } type codexGlobalBins struct { bun string pnpm string npm string homebrew string } // discoverCodexGlobalBins runs independent package-manager queries together so // one slow manager does not hide later valid Codex installations. Candidates // are still added in a stable source order after every query completes. func (s Service) discoverCodexGlobalBins( ctx context.Context, resolver runtimecmd.Resolver, overrides []string, ) codexGlobalBins { var result codexGlobalBins var queries sync.WaitGroup queries.Add(4) go func() { defer queries.Done() result.bun = s.discoverBunGlobalBinDir(ctx, resolver, overrides) }() go func() { defer queries.Done() result.pnpm = s.discoverPnpmGlobalBinDir(ctx, resolver, overrides) }() go func() { defer queries.Done() result.npm = s.discoverNpmGlobalBinDir(ctx, resolver, overrides) }() go func() { defer queries.Done() result.homebrew = s.discoverHomebrewBinDir(ctx, resolver, overrides) }() queries.Wait() return result } func resolveCodexLaunchersInDir(resolver runtimecmd.Resolver, dir string) []string { dir = strings.TrimSpace(dir) if dir == "" { return nil } return resolveCodexLaunchers(resolver, []string{"PATH=" + dir}) } func resolveCodexLaunchers(resolver runtimecmd.Resolver, env []string) []string { result := []string{} seen := map[string]struct{}{} for _, path := range resolver.ResolveAllNames(codexLauncherNames(), env) { key := codexRuntimeCandidateIdentity(path, path, "") if _, ok := seen[key]; ok { continue } seen[key] = struct{}{} result = append(result, path) } return result } func codexLauncherNames() []string { if runtime.GOOS == "windows" { // Windows package managers expose executable shims with one of these // extensions. An extensionless file in an AppX resources directory is // the non-Windows companion shipped beside codex.exe and cannot be // launched by CreateProcess on Windows. return []string{"codex.exe", "codex.cmd", "codex.bat"} } return []string{"codex"} } func (s Service) discoverPnpmGlobalBinDir(ctx context.Context, resolver runtimecmd.Resolver, overrides []string) string { return s.runGlobalBinDirCommand(ctx, resolver, overrides, pnpmCommandNames(), []string{"bin", "-g"}) } func (s Service) discoverNpmGlobalBinDir(ctx context.Context, resolver runtimecmd.Resolver, overrides []string) string { prefix := s.runGlobalBinDirCommand(ctx, resolver, overrides, npmCommandNames(), []string{"prefix", "-g"}) if prefix == "" { return "" } if runtime.GOOS == "windows" { return prefix } return filepath.Join(prefix, "bin") } func (s Service) discoverHomebrewBinDir(ctx context.Context, resolver runtimecmd.Resolver, overrides []string) string { if runtime.GOOS == "windows" { return "" } prefix := s.runGlobalBinDirCommand(ctx, resolver, overrides, []string{"brew"}, []string{"--prefix"}) if prefix == "" { return "" } return filepath.Join(prefix, "bin") } func (s Service) runGlobalBinDirCommand( ctx context.Context, resolver runtimecmd.Resolver, overrides []string, binaryNames []string, args []string, ) string { binaryPath := resolver.ResolveBinary(binaryNames, overrides) if binaryPath == "" { return "" } return s.GlobalBinDiscoveryCache.load(binaryPath, strings.Join(args, "\x00"), func() string { release, acquired := s.DetectionCommands.acquire(ctx) if !acquired { return "" } defer release() commandCtx, cancel := context.WithTimeout(baseContext(ctx), globalBinDiscoveryTimeout) defer cancel() command := exec.CommandContext(commandCtx, binaryPath, args...) command.Env = resolver.Env(overrides) output := &boundedCommandOutput{limit: bunGlobalBinOutputLimit} command.Stdout = output if err := command.Run(); err != nil { return "" } value := strings.TrimSpace(output.String()) if !filepath.IsAbs(value) { return "" } return filepath.Clean(value) }) } func pnpmCommandNames() []string { if runtime.GOOS == "windows" { return []string{"pnpm.cmd", "pnpm"} } return []string{"pnpm"} } func npmCommandNames() []string { if runtime.GOOS == "windows" { return []string{"npm.cmd", "npm"} } return []string{"npm"} } type codexRuntimeCandidateCollector struct { candidates []codexRuntimeCandidate byIdentity map[string]int } func (c *codexRuntimeCandidateCollector) addAll(paths []string, source codexRuntimeCandidateSource) { for _, path := range paths { c.add(path, source) } } func (c *codexRuntimeCandidateCollector) add(path string, source codexRuntimeCandidateSource) { path = strings.TrimSpace(path) if path == "" { return } path = materializeCodexWindowsAppsLauncher(path) realPath := resolvedCodexLauncherPath(path) packageRoot := codexPackageDirForBinary(realPath) identity := codexRuntimeCandidateIdentity(path, realPath, packageRoot) if c.byIdentity == nil { c.byIdentity = map[string]int{} } if index, found := c.byIdentity[identity]; found { candidate := &c.candidates[index] candidate.Sources = appendCodexRuntimeCandidateSource(candidate.Sources, source) return } c.byIdentity[identity] = len(c.candidates) c.candidates = append(c.candidates, codexRuntimeCandidate{ LauncherPath: filepath.Clean(path), RealPath: realPath, PackageRoot: packageRoot, Sources: []codexRuntimeCandidateSource{source}, }) } func resolvedCodexLauncherPath(path string) string { if resolved, err := filepath.EvalSymlinks(path); err == nil { return filepath.Clean(resolved) } return filepath.Clean(path) } func codexRuntimeCandidateIdentity(launcherPath, realPath, packageRoot string) string { identity := firstNonBlank(packageRoot, realPath, launcherPath) if runtime.GOOS == "windows" { return strings.ToLower(filepath.Clean(identity)) } return filepath.Clean(identity) } func appendCodexRuntimeCandidateSource( sources []codexRuntimeCandidateSource, source codexRuntimeCandidateSource, ) []codexRuntimeCandidateSource { for _, existing := range sources { if existing == source { return sources } } return append(sources, source) }