diff --git a/cmd/bd/config.go b/cmd/bd/config.go index ebdfb6ed6..ca7e1971f 100644 --- a/cmd/bd/config.go +++ b/cmd/bd/config.go @@ -239,7 +239,7 @@ var configSetCmd = &cobra.Command{ if !validRoles[value] { return HandleError("invalid role %q (valid values: maintainer, contributor)", value) } - // bd config's own beads.role reads and writes ignore inherited Git + // bd config get/set/unset/set-many beads.role ignore inherited Git // routing, including GIT_CONFIG_GLOBAL, so the value lands in the // repository this command selected. beads.role is an authority // value and the reader it feeds treats a missing value as diff --git a/cmd/bd/doctor/gitignore.go b/cmd/bd/doctor/gitignore.go index ebafa5dc8..1dc6052e7 100644 --- a/cmd/bd/doctor/gitignore.go +++ b/cmd/bd/doctor/gitignore.go @@ -790,6 +790,8 @@ func EnsureProjectGitignore(repoPath string) error { return nil // All patterns already present } + // A fresh .gitignore must not start with a blank line; the separator only + // belongs between existing content and the appended block. lines := make([]string, 0, len(toAdd)+2) if len(content) > 0 { lines = append(lines, "") diff --git a/cmd/bd/doctor/gitignore_test.go b/cmd/bd/doctor/gitignore_test.go index e123d53c7..650863a6b 100644 --- a/cmd/bd/doctor/gitignore_test.go +++ b/cmd/bd/doctor/gitignore_test.go @@ -1924,6 +1924,36 @@ func TestEnsureProjectGitignore_CreatesFile(t *testing.T) { } } +func TestEnsureProjectGitignore_LeadingSeparatorOnlyAfterExistingContent(t *testing.T) { + for _, tc := range []struct { + name string + existing string + want string + }{ + {name: "fresh file", existing: "", want: ProjectGitignoreHeader + "\n"}, + {name: "existing content", existing: "build/\n", want: "build/\n\n" + ProjectGitignoreHeader + "\n"}, + } { + t.Run(tc.name, func(t *testing.T) { + t.Chdir(t.TempDir()) + if tc.existing != "" { + if err := os.WriteFile(".gitignore", []byte(tc.existing), 0o600); err != nil { + t.Fatal(err) + } + } + if err := EnsureProjectGitignore("."); err != nil { + t.Fatalf("EnsureProjectGitignore() error = %v", err) + } + content, err := os.ReadFile(".gitignore") + if err != nil { + t.Fatal(err) + } + if got := string(content); !strings.HasPrefix(got, tc.want) { + t.Errorf(".gitignore starts with %q, want prefix %q", got[:min(len(got), len(tc.want)+16)], tc.want) + } + }) + } +} + func TestEnsureProjectGitignore_AppendsToExisting(t *testing.T) { tmpDir := t.TempDir() oldDir, err := os.Getwd() diff --git a/cmd/bd/dolt.go b/cmd/bd/dolt.go index d4b28d05d..c7a3e4633 100644 --- a/cmd/bd/dolt.go +++ b/cmd/bd/dolt.go @@ -2375,6 +2375,13 @@ func extractSSHHost(url string) string { // Bare dial+close (no doltserver.ProbeSQLServer): SSH, not MySQL — there is // no handshake greeting to drain here. func testSSHConnectivity(host string) bool { + // #nosec G704 -- host is extractSSHHost(r.URL) over the remotes this repo's + // own store returns, i.e. operator-configured local state, not request data. + // The probe dials and immediately closes: nothing is sent and no response is + // read, so there is no forgeable request. gosec only reaches this call after + // this PR routed config discovery through env-derived paths; its taint + // analysis is not field-sensitive, so one env-derived path marks the whole + // store value tainted and every URL read back off it inherits that. conn, err := net.DialTimeout("tcp", net.JoinHostPort(host, "22"), 5*time.Second) if err != nil { return false @@ -2413,6 +2420,9 @@ func httpURLToTCPAddr(url string) string { // is no handshake greeting to drain here. func testHTTPConnectivity(url string) bool { addr := httpURLToTCPAddr(url) + // #nosec G704 -- same probe shape and same taint path as testSSHConnectivity + // above: url is a remote URL from this repo's own store, and the dial is + // closed without sending or reading anything. conn, err := net.DialTimeout("tcp", addr, 5*time.Second) if err != nil { return false diff --git a/cmd/bd/hooks.go b/cmd/bd/hooks.go index 5274f55ba..deed54e94 100644 --- a/cmd/bd/hooks.go +++ b/cmd/bd/hooks.go @@ -2036,6 +2036,14 @@ func hookSubprocessEnv(env []string) []string { // the pending index — where the staged deletion lives — so scrubbing it // here would make git fall back to the on-disk index and miss the // deletion. Reimplements gastownhall/beads#3838 (ckumar1). +// +// #nosec G702 -- no shell is involved: the binary is the literal "git" and +// every argument is its own argv element. The only variable argument is the +// export file's own path, and it sits after the "--" terminator, so git +// always reads it as a pathspec and never as an option. Annotated on the +// function rather than on the call so it stays correct however the body +// addresses that path. Mirrors the annotation on configureHooksPath in +// init_git_hooks.go. func isExportFileStagedForDeletion(fullPath string) bool { // The export file's directory is not guaranteed to exist — hookJSONLDir // can retarget into a worktree with no .beads yet, and a nested diff --git a/cmd/bd/hooks_worktree_test.go b/cmd/bd/hooks_worktree_test.go index f0e792e35..61617e124 100644 --- a/cmd/bd/hooks_worktree_test.go +++ b/cmd/bd/hooks_worktree_test.go @@ -373,6 +373,106 @@ func readInitHooksFile(t *testing.T, path string) []byte { return data } +func TestInitEmbeddedHooksSelectedTail(t *testing.T) { + for _, name := range []string{"missing", "skip", "nonrepo", "pure_jj", "quiet_pure_jj", "colocated", "bare", "config_lock", "quiet_config_lock"} { + t.Run(name, func(t *testing.T) { + selected, decoy, storage, common := newInitHooksFixture(t) + preserveInitRoleInputs(t, filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index")) + if name == "nonrepo" || strings.Contains(name, "pure_jj") || name == "bare" { + selected = t.TempDir() + } + if name == "bare" { + initExcludeGit(t, selected, "init", "--bare") + } + if strings.Contains(name, "pure_jj") || name == "colocated" { + require.NoError(t, os.Mkdir(filepath.Join(selected, ".jj"), 0755)) + } + if name == "colocated" { + initExcludeGit(t, selected, "config", "--local", "core.hooksPath", filepath.Join(common, "hooks")) + } + locked, quiet := strings.Contains(name, "config_lock"), strings.HasPrefix(name, "quiet") + if locked { + require.NoError(t, os.WriteFile(filepath.Join(common, "config.lock"), []byte("owned lock"), 0600)) + preserveInitRoleInputs(t, filepath.Join(common, "config")) + } + run := func() { runEmbeddedInitHooks(t.Context(), selected, storage, name == "skip", quiet) } + if locked { + stderr := captureStderr(t, run) + require.Equal(t, !quiet, strings.Contains(stderr, "Failed to install git hooks")) + require.Equal(t, !quiet, strings.Contains(stderr, "bd hooks install --beads")) + } else { + stdout := captureStdout(t, func() error { run(); return nil }) + require.Equal(t, name == "pure_jj", strings.Contains(stdout, "Jujutsu repository detected")) + } + destination := filepath.Join(storage, "hooks") + if name == "colocated" { + destination = filepath.Join(common, "hooks") + } + if name == "skip" || name == "nonrepo" || strings.Contains(name, "pure_jj") { + _, err := os.Stat(destination) + require.ErrorIs(t, err, os.ErrNotExist) + return + } + require.Contains(t, string(readInitHooksFile(t, filepath.Join(destination, "pre-commit"))), hookSectionBeginPrefix) + if !locked && name != "colocated" { + // A bare repository has no work tree to anchor, so it resolves + // through the work-tree-less hooks context (GH#6457) and is its own + // common directory. It installs like any other selected repository + // rather than degrading to a warning and no install at all. + configRoot := common + if name == "bare" { + configRoot = selected + } + got := initExcludeGit(t, selected, "config", "--file", filepath.Join(configRoot, "config"), "--get", "core.hooksPath") + require.Equal(t, filepath.Clean(destination), filepath.Clean(got)) + } + }) + } +} + +func TestInitEmbeddedHooksSelectedStatus(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("hook current-status checks require POSIX executable bits") + } + for _, name := range []string{"decoy_current", "target_current", "target_outdated"} { + t.Run(name, func(t *testing.T) { + selected, decoy, storage, common := newInitHooksFixture(t) + current := filepath.Join(decoy, ".git", "hooks") + configuredRepo := decoy + if name != "decoy_current" { + current = filepath.Join(common, "hooks") + configuredRepo = selected + } + initExcludeGit(t, configuredRepo, "config", "--local", "core.hooksPath", current) + require.NoError(t, os.MkdirAll(current, 0755)) + for _, hook := range managedHookNames { + content := "#!/bin/sh\n" + generateHookSection(hook) + if name == "target_outdated" { + content = "#!/bin/sh\n" + hookVersionPrefix + "0.0.0\n# bd (beads) " + hook + " hook\n" + } + require.NoError(t, os.WriteFile(filepath.Join(current, hook), []byte(content), 0755)) + } + require.True(t, hooksInstalledAt(current)) + require.Equal(t, name == "target_outdated", hookStatusesNeedUpdate(checkGitHooksAt(current))) + if name == "decoy_current" { + require.True(t, hooksInstalled() && !hooksNeedUpdate(), "inherited decoy hooks must be current") + } + preserveInitRoleInputs(t, filepath.Join(current, "pre-commit"), filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index")) + stdout := captureStdout(t, func() error { + runEmbeddedInitHooks(t.Context(), selected, storage, false, false) + return nil + }) + require.Equal(t, name == "target_outdated", strings.Contains(stdout, "Updating hooks to version")) + if name == "target_current" { + _, err := os.Stat(filepath.Join(storage, "hooks")) + require.ErrorIs(t, err, os.ErrNotExist) + } else { + require.Contains(t, string(readInitHooksFile(t, filepath.Join(storage, "hooks", "pre-commit"))), hookSectionBeginLine()) + } + }) + } +} + func preserveStandaloneHookInputs(t *testing.T, paths ...string) { t.Helper() beforeEnv := os.Environ() diff --git a/cmd/bd/init.go b/cmd/bd/init.go index 5064509d2..69a93e6fc 100644 --- a/cmd/bd/init.go +++ b/cmd/bd/init.go @@ -2051,41 +2051,7 @@ Non-interactive mode (--non-interactive or BD_NON_INTERACTIVE=1): } } - // Check if we're in a git repo and hooks aren't installed - // Install by default unless --skip-hooks is passed - // Hooks are installed to .beads/hooks/ (uses git config core.hooksPath) - // For jujutsu colocated repos, use simplified hooks (no staging needed) - hooksExist := hooksInstalled() - if !skipHooks && (!hooksExist || hooksNeedUpdate()) { - if hooksExist && !quiet { - fmt.Printf(" Updating hooks to version %s...\n", Version) - } - isJJ := git.IsJujutsuRepo() - isColocated := git.IsColocatedJJGit() - - if isJJ && !isColocated { - // Pure jujutsu repo (no git) - print alias instructions - if !quiet { - printJJAliasInstructions() - } - } else if isColocated { - // Colocated jj+git repo - use simplified hooks - if err := installJJHooks(); err != nil && !quiet { - fmt.Fprintf(os.Stderr, "\n%s Failed to install jj hooks: %v\n", ui.RenderWarn("⚠"), err) - fmt.Fprintf(os.Stderr, "You can try again with: %s\n\n", ui.RenderAccent("bd doctor --fix")) - } else if !quiet { - fmt.Printf(" Hooks installed (jujutsu mode - no staging)\n") - } - } else if isGitRepo() { - // Regular git repo - install hooks to .beads/hooks/ - if err := installHooksWithOptions(managedHookNames, false, false, false, true); err != nil && !quiet { - fmt.Fprintf(os.Stderr, "\n%s Failed to install git hooks to .beads/hooks/: %v\n", ui.RenderWarn("⚠"), err) - fmt.Fprintf(os.Stderr, "You can try again with: %s\n\n", ui.RenderAccent("bd hooks install --beads")) - } else if !quiet { - fmt.Printf(" Hooks installed to: .beads/hooks/\n") - } - } - } + runEmbeddedInitHooks(rootCtx, cwd, beadsDir, skipHooks, quiet) // Initialize version tracking: create .local_version file during bd init // instead of deferring it to the first bd command. diff --git a/cmd/bd/init_embedded_test.go b/cmd/bd/init_embedded_test.go index b2aa498a4..8b5e25235 100644 --- a/cmd/bd/init_embedded_test.go +++ b/cmd/bd/init_embedded_test.go @@ -22,8 +22,48 @@ import ( "github.com/steveyegge/beads/internal/storage/embeddeddolt" "github.com/steveyegge/beads/internal/storage/schema" "github.com/steveyegge/beads/internal/types" + "github.com/stretchr/testify/require" ) +func TestEmbeddedInitHooksRouting(t *testing.T) { + if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { + t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt init tests") + } + bd := buildEmbeddedBD(t) + target, decoy, home := newInitRoleFixture(t) + global := filepath.Join(home, ".gitconfig") + initRoleFixtureGit(t, target, "config", "--file", global, "user.name", "Hook Fixture") + initRoleFixtureGit(t, target, "config", "--file", global, "user.email", "hooks@example.invalid") + require.NoError(t, os.WriteFile(filepath.Join(decoy, "seed"), []byte("decoy\n"), 0600)) + initRoleFixtureGit(t, decoy, "add", "seed") + t.Setenv("GIT_DIR", filepath.Join(home, "missing.git")) + t.Setenv("GIT_WORK_TREE", decoy) + t.Setenv("GIT_INDEX_FILE", filepath.Join(decoy, ".git", "index")) + preserveInitRoleInputs(t, filepath.Join(decoy, ".git", "config"), filepath.Join(decoy, ".git", "index"), global) + storage := filepath.Join(home, "separate storage", ".beads") + require.NoError(t, os.MkdirAll(filepath.Dir(storage), 0750)) + cmd := exec.Command(bd, "init", "--prefix", "hookfixture", "--quiet", "--non-interactive", "--skip-agents", "--role", "maintainer") + env := bdEnv(home) + for _, key := range []string{"BEADS_DIR", "BEADS_DB", "BD_DB", "BD_DOLT_HOST", "BD_DOLT_PORT"} { + env = envWithout(env, key) + } + cmd.Dir, cmd.Env = target, append(env, "BEADS_DIR="+storage, "DOLT_ROOT_PATH="+home, "BD_DOLT_MODE=embedded", "BD_EVENTS_JOURNAL=false") + out, err := cmd.CombinedOutput() + require.NoError(t, err, "embedded hook init: %s", out) + cfg, err := configfile.Load(storage) + require.NoError(t, err) + require.NotNil(t, cfg) + require.Equal(t, configfile.DoltModeEmbedded, cfg.DoltMode) + info, err := os.Stat(filepath.Join(storage, "embeddeddolt", "hookfixture", ".dolt")) + require.NoError(t, err) + require.True(t, info.IsDir()) + for _, name := range managedHookNames { + require.Contains(t, string(readInitHooksFile(t, filepath.Join(storage, "hooks", name))), hookSectionBeginPrefix) + } + got := initRoleFixtureGit(t, target, "config", "--local", "--get", "core.hooksPath") + require.Equal(t, filepath.Clean(filepath.Join(storage, "hooks")), filepath.Clean(got)) +} + var ( embeddedBDOnce sync.Once embeddedBD string diff --git a/cmd/bd/init_git_hooks.go b/cmd/bd/init_git_hooks.go index 8e711b607..e74d654a1 100644 --- a/cmd/bd/init_git_hooks.go +++ b/cmd/bd/init_git_hooks.go @@ -1,6 +1,7 @@ package main import ( + "context" "fmt" "os" "os/exec" @@ -10,9 +11,58 @@ import ( "github.com/steveyegge/beads/internal/git" "github.com/steveyegge/beads/internal/gitenv" + "github.com/steveyegge/beads/internal/storage/domain" + domaingit "github.com/steveyegge/beads/internal/storage/domain/git" "github.com/steveyegge/beads/internal/ui" ) +// runEmbeddedInitHooks uses the project for Git and the captured storage for hooks. +func runEmbeddedInitHooks(ctx context.Context, workDir, beadsDir string, skip, quiet bool) { + if skip { + return + } + gitUC := domain.NewGitUseCase(workDir, domaingit.NewInitGitRepository(workDir)) + isColocated := gitUC.IsColocatedJJGit(ctx) + if gitUC.IsJujutsuRepo(ctx) && !isColocated { + if !quiet { + printJJAliasInstructions() + } + return + } + if !isColocated && !gitUC.IsGitRepo(ctx) { + return + } + hooks, err := resolveInitHooksContext(workDir, beadsDir) + if err != nil { + if !quiet { + fmt.Fprintf(os.Stderr, "\n%s Failed to resolve git hooks: %v\n", ui.RenderWarn("⚠"), err) + } + return + } + hooksExist := hooks.installed() + if hooksExist && !hooks.needsUpdate() { + return + } + if hooksExist && !quiet { + fmt.Printf(" Updating hooks to version %s...\n", Version) + } + if isColocated { + if err := installHooksWithContext(jjHookNames, false, false, false, false, hooks); err != nil && !quiet { + fmt.Fprintf(os.Stderr, "\n%s Failed to install jj hooks: %v\n", ui.RenderWarn("⚠"), err) + fmt.Fprintf(os.Stderr, "You can try again with: %s\n\n", ui.RenderAccent("bd doctor --fix")) + } else if !quiet { + fmt.Printf(" Hooks installed (jujutsu mode - no staging)\n") + } + } else { + if err := installHooksWithContext(managedHookNames, false, false, false, true, hooks); err != nil && !quiet { + fmt.Fprintf(os.Stderr, "\n%s Failed to install git hooks to .beads/hooks/: %v\n", ui.RenderWarn("⚠"), err) + fmt.Fprintf(os.Stderr, "You can try again with: %s\n\n", ui.RenderAccent("bd hooks install --beads")) + } else if !quiet { + fmt.Printf(" Hooks installed to: .beads/hooks/\n") + } + } +} + // preCommitFrameworkPattern matches pre-commit or prek framework hooks. // Uses same patterns as hookManagerPatterns in doctor/fix/hooks.go for consistency. // Includes all detection patterns: pre-commit run, prek run/hook-impl, config file refs, and pre-commit env vars. @@ -375,6 +425,11 @@ func (c *initHooksContext) needsUpdate() bool { } func (c *initHooksContext) configureHooksPath(hooksDir string) error { + // #nosec G702 -- no shell is involved: the binary is the literal "git" and + // every path is passed as its own argv element, so neither c.paths.CommonDir + // nor hooksDir can inject a command. Both reach here from the selected hooks + // context and are absolute, and this mirrors the pre-existing + // configureBeadsHooksPath in hooks.go. cmd := exec.Command("git", "--git-dir", c.paths.CommonDir, "config", "--local", "core.hooksPath", hooksDir) cmd.Dir, cmd.Env = c.workDir, c.env if output, err := cmd.CombinedOutput(); err != nil { diff --git a/cmd/bd/init_proxied_server.go b/cmd/bd/init_proxied_server.go index 2d101e51f..29161a5a4 100644 --- a/cmd/bd/init_proxied_server.go +++ b/cmd/bd/init_proxied_server.go @@ -5,7 +5,6 @@ import ( "encoding/json" "fmt" "os" - "os/exec" "path/filepath" "strings" "time" @@ -15,7 +14,6 @@ import ( "github.com/steveyegge/beads/internal/beads" "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/configfile" - "github.com/steveyegge/beads/internal/gitenv" "github.com/steveyegge/beads/internal/storage/domain" domaingit "github.com/steveyegge/beads/internal/storage/domain/git" "github.com/steveyegge/beads/internal/storage/fs" @@ -521,27 +519,21 @@ type runInitTailContext struct { gitUC domain.GitUseCase } -func (t runInitTailContext) isRoleGitRepo(ctx context.Context, fallback bool) bool { - // Isolated tail contexts without a selected path retain their supplied use case. - if t.workDir == "" { - return fallback - } - // Dropping discovery ceilings can select a containing parent repository, - // matching the role adapter's existing scrubbed reads and writes. - probe := exec.CommandContext(ctx, "git", "rev-parse", "--git-dir") - probe.Dir, probe.Env = t.workDir, gitenv.ScrubRouting(os.Environ()) - return probe.Run() == nil -} - func runInitProxiedServerTail(cmd *cobra.Command, ctx context.Context, in initProxiedServerInput, t runInitTailContext) error { gitUC := t.gitUC if t.workDir != "" { // Only the selected tail uses this scope; earlier bootstrap keeps its provider. + // NewInitGitRepository runs `git rev-parse --git-dir` with Dir=workDir and + // scrubbed routing, so dropping discovery ceilings can select a containing + // parent repository, matching the role adapter's scrubbed reads and writes. gitUC = domain.NewGitUseCase(t.workDir, domaingit.NewInitGitRepository(t.workDir)) } + // One probe answers both the role gate and the artifact gates: gitUC is the + // scrubbed selected-directory repository whenever workDir is set, and the + // supplied use case otherwise, so a separate role probe could only repeat it. isRepo := gitUC.IsGitRepo(ctx) - if t.isRoleGitRepo(ctx, isRepo) { + if isRepo { role := in.roleFlag if role == "" { role = "maintainer" diff --git a/cmd/bd/sync_git.go b/cmd/bd/sync_git.go index ee42fe8b4..f660b595a 100644 --- a/cmd/bd/sync_git.go +++ b/cmd/bd/sync_git.go @@ -121,6 +121,12 @@ func gitOriginHasDoltDataRefStatus() (bool, error) { func gitRemoteHasDoltDataRefStatus(remote string) (bool, error) { ctx, cancel := context.WithTimeout(context.Background(), gitDoltDataProbeTimeout) defer cancel() + // #nosec G702 -- no shell is involved: the binary is the literal "git" and + // the remote URL is its own argv element, so it cannot inject a command. + // The value is this repo's configured sync remote, local operator state + // rather than request data; gosec only reaches it because this PR routed + // config discovery through env-derived paths (see testSSHConnectivity in + // dolt.go for the same taint path). cmd := exec.CommandContext(ctx, "git", "ls-remote", gitRemoteURLForLsRemote(remote), "refs/dolt/data") cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0") output, err := cmd.Output() diff --git a/cmd/bd/worktree_cmd.go b/cmd/bd/worktree_cmd.go index d4b123f5e..37a3b6b12 100644 --- a/cmd/bd/worktree_cmd.go +++ b/cmd/bd/worktree_cmd.go @@ -718,11 +718,31 @@ func worktreeGitEnvKey(entry string) string { // internal/git/gitdir.go still honor inherited routing, so those planes can // still resolve a different repository than this one (bd-p4che). // -// The boundary removes inherited discovery *redirects*. It is not a floor: -// GIT_CEILING_DIRECTORIES is a routing key too, so dropping it also re-enables -// upward discovery, and a `bd worktree` command run outside a repository can -// then select a containing parent that an inherited ceiling would have hidden -// (init's role probe records the same trade-off). +// Unlike the child-process scrubs elsewhere in this package, ClearRouting +// unsets the variables on the bd process itself, so bd's own discovery — +// getGitContext, GetMainRepoRoot, FindBeadsDir and startup config discovery — +// runs under the cleared environment for the whole command. The boundary +// removes inherited discovery redirects, but it is not a floor: the +// discovery-scope controls go with the redirection ones, and they do not all +// move discovery the same way: +// +// - GIT_CEILING_DIRECTORIES is a stop, so clearing it widens the walk: a +// stale inherited ceiling can no longer hide the repository the command is +// standing in, but with no repository at or below the working directory the +// walk can now reach a containing parent that ceiling excluded (init's role +// probe records the same trade-off). +// - GIT_DISCOVERY_ACROSS_FILESYSTEM only ever permits — git stops at a +// filesystem boundary unless this is true — so clearing it narrows the +// walk: a repository reachable from the working directory only by crossing +// a mount point is no longer found by any bd worktree verb, and there is no +// opt-out. +// - ClearRouting matches GIT_CONFIG by prefix, so the redirecting members of +// the GIT_CONFIG* family — a custom GIT_CONFIG_GLOBAL or GIT_CONFIG_SYSTEM +// path, GIT_CONFIG_COUNT and its numbered key/value pairs — are dropped for +// the command's lifetime rather than for one child probe. The explicit +// suppression forms are the exception: ClearRouting keeps +// GIT_CONFIG_NOSYSTEM and the /dev/null spellings of GIT_CONFIG_GLOBAL and +// GIT_CONFIG_SYSTEM, which can blind a read but cannot redirect one. func clearWorktreeGitRoutingEnv(cmd *cobra.Command) error { if !hasWorktreeCommandAncestor(cmd) { return nil diff --git a/internal/config/git_routing_test.go b/internal/config/git_routing_test.go index e2b6fb59c..76960d5f8 100644 --- a/internal/config/git_routing_test.go +++ b/internal/config/git_routing_test.go @@ -127,6 +127,52 @@ func TestSecretGitTrackingIgnoresInheritedGitRouting(t *testing.T) { } }) } + + // The scrub alone narrows the probe to upward discovery from the config + // file's directory. A detached work tree — GIT_DIR plus GIT_WORK_TREE with + // no in-tree .git beside the config — is reachable only through the + // inherited context, so without the inherited fallback the guard reports + // "untracked" and writes the secret into a tracked file. + t.Run("legitimate routing", func(t *testing.T) { + gitDir := filepath.Join(t.TempDir(), "repo.git") + if err := os.MkdirAll(gitDir, 0o750); err != nil { + t.Fatal(err) + } + runConfigProbeGit(t, gitDir, "init", "--bare", "--quiet") + work := t.TempDir() + beadsDir := filepath.Join(work, ".beads") + if err := os.MkdirAll(beadsDir, 0o750); err != nil { + t.Fatal(err) + } + detachedTracked := filepath.Join(beadsDir, "config.yaml") + detachedUntracked := filepath.Join(beadsDir, "untracked.yaml") + for _, path := range []string{detachedTracked, detachedUntracked} { + if err := os.WriteFile(path, []byte("json: false\n"), 0o600); err != nil { + t.Fatal(err) + } + } + runConfigProbeGit(t, work, "--git-dir", gitDir, "--work-tree", work, "add", "--", detachedTracked) + + t.Setenv("GIT_DIR", gitDir) + t.Setenv("GIT_WORK_TREE", work) + // Guard the fixture: the scrubbed probe must not see this repository at + // all, or the fallback below would be satisfied by discovery instead. + if isGitTrackedWithEnv(detachedTracked, gitenv.ScrubRouting(os.Environ())) { + t.Fatal("scrubbed discovery reached the detached work tree; fixture cannot exercise the fallback") + } + if !isGitTracked(detachedTracked) { + t.Error("legitimate routing lost the tracked file; the secret guard would write into it") + } + if isGitTracked(detachedUntracked) { + t.Error("untracked file reported as tracked") + } + if err := checkSecretGitTracked(detachedTracked, "linear.api_key"); err == nil || !strings.Contains(err.Error(), "refusing to write secret key") { + t.Errorf("tracked secret refusal = %v", err) + } + if err := checkSecretGitTracked(detachedUntracked, "linear.api_key"); err != nil { + t.Errorf("untracked secret refused: %v", err) + } + }) } // A checkout reachable only through inherited Git routing is the case a diff --git a/internal/config/yaml_config.go b/internal/config/yaml_config.go index b19969463..78cc98cb0 100644 --- a/internal/config/yaml_config.go +++ b/internal/config/yaml_config.go @@ -193,18 +193,42 @@ func IsSecretKey(key string) bool { // named only by GIT_DIR/GIT_WORK_TREE — so the inherited context is consulted // before declaring the file untracked. Mirrors isGitTrackedFile in cmd/bd. func isGitTracked(path string) bool { - dir := filepath.Dir(path) inherited := os.Environ() - for _, env := range [][]string{gitenv.ScrubRouting(inherited), inherited} { + return isGitTrackedWithEnv(path, gitenv.ScrubRouting(inherited), inherited) +} + +// isGitTrackedWithEnv probes path under env, then under each fallback in +// order, stopping at the first that reports it as tracked. Callers pass the +// scrubbed environment as env so inherited routing cannot hide a tracked +// config file, and the inherited one as the fallback: that preserves bare work +// trees and trusted config, where the repository is reachable only through the +// inherited context. Either probe reporting the path as tracked is sufficient +// to refuse the write. This mirrors the hook guard in cmd/bd/hooks.go. +// +// The first environment is a separate parameter rather than part of the +// variadic so that a zero-probe call, which would fall through to "untracked" +// and write the secret, cannot be spelled. The tail stays variadic because a +// test needs to probe one environment alone; the twin's fixed (clean, +// inherited) arity cannot express that, since exec treats a nil Env as +// "inherit the current process" rather than as a disabled probe. +// +// Every probe failing counts as untracked, so the guard only blocks writes it +// can prove are unsafe. +func isGitTrackedWithEnv(path string, env []string, fallbacks ...[]string) bool { + dir := filepath.Dir(path) + for _, probe := range append([][]string{env}, fallbacks...) { cmd := exec.Command("git", "ls-files", "--error-unmatch", path) cmd.Dir = dir - cmd.Env = env + cmd.Env = probe cmd.Stdout = nil cmd.Stderr = nil err := cmd.Run() if err == nil { return true } + // Exit 1 is git's "repository reached, path is not tracked" answer and + // is final, so a later probe runs only when this one failed for a + // configuration reason (no reachable repository). if exit, ok := err.(*exec.ExitError); ok && exit.ExitCode() == 1 { return false } diff --git a/internal/git/gitdir.go b/internal/git/gitdir.go index f7464bfe7..1e82e14cf 100644 --- a/internal/git/gitdir.go +++ b/internal/git/gitdir.go @@ -156,7 +156,8 @@ func normalizeHooksWorkDir(workDir string) (string, error) { // // This is the explicit-context sibling of GetGitHooksDir. It returns a struct // instead of following this file's GetXFrom(startDir) convention because all -// four paths must come from one resolution of one directory. +// four paths must come from one resolution of one directory. The first in-repo +// caller is the selected-hook setup in cmd/bd/init_git_hooks.go (GH#6440). func ResolveHooksContext(workDir string, env []string) (HooksContext, error) { if workDir == "" { return HooksContext{}, fmt.Errorf("hooks context requires a working directory")