From ebc6dd67e67a22dbc3832c8229c2a757be39e248 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Sat, 31 Oct 2026 15:36:56 +1100 Subject: [PATCH] fix(setup): offer the bundled database as an explicit choice on a re-run (#1388) With an existing database_url, setup prefilled the URL, so a blank answer kept it and the bundled socket database was unreachable without typing its URL. The re-run database step now presents a choice menu: keep the existing URL (still the default), switch to the bundled database (socket URL plus a generated PGPASSWORD written to the env file), or enter a different URL. Fresh installs and -database-url are unchanged; a blank answer anywhere still keeps the existing URL. Pinned at the setup API level with fake prompter/sink: TestRunParamsDatabaseChoice. --- .../configuration/setup/setup.go | 46 +++- .../configuration/setup/setup_test.go | 212 ++++++++++++++++++ 2 files changed, 251 insertions(+), 7 deletions(-) create mode 100644 internal/infrastructure/configuration/setup/setup_test.go diff --git a/internal/infrastructure/configuration/setup/setup.go b/internal/infrastructure/configuration/setup/setup.go index 2817f0621..bcb522158 100644 --- a/internal/infrastructure/configuration/setup/setup.go +++ b/internal/infrastructure/configuration/setup/setup.go @@ -136,24 +136,56 @@ func RunParams(ctx context.Context, p Prompter, discovery ModelDiscovery, secret } // stepDatabase returns the PostgreSQL URL. A blank answer on a fresh install -// means the bundled database: no network, reached through its Unix socket, with -// a generated password that goes only to the env file as PGPASSWORD, which pgx -// and Compose both read, so config.toml holds no secret. +// means the bundled database. On a re-run with an existing URL the bundled +// database is an explicit choice rather than something reachable only by +// typing its socket URL; keeping the existing URL is the first option, so +// the default answer is unchanged. func stepDatabase(ctx context.Context, p Prompter, secrets SecretSink, existing, param string) (string, error) { if strings.TrimSpace(param) != "" { return param, nil } - prompt := "PostgreSQL 18 URL (blank for the bundled database with a generated password): " - if existing != "" { - prompt = "PostgreSQL 18 URL: " + if strings.TrimSpace(existing) != "" { + choice, err := p.Select(ctx, "Database:", []string{ + "Keep the existing database URL", + "Bundled database (Unix socket, generated password in the env file)", + "Enter a different PostgreSQL 18 URL", + }) + if err != nil { + return "", fmt.Errorf("setup: database choice: %w", err) + } + switch choice { + case 0: + return existing, nil + case 1: + return bundledDatabase(secrets) + default: + url, err := p.ReadLine(ctx, "PostgreSQL 18 URL: ", "") + if err != nil { + return "", fmt.Errorf("setup: database url: %w", err) + } + if strings.TrimSpace(url) == "" { + // A blank answer keeps the existing URL, as it always has. + return existing, nil + } + return url, nil + } } - url, err := p.ReadLine(ctx, prompt, existing) + prompt := "PostgreSQL 18 URL (blank for the bundled database with a generated password): " + url, err := p.ReadLine(ctx, prompt, "") if err != nil { return "", fmt.Errorf("setup: database url: %w", err) } if strings.TrimSpace(url) != "" { return url, nil } + return bundledDatabase(secrets) +} + +// bundledDatabase switches to the bundled database: no network, reached +// through its Unix socket, with a generated password that goes only to the +// env file as PGPASSWORD, which pgx and Compose both read, so config.toml +// holds no secret. +func bundledDatabase(secrets SecretSink) (string, error) { pw := make([]byte, 24) if _, err := rand.Read(pw); err != nil { return "", fmt.Errorf("setup: generate database password: %w", err) diff --git a/internal/infrastructure/configuration/setup/setup_test.go b/internal/infrastructure/configuration/setup/setup_test.go new file mode 100644 index 000000000..aa8120eb0 --- /dev/null +++ b/internal/infrastructure/configuration/setup/setup_test.go @@ -0,0 +1,212 @@ +package setup + +import ( + "context" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/infrastructure/configuration" + "github.com/samcharles93/archie-core/internal/infrastructure/configuration/tomlwrite" +) + +// fakePrompter answers prompts from maps keyed by the exact prompt text and +// records what it was asked, so a test can pin both the answers and that the +// bundled database was actually offered. +type fakePrompter struct { + selectAnswers map[string]int + lineAnswers map[string]string + confirmAnswer bool + + selects []recordedSelect + lines []recordedLine +} + +type recordedSelect struct { + prompt string + options []string +} + +type recordedLine struct { + prompt string + defaultValue string +} + +func (f *fakePrompter) Select(_ context.Context, prompt string, options []string) (int, error) { + f.selects = append(f.selects, recordedSelect{prompt: prompt, options: options}) + if ans, ok := f.selectAnswers[prompt]; ok { + return ans, nil + } + return 0, nil +} + +func (f *fakePrompter) ReadLine(_ context.Context, prompt, defaultValue string) (string, error) { + f.lines = append(f.lines, recordedLine{prompt: prompt, defaultValue: defaultValue}) + if ans, ok := f.lineAnswers[prompt]; ok { + return ans, nil + } + return defaultValue, nil +} + +func (f *fakePrompter) ReadSecret(context.Context, string) (string, error) { return "", nil } + +func (f *fakePrompter) Confirm(context.Context, string, bool) (bool, error) { + return f.confirmAnswer, nil +} + +// fakeSink records Put calls by engine/key. +type fakeSink struct { + puts map[string]string +} + +func (s *fakeSink) Put(engine, key, value string) error { + if s.puts == nil { + s.puts = map[string]string{} + } + s.puts[engine+"/"+key] = value + return nil +} + +func (s *fakeSink) Commit() error { return nil } + +// databasePrompt is the re-run database choice; bundledChoice is the index of +// the bundled database option in that menu. +const ( + databasePrompt = "Database:" + bundledChoice = 1 + differentURL = 2 +) + +func bundledURL() string { + return "postgres://archie@/archie?host=" + configuration.DefaultPostgresSocketDir() +} + +// TestRunParamsDatabaseChoice pins the re-run database step at the setup API +// level: with an existing database_url the flow must offer the bundled +// database as an explicit choice, switching to it must generate PGPASSWORD +// into the sink, and keeping must leave the existing URL untouched. +func TestRunParamsDatabaseChoice(t *testing.T) { + const existing = "postgres://operator:secret@db.internal:5432/archie" + + tests := []struct { + name string + // existing is the prefilled database_url; empty means fresh install. + existing string + // param is Params.DatabaseURL (the -database-url flag). + param string + selectAnswers map[string]int + lineAnswers map[string]string + wantURL string + wantPassword bool + wantChoice bool // a database Select menu must be presented + }{ + { + name: "re-run keep existing is the default choice", + existing: existing, + selectAnswers: map[string]int{databasePrompt: 0}, + wantURL: existing, + wantChoice: true, + }, + { + name: "re-run switch to the bundled database", + existing: existing, + selectAnswers: map[string]int{databasePrompt: bundledChoice}, + wantURL: bundledURL(), + wantPassword: true, + wantChoice: true, + }, + { + name: "re-run enter a different URL", + existing: existing, + selectAnswers: map[string]int{databasePrompt: differentURL}, + lineAnswers: map[string]string{"PostgreSQL 18 URL: ": "postgres://other.internal/archie"}, + wantURL: "postgres://other.internal/archie", + wantChoice: true, + }, + { + name: "re-run blank answer on the different-URL prompt keeps existing", + existing: existing, + selectAnswers: map[string]int{databasePrompt: differentURL}, + lineAnswers: map[string]string{"PostgreSQL 18 URL: ": ""}, + wantURL: existing, + wantChoice: true, + }, + { + name: "fresh install blank answer means the bundled database", + existing: "", + lineAnswers: map[string]string{"PostgreSQL 18 URL (blank for the bundled database with a generated password): ": ""}, + wantURL: bundledURL(), + wantPassword: true, + wantChoice: false, + }, + { + name: "database-url flag wins without prompting", + existing: existing, + param: "postgres://flag.internal/archie", + wantURL: "postgres://flag.internal/archie", + wantChoice: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + p := &fakePrompter{ + selectAnswers: tt.selectAnswers, + lineAnswers: tt.lineAnswers, + confirmAnswer: false, + } + sink := &fakeSink{} + params := Params{ + DatabaseURL: tt.param, + BotUser: "archie-bot", + ForgeType: "none", + Provider: "ollama", + Model: "llama3", + } + edits, err := RunParams(context.Background(), p, nil, sink, ExistingValues{DatabaseURL: tt.existing}, params) + if err != nil { + t.Fatalf("RunParams: %v", err) + } + + var gotURL string + for _, e := range edits { + if e.Table == "" && e.Key == "database_url" { + gotURL = e.Value + } + } + if gotURL != tomlwrite.String(tt.wantURL) { + t.Errorf("database_url = %s, want %s", gotURL, tomlwrite.String(tt.wantURL)) + } + + password, hasPassword := sink.puts["env/PGPASSWORD"] + if hasPassword != tt.wantPassword { + t.Fatalf("PGPASSWORD stored = %v, want %v", hasPassword, tt.wantPassword) + } + if tt.wantPassword && len(password) != 48 { + t.Errorf("PGPASSWORD = %q, want a 48-character hex password", password) + } + + var offered []string + for _, sel := range p.selects { + if sel.prompt == databasePrompt { + offered = sel.options + } + } + if tt.wantChoice { + if offered == nil { + t.Fatalf("no database choice was presented on a re-run; prompts seen: %+v", p.selects) + } + bundled := false + for _, opt := range offered { + if strings.Contains(strings.ToLower(opt), "bundled") { + bundled = true + } + } + if !bundled { + t.Errorf("database choice options %v do not offer the bundled database", offered) + } + } else if offered != nil { + t.Errorf("database choice was presented (%v) where the flow should not ask", offered) + } + }) + } +}