Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
launch: add hermes (#15569)
Parth Sareen43f90def0458
diff --git a/cmd/launch/command_test.go b/cmd/launch/command_test.goindex da168438b..cc8d0df49 100644--- a/cmd/launch/command_test.go+++ b/cmd/launch/command_test.go@@ -58,6 +58,9 @@ func TestLaunchCmd(t *testing.T) {if cmd.Long == "" {t.Error("Long description should not be empty")}+ if !strings.Contains(cmd.Long, "hermes") {+ t.Error("Long description should mention hermes")+ }})t.Run("flags exist", func(t *testing.T) {diff --git a/cmd/launch/hermes.go b/cmd/launch/hermes.gonew file mode 100644index 000000000..02619100e--- /dev/null+++ b/cmd/launch/hermes.go@@ -0,0 +1,962 @@+package launch++import (+ "bufio"+ "bytes"+ "context"+ "errors"+ "fmt"+ "net/http"+ "os"+ "os/exec"+ pathpkg "path"+ "path/filepath"+ "runtime"+ "slices"+ "strconv"+ "strings"+ "time"++ "gopkg.in/yaml.v3"++ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/cmd/config"+ "github.com/ollama/ollama/cmd/internal/fileutil"+ "github.com/ollama/ollama/envconfig"+)++const (+ hermesInstallScript = "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup"+ hermesProviderName = "Ollama"+ hermesProviderKey = "ollama-launch"+ hermesLegacyKey = "ollama"+ hermesPlaceholderKey = "ollama"+ hermesGatewaySetupHint = "hermes gateway setup"+ hermesGatewaySetupTitle = "Connect a messaging app now?"+)++var (+ hermesGOOS = runtime.GOOS+ hermesLookPath = exec.LookPath+ hermesCommand = exec.Command+ hermesUserHome = os.UserHomeDir+ hermesOllamaURL = envconfig.ConnectableHost+)++var hermesMessagingEnvGroups = [][]string{+ {"TELEGRAM_BOT_TOKEN"},+ {"DISCORD_BOT_TOKEN"},+ {"SLACK_BOT_TOKEN"},+ {"SIGNAL_ACCOUNT"},+ {"EMAIL_ADDRESS"},+ {"TWILIO_ACCOUNT_SID"},+ {"MATRIX_ACCESS_TOKEN", "MATRIX_PASSWORD"},+ {"MATTERMOST_TOKEN"},+ {"WHATSAPP_PHONE_NUMBER_ID"},+ {"DINGTALK_CLIENT_ID"},+ {"FEISHU_APP_ID"},+ {"WECOM_BOT_ID"},+ {"WEIXIN_ACCOUNT_ID"},+ {"BLUEBUBBLES_SERVER_URL"},+ {"WEBHOOK_ENABLED"},+}++// Hermes is intentionally not an Editor integration: launch owns one primary+// model and the local Ollama endpoint, while Hermes keeps its own discovery and+// switching UX after startup.+type Hermes struct{}++type hermesConfigBackend struct {+ displayPath string+ read func() ([]byte, error)+ write func([]byte) error+}++func (h *Hermes) String() string { return "Hermes Agent" }++func (h *Hermes) Run(_ string, args []string) error {+ // Hermes reads its primary model from config.yaml. launch configures that+ // default model ahead of time so we can keep runtime invocation simple and+ // still let Hermes discover additional models later via its own UX.+ if hermesGOOS == "windows" {+ return h.runWindows(args)+ }++ bin, err := h.findUnixBinary()+ if err != nil {+ return err+ }+ if err := h.runGatewaySetupPreflight(args, func() error {+ return hermesAttachedCommand(bin, "gateway", "setup").Run()+ }); err != nil {+ return err+ }+ return hermesAttachedCommand(bin, args...).Run()+}++func (h *Hermes) Paths() []string {+ backend, err := h.configBackend()+ if err != nil {+ return nil+ }+ return []string{backend.displayPath}+}++func (h *Hermes) Configure(model string) error {+ backend, err := h.configBackend()+ if err != nil {+ return err+ }++ cfg := map[string]any{}+ if data, err := backend.read(); err == nil {+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ return fmt.Errorf("parse hermes config: %w", err)+ }+ } else if !os.IsNotExist(err) {+ return err+ }++ modelSection, _ := cfg["model"].(map[string]any)+ if modelSection == nil {+ modelSection = make(map[string]any)+ }+ models := h.listModels(model)+ applyHermesManagedProviders(cfg, hermesBaseURL(), model, models)++ // launch writes the minimum provider/default-model settings needed to+ // bootstrap Hermes against Ollama. The active provider stays on a+ // launch-owned key so /model stays aligned with the launcher-managed entry,+ // and the Ollama endpoint lives in providers: so the picker shows one row.+ modelSection["provider"] = hermesProviderKey+ modelSection["default"] = model+ modelSection["base_url"] = hermesBaseURL()+ modelSection["api_key"] = hermesPlaceholderKey+ cfg["model"] = modelSection++ // use Hermes' built-in web toolset for now.+ // TODO(parthsareen): move this to using Ollama web search+ cfg["toolsets"] = mergeHermesToolsets(cfg["toolsets"])++ data, err := yaml.Marshal(cfg)+ if err != nil {+ return err+ }+ return backend.write(data)+}++func (h *Hermes) CurrentModel() string {+ backend, err := h.configBackend()+ if err != nil {+ return ""+ }+ data, err := backend.read()+ if err != nil {+ return ""+ }++ cfg := map[string]any{}+ if yaml.Unmarshal(data, &cfg) != nil {+ return ""+ }+ return hermesManagedCurrentModel(cfg, hermesBaseURL())+}++func (h *Hermes) Onboard() error {+ return config.MarkIntegrationOnboarded("hermes")+}++func (h *Hermes) RequiresInteractiveOnboarding() bool {+ return false+}++func (h *Hermes) RefreshRuntimeAfterConfigure() error {+ running, err := h.gatewayRunning()+ if err != nil {+ return fmt.Errorf("check Hermes gateway status: %w", err)+ }+ if !running {+ return nil+ }++ fmt.Fprintf(os.Stderr, "%sRefreshing Hermes messaging gateway...%s\n", ansiGray, ansiReset)+ if err := h.restartGateway(); err != nil {+ return fmt.Errorf("restart Hermes gateway: %w", err)+ }+ fmt.Fprintln(os.Stderr)+ return nil+}++func (h *Hermes) installed() bool {+ if hermesGOOS == "windows" {+ if _, err := hermesLookPath("hermes"); err == nil {+ return true+ }+ return h.wslHasHermes()+ }++ _, err := h.findUnixBinary()+ return err == nil+}++func (h *Hermes) ensureInstalled() error {+ if h.installed() {+ return nil+ }++ if hermesGOOS == "windows" {+ return h.ensureInstalledWindows()+ }++ var missing []string+ for _, dep := range []string{"bash", "curl", "git"} {+ if _, err := hermesLookPath(dep); err != nil {+ missing = append(missing, dep)+ }+ }+ if len(missing) > 0 {+ return fmt.Errorf("Hermes is not installed and required dependencies are missing\n\nInstall the following first:\n %s\n\nThen re-run:\n ollama launch hermes", strings.Join(missing, "\n "))+ }++ ok, err := ConfirmPrompt("Hermes is not installed. Install now?")+ if err != nil {+ return err+ }+ if !ok {+ return fmt.Errorf("hermes installation cancelled")+ }++ fmt.Fprintf(os.Stderr, "\nInstalling Hermes...\n")+ if err := hermesAttachedCommand("bash", "-lc", hermesInstallScript).Run(); err != nil {+ return fmt.Errorf("failed to install hermes: %w", err)+ }++ if !h.installed() {+ return fmt.Errorf("hermes was installed but the binary was not found on PATH\n\nYou may need to restart your shell")+ }++ fmt.Fprintf(os.Stderr, "%sHermes installed successfully%s\n\n", ansiGreen, ansiReset)+ return nil+}++func (h *Hermes) ensureInstalledWindows() error {+ // Hermes upstream support is WSL-oriented, so Windows launch uses a hybrid+ // WSL handoff that stays on the same install path as upstream Hermes.+ if _, err := hermesLookPath("hermes"); err == nil {+ return nil+ }+ if !h.wslAvailable() {+ return hermesWindowsHint(fmt.Errorf("hermes is not installed"))+ }+ if h.wslHasHermes() {+ return nil+ }++ ok, err := ConfirmPromptWithOptions("Hermes runs through WSL2 on Windows. Install it in WSL now?", ConfirmOptions{+ YesLabel: "Use WSL",+ NoLabel: "Show manual steps",+ })+ if err != nil {+ return err+ }+ if !ok {+ return hermesWindowsHint(fmt.Errorf("hermes is not installed"))+ }++ fmt.Fprintf(os.Stderr, "\nInstalling Hermes in WSL...\n")+ if err := h.runWSL("bash", "-lc", hermesInstallScript); err != nil {+ return hermesWindowsHint(fmt.Errorf("failed to install hermes in WSL: %w", err))+ }+ if !h.wslHasHermes() {+ return hermesWindowsHint(fmt.Errorf("hermes install finished but the WSL binary was not found"))+ }++ fmt.Fprintf(os.Stderr, "%sHermes installed successfully in WSL%s\n\n", ansiGreen, ansiReset)+ return nil+}++func (h *Hermes) listModels(defaultModel string) []string {+ client := hermesOllamaClient()+ resp, err := client.List(context.Background())+ if err != nil {+ return []string{defaultModel}+ }++ models := make([]string, 0, len(resp.Models)+1)+ seen := make(map[string]struct{}, len(resp.Models)+1)+ add := func(name string) {+ name = strings.TrimSpace(name)+ if name == "" {+ return+ }+ if _, ok := seen[name]; ok {+ return+ }+ seen[name] = struct{}{}+ models = append(models, name)+ }++ add(defaultModel)+ for _, entry := range resp.Models {+ add(entry.Name)+ }+ if len(models) == 0 {+ return []string{defaultModel}+ }+ return models+}++func (h *Hermes) findUnixBinary() (string, error) {+ if path, err := hermesLookPath("hermes"); err == nil {+ return path, nil+ }++ home, err := hermesUserHome()+ if err != nil {+ return "", err+ }+ fallback := filepath.Join(home, ".local", "bin", "hermes")+ if _, err := os.Stat(fallback); err == nil {+ return fallback, nil+ }++ return "", fmt.Errorf("hermes is not installed")+}++func (h *Hermes) runWindows(args []string) error {+ if path, err := hermesLookPath("hermes"); err == nil {+ if err := h.runGatewaySetupPreflight(args, func() error {+ return hermesAttachedCommand(path, "gateway", "setup").Run()+ }); err != nil {+ return err+ }+ return hermesAttachedCommand(path, args...).Run()+ }+ if !h.wslAvailable() {+ return hermesWindowsHint(fmt.Errorf("hermes is not installed"))+ }+ if err := h.runGatewaySetupPreflight(args, func() error {+ return h.runWSL("hermes", "gateway", "setup")+ }); err != nil {+ return err+ }+ if err := h.runWSL(append([]string{"hermes"}, args...)...); err != nil {+ return hermesWindowsHint(err)+ }+ return nil+}++func (h *Hermes) runWSL(args ...string) error {+ if !h.wslAvailable() {+ return fmt.Errorf("wsl.exe is not available")+ }++ return hermesAttachedCommand("wsl.exe", "bash", "-lc", shellQuoteArgs(args)).Run()+}++func (h *Hermes) runWSLCombinedOutput(args ...string) ([]byte, error) {+ if !h.wslAvailable() {+ return nil, fmt.Errorf("wsl.exe is not available")+ }++ return hermesCommand("wsl.exe", "bash", "-lc", shellQuoteArgs(args)).CombinedOutput()+}++func (h *Hermes) wslAvailable() bool {+ _, err := hermesLookPath("wsl.exe")+ return err == nil+}++func (h *Hermes) wslHasHermes() bool {+ if !h.wslAvailable() {+ return false+ }+ cmd := hermesCommand("wsl.exe", "bash", "-lc", "command -v hermes >/dev/null 2>&1")+ return cmd.Run() == nil+}++func (h *Hermes) configBackend() (*hermesConfigBackend, error) {+ if hermesGOOS == "windows" {+ if _, err := hermesLookPath("hermes"); err == nil {+ return hermesLocalConfigBackend()+ }+ if h.wslAvailable() {+ return h.wslConfigBackend()+ }+ }+ return hermesLocalConfigBackend()+}++func hermesConfigPath() (string, error) {+ home, err := hermesUserHome()+ if err != nil {+ return "", err+ }+ return filepath.Join(home, ".hermes", "config.yaml"), nil+}++func hermesLocalConfigBackend() (*hermesConfigBackend, error) {+ configPath, err := hermesConfigPath()+ if err != nil {+ return nil, err+ }+ return &hermesConfigBackend{+ displayPath: configPath,+ read: func() ([]byte, error) {+ return os.ReadFile(configPath)+ },+ write: func(data []byte) error {+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ return err+ }+ return fileutil.WriteWithBackup(configPath, data)+ },+ }, nil+}++func (h *Hermes) wslConfigBackend() (*hermesConfigBackend, error) {+ home, err := h.wslHome()+ if err != nil {+ return nil, err+ }+ configPath := pathpkg.Join(home, ".hermes", "config.yaml")+ return &hermesConfigBackend{+ displayPath: configPath,+ read: func() ([]byte, error) {+ return h.readWSLFile(configPath)+ },+ write: func(data []byte) error {+ return h.writeWSLConfig(configPath, data)+ },+ }, nil+}++func (h *Hermes) wslHome() (string, error) {+ if !h.wslAvailable() {+ return "", fmt.Errorf("wsl.exe is not available")+ }+ cmd := hermesCommand("wsl.exe", "bash", "-lc", `printf %s "$HOME"`)+ out, err := cmd.Output()+ if err != nil {+ return "", err+ }+ home := strings.TrimSpace(string(out))+ if home == "" {+ return "", fmt.Errorf("could not resolve WSL home directory")+ }+ return home, nil+}++func (h *Hermes) readWSLFile(path string) ([]byte, error) {+ pathArg := shellQuoteArgs([]string{path})+ cmd := hermesCommand("wsl.exe", "bash", "-lc", fmt.Sprintf("if [ -f %s ]; then cat %s; else exit 42; fi", pathArg, pathArg))+ out, err := cmd.Output()+ if err == nil {+ return out, nil+ }+ var exitErr *exec.ExitError+ if errors.As(err, &exitErr) && exitErr.ExitCode() == 42 {+ return nil, os.ErrNotExist+ }+ return nil, err+}++func (h *Hermes) writeWSLConfig(path string, data []byte) error {+ if existing, err := h.readWSLFile(path); err == nil {+ if !bytes.Equal(existing, data) {+ if err := hermesBackupData(path, existing); err != nil {+ return fmt.Errorf("backup failed: %w", err)+ }+ }+ } else if !os.IsNotExist(err) {+ return fmt.Errorf("read existing file: %w", err)+ }++ dir := pathpkg.Dir(path)+ dirArg := shellQuoteArgs([]string{dir})+ pathArg := shellQuoteArgs([]string{path})+ script := fmt.Sprintf(+ "dir=%s; path=%s; mkdir -p \"$dir\" && tmp=$(mktemp \"$dir/.tmp-XXXXXX\") && cat > \"$tmp\" && mv \"$tmp\" \"$path\"",+ dirArg,+ pathArg,+ )+ cmd := hermesCommand("wsl.exe", "bash", "-lc", script)+ cmd.Stdin = bytes.NewReader(data)+ if out, err := cmd.CombinedOutput(); err != nil {+ if msg := strings.TrimSpace(string(out)); msg != "" {+ return fmt.Errorf("%w: %s", err, msg)+ }+ return err+ }+ return nil+}++func hermesBackupData(path string, data []byte) error {+ if err := os.MkdirAll(fileutil.BackupDir(), 0o755); err != nil {+ return err+ }+ backupPath := filepath.Join(fileutil.BackupDir(), fmt.Sprintf("%s.%d", filepath.Base(path), time.Now().Unix()))+ return os.WriteFile(backupPath, data, 0o644)+}++func hermesBaseURL() string {+ return strings.TrimRight(hermesOllamaURL().String(), "/") + "/v1"+}++func hermesEnvPath() (string, error) {+ home, err := hermesUserHome()+ if err != nil {+ return "", err+ }+ return filepath.Join(home, ".hermes", ".env"), nil+}++func (h *Hermes) runGatewaySetupPreflight(args []string, runSetup func() error) error {+ if len(args) > 0 || !isInteractiveSession() || currentLaunchConfirmPolicy.yes || currentLaunchConfirmPolicy.requireYesMessage {+ return nil+ }+ if h.messagingConfigured() {+ return nil+ }++ fmt.Fprintf(os.Stderr, "\nHermes can message you on Telegram, Discord, Slack, and more.\n\n")+ ok, err := ConfirmPromptWithOptions(hermesGatewaySetupTitle, ConfirmOptions{+ YesLabel: "Yes",+ NoLabel: "Set up later",+ })+ if err != nil {+ return err+ }+ if !ok {+ return nil+ }+ if err := runSetup(); err != nil {+ return fmt.Errorf("hermes messaging setup failed: %w\n\nTry running: %s", err, hermesGatewaySetupHint)+ }+ return nil+}++func (h *Hermes) messagingConfigured() bool {+ envVars, err := h.gatewayEnvVars()+ if err != nil {+ return false+ }+ for _, group := range hermesMessagingEnvGroups {+ for _, key := range group {+ if strings.TrimSpace(envVars[key]) != "" {+ return true+ }+ }+ }+ return false+}++func (h *Hermes) gatewayEnvVars() (map[string]string, error) {+ envVars := make(map[string]string)++ data, err := h.readGatewayEnvFile()+ switch {+ case err == nil:+ for key, value := range hermesParseEnvFile(data) {+ envVars[key] = value+ }+ case os.IsNotExist(err):+ // nothing persisted yet+ default:+ return nil, err+ }++ if h.usesLocalRuntimeEnv() {+ for _, group := range hermesMessagingEnvGroups {+ for _, key := range group {+ if value, ok := os.LookupEnv(key); ok {+ envVars[key] = value+ }+ }+ }+ }++ return envVars, nil+}++func (h *Hermes) readGatewayEnvFile() ([]byte, error) {+ if hermesGOOS == "windows" {+ if _, err := hermesLookPath("hermes"); err == nil {+ path, err := hermesEnvPath()+ if err != nil {+ return nil, err+ }+ return os.ReadFile(path)+ }+ if h.wslAvailable() {+ home, err := h.wslHome()+ if err != nil {+ return nil, err+ }+ return h.readWSLFile(pathpkg.Join(home, ".hermes", ".env"))+ }+ }++ path, err := hermesEnvPath()+ if err != nil {+ return nil, err+ }+ return os.ReadFile(path)+}++func (h *Hermes) usesLocalRuntimeEnv() bool {+ if hermesGOOS != "windows" {+ return true+ }+ _, err := hermesLookPath("hermes")+ return err == nil+}++func (h *Hermes) gatewayRunning() (bool, error) {+ status, err := h.gatewayStatusOutput()+ if err != nil {+ return false, err+ }+ return hermesGatewayStatusRunning(status), nil+}++func (h *Hermes) gatewayStatusOutput() (string, error) {+ if hermesGOOS == "windows" {+ if path, err := hermesLookPath("hermes"); err == nil {+ out, err := hermesCommand(path, "gateway", "status").CombinedOutput()+ return string(out), err+ }+ if !h.wslAvailable() {+ return "", hermesWindowsHint(fmt.Errorf("hermes is not installed"))+ }+ out, err := h.runWSLCombinedOutput("hermes", "gateway", "status")+ return string(out), err+ }++ bin, err := h.findUnixBinary()+ if err != nil {+ return "", err+ }+ out, err := hermesCommand(bin, "gateway", "status").CombinedOutput()+ return string(out), err+}++func (h *Hermes) restartGateway() error {+ if hermesGOOS == "windows" {+ if path, err := hermesLookPath("hermes"); err == nil {+ return hermesAttachedCommand(path, "gateway", "restart").Run()+ }+ if !h.wslAvailable() {+ return hermesWindowsHint(fmt.Errorf("hermes is not installed"))+ }+ if err := h.runWSL("hermes", "gateway", "restart"); err != nil {+ return hermesWindowsHint(err)+ }+ return nil+ }++ bin, err := h.findUnixBinary()+ if err != nil {+ return err+ }+ return hermesAttachedCommand(bin, "gateway", "restart").Run()+}++func hermesGatewayStatusRunning(output string) bool {+ status := strings.ToLower(output)+ switch {+ case strings.Contains(status, "gateway is not running"):+ return false+ case strings.Contains(status, "gateway service is stopped"):+ return false+ case strings.Contains(status, "gateway service is not loaded"):+ return false+ case strings.Contains(status, "gateway is running"):+ return true+ case strings.Contains(status, "gateway service is running"):+ return true+ case strings.Contains(status, "gateway service is loaded"):+ return true+ default:+ return false+ }+}++func hermesParseEnvFile(data []byte) map[string]string {+ out := make(map[string]string)+ scanner := bufio.NewScanner(bytes.NewReader(data))+ for scanner.Scan() {+ line := strings.TrimSpace(strings.TrimPrefix(scanner.Text(), "\ufeff"))+ if line == "" || strings.HasPrefix(line, "#") {+ continue+ }+ if strings.HasPrefix(line, "export ") {+ line = strings.TrimSpace(strings.TrimPrefix(line, "export "))+ }++ key, value, ok := strings.Cut(line, "=")+ if !ok {+ continue+ }++ key = strings.TrimSpace(key)+ if key == "" {+ continue+ }++ value = strings.TrimSpace(value)+ if len(value) >= 2 {+ switch {+ case value[0] == '"' && value[len(value)-1] == '"':+ if unquoted, err := strconv.Unquote(value); err == nil {+ value = unquoted+ }+ case value[0] == '\'' && value[len(value)-1] == '\'':+ value = value[1 : len(value)-1]+ }+ }++ out[key] = value+ }+ return out+}++func hermesOllamaClient() *api.Client {+ // Hermes queries the same launch-resolved Ollama host that launch writes+ // into config, so model discovery follows the configured endpoint.+ return api.NewClient(hermesOllamaURL(), http.DefaultClient)+}++func applyHermesManagedProviders(cfg map[string]any, baseURL string, model string, models []string) {+ providers := hermesUserProviders(cfg["providers"])+ entry := hermesManagedProviderEntry(providers)+ if entry == nil {+ entry = make(map[string]any)+ }+ entry["name"] = hermesProviderName+ entry["api"] = baseURL+ entry["default_model"] = model+ entry["models"] = hermesStringListAny(models)+ providers[hermesProviderKey] = entry+ delete(providers, hermesLegacyKey)+ cfg["providers"] = providers++ customProviders := hermesWithoutManagedCustomProviders(cfg["custom_providers"])+ if len(customProviders) == 0 {+ delete(cfg, "custom_providers")+ return+ }+ cfg["custom_providers"] = customProviders+}++func hermesManagedCurrentModel(cfg map[string]any, baseURL string) string {+ modelCfg, _ := cfg["model"].(map[string]any)+ if modelCfg == nil {+ return ""+ }++ provider, _ := modelCfg["provider"].(string)+ if strings.TrimSpace(strings.ToLower(provider)) != hermesProviderKey {+ return ""+ }++ configBaseURL, _ := modelCfg["base_url"].(string)+ if hermesNormalizeURL(configBaseURL) != hermesNormalizeURL(baseURL) {+ return ""+ }++ current, _ := modelCfg["default"].(string)+ current = strings.TrimSpace(current)+ if current == "" {+ return ""+ }++ providers := hermesUserProviders(cfg["providers"])+ entry, _ := providers[hermesProviderKey].(map[string]any)+ if entry == nil {+ return ""+ }+ if hermesHasManagedCustomProvider(cfg["custom_providers"]) {+ return ""+ }++ apiURL, _ := entry["api"].(string)+ if hermesNormalizeURL(apiURL) != hermesNormalizeURL(baseURL) {+ return ""+ }++ defaultModel, _ := entry["default_model"].(string)+ if strings.TrimSpace(defaultModel) != current {+ return ""+ }++ return current+}++func hermesUserProviders(current any) map[string]any {+ switch existing := current.(type) {+ case map[string]any:+ out := make(map[string]any, len(existing))+ for key, value := range existing {+ out[key] = value+ }+ return out+ case map[any]any:+ out := make(map[string]any, len(existing))+ for key, value := range existing {+ if s, ok := key.(string); ok {+ out[s] = value+ }+ }+ return out+ default:+ return make(map[string]any)+ }+}++func hermesCustomProviders(current any) []any {+ switch existing := current.(type) {+ case []any:+ return append([]any(nil), existing...)+ case []map[string]any:+ out := make([]any, 0, len(existing))+ for _, entry := range existing {+ out = append(out, entry)+ }+ return out+ default:+ return nil+ }+}++func hermesManagedProviderEntry(providers map[string]any) map[string]any {+ for _, key := range []string{hermesProviderKey, hermesLegacyKey} {+ if entry, _ := providers[key].(map[string]any); entry != nil {+ return entry+ }+ }+ return nil+}++func hermesWithoutManagedCustomProviders(current any) []any {+ customProviders := hermesCustomProviders(current)+ preserved := make([]any, 0, len(customProviders))++ for _, item := range customProviders {+ entry, _ := item.(map[string]any)+ if entry == nil {+ preserved = append(preserved, item)+ continue+ }+ if hermesManagedCustomProvider(entry) {+ continue+ }+ preserved = append(preserved, entry)+ }++ return preserved+}++func hermesHasManagedCustomProvider(current any) bool {+ for _, item := range hermesCustomProviders(current) {+ entry, _ := item.(map[string]any)+ if entry != nil && hermesManagedCustomProvider(entry) {+ return true+ }+ }+ return false+}++func hermesManagedCustomProvider(entry map[string]any) bool {+ name, _ := entry["name"].(string)+ return strings.EqualFold(strings.TrimSpace(name), hermesProviderName)+}++func hermesNormalizeURL(raw string) string {+ return strings.TrimRight(strings.TrimSpace(raw), "/")+}++func hermesStringListAny(models []string) []any {+ out := make([]any, 0, len(models))+ for _, model := range dedupeModelList(models) {+ model = strings.TrimSpace(model)+ if model == "" {+ continue+ }+ out = append(out, model)+ }+ return out+}++func mergeHermesToolsets(current any) any {+ added := false+ switch existing := current.(type) {+ case []any:+ out := make([]any, 0, len(existing)+1)+ for _, item := range existing {+ out = append(out, item)+ if s, _ := item.(string); s == "web" {+ added = true+ }+ }+ if !added {+ out = append(out, "web")+ }+ return out+ case []string:+ out := append([]string(nil), existing...)+ if !slices.Contains(out, "web") {+ out = append(out, "web")+ }+ asAny := make([]any, 0, len(out))+ for _, item := range out {+ asAny = append(asAny, item)+ }+ return asAny+ case string:+ if strings.TrimSpace(existing) == "" {+ return []any{"hermes-cli", "web"}+ }+ parts := strings.Split(existing, ",")+ out := make([]any, 0, len(parts)+1)+ for _, part := range parts {+ part = strings.TrimSpace(part)+ if part == "" {+ continue+ }+ if part == "web" {+ added = true+ }+ out = append(out, part)+ }+ if !added {+ out = append(out, "web")+ }+ return out+ default:+ return []any{"hermes-cli", "web"}+ }+}++func shellQuoteArgs(args []string) string {+ quoted := make([]string, 0, len(args))+ for _, arg := range args {+ quoted = append(quoted, "'"+strings.ReplaceAll(arg, "'", `'\''`)+"'")+ }+ return strings.Join(quoted, " ")+}++func hermesAttachedCommand(name string, args ...string) *exec.Cmd {+ cmd := hermesCommand(name, args...)+ cmd.Stdin = os.Stdin+ cmd.Stdout = os.Stdout+ cmd.Stderr = os.Stderr+ return cmd+}++func hermesWindowsHint(err error) error {+ if hermesGOOS != "windows" {+ return err+ }+ return fmt.Errorf("%w\n\nHermes runs on Windows through WSL2.\nQuick setup: wsl --install\nInstaller docs: https://hermes-agent.nousresearch.com/docs/getting-started/installation/", err)+}diff --git a/cmd/launch/hermes_test.go b/cmd/launch/hermes_test.gonew file mode 100644index 000000000..a4b2a397d--- /dev/null+++ b/cmd/launch/hermes_test.go@@ -0,0 +1,1236 @@+package launch++import (+ "fmt"+ "net/http"+ "net/http/httptest"+ "net/url"+ "os"+ "path/filepath"+ "runtime"+ "strings"+ "testing"++ "gopkg.in/yaml.v3"++ "github.com/ollama/ollama/cmd/config"+)++func withHermesPlatform(t *testing.T, goos string) {+ t.Helper()+ old := hermesGOOS+ hermesGOOS = goos+ t.Cleanup(func() {+ hermesGOOS = old+ })+}++func withHermesOllamaURL(t *testing.T, rawURL string) {+ t.Helper()+ old := hermesOllamaURL+ hermesOllamaURL = func() *url.URL {+ u, err := url.Parse(rawURL)+ if err != nil {+ t.Fatalf("parse test Ollama URL: %v", err)+ }+ return u+ }+ t.Cleanup(func() {+ hermesOllamaURL = old+ })+}++func withHermesUserHome(t *testing.T, dir string) {+ t.Helper()+ old := hermesUserHome+ hermesUserHome = func() (string, error) { return dir, nil }+ t.Cleanup(func() {+ hermesUserHome = old+ })+}++func withHermesLookPath(t *testing.T, fn func(string) (string, error)) {+ t.Helper()+ old := hermesLookPath+ hermesLookPath = fn+ t.Cleanup(func() {+ hermesLookPath = old+ })+}++func clearHermesMessagingEnvVars(t *testing.T) {+ t.Helper()+ for _, group := range hermesMessagingEnvGroups {+ for _, key := range group {+ if value, ok := os.LookupEnv(key); ok {+ t.Setenv(key, value)+ } else {+ t.Setenv(key, "")+ }+ if err := os.Unsetenv(key); err != nil {+ t.Fatalf("unset %s: %v", key, err)+ }+ }+ }+}++func TestHermesIntegration(t *testing.T) {+ h := &Hermes{}++ t.Run("implements Runner", func(t *testing.T) {+ var _ Runner = h+ })++ t.Run("implements managed single model", func(t *testing.T) {+ var _ ManagedSingleModel = h+ })++ t.Run("implements managed runtime refresher", func(t *testing.T) {+ var _ ManagedRuntimeRefresher = h+ })+}++func TestHermesConfigurePreservesExistingConfigAndEnablesWeb(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")++ configPath := filepath.Join(tmpDir, ".hermes", "config.yaml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ "memory:\n" ++ " provider: local\n" ++ "toolsets:\n" ++ " - terminal\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ 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}}`)+ case "/api/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"},{"name":"qwen3.5"},{"name":"llama3.3"}]}`)+ default:+ http.NotFound(w, r)+ }+ }))+ defer srv.Close()+ t.Setenv("OLLAMA_HOST", srv.URL)++ h := &Hermes{}+ if err := h.Configure("gemma4"); err != nil {+ t.Fatalf("Configure returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }++ var cfg map[string]any+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ t.Fatalf("failed to parse rewritten yaml: %v", err)+ }++ modelCfg, _ := cfg["model"].(map[string]any)+ if got, _ := modelCfg["provider"].(string); got != "ollama-launch" {+ t.Fatalf("expected provider ollama-launch, got %q", got)+ }+ if got, _ := modelCfg["default"].(string); got != "gemma4" {+ t.Fatalf("expected default model gemma4, got %q", got)+ }+ if got, _ := modelCfg["base_url"].(string); got != srv.URL+"/v1" {+ t.Fatalf("expected Ollama base_url %q, got %q", srv.URL+"/v1", got)+ }+ if got, _ := modelCfg["api_key"].(string); got != "ollama" {+ t.Fatalf("expected placeholder api_key ollama, got %q", got)+ }+ if memoryCfg, _ := cfg["memory"].(map[string]any); memoryCfg == nil {+ t.Fatal("expected unrelated config to be preserved")+ }+ if _, ok := cfg["custom_providers"]; ok {+ t.Fatal("expected launcher-managed config to avoid custom_providers duplicates")+ }+ providersCfg, _ := cfg["providers"].(map[string]any)+ ollamaProvider, _ := providersCfg["ollama-launch"].(map[string]any)+ if ollamaProvider == nil {+ t.Fatal("expected ollama-launch provider entry")+ }+ if got, _ := ollamaProvider["name"].(string); got != "Ollama" {+ t.Fatalf("expected providers entry name Ollama, got %q", got)+ }+ if got, _ := ollamaProvider["api"].(string); got != srv.URL+"/v1" {+ t.Fatalf("expected providers entry api %q, got %q", srv.URL+"/v1", got)+ }+ if got, _ := ollamaProvider["default_model"].(string); got != "gemma4" {+ t.Fatalf("expected providers entry default_model gemma4, got %q", got)+ }+ models, _ := ollamaProvider["models"].([]any)+ if len(models) != 3 {+ t.Fatalf("expected providers entry to expose 3 models, got %v", models)+ }++ toolsets, _ := cfg["toolsets"].([]any)+ var gotToolsets []string+ for _, item := range toolsets {+ if s, _ := item.(string); s != "" {+ gotToolsets = append(gotToolsets, s)+ }+ }+ if !strings.Contains(strings.Join(gotToolsets, ","), "terminal") || !strings.Contains(strings.Join(gotToolsets, ","), "web") {+ t.Fatalf("expected toolsets to preserve terminal and add web, got %v", gotToolsets)+ }+}++func TestHermesConfigureUpdatesMatchingCustomProviderWithoutDroppingFields(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")++ configPath := filepath.Join(tmpDir, ".hermes", "config.yaml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ "providers:\n" ++ " ollama:\n" ++ " name: Ollama\n" ++ " api: http://127.0.0.1:11434/v1\n" ++ " default_model: old-model\n" ++ " models:\n" ++ " - old-model\n" ++ " - older-model\n" ++ " extra_field: keep-me\n" ++ "custom_providers:\n" ++ " - name: Ollama\n" ++ " base_url: http://127.0.0.1:11434/v1\n" ++ " model: old-model\n" ++ " api_mode: chat_completions\n" ++ " models:\n" ++ " old-model:\n" ++ " context_length: 65536\n" ++ " - name: Other Endpoint\n" ++ " base_url: https://example.invalid/v1\n" ++ " model: untouched\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ 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}}`)+ case "/api/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"},{"name":"qwen3.5"},{"name":"llama3.3"}]}`)+ default:+ http.NotFound(w, r)+ }+ }))+ defer srv.Close()+ t.Setenv("OLLAMA_HOST", srv.URL)++ h := &Hermes{}+ if err := h.Configure("gemma4"); err != nil {+ t.Fatalf("Configure returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }++ var cfg map[string]any+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ t.Fatalf("failed to parse rewritten yaml: %v", err)+ }++ modelCfg, _ := cfg["model"].(map[string]any)+ if got, _ := modelCfg["provider"].(string); got != "ollama-launch" {+ t.Fatalf("expected managed providers entry to migrate to ollama-launch, got %q", got)+ }++ customProviders, _ := cfg["custom_providers"].([]any)+ if len(customProviders) != 1 {+ t.Fatalf("expected only unrelated custom providers to remain, got %d", len(customProviders))+ }++ providersCfg, _ := cfg["providers"].(map[string]any)+ if _, ok := providersCfg["ollama"]; ok {+ t.Fatal("expected legacy providers.ollama entry to be removed")+ }+ ollamaProvider, _ := providersCfg["ollama-launch"].(map[string]any)+ if ollamaProvider == nil {+ t.Fatal("expected ollama-launch providers entry to remain")+ }+ if got, _ := ollamaProvider["api"].(string); got != srv.URL+"/v1" {+ t.Fatalf("expected providers entry api to update to %q, got %q", srv.URL+"/v1", got)+ }+ if got, _ := ollamaProvider["default_model"].(string); got != "gemma4" {+ t.Fatalf("expected providers entry default_model gemma4, got %q", got)+ }+ if got, _ := ollamaProvider["extra_field"].(string); got != "keep-me" {+ t.Fatalf("expected providers entry extra_field to be preserved, got %q", got)+ }+ providerModels, _ := ollamaProvider["models"].([]any)+ if len(providerModels) != 3 {+ t.Fatalf("expected providers entry to refresh full model catalog, got %v", providerModels)+ }++ remaining, _ := customProviders[0].(map[string]any)+ if got, _ := remaining["name"].(string); got != "Other Endpoint" {+ t.Fatalf("expected unrelated custom provider to be preserved, got %q", got)+ }+}++func TestHermesConfigureUsesLaunchResolvedHostForModelDiscovery(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")++ configPath := filepath.Join(tmpDir, ".hermes", "config.yaml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }++ 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}}`)+ case "/api/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"},{"name":"qwen3.5"},{"name":"llama3.3"}]}`)+ default:+ http.NotFound(w, r)+ }+ }))+ defer srv.Close()++ withHermesOllamaURL(t, srv.URL)+ t.Setenv("OLLAMA_HOST", "http://127.0.0.1:1")++ h := &Hermes{}+ if err := h.Configure("gemma4"); err != nil {+ t.Fatalf("Configure returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }++ var cfg map[string]any+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ t.Fatalf("failed to parse rewritten yaml: %v", err)+ }++ providersCfg, _ := cfg["providers"].(map[string]any)+ ollamaProvider, _ := providersCfg["ollama-launch"].(map[string]any)+ if ollamaProvider == nil {+ t.Fatal("expected ollama-launch provider entry")+ }+ models, _ := ollamaProvider["models"].([]any)+ if len(models) != 3 {+ t.Fatalf("expected providers entry to expose 3 launch-resolved models, got %v", models)+ }+}++func TestHermesConfigureMigratesLegacyManagedAliases(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")++ configPath := filepath.Join(tmpDir, ".hermes", "config.yaml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }+ existing := "" ++ "model:\n" ++ " provider: custom:ollama\n" ++ " default: old-model\n" ++ "providers:\n" ++ " ollama:\n" ++ " name: Ollama\n" ++ " api: http://127.0.0.1:11434/v1\n" ++ " default_model: old-model\n" ++ "custom_providers:\n" ++ " - name: Ollama\n" ++ " base_url: http://127.0.0.1:11434/v1\n" ++ " model: old-model\n"+ if err := os.WriteFile(configPath, []byte(existing), 0o644); err != nil {+ t.Fatal(err)+ }++ 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.5"}]}`)+ default:+ http.NotFound(w, r)+ }+ }))+ defer srv.Close()+ t.Setenv("OLLAMA_HOST", srv.URL)++ h := &Hermes{}+ if err := h.Configure("gemma4"); err != nil {+ t.Fatalf("Configure returned error: %v", err)+ }++ data, err := os.ReadFile(configPath)+ if err != nil {+ t.Fatal(err)+ }++ var cfg map[string]any+ if err := yaml.Unmarshal(data, &cfg); err != nil {+ t.Fatalf("failed to parse rewritten yaml: %v", err)+ }++ modelCfg, _ := cfg["model"].(map[string]any)+ if got, _ := modelCfg["provider"].(string); got != "ollama-launch" {+ t.Fatalf("expected migrated provider ollama-launch, got %q", got)+ }++ providersCfg, _ := cfg["providers"].(map[string]any)+ if _, ok := providersCfg["ollama"]; ok {+ t.Fatal("expected legacy providers.ollama entry to be removed")+ }+ if _, ok := providersCfg["ollama-launch"]; !ok {+ t.Fatal("expected providers.ollama-launch entry")+ }+ if _, ok := cfg["custom_providers"]; ok {+ t.Fatal("expected managed custom_providers entry to be removed during migration")+ }+}++func TestHermesPathsUsesLocalConfigPathForNativeWindowsHermes(t *testing.T) {+ tmpDir := t.TempDir()+ winHome := filepath.Join(tmpDir, "winhome")+ setTestHome(t, winHome)+ withHermesPlatform(t, "windows")+ withHermesUserHome(t, winHome)+ t.Setenv("PATH", tmpDir)+ writeFakeBinary(t, tmpDir, "hermes")++ got := (&Hermes{}).Paths()+ want := filepath.Join(winHome, ".hermes", "config.yaml")+ if len(got) != 1 || got[0] != want {+ t.Fatalf("expected local config path %q, got %v", want, got)+ }+}++func TestHermesCurrentModelRequiresHealthyManagedConfig(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")+ withHermesOllamaURL(t, "http://127.0.0.1:11434")++ configPath := filepath.Join(tmpDir, ".hermes", "config.yaml")+ if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {+ t.Fatal(err)+ }++ tests := []struct {+ name string+ cfg string+ }{+ {+ name: "wrong provider",+ cfg: "" ++ "model:\n" ++ " provider: openrouter\n" ++ " default: gemma4\n" ++ " base_url: http://127.0.0.1:11434/v1\n",+ },+ {+ name: "wrong base url",+ cfg: "" ++ "model:\n" ++ " provider: ollama-launch\n" ++ " default: gemma4\n" ++ " base_url: http://127.0.0.1:9999/v1\n" ++ "providers:\n" ++ " ollama-launch:\n" ++ " api: http://127.0.0.1:9999/v1\n" ++ " default_model: gemma4\n",+ },+ {+ name: "missing managed provider entry",+ cfg: "" ++ "model:\n" ++ " provider: ollama-launch\n" ++ " default: gemma4\n" ++ " base_url: http://127.0.0.1:11434/v1\n",+ },+ {+ name: "inconsistent managed provider entry",+ cfg: "" ++ "model:\n" ++ " provider: ollama-launch\n" ++ " default: gemma4\n" ++ " base_url: http://127.0.0.1:11434/v1\n" ++ "providers:\n" ++ " ollama-launch:\n" ++ " api: http://127.0.0.1:11434/v1\n" ++ " default_model: qwen3.5\n",+ },+ {+ name: "legacy launch managed config",+ cfg: "" ++ "model:\n" ++ " provider: custom:ollama\n" ++ " default: gemma4\n" ++ " base_url: http://127.0.0.1:11434/v1\n" ++ "providers:\n" ++ " ollama:\n" ++ " api: http://127.0.0.1:11434/v1\n" ++ " default_model: gemma4\n",+ },+ {+ name: "duplicate managed custom provider",+ cfg: "" ++ "model:\n" ++ " provider: ollama-launch\n" ++ " default: gemma4\n" ++ " base_url: http://127.0.0.1:11434/v1\n" ++ "providers:\n" ++ " ollama-launch:\n" ++ " api: http://127.0.0.1:11434/v1\n" ++ " default_model: gemma4\n" ++ "custom_providers:\n" ++ " - name: Ollama\n" ++ " base_url: http://127.0.0.1:11434/v1\n" ++ " model: gemma4\n",+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ if err := os.WriteFile(configPath, []byte(tt.cfg), 0o644); err != nil {+ t.Fatal(err)+ }+ if got := (&Hermes{}).CurrentModel(); got != "" {+ t.Fatalf("expected stale config to return empty current model, got %q", got)+ }+ })+ }+}++func TestHermesCurrentModelReturnsEmptyWhenConfigMissing(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")++ if got := (&Hermes{}).CurrentModel(); got != "" {+ t.Fatalf("expected missing config to return empty current model, got %q", got)+ }+}++func TestHermesRunPassthroughArgs(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, runtime.GOOS)+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ if err := os.WriteFile(bin, []byte("#!/bin/sh\nprintf '[%s]\\n' \"$*\" >> \"$HOME/hermes-invocations.log\"\n"), 0o755); err != nil {+ t.Fatal(err)+ }++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ t.Fatalf("did not expect messaging prompt during passthrough launch: %s", prompt)+ return false, nil+ }++ h := &Hermes{}+ if err := h.Run("", []string{"--continue"}); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ if got := strings.TrimSpace(string(data)); got != "[--continue]" {+ t.Fatalf("expected passthrough args to reach hermes, got %q", got)+ }+}++func TestHermesRun_PromptsForMessagingSetupBeforeDefaultLaunch(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, runtime.GOOS)+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ script := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"+if [ "$1" = "gateway" ] && [ "$2" = "setup" ]; then+ /bin/mkdir -p "$HOME/.hermes"+ printf 'TELEGRAM_BOT_TOKEN=configured\n' > "$HOME/.hermes/.env"+fi+`+ if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {+ t.Fatal(err)+ }++ promptCount := 0+ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ promptCount+++ if prompt != hermesGatewaySetupTitle {+ t.Fatalf("unexpected prompt %q", prompt)+ }+ if options.YesLabel != "Yes" || options.NoLabel != "Set up later" {+ t.Fatalf("unexpected prompt labels: %+v", options)+ }+ return true, nil+ }++ h := &Hermes{}+ if err := h.Run("", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }++ if promptCount != 1 {+ t.Fatalf("expected one messaging prompt, got %d", promptCount)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ lines := strings.Split(strings.TrimSpace(string(data)), "\n")+ if len(lines) != 2 {+ t.Fatalf("expected setup then launch invocations, got %v", lines)+ }+ if lines[0] != "[gateway setup]" {+ t.Fatalf("expected gateway setup first, got %q", lines[0])+ }+ if lines[1] != "[]" {+ t.Fatalf("expected default hermes launch after setup, got %q", lines[1])+ }+}++func TestHermesRun_SetUpLaterRepromptsOnLaterLaunches(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, runtime.GOOS)+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ if err := os.WriteFile(bin, []byte("#!/bin/sh\nprintf '[%s]\\n' \"$*\" >> \"$HOME/hermes-invocations.log\"\n"), 0o755); err != nil {+ t.Fatal(err)+ }++ promptCount := 0+ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ promptCount+++ if prompt != hermesGatewaySetupTitle {+ t.Fatalf("unexpected prompt %q", prompt)+ }+ return false, nil+ }++ h := &Hermes{}+ if err := h.Run("", nil); err != nil {+ t.Fatalf("first Run returned error: %v", err)+ }+ if err := h.Run("", nil); err != nil {+ t.Fatalf("second Run returned error: %v", err)+ }++ if promptCount != 2 {+ t.Fatalf("expected two prompts across two launches, got %d", promptCount)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ lines := strings.Split(strings.TrimSpace(string(data)), "\n")+ if len(lines) != 2 {+ t.Fatalf("expected one default launch per run, got %v", lines)+ }+ for _, line := range lines {+ if line != "[]" {+ t.Fatalf("expected only default launches after choosing later, got %v", lines)+ }+ }+}++func TestHermesRun_SkipsMessagingPromptWhenConfigured(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, runtime.GOOS)+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ envPath := filepath.Join(tmpDir, ".hermes", ".env")+ if err := os.MkdirAll(filepath.Dir(envPath), 0o755); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(envPath, []byte("DISCORD_BOT_TOKEN=configured\n"), 0o644); err != nil {+ t.Fatal(err)+ }++ bin := filepath.Join(tmpDir, "hermes")+ if err := os.WriteFile(bin, []byte("#!/bin/sh\nprintf '[%s]\\n' \"$*\" >> \"$HOME/hermes-invocations.log\"\n"), 0o755); err != nil {+ t.Fatal(err)+ }++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ t.Fatalf("did not expect messaging prompt when Hermes gateway is configured: %s", prompt)+ return false, nil+ }++ h := &Hermes{}+ if err := h.Run("", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ if got := strings.TrimSpace(string(data)); got != "[]" {+ t.Fatalf("expected only default launch invocation, got %q", got)+ }+}++func TestHermesRun_SkipsMessagingPromptWithYesPolicy(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, runtime.GOOS)+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ if err := os.WriteFile(bin, []byte("#!/bin/sh\nprintf '[%s]\\n' \"$*\" >> \"$HOME/hermes-invocations.log\"\n"), 0o755); err != nil {+ t.Fatal(err)+ }++ restoreConfirm := withLaunchConfirmPolicy(launchConfirmPolicy{yes: true})+ defer restoreConfirm()++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ t.Fatalf("did not expect messaging prompt in --yes mode: %s", prompt)+ return false, nil+ }++ h := &Hermes{}+ if err := h.Run("", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ if got := strings.TrimSpace(string(data)); got != "[]" {+ t.Fatalf("expected only default launch invocation, got %q", got)+ }+}++func TestHermesRun_MessagingSetupFailureStopsLaunch(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, runtime.GOOS)+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ script := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"+if [ "$1" = "gateway" ] && [ "$2" = "setup" ]; then+ exit 23+fi+`+ if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {+ t.Fatal(err)+ }++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ if prompt != hermesGatewaySetupTitle {+ t.Fatalf("unexpected prompt %q", prompt)+ }+ return true, nil+ }++ h := &Hermes{}+ err := h.Run("", nil)+ if err == nil {+ t.Fatal("expected messaging setup failure")+ }+ if !strings.Contains(err.Error(), "hermes messaging setup failed") {+ t.Fatalf("expected helpful messaging setup error, got %v", err)+ }+ if !strings.Contains(err.Error(), hermesGatewaySetupHint) {+ t.Fatalf("expected recovery hint, got %v", err)+ }++ data, readErr := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if readErr != nil {+ t.Fatal(readErr)+ }+ if got := strings.TrimSpace(string(data)); got != "[gateway setup]" {+ t.Fatalf("expected launch to stop after failed setup, got %q", got)+ }+}++func TestHermesRefreshRuntimeAfterConfigure_RestartsRunningGateway(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, runtime.GOOS)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ script := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"+if [ "$1" = "gateway" ] && [ "$2" = "status" ]; then+ printf '✓ Gateway is running (PID: 123)\n'+fi+`+ if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {+ t.Fatal(err)+ }++ h := &Hermes{}+ if err := h.RefreshRuntimeAfterConfigure(); err != nil {+ t.Fatalf("RefreshRuntimeAfterConfigure returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ lines := strings.Split(strings.TrimSpace(string(data)), "\n")+ if len(lines) != 2 {+ t.Fatalf("expected status then restart invocations, got %v", lines)+ }+ if lines[0] != "[gateway status]" {+ t.Fatalf("expected gateway status first, got %q", lines[0])+ }+ if lines[1] != "[gateway restart]" {+ t.Fatalf("expected gateway restart second, got %q", lines[1])+ }+}++func TestHermesRefreshRuntimeAfterConfigure_SkipsRestartWhenGatewayStopped(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses a POSIX shell test binary")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, runtime.GOOS)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ bin := filepath.Join(tmpDir, "hermes")+ script := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"+if [ "$1" = "gateway" ] && [ "$2" = "status" ]; then+ printf '✗ Gateway is not running\n'+fi+`+ if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {+ t.Fatal(err)+ }++ h := &Hermes{}+ if err := h.RefreshRuntimeAfterConfigure(); err != nil {+ t.Fatalf("RefreshRuntimeAfterConfigure returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ if got := strings.TrimSpace(string(data)); got != "[gateway status]" {+ t.Fatalf("expected only gateway status invocation, got %q", got)+ }+}++func TestHermesRefreshRuntimeAfterConfigure_WindowsWSLRestartsRunningGateway(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses POSIX shell test binaries to simulate WSL")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "windows")+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ wslPath := filepath.Join(tmpDir, "wsl.exe")+ wslScript := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/wsl-invocations.log"+exec /bin/sh -lc "$3"+`+ if err := os.WriteFile(wslPath, []byte(wslScript), 0o755); err != nil {+ t.Fatal(err)+ }++ hermesBin := filepath.Join(tmpDir, "hermes")+ hermesScript := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"+if [ "$1" = "gateway" ] && [ "$2" = "status" ]; then+ printf '✓ Gateway is running (PID: 321)\n'+fi+`+ if err := os.WriteFile(hermesBin, []byte(hermesScript), 0o755); err != nil {+ t.Fatal(err)+ }++ withHermesLookPath(t, func(file string) (string, error) {+ if file == "wsl.exe" {+ return wslPath, nil+ }+ return "", os.ErrNotExist+ })++ h := &Hermes{}+ if err := h.RefreshRuntimeAfterConfigure(); err != nil {+ t.Fatalf("RefreshRuntimeAfterConfigure returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ lines := strings.Split(strings.TrimSpace(string(data)), "\n")+ if len(lines) != 2 {+ t.Fatalf("expected WSL status then restart invocations, got %v", lines)+ }+ if lines[0] != "[gateway status]" {+ t.Fatalf("expected WSL gateway status first, got %q", lines[0])+ }+ if lines[1] != "[gateway restart]" {+ t.Fatalf("expected WSL gateway restart second, got %q", lines[1])+ }+}++func TestHermesMessagingConfiguredRecognizesSupportedGatewayVars(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")+ clearHermesMessagingEnvVars(t)++ envPath := filepath.Join(tmpDir, ".hermes", ".env")+ if err := os.MkdirAll(filepath.Dir(envPath), 0o755); err != nil {+ t.Fatal(err)+ }++ tests := []struct {+ name string+ env string+ want bool+ }{+ {name: "none", env: "", want: false},+ {name: "telegram", env: "TELEGRAM_BOT_TOKEN=token\n", want: true},+ {name: "discord", env: "DISCORD_BOT_TOKEN=token\n", want: true},+ {name: "slack", env: "SLACK_BOT_TOKEN=token\n", want: true},+ {name: "signal", env: "SIGNAL_ACCOUNT=account\n", want: true},+ {name: "email", env: "[email protected]\n", want: true},+ {name: "sms", env: "TWILIO_ACCOUNT_SID=sid\n", want: true},+ {name: "matrix token", env: "MATRIX_ACCESS_TOKEN=token\n", want: true},+ {name: "matrix password", env: "MATRIX_PASSWORD=secret\n", want: true},+ {name: "mattermost", env: "MATTERMOST_TOKEN=token\n", want: true},+ {name: "whatsapp", env: "WHATSAPP_PHONE_NUMBER_ID=phone\n", want: true},+ {name: "dingtalk", env: "DINGTALK_CLIENT_ID=client\n", want: true},+ {name: "feishu", env: "FEISHU_APP_ID=app\n", want: true},+ {name: "wecom", env: "WECOM_BOT_ID=bot\n", want: true},+ {name: "weixin", env: "WEIXIN_ACCOUNT_ID=account\n", want: true},+ {name: "bluebubbles", env: "BLUEBUBBLES_SERVER_URL=https://example.invalid\n", want: true},+ {name: "webhooks", env: "WEBHOOK_ENABLED=true\n", want: true},+ }++ h := &Hermes{}+ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ if err := os.WriteFile(envPath, []byte(tt.env), 0o644); err != nil {+ t.Fatal(err)+ }+ if got := h.messagingConfigured(); got != tt.want {+ t.Fatalf("messagingConfigured() = %v, want %v", got, tt.want)+ }+ })+ }+}++func TestHermesRunWindowsWSL_UsesGatewaySetupPreflight(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses POSIX shell test binaries to simulate WSL")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withLauncherHooks(t)+ withInteractiveSession(t, true)+ withHermesPlatform(t, "windows")+ clearHermesMessagingEnvVars(t)+ t.Setenv("PATH", tmpDir+string(os.PathListSeparator)+os.Getenv("PATH"))++ wslPath := filepath.Join(tmpDir, "wsl.exe")+ wslScript := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/wsl-invocations.log"+exec /bin/sh -lc "$3"+`+ if err := os.WriteFile(wslPath, []byte(wslScript), 0o755); err != nil {+ t.Fatal(err)+ }++ hermesBin := filepath.Join(tmpDir, "hermes")+ hermesScript := `#!/bin/sh+printf '[%s]\n' "$*" >> "$HOME/hermes-invocations.log"+if [ "$1" = "gateway" ] && [ "$2" = "setup" ]; then+ /bin/mkdir -p "$HOME/.hermes"+ printf 'TELEGRAM_BOT_TOKEN=configured\n' > "$HOME/.hermes/.env"+fi+`+ if err := os.WriteFile(hermesBin, []byte(hermesScript), 0o755); err != nil {+ t.Fatal(err)+ }++ withHermesLookPath(t, func(file string) (string, error) {+ if file == "wsl.exe" {+ return wslPath, nil+ }+ return "", os.ErrNotExist+ })++ promptCount := 0+ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ promptCount+++ if prompt != hermesGatewaySetupTitle {+ t.Fatalf("unexpected prompt %q", prompt)+ }+ return true, nil+ }++ h := &Hermes{}+ if err := h.Run("", nil); err != nil {+ t.Fatalf("Run returned error: %v", err)+ }++ if promptCount != 1 {+ t.Fatalf("expected one messaging prompt, got %d", promptCount)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "hermes-invocations.log"))+ if err != nil {+ t.Fatal(err)+ }+ lines := strings.Split(strings.TrimSpace(string(data)), "\n")+ if len(lines) != 2 {+ t.Fatalf("expected WSL hermes to run setup then launch, got %v", lines)+ }+ if lines[0] != "[gateway setup]" {+ t.Fatalf("expected WSL gateway setup first, got %q", lines[0])+ }+ if lines[1] != "[]" {+ t.Fatalf("expected WSL default hermes launch second, got %q", lines[1])+ }+}++func TestHermesEnsureInstalledWindowsWithoutWSLGivesGuidance(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "windows")+ t.Setenv("PATH", tmpDir)++ h := &Hermes{}+ err := h.ensureInstalled()+ if err == nil {+ t.Fatal("expected missing WSL guidance error")+ }+ if !strings.Contains(err.Error(), "wsl --install") {+ t.Fatalf("expected WSL guidance, got %v", err)+ }+}++func TestHermesEnsureInstalledUnixPromptsBeforeInstall(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses POSIX shell test binaries")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")+ withLauncherHooks(t)+ t.Setenv("PATH", tmpDir)++ writeScript := func(name, content string) {+ t.Helper()+ if err := os.WriteFile(filepath.Join(tmpDir, name), []byte(content), 0o755); err != nil {+ t.Fatal(err)+ }+ }++ writeScript("curl", "#!/bin/sh\nexit 0\n")+ writeScript("git", "#!/bin/sh\nexit 0\n")+ writeScript("bash", fmt.Sprintf(`#!/bin/sh+printf '%%s\n' "$*" >> %q+/bin/cat > %q <<'EOS'+#!/bin/sh+exit 0+EOS+/bin/chmod +x %q+exit 0+`, filepath.Join(tmpDir, "bash.log"), filepath.Join(tmpDir, "hermes"), filepath.Join(tmpDir, "hermes")))++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ if prompt != "Hermes is not installed. Install now?" {+ t.Fatalf("unexpected install prompt %q", prompt)+ }+ return true, nil+ }++ h := &Hermes{}+ if err := h.ensureInstalled(); err != nil {+ t.Fatalf("ensureInstalled returned error: %v", err)+ }++ data, err := os.ReadFile(filepath.Join(tmpDir, "bash.log"))+ if err != nil {+ t.Fatal(err)+ }+ if !strings.Contains(string(data), "--skip-setup") {+ t.Fatalf("expected install script to skip upstream setup, got logs:\n%s", data)+ }+ if !strings.Contains(string(data), "-lc "+hermesInstallScript) {+ t.Fatalf("expected official install script invocation, got logs:\n%s", data)+ }+}++func TestHermesEnsureInstalledUnixCanBeDeclined(t *testing.T) {+ if runtime.GOOS == "windows" {+ t.Skip("uses POSIX shell test binaries")+ }++ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, "darwin")+ withLauncherHooks(t)+ t.Setenv("PATH", tmpDir)++ for _, name := range []string{"bash", "curl", "git"} {+ if err := os.WriteFile(filepath.Join(tmpDir, name), []byte("#!/bin/sh\nexit 0\n"), 0o755); err != nil {+ t.Fatal(err)+ }+ }++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ if prompt != "Hermes is not installed. Install now?" {+ t.Fatalf("unexpected install prompt %q", prompt)+ }+ return false, nil+ }++ h := &Hermes{}+ err := h.ensureInstalled()+ if err == nil || !strings.Contains(err.Error(), "hermes installation cancelled") {+ t.Fatalf("expected install cancellation error, got %v", err)+ }+}++func TestHermesOnboardSkipsWhenLaunchConfigAlreadyMarked(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, runtime.GOOS)++ if err := config.MarkIntegrationOnboarded("hermes"); err != nil {+ t.Fatalf("failed to mark Hermes onboarded: %v", err)+ }++ h := &Hermes{}+ if err := h.Onboard(); err != nil {+ t.Fatalf("expected Onboard to no-op when already marked, got %v", err)+ }+}++func TestHermesOnboardMarksLaunchConfig(t *testing.T) {+ tmpDir := t.TempDir()+ setTestHome(t, tmpDir)+ withHermesPlatform(t, runtime.GOOS)++ h := &Hermes{}+ if err := h.Onboard(); err != nil {+ t.Fatalf("Onboard returned error: %v", err)+ }++ saved, err := config.LoadIntegration("hermes")+ if err != nil {+ t.Fatalf("failed to load Hermes integration config: %v", err)+ }+ if !saved.Onboarded {+ t.Fatal("expected Hermes to be marked onboarded")+ }+}++func TestHermesGatewayStatusRunningRecognizesRunningStates(t *testing.T) {+ tests := []struct {+ name string+ output string+ want bool+ }{+ {name: "manual", output: "✓ Gateway is running (PID: 123)", want: true},+ {name: "systemd", output: "✓ User gateway service is running", want: true},+ {name: "launchd", output: "✓ Gateway service is loaded", want: true},+ {name: "manual stopped", output: "✗ Gateway is not running", want: false},+ {name: "systemd stopped", output: "✗ User gateway service is stopped", want: false},+ {name: "launchd unloaded", output: "✗ Gateway service is not loaded", want: false},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ if got := hermesGatewayStatusRunning(tt.output); got != tt.want {+ t.Fatalf("hermesGatewayStatusRunning(%q) = %v, want %v", tt.output, got, tt.want)+ }+ })+ }+}diff --git a/cmd/launch/integrations_test.go b/cmd/launch/integrations_test.goindex 68f1148f2..0f7313301 100644--- a/cmd/launch/integrations_test.go+++ b/cmd/launch/integrations_test.go@@ -74,7 +74,7 @@ func TestIntegrationLookup(t *testing.T) {}func TestIntegrationRegistry(t *testing.T) {- expectedIntegrations := []string{"claude", "codex", "droid", "opencode"}+ expectedIntegrations := []string{"claude", "codex", "droid", "opencode", "hermes"}for _, name := range expectedIntegrations {t.Run(name, func(t *testing.T) {@@ -1509,27 +1509,13 @@ func TestListIntegrationInfos(t *testing.T) {}})- t.Run("sorted with custom order at end", func(t *testing.T) {- // integrationOrder entries (cline, opencode) should appear last, in that order.- // All other entries should be sorted alphabetically before them.- orderRank := make(map[string]int)- for i, name := range integrationOrder {- orderRank[name] = i + 1+ t.Run("follows launcher order", func(t *testing.T) {+ got := make([]string, 0, len(infos))+ for _, info := range infos {+ got = append(got, info.Name)}- for i := 1; i < len(infos); i++ {- aRank, bRank := orderRank[infos[i-1].Name], orderRank[infos[i].Name]- switch {- case aRank == 0 && bRank == 0:- if infos[i-1].Name >= infos[i].Name {- t.Errorf("non-ordered items not sorted: %q >= %q", infos[i-1].Name, infos[i].Name)- }- case aRank > 0 && bRank == 0:- t.Errorf("ordered item %q should come after non-ordered %q", infos[i-1].Name, infos[i].Name)- case aRank > 0 && bRank > 0:- if aRank >= bRank {- t.Errorf("ordered items wrong: %q (rank %d) before %q (rank %d)", infos[i-1].Name, aRank, infos[i].Name, bRank)- }- }+ if diff := compareStrings(got, integrationOrder); diff != "" {+ t.Fatalf("launcher integration order mismatch: %s", diff)}})@@ -1557,6 +1543,28 @@ func TestListIntegrationInfos(t *testing.T) {}}})++ t.Run("includes hermes", func(t *testing.T) {+ for _, info := range infos {+ if info.Name == "hermes" {+ return+ }+ }+ t.Fatal("expected hermes to be included in ListIntegrationInfos")+ })++ t.Run("hermes still resolves explicitly", func(t *testing.T) {+ name, runner, err := LookupIntegration("hermes")+ if err != nil {+ t.Fatalf("expected explicit hermes integration lookup to work, got %v", err)+ }+ if name != "hermes" {+ t.Fatalf("expected canonical name hermes, got %q", name)+ }+ if runner.String() == "" {+ t.Fatal("expected hermes integration runner to be present")+ }+ })}func TestBuildModelList_Descriptions(t *testing.T) {@@ -1645,6 +1653,7 @@ func TestIntegration_AutoInstallable(t *testing.T) {}{{"openclaw", true},{"pi", true},+ {"hermes", true},{"claude", false},{"codex", false},{"opencode", false},diff --git a/cmd/launch/launch.go b/cmd/launch/launch.goindex 7786c09c7..91196cf1f 100644--- a/cmd/launch/launch.go+++ b/cmd/launch/launch.go@@ -141,6 +141,36 @@ type Editor interface {Models() []string}+// ManagedSingleModel is the narrow launch-owned config path for integrations+// like Hermes that have one primary model selected by launcher, need launcher+// to persist minimal config, and still keep their own model discovery and+// onboarding UX. This stays separate from Runner-only integrations and the+// multi-model Editor flow so Hermes-specific behavior stays scoped to one path.+type ManagedSingleModel interface {+ Paths() []string+ Configure(model string) error+ CurrentModel() string+ Onboard() error+}++// ManagedRuntimeRefresher lets managed integrations refresh any long-lived+// background runtime after launch rewrites their config.+type ManagedRuntimeRefresher interface {+ RefreshRuntimeAfterConfigure() error+}++// ManagedOnboardingValidator lets managed integrations re-check saved+// onboarding state when launcher needs a stronger live readiness signal.+type ManagedOnboardingValidator interface {+ OnboardingComplete() bool+}++// ManagedInteractiveOnboarding lets a managed integration declare whether its+// onboarding step really requires an interactive terminal. Hermes does not.+type ManagedInteractiveOnboarding interface {+ RequiresInteractiveOnboarding() bool+}+type modelInfo struct {Name stringRemote bool@@ -177,6 +207,7 @@ Supported integrations:cline Clinecodex Codexdroid Droid+ hermes Hermes Agentopencode OpenCodeopenclaw OpenClaw (aliases: clawdbot, moltbot)pi Pi@@ -186,6 +217,7 @@ Examples:ollama launchollama launch claudeollama launch claude --model <model>+ ollama launch hermesollama launch droid --config (does not auto-launch)ollama launch codex -- -p myprofile (pass extra args to integration)ollama launch codex -- --sandbox workspace-write`,@@ -308,28 +340,28 @@ func LaunchIntegration(ctx context.Context, req IntegrationLaunchRequest) errorif err != nil {return err}- if !req.ConfigureOnly {- if err := EnsureIntegrationInstalled(name, runner); err != nil {- return err- }- }- var policy LaunchPolicy- // TUI does not set a policy, whereas ollama launch <app> does as it can have flags which change the behavior- if req.Policy == nil {- policy = defaultLaunchPolicy(isInteractiveSession(), false)- } else {- policy = *req.Policy+ policy := launchIntegrationPolicy(req)+ if policy.Confirm == LaunchConfirmAutoApprove && !isInteractiveSession() && req.ModelOverride == "" {+ return fmt.Errorf("headless --yes launch for %s requires --model <model>", name)}- launchClient, err := newLauncherClient(policy)+ launchClient, saved, err := prepareIntegrationLaunch(name, policy)if err != nil {return err}- saved, _ := loadStoredIntegrationConfig(name)- // In headless --yes mode we cannot prompt, so require an explicit --model.- if policy.Confirm == LaunchConfirmAutoApprove && !isInteractiveSession() && req.ModelOverride == "" {- return fmt.Errorf("headless --yes launch for %s requires --model <model>", name)++ if managed, ok := runner.(ManagedSingleModel); ok {+ if err := EnsureIntegrationInstalled(name, runner); err != nil {+ return err+ }+ return launchClient.launchManagedSingleIntegration(ctx, name, runner, managed, saved, req)+ }++ if !req.ConfigureOnly {+ if err := EnsureIntegrationInstalled(name, runner); err != nil {+ return err+ }}if editor, ok := runner.(Editor); ok {@@ -338,6 +370,24 @@ func LaunchIntegration(ctx context.Context, req IntegrationLaunchRequest) errorreturn launchClient.launchSingleIntegration(ctx, name, runner, saved, req)}+func launchIntegrationPolicy(req IntegrationLaunchRequest) LaunchPolicy {+ // TUI does not set a policy, whereas ollama launch <app> does as it can+ // have flags which change the behavior.+ if req.Policy != nil {+ return *req.Policy+ }+ return defaultLaunchPolicy(isInteractiveSession(), false)+}++func prepareIntegrationLaunch(name string, policy LaunchPolicy) (*launcherClient, *config.IntegrationConfig, error) {+ launchClient, err := newLauncherClient(policy)+ if err != nil {+ return nil, nil, err+ }+ saved, _ := loadStoredIntegrationConfig(name)+ return launchClient, saved, nil+}+func (c *launcherClient) buildLauncherState(ctx context.Context) (*LauncherState, error) {_ = c.loadModelInventoryOnce(ctx)@@ -368,9 +418,18 @@ func (c *launcherClient) buildLauncherIntegrationState(ctx context.Context, infoif err != nil {return LauncherIntegrationState{}, err}- currentModel, usable, err := c.launcherModelState(ctx, info.Name, integration.editor)- if err != nil {- return LauncherIntegrationState{}, err+ var currentModel string+ var usable bool+ if managed, ok := integration.spec.Runner.(ManagedSingleModel); ok {+ currentModel, usable, err = c.launcherManagedModelState(ctx, info.Name, managed)+ if err != nil {+ return LauncherIntegrationState{}, err+ }+ } else {+ currentModel, usable, err = c.launcherModelState(ctx, info.Name, integration.editor)+ if err != nil {+ return LauncherIntegrationState{}, err+ }}return LauncherIntegrationState{@@ -408,6 +467,28 @@ func (c *launcherClient) launcherModelState(ctx context.Context, name string, isreturn model, usableErr == nil && usable, nil}+func (c *launcherClient) launcherManagedModelState(ctx context.Context, name string, managed ManagedSingleModel) (string, bool, error) {+ current := managed.CurrentModel()+ if current == "" {+ cfg, loadErr := loadStoredIntegrationConfig(name)+ if loadErr == nil {+ current = primaryModelFromConfig(cfg)+ }+ if current != "" {+ return current, false, nil+ }+ }+ if current == "" {+ return "", false, nil+ }++ usable, err := c.savedModelUsable(ctx, current)+ if err != nil {+ return current, false, err+ }+ return current, usable, nil+}+func (c *launcherClient) resolveRunModel(ctx context.Context, req RunModelRequest) (string, error) {current := config.LastModel()if !req.ForcePicker && current != "" && c.policy.Confirm == LaunchConfirmAutoApprove && !isInteractiveSession() {@@ -444,35 +525,15 @@ func (c *launcherClient) resolveRunModel(ctx context.Context, req RunModelReques}func (c *launcherClient) launchSingleIntegration(ctx context.Context, name string, runner Runner, saved *config.IntegrationConfig, req IntegrationLaunchRequest) error {- current := primaryModelFromConfig(saved)- target := req.ModelOverride- needsConfigure := req.ForceConfigure-- if target == "" {- target = current- usable, err := c.savedModelUsable(ctx, target)- if err != nil {- return err- }- if !usable {- needsConfigure = true- }- }-- if needsConfigure {- selected, err := c.selectSingleModelWithSelector(ctx, fmt.Sprintf("Select model for %s:", runner), target, DefaultSingleSelector)- if err != nil {- return err- }- target = selected- } else if err := c.ensureModelsReady(ctx, []string{target}); err != nil {+ target, _, err := c.resolveSingleIntegrationTarget(ctx, runner, primaryModelFromConfig(saved), req)+ if err != nil {return err}-if target == "" {return nil}+ current := primaryModelFromConfig(saved)if target != current {if err := config.SaveIntegration(name, []string{target}); err != nil {return fmt.Errorf("failed to save: %w", err)@@ -510,6 +571,102 @@ func (c *launcherClient) launchEditorIntegration(ctx context.Context, name strinreturn launchAfterConfiguration(name, runner, models[0], req)}+func (c *launcherClient) launchManagedSingleIntegration(ctx context.Context, name string, runner Runner, managed ManagedSingleModel, saved *config.IntegrationConfig, req IntegrationLaunchRequest) error {+ current := managed.CurrentModel()+ selectionCurrent := current+ if selectionCurrent == "" {+ selectionCurrent = primaryModelFromConfig(saved)+ }++ target, needsConfigure, err := c.resolveSingleIntegrationTarget(ctx, runner, selectionCurrent, req)+ if err != nil {+ return err+ }+ if target == "" {+ return nil+ }++ if current == "" || needsConfigure || req.ModelOverride != "" || target != current {+ if err := prepareManagedSingleIntegration(name, runner, managed, target); err != nil {+ return err+ }+ if refresher, ok := managed.(ManagedRuntimeRefresher); ok {+ if err := refresher.RefreshRuntimeAfterConfigure(); err != nil {+ return err+ }+ }+ }++ if !managedIntegrationOnboarded(saved, managed) {+ if !isInteractiveSession() && managedRequiresInteractiveOnboarding(managed) {+ return fmt.Errorf("%s still needs interactive gateway setup; run 'ollama launch %s' in a terminal to finish onboarding", runner, name)+ }+ if err := managed.Onboard(); err != nil {+ return err+ }+ }++ if req.ConfigureOnly {+ return nil+ }++ return runIntegration(runner, target, req.ExtraArgs)+}++func (c *launcherClient) resolveSingleIntegrationTarget(ctx context.Context, runner Runner, current string, req IntegrationLaunchRequest) (string, bool, error) {+ target := req.ModelOverride+ needsConfigure := req.ForceConfigure++ if target == "" {+ target = current+ usable, err := c.savedModelUsable(ctx, target)+ if err != nil {+ return "", false, err+ }+ if !usable {+ needsConfigure = true+ }+ }++ if needsConfigure {+ selected, err := c.selectSingleModelWithSelector(ctx, fmt.Sprintf("Select model for %s:", runner), target, DefaultSingleSelector)+ if err != nil {+ return "", false, err+ }+ target = selected+ } else if err := c.ensureModelsReady(ctx, []string{target}); err != nil {+ return "", false, err+ }++ return target, needsConfigure, nil+}++func savedIntegrationOnboarded(saved *config.IntegrationConfig) bool {+ return saved != nil && saved.Onboarded+}++func managedIntegrationOnboarded(saved *config.IntegrationConfig, managed ManagedSingleModel) bool {+ if !savedIntegrationOnboarded(saved) {+ return false+ }+ validator, ok := managed.(ManagedOnboardingValidator)+ if !ok {+ return true+ }+ return validator.OnboardingComplete()+}++// Most managed integrations treat onboarding as an interactive terminal step.+// Hermes opts out because its launch-owned onboarding is just bookkeeping, so+// headless launches should not be blocked once config is already prepared.+func managedRequiresInteractiveOnboarding(managed ManagedSingleModel) bool {+ onboarding, ok := managed.(ManagedInteractiveOnboarding)+ if !ok {+ return true+ }+ return onboarding.RequiresInteractiveOnboarding()+}+func (c *launcherClient) selectSingleModelWithSelector(ctx context.Context, title, current string, selector SingleSelector) (string, error) {if selector == nil {return "", fmt.Errorf("no selector configured")diff --git a/cmd/launch/launch_test.go b/cmd/launch/launch_test.goindex a9bd53c7b..3e088cc86 100644--- a/cmd/launch/launch_test.go+++ b/cmd/launch/launch_test.go@@ -49,6 +49,55 @@ func (r *launcherSingleRunner) Run(model string, args []string) error {func (r *launcherSingleRunner) String() string { return "StubSingle" }+type launcherManagedRunner struct {+ paths []string+ currentModel string+ configured []string+ ranModel string+ onboarded bool+ onboardCalls int+ onboardingComplete bool+ refreshCalls int+ refreshErr error+}++func (r *launcherManagedRunner) Run(model string, args []string) error {+ r.ranModel = model+ return nil+}++func (r *launcherManagedRunner) String() string { return "StubManaged" }++func (r *launcherManagedRunner) Paths() []string { return r.paths }++func (r *launcherManagedRunner) Configure(model string) error {+ r.configured = append(r.configured, model)+ r.currentModel = model+ return nil+}++func (r *launcherManagedRunner) CurrentModel() string { return r.currentModel }++func (r *launcherManagedRunner) Onboard() error {+ r.onboardCalls+++ r.onboarded = true+ r.onboardingComplete = true+ return nil+}++func (r *launcherManagedRunner) OnboardingComplete() bool { return r.onboardingComplete }++func (r *launcherManagedRunner) RefreshRuntimeAfterConfigure() error {+ r.refreshCalls+++ return r.refreshErr+}++type launcherHeadlessManagedRunner struct {+ launcherManagedRunner+}++func (r *launcherHeadlessManagedRunner) RequiresInteractiveOnboarding() bool { return false }+func setLaunchTestHome(t *testing.T, dir string) {t.Helper()t.Setenv("HOME", dir)@@ -141,6 +190,448 @@ func TestDefaultLaunchPolicy(t *testing.T) {}}+func TestBuildLauncherState_ManagedSingleIntegrationUsesCurrentModel(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)++ 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"}]}`)+ 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)++ runner := &launcherManagedRunner{currentModel: "gemma4"}+ withIntegrationOverride(t, "pi", runner)++ state, err := BuildLauncherState(context.Background())+ if err != nil {+ t.Fatalf("BuildLauncherState returned error: %v", err)+ }++ if state.Integrations["pi"].CurrentModel != "gemma4" {+ t.Fatalf("expected managed current model from integration config, got %q", state.Integrations["pi"].CurrentModel)+ }+ if !state.Integrations["pi"].ModelUsable {+ t.Fatal("expected managed current model to be usable")+ }+}++func TestBuildLauncherState_ManagedSingleIntegrationShowsSavedModelWhenLiveConfigMissing(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)++ 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"}]}`)+ 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("pi", []string{"gemma4"}); err != nil {+ t.Fatalf("failed to save managed integration config: %v", err)+ }++ runner := &launcherManagedRunner{}+ withIntegrationOverride(t, "pi", runner)++ state, err := BuildLauncherState(context.Background())+ if err != nil {+ t.Fatalf("BuildLauncherState returned error: %v", err)+ }++ if state.Integrations["pi"].CurrentModel != "gemma4" {+ t.Fatalf("expected saved model to remain visible, got %q", state.Integrations["pi"].CurrentModel)+ }+ if state.Integrations["pi"].ModelUsable {+ t.Fatal("expected missing live config to mark managed model unusable")+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationConfiguresOnboardsAndRuns(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/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)+ 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)++ runner := &launcherManagedRunner{+ paths: nil,+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ DefaultSingleSelector = func(title string, items []ModelItem, current string) (string, error) {+ return "gemma4", 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("configured models mismatch: %s", diff)+ }+ if runner.refreshCalls != 1 {+ t.Fatalf("expected runtime refresh once after configure, got %d", runner.refreshCalls)+ }+ if runner.onboardCalls != 1 {+ t.Fatalf("expected onboarding to run once, got %d", runner.onboardCalls)+ }+ if runner.ranModel != "gemma4" {+ t.Fatalf("expected launch to run configured model, got %q", runner.ranModel)+ }++ saved, err := config.LoadIntegration("stubmanaged")+ if err != nil {+ t.Fatalf("failed to reload managed integration config: %v", err)+ }+ if diff := compareStrings(saved.Models, []string{"gemma4"}); diff != "" {+ t.Fatalf("saved models mismatch: %s", diff)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationReOnboardsWhenSavedFlagIsStale(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/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)+ 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)++ runner := &launcherManagedRunner{+ currentModel: "gemma4",+ onboardingComplete: false,+ }+ 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 managed integration onboarded: %v", err)+ }++ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }++ if runner.onboardCalls != 1 {+ t.Fatalf("expected stale onboarded flag to trigger onboarding, got %d calls", runner.onboardCalls)+ }+ if runner.refreshCalls != 0 {+ t.Fatalf("expected no runtime refresh when config is unchanged, got %d", runner.refreshCalls)+ }+ if runner.ranModel != "gemma4" {+ t.Fatalf("expected launch to run saved model after onboarding repair, got %q", runner.ranModel)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationConfigOnlySkipsFinalRun(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)++ runner := &launcherManagedRunner{+ paths: nil,+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ return true, nil+ }++ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ModelOverride: "gemma4",+ ConfigureOnly: true,+ }); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }++ if runner.ranModel != "" {+ t.Fatalf("expected configure-only flow to skip final launch, got %q", runner.ranModel)+ }+ if runner.refreshCalls != 1 {+ t.Fatalf("expected configure-only flow to refresh runtime once, got %d", runner.refreshCalls)+ }+ if runner.onboardCalls != 1 {+ t.Fatalf("expected configure-only flow to onboard once, got %d", runner.onboardCalls)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationRepairsMissingLiveConfigUsingSavedModel(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/tags":+ fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)+ 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 []ModelItem, current string) (string, error) {+ t.Fatal("selector should not be called when saved model is reused for repair")+ 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 missing live config to be rewritten from saved model: %s", diff)+ }+ if runner.refreshCalls != 1 {+ t.Fatalf("expected repaired config to refresh runtime once, got %d", runner.refreshCalls)+ }+ if runner.ranModel != "gemma4" {+ t.Fatalf("expected launch to use repaired saved model, got %q", runner.ranModel)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationConfigureOnlyRepairsMissingLiveConfig(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 []ModelItem, current string) (string, error) {+ t.Fatal("selector should not be called when saved model is reused for repair")+ return "", nil+ }+ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ return true, nil+ }++ if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ConfigureOnly: true,+ }); err != nil {+ t.Fatalf("LaunchIntegration returned error: %v", err)+ }++ if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {+ t.Fatalf("expected configure-only flow to rewrite missing live config: %s", diff)+ }+ if runner.refreshCalls != 1 {+ t.Fatalf("expected configure-only repair to refresh runtime once, got %d", runner.refreshCalls)+ }+ if runner.ranModel != "" {+ t.Fatalf("expected configure-only flow to skip final launch, got %q", runner.ranModel)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationStopsWhenRuntimeRefreshFails(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)++ runner := &launcherManagedRunner{+ refreshErr: fmt.Errorf("boom"),+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {+ return true, nil+ }++ err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ModelOverride: "gemma4",+ })+ if err == nil || !strings.Contains(err.Error(), "boom") {+ t.Fatalf("expected runtime refresh error, got %v", err)+ }+ if runner.ranModel != "" {+ t.Fatalf("expected final launch to stop on runtime refresh failure, got %q", runner.ranModel)+ }+ if runner.refreshCalls != 1 {+ t.Fatalf("expected one runtime refresh attempt, got %d", runner.refreshCalls)+ }+ if runner.onboardCalls != 0 {+ t.Fatalf("expected onboarding to stop after refresh failure, got %d", runner.onboardCalls)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationHeadlessNeedsInteractiveOnboarding(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)+ withInteractiveSession(t, false)+ 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)++ runner := &launcherManagedRunner{+ paths: nil,+ }+ withIntegrationOverride(t, "stubmanaged", runner)++ err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ModelOverride: "gemma4",+ Policy: &LaunchPolicy{Confirm: LaunchConfirmAutoApprove, MissingModel: LaunchMissingModelAutoPull},+ })+ if err == nil {+ t.Fatal("expected headless onboarding requirement to fail")+ }+ if !strings.Contains(err.Error(), "interactive gateway setup") {+ t.Fatalf("expected interactive onboarding guidance, got %v", err)+ }+ if runner.ranModel != "" {+ t.Fatalf("expected no final launch when onboarding is still required, got %q", runner.ranModel)+ }+ if runner.onboardCalls != 0 {+ t.Fatalf("expected no onboarding attempts in headless mode, got %d", runner.onboardCalls)+ }+}++func TestLaunchIntegration_ManagedSingleIntegrationHeadlessAllowsNonInteractiveOnboarding(t *testing.T) {+ tmpDir := t.TempDir()+ setLaunchTestHome(t, tmpDir)+ withInteractiveSession(t, false)+ 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)++ runner := &launcherHeadlessManagedRunner{}+ withIntegrationOverride(t, "stubmanaged", runner)++ err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{+ Name: "stubmanaged",+ ModelOverride: "gemma4",+ Policy: &LaunchPolicy{Confirm: LaunchConfirmAutoApprove, MissingModel: LaunchMissingModelAutoPull},+ })+ if err != nil {+ t.Fatalf("expected non-interactive onboarding to succeed headlessly, got %v", err)+ }+ if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {+ t.Fatalf("configured models mismatch: %s", diff)+ }+ if runner.onboardCalls != 1 {+ t.Fatalf("expected onboarding to run once, got %d", runner.onboardCalls)+ }+ if runner.ranModel != "gemma4" {+ t.Fatalf("expected launch to run configured model, got %q", runner.ranModel)+ }+}+func TestBuildLauncherState_InstalledAndCloudDisabled(t *testing.T) {tmpDir := t.TempDir()setLaunchTestHome(t, tmpDir)diff --git a/cmd/launch/models.go b/cmd/launch/models.goindex 7c45ddfe0..fb962b4a1 100644--- a/cmd/launch/models.go+++ b/cmd/launch/models.go@@ -230,7 +230,7 @@ func pullMissingModel(ctx context.Context, client *api.Client, model string) err// prepareEditorIntegration persists models and applies editor-managed config files.func prepareEditorIntegration(name string, runner Runner, editor Editor, models []string) error {- if ok, err := confirmEditorEdit(runner, editor); err != nil {+ if ok, err := confirmConfigEdit(runner, editor.Paths()); err != nil {return err} else if !ok {return errCancelled@@ -244,8 +244,22 @@ func prepareEditorIntegration(name string, runner Runner, editor Editor, modelsreturn nil}-func confirmEditorEdit(runner Runner, editor Editor) (bool, error) {- paths := editor.Paths()+func prepareManagedSingleIntegration(name string, runner Runner, managed ManagedSingleModel, model string) error {+ if ok, err := confirmConfigEdit(runner, managed.Paths()); err != nil {+ return err+ } else if !ok {+ return errCancelled+ }+ if err := managed.Configure(model); err != nil {+ return fmt.Errorf("setup failed: %w", err)+ }+ if err := config.SaveIntegration(name, []string{model}); err != nil {+ return fmt.Errorf("failed to save: %w", err)+ }+ return nil+}++func confirmConfigEdit(runner Runner, paths []string) (bool, error) {if len(paths) == 0 {return true, nil}diff --git a/cmd/launch/registry.go b/cmd/launch/registry.goindex 8d70b3db1..77c134d77 100644--- a/cmd/launch/registry.go+++ b/cmd/launch/registry.go@@ -33,7 +33,7 @@ type IntegrationInfo struct {Description string}-var launcherIntegrationOrder = []string{"opencode", "droid", "pi"}+var launcherIntegrationOrder = []string{"openclaw", "claude", "opencode", "hermes", "codex", "droid", "pi"}var integrationSpecs = []*IntegrationSpec{{@@ -136,6 +136,20 @@ var integrationSpecs = []*IntegrationSpec{Command: []string{"npm", "install", "-g", "@mariozechner/pi-coding-agent@latest"},},},+ {+ Name: "hermes",+ Runner: &Hermes{},+ Description: "Self-improving AI agent built by Nous Research",+ Install: IntegrationInstallSpec{+ CheckInstalled: func() bool {+ return (&Hermes{}).installed()+ },+ EnsureInstalled: func() error {+ return (&Hermes{}).ensureInstalled()+ },+ URL: "https://hermes-agent.nousresearch.com/docs/getting-started/installation/",+ },+ },{Name: "vscode",Runner: &VSCode{},@@ -255,10 +269,10 @@ func ListVisibleIntegrationSpecs() []IntegrationSpec {return aRank - bRank}if aRank > 0 {- return 1+ return -1}if bRank > 0 {- return -1+ return 1}return strings.Compare(a.Name, b.Name)})diff --git a/cmd/tui/tui.go b/cmd/tui/tui.goindex 15bd9cf4f..a683c1c5a 100644--- a/cmd/tui/tui.go+++ b/cmd/tui/tui.go@@ -45,21 +45,12 @@ type menuItem struct {isOthers bool}-var mainMenuItems = []menuItem{- {- title: "Chat with a model",- description: "Start an interactive chat with a model",- isRunModel: true,- },- {- integration: "openclaw",- },- {- integration: "claude",- },- {- integration: "opencode",- },+const pinnedIntegrationCount = 3++var runModelMenuItem = menuItem{+ title: "Chat with a model",+ description: "Start an interactive chat with a model",+ isRunModel: true,}var othersMenuItem = menuItem{@@ -102,20 +93,14 @@ func shouldExpandOthers(state *launch.LauncherState) bool {}func buildMenuItems(state *launch.LauncherState, showOthers bool) []menuItem {- items := make([]menuItem, 0, len(mainMenuItems)+1)- for _, item := range mainMenuItems {- if item.integration == "" {- items = append(items, item)- continue- }- if integrationState, ok := state.Integrations[item.integration]; ok {- items = append(items, integrationMenuItem(integrationState))- }- }+ items := []menuItem{runModelMenuItem}+ items = append(items, pinnedIntegrationItems(state)...)- if showOthers {- items = append(items, otherIntegrationItems(state)...)- } else {+ otherItems := otherIntegrationItems(state)+ switch {+ case showOthers:+ items = append(items, otherItems...)+ case len(otherItems) > 0:items = append(items, othersMenuItem)}@@ -135,17 +120,28 @@ func integrationMenuItem(state launch.LauncherIntegrationState) menuItem {}func otherIntegrationItems(state *launch.LauncherState) []menuItem {- pinned := map[string]bool{- "openclaw": true,- "claude": true,- "opencode": true,+ ordered := orderedIntegrationItems(state)+ if len(ordered) <= pinnedIntegrationCount {+ return nil+ }+ return ordered[pinnedIntegrationCount:]+}++func pinnedIntegrationItems(state *launch.LauncherState) []menuItem {+ ordered := orderedIntegrationItems(state)+ if len(ordered) <= pinnedIntegrationCount {+ return ordered+ }+ return ordered[:pinnedIntegrationCount]+}++func orderedIntegrationItems(state *launch.LauncherState) []menuItem {+ if state == nil {+ return nil}- var items []menuItem+ items := make([]menuItem, 0, len(state.Integrations))for _, info := range launch.ListIntegrationInfos() {- if pinned[info.Name] {- continue- }integrationState, ok := state.Integrations[info.Name]if !ok {continue@@ -155,6 +151,10 @@ func otherIntegrationItems(state *launch.LauncherState) []menuItem {return items}+func primaryMenuItemCount(state *launch.LauncherState) int {+ return 1 + len(pinnedIntegrationItems(state))+}+func initialCursor(state *launch.LauncherState, items []menuItem) int {if state == nil || state.LastSelection == "" {return 0@@ -190,7 +190,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {if m.cursor > 0 {m.cursor--}- if m.showOthers && m.cursor < len(mainMenuItems) {+ if m.showOthers && m.cursor < primaryMenuItemCount(m.state) {m.showOthers = falsem.items = buildMenuItems(m.state, false)m.cursor = min(m.cursor, len(m.items)-1)diff --git a/cmd/tui/tui_test.go b/cmd/tui/tui_test.goindex 1f7720c98..6f5811d50 100644--- a/cmd/tui/tui_test.go+++ b/cmd/tui/tui_test.go@@ -5,6 +5,7 @@ import ("testing"tea "github.com/charmbracelet/bubbletea"+ "github.com/google/go-cmp/cmp""github.com/ollama/ollama/cmd/launch")@@ -43,6 +44,13 @@ func launcherTestState() *launch.LauncherState {Selectable: true,Changeable: true,},+ "hermes": {+ Name: "hermes",+ DisplayName: "Hermes Agent",+ Description: "Self-improving AI agent built by Nous Research",+ Selectable: true,+ Changeable: true,+ },"droid": {Name: "droid",DisplayName: "Droid",@@ -70,8 +78,28 @@ func findMenuCursorByIntegration(items []menuItem, name string) int {return -1}+func integrationSequence(items []menuItem) []string {+ sequence := make([]string, 0, len(items))+ for _, item := range items {+ switch {+ case item.isRunModel:+ sequence = append(sequence, "run")+ case item.isOthers:+ sequence = append(sequence, "more")+ case item.integration != "":+ sequence = append(sequence, item.integration)+ }+ }+ return sequence+}++func compareStrings(got, want []string) string {+ return cmp.Diff(want, got)+}+func TestMenuRendersPinnedItemsAndMore(t *testing.T) {- view := newModel(launcherTestState()).View()+ menu := newModel(launcherTestState())+ view := menu.View()for _, want := range []string{"Chat with a model", "Launch OpenClaw", "Launch Claude Code", "Launch OpenCode", "More..."} {if !strings.Contains(view, want) {t.Fatalf("expected menu view to contain %q\n%s", want, view)@@ -80,23 +108,31 @@ func TestMenuRendersPinnedItemsAndMore(t *testing.T) {if strings.Contains(view, "Launch Codex") {t.Fatalf("expected Codex to be under More, not pinned\n%s", view)}+ wantOrder := []string{"run", "openclaw", "claude", "opencode", "more"}+ if diff := compareStrings(integrationSequence(menu.items), wantOrder); diff != "" {+ t.Fatalf("unexpected pinned order: %s", diff)+ }}func TestMenuExpandsOthersFromLastSelection(t *testing.T) {state := launcherTestState()- state.LastSelection = "pi"+ state.LastSelection = "codex"menu := newModel(state)if !menu.showOthers {t.Fatal("expected others section to expand when last selection is in the overflow list")}view := menu.View()- if !strings.Contains(view, "Launch Pi") {+ if !strings.Contains(view, "Launch Codex") {t.Fatalf("expected expanded view to contain overflow integration\n%s", view)}if strings.Contains(view, "More...") {t.Fatalf("expected expanded view to replace More... item\n%s", view)}+ wantOrder := []string{"run", "openclaw", "claude", "opencode", "hermes", "codex", "droid", "pi"}+ if diff := compareStrings(integrationSequence(menu.items), wantOrder); diff != "" {+ t.Fatalf("unexpected expanded order: %s", diff)+ }}func TestMenuEnterOnRunSelectsRun(t *testing.T) {diff --git a/docs/integrations/hermes.mdx b/docs/integrations/hermes.mdxindex 590f8ec65..3cabe4454 100644--- a/docs/integrations/hermes.mdx+++ b/docs/integrations/hermes.mdx@@ -6,6 +6,10 @@ Hermes Agent is a self-improving AI agent built by Nous Research. It features au## Quick start+```bash+ollama launch hermes+```+### Pull a modelBefore running the setup wizard, make sure you have a model available. Hermes will auto-detect models downloaded through Ollama.diff --git a/go.mod b/go.modindex a5bac3028..bf18ae8d3 100644--- a/go.mod+++ b/go.mod@@ -106,5 +106,5 @@ require (golang.org/x/term v0.36.0golang.org/x/text v0.30.0google.golang.org/protobuf v1.34.1- gopkg.in/yaml.v3 v3.0.1 // indirect+ gopkg.in/yaml.v3 v3.0.1)