diff --git a/CHANGELOG.md b/CHANGELOG.md index 01a01d288..1adbbe135 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +### Fixed + +- Prevent phantom catalog entries by respecting existing `dolt_database` config in init and migrate paths ([#2051](https://github.com/steveyegge/beads/issues/2051)) +- Replace `information_schema` queries with `SHOW COLUMNS`/`SHOW TABLES` for phantom resilience +- Add phantom catalog detection to `bd doctor` +- Fix `bd doctor --server` crash on phantom entries (replace `INFORMATION_SCHEMA.SCHEMATA` with `SHOW DATABASES`) + ## [0.56.1] - 2026-02-23 ### Fixed diff --git a/cmd/bd/config_guard_test.go b/cmd/bd/config_guard_test.go new file mode 100644 index 000000000..be6671749 --- /dev/null +++ b/cmd/bd/config_guard_test.go @@ -0,0 +1,126 @@ +//go:build cgo + +package main + +import ( + "os" + "path/filepath" + "testing" + + "github.com/steveyegge/beads/internal/configfile" +) + +// TestConfigWinsOverConvention verifies SC-003: when metadata.json already +// has a non-empty dolt_database value, the init guard logic uses it instead +// of deriving beads_{prefix}. +func TestConfigWinsOverConvention(t *testing.T) { + tests := map[string]struct { + configJSON string + prefix string + wantDB string + }{ + "existing config wins over prefix": { + configJSON: `{"backend":"dolt","dolt_database":"custom_beads"}`, + prefix: "test", + wantDB: "custom_beads", + }, + "empty config falls through to prefix": { + configJSON: `{"backend":"dolt"}`, + prefix: "test", + wantDB: "beads_test", + }, + "no prefix uses default": { + configJSON: `{"backend":"dolt"}`, + prefix: "", + wantDB: "beads", + }, + "no config file falls through to prefix": { + configJSON: "", // don't create file + prefix: "myrig", + wantDB: "beads_myrig", + }, + "existing config with no prefix still wins": { + configJSON: `{"backend":"dolt","dolt_database":"acf_beads"}`, + prefix: "", + wantDB: "acf_beads", + }, + } + + for name, tt := range tests { + t.Run(name, func(t *testing.T) { + tmpDir := t.TempDir() + beadsDir := filepath.Join(tmpDir, ".beads") + if err := os.MkdirAll(beadsDir, 0755); err != nil { + t.Fatalf("failed to create beads dir: %v", err) + } + + // Write metadata.json if provided + if tt.configJSON != "" { + configPath := filepath.Join(beadsDir, "metadata.json") + if err := os.WriteFile(configPath, []byte(tt.configJSON), 0644); err != nil { + t.Fatalf("failed to write config: %v", err) + } + } + + // Simulate the guard logic from init.go:248-258 + dbName := "beads" + if tt.prefix != "" { + dbName = "beads_" + tt.prefix + } + // Guard: config wins over convention + if existingCfg, loadErr := configfile.Load(beadsDir); loadErr == nil && existingCfg != nil { + if existingCfg.DoltDatabase != "" { + dbName = existingCfg.DoltDatabase + } + } + + if dbName != tt.wantDB { + t.Errorf("dbName = %q, want %q", dbName, tt.wantDB) + } + }) + } +} + +// TestMetadataSavePreservesExistingDoltDatabase verifies FR-022: when +// metadata.json save path encounters an existing DoltDatabase value, +// it does not overwrite it with beads_{prefix}. +func TestMetadataSavePreservesExistingDoltDatabase(t *testing.T) { + tests := map[string]struct { + existingDB string + prefix string + wantDB string + }{ + "existing value preserved": { + existingDB: "custom_beads", + prefix: "test", + wantDB: "custom_beads", + }, + "empty value gets prefix": { + existingDB: "", + prefix: "test", + wantDB: "beads_test", + }, + "no prefix no overwrite": { + existingDB: "", + prefix: "", + wantDB: "", + }, + } + + for name, tt := range tests { + t.Run(name, func(t *testing.T) { + cfg := &configfile.Config{ + DoltDatabase: tt.existingDB, + } + + // Simulate the guard logic from init.go:361 + if tt.prefix != "" && cfg.DoltDatabase == "" { + cfg.DoltDatabase = "beads_" + tt.prefix + } + + if cfg.DoltDatabase != tt.wantDB { + t.Errorf("DoltDatabase = %q, want %q", cfg.DoltDatabase, tt.wantDB) + } + }) + } +} diff --git a/cmd/bd/init.go b/cmd/bd/init.go index 7befdf714..235739032 100644 --- a/cmd/bd/init.go +++ b/cmd/bd/init.go @@ -30,6 +30,10 @@ var initCmd = &cobra.Command{ Long: `Initialize bd in the current directory by creating a .beads/ directory and database file. Optionally specify a custom issue prefix. +Use --database to specify an existing server database name, overriding the +default prefix-based naming. This is useful when an external tool (e.g. gastown) +has already created the database. + With --stealth: configures per-repository git settings for invisible beads usage: • .git/info/exclude to prevent beads files from being committed • Claude Code settings with bd onboard instruction @@ -53,6 +57,14 @@ environment variable.`, serverHost, _ := cmd.Flags().GetString("server-host") serverPort, _ := cmd.Flags().GetInt("server-port") serverUser, _ := cmd.Flags().GetString("server-user") + database, _ := cmd.Flags().GetString("database") + + // Validate --database early, before any side effects + if database != "" { + if err := dolt.ValidateDatabaseName(database); err != nil { + FatalError("invalid database name %q: %v", database, err) + } + } // Dolt is the only supported backend backend := configfile.BackendDolt @@ -270,6 +282,12 @@ environment variable.`, } else { dbName = "beads" } + // --database flag overrides all prefix-based naming. This allows callers + // (e.g. gastown) to specify a pre-existing database name, preventing orphan + // database creation when the database was already created externally. + if database != "" { + dbName = database + } // Build config. Beads always uses dolt sql-server. // AutoStart is always enabled during init — we need a server to initialize the database. doltCfg := &dolt.Config{ @@ -366,10 +384,13 @@ environment variable.`, cfg.Database = "dolt" } - // Set prefix-based SQL database name to avoid cross-rig contamination (bd-u8rda). - // Only set if not already configured — overwriting a user-renamed database + // Set SQL database name. --database flag takes precedence over prefix-based + // naming to avoid cross-rig contamination (bd-u8rda). Only set prefix-based + // name if not already configured — overwriting a user-renamed database // creates phantom catalog entries that crash information_schema (GH#2051). - if cfg.DoltDatabase == "" && prefix != "" { + if database != "" { + cfg.DoltDatabase = database + } else if cfg.DoltDatabase == "" && prefix != "" { cfg.DoltDatabase = prefix } @@ -619,7 +640,7 @@ environment variable.`, } fmt.Printf(" Mode: %s\n", ui.RenderAccent("server")) fmt.Printf(" Server: %s\n", ui.RenderAccent(fmt.Sprintf("%s@%s:%d", user, host, port))) - fmt.Printf(" Database: %s\n", ui.RenderAccent(storagePath)) + fmt.Printf(" Database: %s\n", ui.RenderAccent(dbName)) fmt.Printf(" Issue prefix: %s\n", ui.RenderAccent(prefix)) fmt.Printf(" Issues will be named: %s\n\n", ui.RenderAccent(prefix+"- (e.g., "+prefix+"-a3f2dd)")) fmt.Printf("Run %s to get started.\n\n", ui.RenderAccent("bd quickstart")) @@ -667,6 +688,7 @@ func init() { initCmd.Flags().String("server-host", "", "Dolt server host (default: 127.0.0.1)") initCmd.Flags().Int("server-port", 0, "Dolt server port (default: 3307)") initCmd.Flags().String("server-user", "", "Dolt server MySQL user (default: root)") + initCmd.Flags().String("database", "", "Use existing server database name (overrides prefix-based naming)") rootCmd.AddCommand(initCmd) } diff --git a/cmd/bd/init_test.go b/cmd/bd/init_test.go index 5cf5d388c..547d16dd8 100644 --- a/cmd/bd/init_test.go +++ b/cmd/bd/init_test.go @@ -5,14 +5,17 @@ package main import ( "bytes" "context" + "fmt" "os" "os/exec" "path/filepath" "runtime" "strings" + "sync" "testing" "github.com/steveyegge/beads/internal/beads" + "github.com/steveyegge/beads/internal/configfile" "github.com/steveyegge/beads/internal/git" "github.com/steveyegge/beads/internal/storage/dolt" ) @@ -1511,3 +1514,224 @@ func TestInitDoltMetadataNoGit(t *testing.T) { t.Errorf("unexpected sqlite database created in dolt mode") } } + +// buildBDOnce builds the bd binary once for subprocess tests in this file. +// Uses sync.Once for efficiency when multiple tests need the binary. +var ( + initTestBD string + initTestBDOnce sync.Once + initTestBDErr error +) + +func buildBDForInitTests(t *testing.T) string { + t.Helper() + initTestBDOnce.Do(func() { + // Check if bd binary exists in repo root (../../bd from cmd/bd/) + bdBinary := "bd" + if runtime.GOOS == "windows" { + bdBinary = "bd.exe" + } + repoRoot := filepath.Join("..", "..") + existingBD := filepath.Join(repoRoot, bdBinary) + if _, err := os.Stat(existingBD); err == nil { + initTestBD, _ = filepath.Abs(existingBD) + return + } + // Fall back to building + tmpDir, err := os.MkdirTemp("", "bd-init-test-*") + if err != nil { + initTestBDErr = fmt.Errorf("failed to create temp dir: %w", err) + return + } + initTestBD = filepath.Join(tmpDir, bdBinary) + cmd := exec.Command("go", "build", "-o", initTestBD, ".") + if out, err := cmd.CombinedOutput(); err != nil { + initTestBDErr = fmt.Errorf("go build failed: %v\n%s", err, out) + } + }) + if initTestBDErr != nil { + t.Fatalf("Failed to build bd binary: %v", initTestBDErr) + } + return initTestBD +} + +// TestInitDatabaseFlag tests the --database flag for bd init. +// Uses subprocess execution because: +// - init manipulates extensive Cobra global state that's difficult to reset +// - FatalError calls os.Exit(1) for validation errors, which kills in-process tests +// +// Each subtest runs bd init in a temp directory and verifies metadata.json. +func TestInitDatabaseFlag(t *testing.T) { + skipIfNoDolt(t) + bd := buildBDForInitTests(t) + + t.Run("metadata_written", func(t *testing.T) { + tmpDir := t.TempDir() + + // Run init with --database to specify a pre-existing database name + cmd := exec.Command(bd, "init", "--database", "myapp_production", "--quiet") + cmd.Dir = tmpDir + cmd.Env = append(os.Environ(), "BEADS_NO_DAEMON=1") + out, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("bd init --database failed: %v\n%s", err, out) + } + + // Verify metadata.json contains the correct database name + beadsDir := filepath.Join(tmpDir, ".beads") + cfg, err := configfile.Load(beadsDir) + if err != nil { + t.Fatalf("Failed to load metadata.json: %v", err) + } + if cfg == nil { + t.Fatal("metadata.json not found") + } + + if cfg.DoltDatabase != "myapp_production" { + t.Errorf("Expected DoltDatabase %q, got %q", "myapp_production", cfg.DoltDatabase) + } + if cfg.DoltMode != configfile.DoltModeServer { + t.Errorf("Expected DoltMode %q, got %q", configfile.DoltModeServer, cfg.DoltMode) + } + }) + + t.Run("with_prefix", func(t *testing.T) { + tmpDir := t.TempDir() + + // Run init with both --database and --prefix + // --database should override prefix for DB name, but prefix still sets issue_prefix + cmd := exec.Command(bd, "init", "--database", "shared_db", "--prefix", "team-alpha", "--quiet") + cmd.Dir = tmpDir + cmd.Env = append(os.Environ(), "BEADS_NO_DAEMON=1") + out, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("bd init --database --prefix failed: %v\n%s", err, out) + } + + // Verify metadata.json + beadsDir := filepath.Join(tmpDir, ".beads") + cfg, err := configfile.Load(beadsDir) + if err != nil { + t.Fatalf("Failed to load metadata.json: %v", err) + } + if cfg == nil { + t.Fatal("metadata.json not found") + } + + // --database overrides the SQL database name + if cfg.DoltDatabase != "shared_db" { + t.Errorf("Expected DoltDatabase %q (from --database), got %q", "shared_db", cfg.DoltDatabase) + } + + // Verify the database was opened and issue_prefix was set + // by reopening the store and checking config + dbPath := filepath.Join(beadsDir, "dolt") + s, err := openExistingTestDB(t, dbPath) + if err != nil { + t.Fatalf("Failed to reopen database: %v", err) + } + defer s.Close() + + ctx := context.Background() + issuePrefix, err := s.GetConfig(ctx, "issue_prefix") + if err != nil { + t.Fatalf("Failed to get issue_prefix: %v", err) + } + if issuePrefix != "team-alpha" { + t.Errorf("Expected issue_prefix %q (from --prefix), got %q", "team-alpha", issuePrefix) + } + }) + + t.Run("server_config_in_metadata", func(t *testing.T) { + tmpDir := t.TempDir() + + // Run init with --database + cmd := exec.Command(bd, "init", "--database", "test_server_cfg", "--quiet") + cmd.Dir = tmpDir + cmd.Env = append(os.Environ(), "BEADS_NO_DAEMON=1") + out, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("bd init --database failed: %v\n%s", err, out) + } + + // Verify metadata.json has both dolt_database and dolt_mode: server + beadsDir := filepath.Join(tmpDir, ".beads") + cfg, err := configfile.Load(beadsDir) + if err != nil { + t.Fatalf("Failed to load metadata.json: %v", err) + } + if cfg == nil { + t.Fatal("metadata.json not found") + } + + if cfg.DoltDatabase != "test_server_cfg" { + t.Errorf("Expected DoltDatabase %q, got %q", "test_server_cfg", cfg.DoltDatabase) + } + if cfg.DoltMode != configfile.DoltModeServer { + t.Errorf("Expected DoltMode %q, got %q", configfile.DoltModeServer, cfg.DoltMode) + } + if cfg.Backend != configfile.BackendDolt { + t.Errorf("Expected Backend %q, got %q", configfile.BackendDolt, cfg.Backend) + } + }) + + t.Run("validation_invalid_name", func(t *testing.T) { + tmpDir := t.TempDir() + + // Run init with an invalid database name (contains semicolon = SQL injection) + cmd := exec.Command(bd, "init", "--database", "bad;name", "--quiet") + cmd.Dir = tmpDir + cmd.Env = append(os.Environ(), "BEADS_NO_DAEMON=1") + out, err := cmd.CombinedOutput() + if err == nil { + t.Fatal("Expected error for invalid database name, but command succeeded") + } + + outStr := string(out) + if !strings.Contains(outStr, "invalid database name") { + t.Errorf("Expected error to mention 'invalid database name', got: %s", outStr) + } + + // Verify no .beads directory was created (early validation prevents side effects) + beadsDir := filepath.Join(tmpDir, ".beads") + if _, err := os.Stat(beadsDir); err == nil { + t.Error(".beads directory should not be created when validation fails") + } + }) + + t.Run("validation_name_with_spaces", func(t *testing.T) { + tmpDir := t.TempDir() + + // Database name with spaces should fail validation + cmd := exec.Command(bd, "init", "--database", "my database", "--quiet") + cmd.Dir = tmpDir + cmd.Env = append(os.Environ(), "BEADS_NO_DAEMON=1") + out, err := cmd.CombinedOutput() + if err == nil { + t.Fatal("Expected error for database name with spaces, but command succeeded") + } + + outStr := string(out) + if !strings.Contains(outStr, "invalid database name") { + t.Errorf("Expected error to mention 'invalid database name', got: %s", outStr) + } + }) + + t.Run("validation_name_with_backtick", func(t *testing.T) { + tmpDir := t.TempDir() + + // Database name with backtick injection should fail validation + cmd := exec.Command(bd, "init", "--database", "db`; DROP DATABASE x; --", "--quiet") + cmd.Dir = tmpDir + cmd.Env = append(os.Environ(), "BEADS_NO_DAEMON=1") + out, err := cmd.CombinedOutput() + if err == nil { + t.Fatal("Expected error for database name with backtick injection, but command succeeded") + } + + outStr := string(out) + if !strings.Contains(outStr, "invalid database name") { + t.Errorf("Expected error to mention 'invalid database name', got: %s", outStr) + } + }) +} diff --git a/examples/bd-example-extension-go/go.mod b/examples/bd-example-extension-go/go.mod index f3ac332d4..ca9469e14 100644 --- a/examples/bd-example-extension-go/go.mod +++ b/examples/bd-example-extension-go/go.mod @@ -1,6 +1,6 @@ module bd-example-extension-go -go 1.24.0 +go 1.25.6 require github.com/steveyegge/beads v0.0.0-00010101000000-000000000000 @@ -11,7 +11,7 @@ require ( github.com/ncruces/go-strftime v0.1.9 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect - golang.org/x/sys v0.34.0 // indirect + golang.org/x/sys v0.41.0 // indirect modernc.org/libc v1.66.3 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect diff --git a/examples/bd-example-extension-go/go.sum b/examples/bd-example-extension-go/go.sum index aac187a8f..c26f8e2d1 100644 --- a/examples/bd-example-extension-go/go.sum +++ b/examples/bd-example-extension-go/go.sum @@ -19,6 +19,7 @@ golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA= golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo= golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg= modernc.org/cc/v4 v4.26.2 h1:991HMkLjJzYBIfha6ECZdjrIYz2/1ayr+FL8GN+CNzM= diff --git a/examples/library-usage/go.mod b/examples/library-usage/go.mod index 8d5af11ca..9c404a13f 100644 --- a/examples/library-usage/go.mod +++ b/examples/library-usage/go.mod @@ -1,6 +1,6 @@ module example.com/beads-library-demo -go 1.24.0 +go 1.25.6 require github.com/steveyegge/beads v0.0.0 @@ -11,7 +11,7 @@ require ( github.com/ncruces/go-strftime v0.1.9 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect - golang.org/x/sys v0.36.0 // indirect + golang.org/x/sys v0.41.0 // indirect modernc.org/libc v1.66.3 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect diff --git a/examples/library-usage/go.sum b/examples/library-usage/go.sum index 9c83a22ff..2eee93ee4 100644 --- a/examples/library-usage/go.sum +++ b/examples/library-usage/go.sum @@ -19,6 +19,7 @@ golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k= golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE= golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w= modernc.org/cc/v4 v4.26.2 h1:991HMkLjJzYBIfha6ECZdjrIYz2/1ayr+FL8GN+CNzM= diff --git a/internal/storage/dolt/dolt_test.go b/internal/storage/dolt/dolt_test.go index 9493cdbd1..abe0a79fb 100644 --- a/internal/storage/dolt/dolt_test.go +++ b/internal/storage/dolt/dolt_test.go @@ -1544,9 +1544,9 @@ func TestValidateDatabaseName(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - err := validateDatabaseName(tt.dbName) + err := ValidateDatabaseName(tt.dbName) if (err != nil) != tt.wantErr { - t.Errorf("validateDatabaseName(%q) error = %v, wantErr %v", tt.dbName, err, tt.wantErr) + t.Errorf("ValidateDatabaseName(%q) error = %v, wantErr %v", tt.dbName, err, tt.wantErr) } }) } diff --git a/internal/storage/dolt/history.go b/internal/storage/dolt/history.go index 511c9e221..b3a2149e0 100644 --- a/internal/storage/dolt/history.go +++ b/internal/storage/dolt/history.go @@ -34,9 +34,9 @@ func validateRef(ref string) error { return nil } -// validateDatabaseName checks if a database name is safe to use in queries. +// ValidateDatabaseName checks if a database name is safe to use in queries. // Prevents SQL injection via backtick escaping in CREATE DATABASE statements. -func validateDatabaseName(name string) error { +func ValidateDatabaseName(name string) error { if name == "" { return fmt.Errorf("database name cannot be empty") } diff --git a/internal/storage/dolt/store.go b/internal/storage/dolt/store.go index eb11815b9..13ce133b0 100644 --- a/internal/storage/dolt/store.go +++ b/internal/storage/dolt/store.go @@ -633,11 +633,11 @@ func openServerConnection(ctx context.Context, cfg *Config) (*sql.DB, string, er defer func() { _ = initDB.Close() }() // Validate database name to prevent SQL injection via backtick escaping - if err := validateDatabaseName(cfg.Database); err != nil { + if err := ValidateDatabaseName(cfg.Database); err != nil { _ = db.Close() return nil, "", fmt.Errorf("invalid database name %q: %w", cfg.Database, err) } - _, err = initDB.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s`", cfg.Database)) //nolint:gosec // G201: cfg.Database validated by validateDatabaseName above + _, err = initDB.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s`", cfg.Database)) //nolint:gosec // G201: cfg.Database validated by ValidateDatabaseName above if err != nil { // Dolt may return error 1007 even with IF NOT EXISTS - ignore if database already exists errLower := strings.ToLower(err.Error())