Fix: bd bootstrap can also silently create an empty server-mode database (#6503)

* test(feat): red — Fix: bd bootstrap can also silently create an empty server-mode database (same root cause as be-5up5) (refs be-cy41)

* feat: green — Fix: bd bootstrap can also silently create an empty server-mode database (same root cause as be-5up5) (refs be-cy41)

* chore: release gate PASS for be-44rad-bootstrap-missing-server-db

* fix(bootstrap): unverifiable server probe is unknown, not existing (review of #6503)

Addresses the three MAJOR points from bee-ghosttrack's review at 49fc8fb5.

MAJOR 1 — a fresh clone whose server is unreachable no longer ends in
"nothing to do". The Err arm in existingBootstrapDBPlan now requires
hasLocalShadowDir: a populated shadow directory is local evidence the
database really does live here, so a down server means "live DB we cannot
see". Without that evidence the identical error describes a fresh clone
ahead of its first sync, which must stay eligible for sync.remote,
refs/dolt/data, .beads/backup/ and issues.jsonl. An unverifiable probe is
UNKNOWN, never "exists".

MAJOR 2 — probeBootstrapServerDB takes retryTransient, passed as
hasLocalShadowDir. The 10/20/40s transient-restart budget was written for a
database known to exist locally that vanishes across a managed restart; a
fresh clone is not watching a database disappear, so it pays one round-trip
instead of 70s.

MAJOR 3 — the refusal moves to plan time. refuseServerModeInitPlan runs in
detectBootstrapAction, so Action="refuse" reaches --dry-run and --json,
printBootstrapPlan never advertises "will create fresh database" for a plan
that cannot run, and executeBootstrapPlan returns the refusal before
confirmPrompt. The plan-time probe result is threaded through the new
serverDBProbe rather than re-dialed. The executeInitAction guard stays as
belt-and-braces for callers that bypass detectBootstrapAction, but probes
once with retryTransient=false.

Landed as one commit rather than three: MAJOR 1 without MAJOR 3 is exactly
the hole the review names — with the Err arm falling through and no
plan-time refusal, an unreachable server reaches CreateIfMissing: true.
Splitting them would publish that state as an intermediate commit.

MINOR 4 — citations now point at PR #5791 as open and unmerged instead of
presenting be-5up5 / initGuardMissingServerDBMessage as landed on main.

Tests (all new, cmd/bd/bootstrap_test.go):
  TestDetectBootstrapAction_FreshCloneUnreachableServerStillSyncs
  TestDetectBootstrapAction_FreshCloneReachableAbsentSkipsTransientBackoff
  TestDetectBootstrapAction_ShadowDirUnreachableServerStillReportsNone
  TestDetectBootstrapAction_ExistingProjectMissingServerDBRefusesAtPlanTime
  TestExecuteBootstrapPlan_RefuseErrsWithoutPrompting

The first two are the review's two probes, adjusted to the fix and renamed
into the file's existing convention; the third pins the shadow-dir case the
review flagged as main's correct behavior.

refs be-ms3ev, be-cy41

* chore: remove leaked internal release-gate doc from PR branch

  release-gates/be-44rad-bootstrap-missing-server-db-gate.md

Tracked our internal gc-management/beads-rig release-gate checklist and
should never have been committed to this upstream branch -- it's process
residue from our deploy tooling, not part of the change itself.

Per maintainer bee-ghosttrack's request during review of PR #6571. The
root cause (our deploy tooling auto-committing this file) is already fixed
as of gm-qatxl1; this branch predates that fix, so this commit is cleanup
only -- no other content on this branch is touched.

Ref: be-lk7o3

* fix(bootstrap): don't let a server-side name match mask sync.remote recovery

Maintainer review fixes for #6503. The PR unlocked the server-mode existence
probe for workspaces carrying a ProjectID, which fixed the negative arm (a
fresh clone behind a dead server stays eligible for recovery) but also
widened the POSITIVE arm, which no test covered.

MAJOR — widened Exists arm masks recovery. A shadow-dir-less workspace now
reaches the probe, and a reachable server merely holding a database of the
configured NAME settled the plan as Action="none"/HasExisting=true, so a
configured sync.remote was never consulted. Nothing checks that the server's
database is this project's, and at the base commit such a workspace never
probed at all and always fell through to sync.remote. The pre-existing guard
against exactly this masking defers only when .beads/ is absent — but
.beads/metadata.json is committed and is the very file supplying the
ProjectID that unlocks the probe, so it is true for the common clone shape.
A stale same-named database, including one left by the bug this PR fixes,
therefore suppressed the recovery clone.

Fix: thread the local-evidence signal out of the probe (serverDBProbe.
LocalEvidence) and defer an Exists verdict reached on the name alone through
the existing deferredExistingPlan path. sync.remote / refs/dolt/data / local
files get their turn and the name match survives as the fallback verdict, so
the PR's own "no local shadow dir still live-checks existing" behavior is
preserved where nothing else matches.

Also, non-gating:

- Set Blocked for Action=="refuse". The Blocked field documents the file's
  compatibility rule ("blocked" is what scripts switch on), and a refusal was
  the one no-database outcome reporting "blocked" absent. No exit code
  changes: a real run reaches executeBootstrapPlan and errors, and --dry-run
  is contractually exit 0 either way. Clearing SyncRemote on Blocked plans
  keeps that field's own "empty on a Blocked plan" contract true, since a
  refusal can be reached with a forge remote already recorded.
- Rewrite the Blocked rationale comment and the long-help bullet, which still
  promised unconditional creation. Only cmd/bd/bootstrap.go changes:
  docs/CLI_REFERENCE.md and docs/cli-reference/ are generated from the release
  tag pinned in docs/cli-docs.pin, so hand-mirroring the bullet there is
  permanent drift against its own regeneration (and forfeits
  check-cli-docs-drift.sh's inherited-drift pass, which requires the PR to
  leave those files untouched). The published text lands at the next pin bump.
- Scope the "local evidence" claim to locally-managed server mode: in shared
  server mode the shadow dir is ~/.beads/shared-server/dolt/, one directory
  for every database on the machine. The behavior is pre-existing on main;
  only the PR's new prose overstated it, so the comment is corrected rather
  than the check narrowed.
- Reword the refusal's recovery block so every route is followable from the
  refused state: bd backup restore is Dolt-native and needs an initialized
  database, so it silently routed the operator back through bd init — the
  unguarded door this refusal exists to keep shut.
- Cover the refuse plan's machine-readable surface (Blocked, marshalled JSON,
  no ANSI, no sync_remote) and printBootstrapPlan's refuse arm, which no test
  reached. Each new assertion was mutation-proved against the code it pins.
- Pin the other half of the new settle gate: an Exists verdict backed by a
  populated local shadow directory must still settle immediately, because
  deferring it re-clones over a database that already exists (GH#5037's
  Error 1007). Only the Err arm of that gate was covered, so a regression
  narrowed to Exists verdicts stayed green suite-wide; it now fails while the
  three incumbent shadow-dir tests still pass.

- Document why printBootstrapPlan's refuse arm prints to stdout while the
  "none"+Blocked arm prints to stderr. Both review lanes read the asymmetry as
  a possible oversight, and it is now test-pinned via captureStdout. Comment
  only: moving the arm to stderr would carry the one-line Reason off stdout,
  where that pin deliberately guarantees it, and a real refuse run already
  exits non-zero through executeBootstrapPlan, so this is not the #5743
  false-success class the stderr sibling guards against.

---------

Co-authored-by: Julian Knutsen <julianknutsen@users.noreply.github.com>
This commit is contained in:
Jim Wordelman 2026-09-27 01:42:24 -07:00 • committed by GitHub
commit 1336d16354
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 872 additions and 62 deletions

View file

@ -29,6 +29,7 @@ import (
"github.com/steveyegge/beads/internal/storage/embeddeddolt"
"github.com/steveyegge/beads/internal/storage/schema"
"github.com/steveyegge/beads/internal/storage/versioncontrolops"
"github.com/steveyegge/beads/internal/ui"
"github.com/steveyegge/beads/internal/utils"
"golang.org/x/term"
)
@ -119,7 +120,9 @@ Bootstrap auto-detects the right action:
• If git origin has Dolt data (refs/dolt/data): clones from git and wires origin for future push/pull
• If .beads/backup/*.jsonl exists: restores from backup
• If .beads/issues.jsonl exists: imports from git-tracked JSONL
• If no database exists: creates a fresh one
• If no database exists: creates a fresh one — unless the workspace was already
initialized (metadata.json has a project_id) and its server-mode database is
missing, in which case bootstrap refuses rather than strand the existing data
• If database already exists: validates and reports status
If sync.remote points at a git repository, bootstrap verifies refs/dolt/data
@ -294,7 +297,7 @@ func applyBootstrapMetadataRepair(beadsDir string, cfg *configfile.Config, apply
// BootstrapPlan describes what bootstrap will do.
type BootstrapPlan struct {
Action string `json:"action"` // "sync", "restore", "jsonl-import", "init", "none"
Action string `json:"action"` // "sync", "restore", "jsonl-import", "init", "none", "refuse"
Reason string `json:"reason"` // Human-readable explanation
BeadsDir string `json:"beads_dir"`
Database string `json:"database"`
@ -315,14 +318,28 @@ type BootstrapPlan struct {
// Blocked marks a plan that took no action and found no database. It is
// derived in detectBootstrapAction from Action+HasExisting, never set by a
// detection branch, and it is the single discriminator the exit code and
// the printed output both switch on. Additive on purpose: JSON consumers
// switch on "action", so a new action value would break them, while
// "none" + "blocked" + a non-zero exit code is backwards compatible.
// the printed output both switch on.
//
// "blocked" is the stable, script-facing signal and must be set for EVERY
// no-database outcome, so a consumer that only understands "none" is never
// told a run succeeded when it did not. A new "action" value is acceptable
// only for a state that must not be conflated with an existing one — the
// refusal is one, because "none" also covers the benign "a database
// already exists, nothing to do" — and only when it is accompanied by
// "blocked" and, outside --dry-run, a non-zero exit code. That is the
// contract to preserve when extending this enum: not "never add an action",
// but "never add an action that is the only signal of what happened".
Blocked bool `json:"blocked,omitempty"`
// BlockedRemote is the credential-free remote URL a Blocked plan could not
// verify, carried only so the diagnostic can name it.
BlockedRemote string `json:"blocked_remote,omitempty"`
HasExisting bool `json:"has_existing"`
// refusalDetail is the full operator-facing explanation for
// Action=="refuse". It is unexported so the ANSI styling it carries never
// leaks into --json output; JSON consumers read the plain-text one-liner
// in Reason instead.
refusalDetail string
}
// MarshalJSON renders the plan for `bd bootstrap --json` (and `--dry-run --json`)
@ -394,8 +411,24 @@ func requireBootstrapDoltBackend(cfg *configfile.Config, beadsDir string) error
// branch can leave a stale flag behind for a later branch to inherit.
func detectBootstrapAction(beadsDir string, cfg *configfile.Config) BootstrapPlan {
plan := detectBootstrapPlan(beadsDir, cfg)
plan.Blocked = plan.Action == "none" && !plan.HasExisting
if !plan.Blocked {
// "refuse" is a no-database outcome too, so it carries the same flag as
// "none": the action string says WHY bootstrap stopped, Blocked says THAT
// it stopped, and only the latter is the contract scripts switch on. This
// changes no exit code — RunE routes Action=="refuse" through
// executeBootstrapPlan, which errors, and --dry-run is contractually
// exit 0 either way (see bootstrapPlanOutcome) — it only stops a refusal
// from being the one bootstrap outcome that produced nothing yet reported
// "blocked" absent.
plan.Blocked = (plan.Action == "none" || plan.Action == "refuse") && !plan.HasExisting
if plan.Blocked {
// Keep SyncRemote's documented "empty on a Blocked plan" invariant
// true now that refusals are Blocked: a refusal can be reached with a
// forge SyncRemote already recorded (planConfiguredSyncRemote keeps it
// for the workspace it expected to create), and no Blocked plan wires
// up, clones from, or pushes to a remote. Inert for execution — every
// consumer of plan.SyncRemote runs on a sync/provisioning action.
plan.SyncRemote = ""
} else {
plan.BlockedRemote = ""
}
return plan
@ -436,8 +469,22 @@ func detectBootstrapPlan(beadsDir string, cfg *configfile.Config) BootstrapPlan
// probe-error branch, which then inherited HasExisting=true and printed the
// #5743 success tick again.
var deferredExistingPlan *BootstrapPlan
if dbAction, ok := existingBootstrapDBPlan(beadsDir, cfg, isServer, isSharedServer); ok {
if beadsDirExists || dbAction.Action != "none" {
dbAction, dbProbe, hasExistingDB := existingBootstrapDBPlan(beadsDir, cfg, isServer, isSharedServer)
// The same masking hazard applies to a server-side hit with no local
// evidence. Probing on ProjectID alone (see existingBootstrapDBPlan) means
// a shadow-dir-less workspace now reaches the Exists arm, where the only
// thing matched is the database NAME — nothing checks that the database on
// the server holds this project's data. Such a workspace previously
// skipped the probe entirely and always fell through to sync.remote, so
// settling here would let a stale or unrelated same-named database (including
// one left behind by the very bug this guard fixes) silently suppress the
// configured recovery path. Defer it exactly as a missing beadsDir is
// deferred: sync.remote / refs/dolt/data / local files get their turn, and
// the name match survives as the fallback verdict rather than becoming the
// verdict.
settledOnNameAlone := dbProbe.Ran && !dbProbe.LocalEvidence
if hasExistingDB {
if dbAction.Action != "none" || (beadsDirExists && !settledOnNameAlone) {
return dbAction
}
deferredExistingPlan = &dbAction
@ -484,6 +531,16 @@ func detectBootstrapPlan(beadsDir string, cfg *configfile.Config) BootstrapPlan
return plan
}
// Every recovery source has now been ruled out, so the fall-through below
// is a fresh, empty database. Decide the refusal HERE rather than inside
// executeInitAction: at plan time the answer reaches --dry-run and --json,
// printBootstrapPlan never advertises "will create fresh database" for a
// plan that cannot run, and confirmPrompt never asks the operator to
// approve one. The probe result is reused, so no second dial is needed.
if refusal, refused := refuseServerModeInitPlan(plan, cfg, isServer, isSharedServer, dbProbe); refused {
return refusal
}
// Fresh setup
plan.Action = "init"
plan.Reason = "No existing database, remote, or backup — will create fresh database"
@ -600,77 +657,176 @@ func localFileRecoveryPlan(plan BootstrapPlan, beadsDir string) (BootstrapPlan,
return BootstrapPlan{}, false
}
func existingBootstrapDBPlan(beadsDir string, cfg *configfile.Config, isServer, isSharedServer bool) (BootstrapPlan, bool) {
// refuseServerModeInitPlan turns a would-be fresh "init" into an explicit
// "refuse" plan when metadata.json proves this workspace was already
// initialized (ProjectID set) and the configured server-mode database could
// not be confirmed to exist. Creating one here would strand the existing issue
// data behind a new, empty database of the same name — the same root cause
// PR #5791 (open, not yet merged) addresses for bd init.
//
// Reaching the init fall-through already implies the database was not
// confirmed: existingBootstrapDBPlan returns a settled "none" plan whenever a
// probe found it. The probe is passed in rather than re-run so the refusal
// costs no extra round-trip and can quote why the check failed.
func refuseServerModeInitPlan(plan BootstrapPlan, cfg *configfile.Config, isServer, isSharedServer bool, probe serverDBProbe) (BootstrapPlan, bool) {
if !isServer || cfg.ProjectID == "" || !probe.Ran || probe.Exists {
return BootstrapPlan{}, false
}
host := cfg.GetDoltServerHost()
port := bootstrapServerPort(plan.BeadsDir, cfg, isSharedServer)
plan.Action = "refuse"
plan.Reason = bootstrapMissingServerDBSummary(plan.Database, host, port, probe.Err)
plan.refusalDetail = bootstrapMissingServerDBRefusal(plan.Database, host, port, probe.Err).Error()
return plan, true
}
// serverDBProbe records what a server-mode existence probe concluded, so the
// answer can be reused by the init fall-through instead of dialing the server
// a second time.
type serverDBProbe struct {
Ran bool // a probe was actually performed
Exists bool // the server confirmed the database exists
Err error // the probe could not reach or question the server
// LocalEvidence records whether anything on this machine ties this
// workspace to the database the probe asked about — in practice a
// populated local shadow directory. Without it the probe can only match
// on the database NAME, which is why the caller refuses to let an
// Exists verdict settle the plan ahead of the real recovery sources.
LocalEvidence bool
}
// existingBootstrapDBPlan reports whether an existing database already settles
// the bootstrap plan. The returned serverDBProbe carries the server-mode
// probe result — including on the false path, where the caller needs it to
// decide whether a fall-through to "init" is safe.
func existingBootstrapDBPlan(beadsDir string, cfg *configfile.Config, isServer, isSharedServer bool) (BootstrapPlan, serverDBProbe, bool) {
plan := BootstrapPlan{
BeadsDir: beadsDir,
Database: cfg.GetDoltDatabase(),
}
var dbPath string
if isServer {
dbPath = bootstrapServerDoltDir(beadsDir, cfg, isSharedServer)
} else {
dbPath = filepath.Join(beadsDir, "embeddeddolt")
// Scope note: this is per-workspace evidence in locally-managed server
// mode only. In shared-server mode bootstrapServerDoltDir resolves to
// doltserver.SharedDoltDir() — ~/.beads/shared-server/dolt/, one
// directory for EVERY shared-server database on the machine — so a
// fresh clone of project B reads a populated directory belonging to
// projects A and C. Everything below that calls this "local evidence"
// is therefore only sound for the locally-managed case; the
// shared-server granularity gap is pre-existing (main probes on the
// same signal) and is tracked separately rather than narrowed here,
// because keying on the database-named subdirectory would also change
// the locally-managed verdict for a data dir holding only .doltcfg.
dbPath := bootstrapServerDoltDir(beadsDir, cfg, isSharedServer)
hasLocalShadowDir := false
if info, err := os.Stat(dbPath); err == nil && info.IsDir() {
if entries, _ := os.ReadDir(dbPath); len(entries) > 0 {
hasLocalShadowDir = true
}
}
// A missing/empty local shadow directory normally means no database
// exists yet. But when metadata.json carries a ProjectID, this
// workspace was already initialized somewhere — most likely a fresh
// clone of an already-bootstrapped server-mode project, which has no
// local shadow directory by design. In that case, skip the local-dir
// short-circuit and live-probe the server directly rather than
// concluding "no database" from local-disk state alone.
if !hasLocalShadowDir && cfg.ProjectID == "" {
return BootstrapPlan{}, serverDBProbe{}, false
}
// Retry the reachable-but-absent window only when the local shadow
// directory says this database really does live here; see
// probeBootstrapServerDB for why a fresh clone must not pay 70s.
result := probeBootstrapServerDB(beadsDir, cfg, isSharedServer, hasLocalShadowDir)
probe := serverDBProbe{Ran: true, Exists: result.Exists, Err: result.Err, LocalEvidence: hasLocalShadowDir}
if result.Exists {
plan.HasExisting = true
plan.Action = "none"
plan.Reason = fmt.Sprintf("Database %s already exists on server at %s:%d", cfg.GetDoltDatabase(), cfg.GetDoltServerHost(), bootstrapServerPort(beadsDir, cfg, isSharedServer))
return plan, probe, true
}
// An unverifiable probe means UNKNOWN, never "exists". Answering
// "nothing to do" for it is only defensible with local evidence that
// the database lives here — a populated shadow directory (in
// locally-managed server mode; see the scope note above, it is not
// per-database in shared-server mode), where a down server is a live
// database we simply cannot see right now.
// Without that evidence the very same error describes a fresh clone
// whose server has not been started yet, which is the normal state of
// every locally-managed server-mode clone before its first sync. Such
// a clone must stay eligible for sync.remote, refs/dolt/data,
// .beads/backup/ and issues.jsonl, so report "not found" and let
// detectBootstrapAction consult them.
//
// When it does settle here, Blocked is still not hand-set:
// detectBootstrapAction derives it from Action=="none" && !HasExisting
// (HasExisting is false on this branch), keeping one owner for the flag
// and the #5743 non-zero exit rather than a false success tick.
if result.Err != nil && hasLocalShadowDir {
plan.Action = "none"
plan.Reason = fmt.Sprintf("Could not verify existing server database %s: %v", cfg.GetDoltDatabase(), result.Err)
return plan, probe, true
}
return BootstrapPlan{}, probe, false
}
dbPath := filepath.Join(beadsDir, "embeddeddolt")
if info, err := os.Stat(dbPath); err != nil || !info.IsDir() {
return BootstrapPlan{}, false
return BootstrapPlan{}, serverDBProbe{}, false
}
entries, _ := os.ReadDir(dbPath)
if len(entries) == 0 {
return BootstrapPlan{}, false
}
if isServer {
probeCfg := bootstrapServerProbeConfig{
host: cfg.GetDoltServerHost(),
port: bootstrapServerPort(beadsDir, cfg, isSharedServer),
user: cfg.GetDoltServerUser(),
pass: cfg.GetDoltServerPassword(),
database: cfg.GetDoltDatabase(),
tls: cfg.GetDoltServerTLS(),
}
// When the server is reachable but the DB appears absent, retry with
// exponential backoff before concluding the DB is genuinely missing.
// A managed Dolt restart completes in <30 s; three retries over 70 s
// cover all observed restart windows.
retryDelays := []time.Duration{10 * time.Second, 20 * time.Second, 40 * time.Second}
var result bootstrapServerDBCheck
for attempt := 0; ; attempt++ {
result = checkBootstrapServerDB(probeCfg)
if result.Err != nil || result.Exists || !result.Reachable {
break
}
if attempt >= len(retryDelays) {
break
}
fmt.Fprintf(os.Stderr, "Database %s not found on reachable server (attempt %d/%d), retrying in %v (possible transient restart)\n",
cfg.GetDoltDatabase(), attempt+1, len(retryDelays), retryDelays[attempt])
bootstrapRetryDelay(retryDelays[attempt])
}
if result.Err != nil {
// Same "declined, and no database was confirmed" class as a
// failed remote probe: report it and exit non-zero rather than
// printing a success tick (#5743). Blocked is not hand-set here —
// detectBootstrapAction derives it from Action=="none" && !HasExisting
// (HasExisting is false on this branch), keeping one owner for the flag.
plan.Action = "none"
plan.Reason = fmt.Sprintf("Could not verify existing server database %s: %v", cfg.GetDoltDatabase(), result.Err)
return plan, true
}
if result.Exists {
plan.HasExisting = true
plan.Action = "none"
plan.Reason = fmt.Sprintf("Database %s already exists on server at %s:%d", probeCfg.database, probeCfg.host, probeCfg.port)
return plan, true
}
return BootstrapPlan{}, false
return BootstrapPlan{}, serverDBProbe{}, false
}
plan.HasExisting = true
plan.Action = "none"
plan.Reason = "Database already exists at " + dbPath
return plan, true
return plan, serverDBProbe{}, true
}
// probeBootstrapServerDB checks whether the configured database exists on
// the Dolt server.
//
// When retryTransient is set, a reachable server that reports the database
// absent is retried with backoff, because a managed Dolt restart can
// transiently look like a missing database for up to ~30s. That budget costs
// 70s, so it is only worth paying when something independent says the
// database really is supposed to be here — in practice, a populated local
// shadow directory. A caller with no such evidence (a fresh clone, which by
// design has no shadow directory) is not watching a database disappear; it is
// simply ahead of its first sync, and must pass retryTransient=false so the
// answer costs one round-trip instead of 70s.
func probeBootstrapServerDB(beadsDir string, cfg *configfile.Config, isSharedServer, retryTransient bool) bootstrapServerDBCheck {
probeCfg := bootstrapServerProbeConfig{
host: cfg.GetDoltServerHost(),
port: bootstrapServerPort(beadsDir, cfg, isSharedServer),
user: cfg.GetDoltServerUser(),
pass: cfg.GetDoltServerPassword(),
database: cfg.GetDoltDatabase(),
tls: cfg.GetDoltServerTLS(),
}
if !retryTransient {
return checkBootstrapServerDB(probeCfg)
}
retryDelays := []time.Duration{10 * time.Second, 20 * time.Second, 40 * time.Second}
var result bootstrapServerDBCheck
for attempt := 0; ; attempt++ {
result = checkBootstrapServerDB(probeCfg)
if result.Err != nil || result.Exists || !result.Reachable {
break
}
if attempt >= len(retryDelays) {
break
}
fmt.Fprintf(os.Stderr, "Database %s not found on reachable server (attempt %d/%d), retrying in %v (possible transient restart)\n",
cfg.GetDoltDatabase(), attempt+1, len(retryDelays), retryDelays[attempt])
bootstrapRetryDelay(retryDelays[attempt])
}
return result
}
func bootstrapSharedServerMode(beadsDir string) bool {
@ -769,6 +925,21 @@ func printBootstrapPlan(plan BootstrapPlan) {
case "init":
fmt.Printf("Bootstrap plan: create fresh database\n")
fmt.Printf(" Database: %s\n", plan.Database)
case "refuse":
// Deliberately the one-line summary, not refusalDetail: the full
// explanation is the error executeBootstrapPlan returns, and printing
// both would render it twice.
//
// Deliberately stdout, unlike the "none"+Blocked arm above: this is the
// plan the command was asked to compute, and the one-line Reason rides
// with it (pinned by TestPrintBootstrapPlan_RefusePrintsSummaryNotDetail)
// so a stdout-only consumer is never left with a bare "refuse". It is
// not the #5743 false-success class either — a real refuse run exits
// non-zero through executeBootstrapPlan, so nothing reads this as
// success.
fmt.Printf("Bootstrap plan: refuse — will NOT create a database\n")
fmt.Printf(" Database: %s\n", plan.Database)
fmt.Printf(" Reason: %s\n", plan.Reason)
}
}
@ -792,6 +963,16 @@ func executeBootstrapPlan(plan BootstrapPlan, cfg *configfile.Config, nonInterac
if err := requireBootstrapDoltBackend(cfg, plan.BeadsDir); err != nil {
return err
}
// A refusal is a decision, not an action awaiting approval: surface it
// before confirmPrompt so the operator is never asked to approve it, and
// before the workspace gates below so no state is touched.
if plan.Action == "refuse" {
detail := plan.refusalDetail
if detail == "" {
detail = plan.Reason
}
return errors.New(detail)
}
if !confirmPrompt("Proceed?", nonInteractive) {
fmt.Fprintf(os.Stderr, "Aborted.\n")
return nil
@ -836,6 +1017,10 @@ func executeBootstrapPlan(plan BootstrapPlan, cfg *configfile.Config, nonInterac
}
func executeInitAction(ctx context.Context, plan BootstrapPlan, cfg *configfile.Config) error {
if err := refuseServerModeInitForExistingProject(plan, cfg); err != nil {
return err
}
prefix := inferPrefix(cfg)
dbName := cfg.GetDoltDatabase()
@ -884,6 +1069,86 @@ func wireBootstrapDoltRemote(ctx context.Context, s storage.DoltStorage, plan Bo
configureInitDoltRemote(ctx, s, doltRemoteURL(plan.SyncRemote), false)
}
// refuseServerModeInitForExistingProject is the belt-and-braces half of the
// guard whose real decision is made at plan time by refuseServerModeInitPlan.
// It re-checks, at the last moment before a database would actually be
// created, that this workspace is not an already-initialized project
// (ProjectID set) whose server-mode database cannot be confirmed to exist —
// covering any caller that reaches executeInitAction with a plan that did not
// come from detectBootstrapAction.
//
// It deliberately probes ONCE. The transient-restart backoff belongs to the
// plan-time probe; repeating it here would charge a second 70s to a decision
// that has already been made, and refusing is the safe direction anyway.
func refuseServerModeInitForExistingProject(plan BootstrapPlan, cfg *configfile.Config) error {
isSharedServer := bootstrapSharedServerMode(plan.BeadsDir)
if (!cfg.IsDoltServerMode() && !isSharedServer) || cfg.ProjectID == "" {
return nil
}
result := probeBootstrapServerDB(plan.BeadsDir, cfg, isSharedServer, false)
if result.Exists {
return nil
}
host := cfg.GetDoltServerHost()
port := bootstrapServerPort(plan.BeadsDir, cfg, isSharedServer)
return bootstrapMissingServerDBRefusal(cfg.GetDoltDatabase(), host, port, result.Err)
}
// bootstrapMissingServerDBSummary is the single-line, unstyled form of
// bootstrapMissingServerDBRefusal, used as BootstrapPlan.Reason so --json
// consumers get the explanation without ANSI escapes.
func bootstrapMissingServerDBSummary(dbName, host string, port int, probeErr error) string {
if probeErr != nil {
return fmt.Sprintf("Could not verify database %q on Dolt server at %s:%d (%v); workspace already initialized (project_id set) — refusing to create an empty database", dbName, host, port, probeErr)
}
return fmt.Sprintf("Database %q not found on server at %s:%d; workspace already initialized (project_id set) — refusing to create an empty database", dbName, host, port)
}
// bootstrapMissingServerDBRefusal builds the refusal error shown when bd
// bootstrap would otherwise create a fresh, empty server-mode database for a
// workspace that was already initialized elsewhere. Per GH#2363, this must
// never suggest a destructive "recreate" action as an actionable next step.
//
// The equivalent guard for `bd init` is proposed in PR #5791, which is open
// and not yet merged; this wording is kept deliberately close to it so the
// two can share one message once that lands.
func bootstrapMissingServerDBRefusal(dbName, host string, port int, probeErr error) error {
var b strings.Builder
if probeErr != nil {
fmt.Fprintf(&b, "\n%s Could not verify database %q on Dolt server at %s:%d: %v\n", ui.RenderWarn("⚠"), dbName, host, port, probeErr)
} else {
fmt.Fprintf(&b, "\n%s Database %q not found on server at %s:%d.\n", ui.RenderWarn("⚠"), dbName, host, port)
}
b.WriteString("This workspace was already initialized (metadata.json has a project_id from a prior\n")
b.WriteString("bd init/bootstrap), so this looks like a recovery situation, not a fresh clone.\n")
b.WriteString("\nbd bootstrap will NOT create an empty database here — that would strand any existing\n")
b.WriteString("issue data behind a new, empty database of the same name.\n")
b.WriteString("\nDiagnose with:\n")
b.WriteString(" bd doctor # check project health\n")
b.WriteString(" bd dolt status # inspect Dolt server state\n")
// Every route here must be followable FROM this state. `bd backup restore`
// alone is not: it restores a Dolt-native snapshot, not a `bd export`
// JSONL, and it requires an initialized database — so it silently routes
// the operator back through `bd init`, the very unguarded door this
// refusal exists to keep shut (PR #5791). Name that precondition instead
// of implying it, and lead with the routes that need no init at all.
b.WriteString("\nTo recover existing data, repopulate the database rather than creating fresh.\n")
b.WriteString("Routes that work from this state:\n")
b.WriteString(" bd dolt push # from another clone that still has the data\n")
b.WriteString(" bd config set sync.remote <url> # then re-run bd bootstrap to clone from it\n")
b.WriteString(" bd init && bd backup restore # ONLY with a Dolt-native backup snapshot:\n")
b.WriteString(" # bd backup restore needs an initialized\n")
b.WriteString(" # database and will not read a bd export JSONL\n")
b.WriteString("\nbd bootstrap only auto-restores .beads/backup/issues.jsonl, so a timestamped or\n")
b.WriteString("otherwise-named export under .beads/backup/ is still yours to import by hand.\n")
b.WriteString("\nAborting.")
return errors.New(b.String())
}
func executeRestoreAction(ctx context.Context, plan BootstrapPlan, cfg *configfile.Config) error {
prefix := inferPrefix(cfg)
dbName := cfg.GetDoltDatabase()

View file

@ -3,6 +3,9 @@
package main
import (
"context"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
@ -1839,3 +1842,545 @@ func TestFinalizeSyncedBootstrapSharedServerSetsServerMode(t *testing.T) {
t.Errorf("dolt_mode = %q, want %q — shared server should set server mode", loaded.GetDoltMode(), configfile.DoltModeServer)
}
}
// TestDetectBootstrapAction_NoLocalShadowDirStillLiveChecksExisting reproduces
// be-cy41 bug #1: existingBootstrapDBPlan returned BootstrapPlan{}, false (and
// detectBootstrapAction fell through toward Action="init") purely because no
// local shadow dolt-data directory existed — but in server mode that is the
// NORMAL state for a fresh clone of an already-initialized project. When
// metadata.json carries a ProjectID (proving this workspace was previously
// initialized), the server-side existence check must still run instead of
// being short-circuited by local filesystem state that a legitimate clone
// will never have (the same ambiguity PR #5791 addresses for bd init; that
// PR is open and not yet merged, so nothing it adds is referenced here).
func TestDetectBootstrapAction_NoLocalShadowDirStillLiveChecksExisting(t *testing.T) {
t.Setenv("BEADS_DOLT_DATA_DIR", "")
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
t.Setenv("BEADS_DOLT_SERVER_DATABASE", "")
t.Setenv("BEADS_DOLT_SERVER_HOST", "")
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
// Deliberately do NOT create doltDataDir at all — no local shadow
// directory, which is the normal state for a fresh clone of a
// pre-existing server-mode project.
doltDataDir := filepath.Join(tmpDir, "dolt-data")
oldWd, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
defer func() { _ = os.Chdir(oldWd) }()
if err := os.Chdir(tmpDir); err != nil {
t.Fatal(err)
}
cfg := configfile.DefaultConfig()
cfg.DoltMode = configfile.DoltModeServer
cfg.DoltDatabase = "project_exists"
cfg.DoltDataDir = doltDataDir
cfg.ProjectID = "proj-already-initialized-456"
t.Setenv("BEADS_DOLT_DATA_DIR", doltDataDir)
probed := false
origCheck := checkBootstrapServerDB
checkBootstrapServerDB = func(probeCfg bootstrapServerProbeConfig) bootstrapServerDBCheck {
probed = true
if probeCfg.database != "project_exists" {
t.Fatalf("unexpected dbName: %s", probeCfg.database)
}
return bootstrapServerDBCheck{Exists: true, Reachable: true}
}
defer func() { checkBootstrapServerDB = origCheck }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if !probed {
t.Fatal("checkBootstrapServerDB was never called — a local-shadow-directory gate short-circuited the real server-side existence check before it could run")
}
if plan.Action != "none" {
t.Fatalf("action = %q, want %q — bootstrap must not plan to recreate a database that already exists on the server just because no local shadow directory is present", plan.Action, "none")
}
if !plan.HasExisting {
t.Error("HasExisting = false, want true")
}
}
// TestExecuteInitAction_ServerModeExistingProjectMissingDBRefuses reproduces
// be-cy41 bug #2: executeInitAction is mode-blind — it always builds a
// dolt.Config with CreateIfMissing:true, AutoStart:true, and no server
// host/port/mode fields, so it silently creates an embedded-style database
// even for a server-mode workspace. When the workspace was already
// initialized (metadata.json has a project_id — the same signal PR #5791 uses) but
// the configured database is missing on the server, this silently strands any
// existing issue data behind a new, empty database of the same name.
// executeInitAction must refuse instead (the same root cause as PR #5791's
// proposed bd init guard, which is still open).
func TestExecuteInitAction_ServerModeExistingProjectMissingDBRefuses(t *testing.T) {
t.Setenv("BEADS_DOLT_DATA_DIR", "")
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
t.Setenv("BEADS_DOLT_SERVER_DATABASE", "")
t.Setenv("BEADS_DOLT_SERVER_HOST", "")
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
oldWd, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
defer func() { _ = os.Chdir(oldWd) }()
if err := os.Chdir(tmpDir); err != nil {
t.Fatal(err)
}
cfg := configfile.DefaultConfig()
cfg.DoltMode = configfile.DoltModeServer
cfg.DoltDatabase = "myproj"
cfg.ProjectID = "proj-existing-123"
origCheck := checkBootstrapServerDB
checkBootstrapServerDB = func(probeCfg bootstrapServerProbeConfig) bootstrapServerDBCheck {
return bootstrapServerDBCheck{Exists: false, Reachable: true}
}
defer func() { checkBootstrapServerDB = origCheck }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := BootstrapPlan{BeadsDir: beadsDir, Database: "myproj", Action: "init"}
err = executeInitAction(context.Background(), plan, cfg)
if err == nil {
t.Fatal("executeInitAction succeeded silently for an existing project with a missing server-mode database — want a refusal error")
}
if !strings.Contains(err.Error(), "myproj") {
t.Errorf("error %q does not mention the missing database name %q", err.Error(), "myproj")
}
if !strings.Contains(err.Error(), "will NOT create") && !strings.Contains(err.Error(), "not found on server") {
t.Errorf("error %q does not read as a refusal to auto-create", err.Error())
}
if _, statErr := os.Stat(filepath.Join(beadsDir, "embeddeddolt")); statErr == nil {
t.Error("executeInitAction created an embedded database as a side effect of a refused server-mode init — no database should have been created at all")
}
}
// freshServerModeCloneFixture builds the state a fresh clone of an
// already-bootstrapped server-mode project is actually in: .beads/ present
// with a configured sync.remote, metadata.json carrying a ProjectID, and no
// local shadow dolt-data directory (a clone never has one).
func freshServerModeCloneFixture(t *testing.T) (beadsDir string, cfg *configfile.Config) {
t.Helper()
snapshotBootstrapEnv(t)
config.ResetForTesting()
t.Cleanup(config.ResetForTesting)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
t.Setenv("BEADS_DOLT_SERVER_HOST", "")
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
tmpDir := t.TempDir()
beadsDir = filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(beadsDir, "config.yaml"), []byte("sync.remote: http://myserver:7007/mydb\n"), 0o644); err != nil {
t.Fatal(err)
}
t.Setenv("BEADS_DIR", beadsDir)
t.Setenv("BEADS_TEST_IGNORE_REPO_CONFIG", "1")
if err := config.Initialize(); err != nil {
t.Fatalf("config.Initialize failed: %v", err)
}
t.Chdir(tmpDir)
cfg = configfile.DefaultConfig()
cfg.DoltMode = configfile.DoltModeServer
cfg.DoltDatabase = "mydb"
cfg.DoltDataDir = filepath.Join(tmpDir, "dolt-data") // never created: fresh clone
cfg.ProjectID = "proj-fresh-clone-789"
t.Setenv("BEADS_DOLT_DATA_DIR", cfg.DoltDataDir)
return beadsDir, cfg
}
// TestDetectBootstrapAction_FreshCloneUnreachableServerStillSyncs pins the
// rule that an unverifiable probe means UNKNOWN, not "exists". A fresh clone
// of a locally-managed server-mode project has nothing running yet, so
// "connection refused" is its NORMAL state — it must not be converted into
// Action="none" ("nothing to do"), which would hide sync.remote,
// refs/dolt/data, .beads/backup/ and issues.jsonl behind a dead server.
func TestDetectBootstrapAction_FreshCloneUnreachableServerStillSyncs(t *testing.T) {
beadsDir, cfg := freshServerModeCloneFixture(t)
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
return bootstrapServerDBCheck{Reachable: false, Err: errors.New("dial tcp 127.0.0.1:3307: connect: connection refused")}
}
defer func() { checkBootstrapServerDB = orig }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "sync" {
t.Errorf("action = %q (reason %q), want sync: an unreachable server must not veto sync.remote recovery on a fresh clone", plan.Action, plan.Reason)
}
}
// TestDetectBootstrapAction_FreshCloneReachableAbsentSkipsTransientBackoff
// pins that the 10/20/40s transient-restart budget is only spent when a local
// shadow directory says the database really does live here. A fresh clone has
// no shadow directory by design, so "reachable but absent" is simply "not
// synced yet" and must cost one probe, not 70 seconds.
func TestDetectBootstrapAction_FreshCloneReachableAbsentSkipsTransientBackoff(t *testing.T) {
beadsDir, cfg := freshServerModeCloneFixture(t)
probes := 0
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
probes++
return bootstrapServerDBCheck{Reachable: true, Exists: false}
}
defer func() { checkBootstrapServerDB = orig }()
var slept time.Duration
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(d time.Duration) { slept += d }
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "sync" {
t.Errorf("action = %q, want sync", plan.Action)
}
if slept > 0 {
t.Errorf("fresh clone with no local DB paid %v of transient-restart backoff before sync", slept)
}
if probes != 1 {
t.Errorf("probes = %d, want exactly 1 — a clone with no local shadow dir has nothing to be transiently missing", probes)
}
}
// TestDetectBootstrapAction_ShadowDirUnreachableServerStillReportsNone pins
// the other side of that rule: with a populated local shadow directory there
// IS local evidence the database lives here, so an unreachable server is a
// live database we cannot see right now and "nothing to do" remains the
// correct answer. This is main's long-standing behavior and must survive the
// narrowing above.
func TestDetectBootstrapAction_ShadowDirUnreachableServerStillReportsNone(t *testing.T) {
beadsDir, cfg := freshServerModeCloneFixture(t)
if err := os.MkdirAll(filepath.Join(cfg.DoltDataDir, "mydb"), 0o750); err != nil {
t.Fatal(err)
}
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
return bootstrapServerDBCheck{Reachable: false, Err: errors.New("dial tcp 127.0.0.1:3307: connect: connection refused")}
}
defer func() { checkBootstrapServerDB = orig }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "none" {
t.Errorf("action = %q, want none — a populated shadow dir is local evidence the DB exists, so a down server means 'do nothing', not 'recover'", plan.Action)
}
if !strings.Contains(plan.Reason, "Could not verify") {
t.Errorf("reason = %q, want the 'Could not verify' wording", plan.Reason)
}
}
// TestDetectBootstrapAction_ExistingProjectMissingServerDBRefusesAtPlanTime
// pins that the refusal is a PLAN, not an execute-time surprise. With every
// recovery source absent the fall-through would be a fresh, empty database;
// because metadata.json proves the workspace was already initialized, the
// plan itself must say "refuse" so --dry-run and --json report it and
// printBootstrapPlan never advertises "will create fresh database".
func TestDetectBootstrapAction_ExistingProjectMissingServerDBRefusesAtPlanTime(t *testing.T) {
snapshotBootstrapEnv(t)
config.ResetForTesting()
t.Cleanup(config.ResetForTesting)
t.Setenv("BEADS_DOLT_SHARED_SERVER", "")
t.Setenv("BEADS_DOLT_SERVER_HOST", "")
t.Setenv("BEADS_DOLT_SERVER_PORT", "")
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
// No sync.remote, no backup, no issues.jsonl: nothing to recover from.
t.Setenv("BEADS_DIR", beadsDir)
t.Setenv("BEADS_TEST_IGNORE_REPO_CONFIG", "1")
if err := config.Initialize(); err != nil {
t.Fatalf("config.Initialize failed: %v", err)
}
t.Chdir(tmpDir)
cfg := configfile.DefaultConfig()
cfg.DoltMode = configfile.DoltModeServer
cfg.DoltDatabase = "mydb"
cfg.DoltDataDir = filepath.Join(tmpDir, "dolt-data")
cfg.ProjectID = "proj-already-initialized-456"
t.Setenv("BEADS_DOLT_DATA_DIR", cfg.DoltDataDir)
probes := 0
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
probes++
return bootstrapServerDBCheck{Reachable: true, Exists: false}
}
defer func() { checkBootstrapServerDB = orig }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "refuse" {
t.Fatalf("action = %q (reason %q), want refuse — an already-initialized workspace must never plan a fresh empty database", plan.Action, plan.Reason)
}
if probes != 1 {
t.Errorf("probes = %d, want exactly 1 — the refusal must reuse the plan-time probe, not dial again", probes)
}
if !strings.Contains(plan.Reason, "mydb") {
t.Errorf("reason = %q does not name the database", plan.Reason)
}
if strings.Contains(plan.Reason, "\x1b[") {
t.Errorf("reason = %q carries ANSI escapes; --json consumers must get plain text", plan.Reason)
}
if plan.refusalDetail == "" {
t.Error("refusalDetail is empty — the operator-facing explanation is lost")
}
if !strings.Contains(plan.refusalDetail, "will NOT create") {
t.Errorf("refusalDetail = %q does not read as a refusal", plan.refusalDetail)
}
// The machine-readable surface is what provisioning scripts consume, and
// "blocked" — not the action string — is the discriminator they are
// documented to switch on (see the BootstrapPlan.Blocked comment). A
// refusal produced no database, so it must carry the flag; otherwise it is
// the one no-database outcome a "blocked"-keyed consumer reads as success.
if !plan.Blocked {
t.Error("Blocked = false on a refuse plan — a run that produced no database must set the flag scripts key on")
}
raw, err := json.Marshal(plan)
if err != nil {
t.Fatalf("json.Marshal(plan): %v", err)
}
var decoded map[string]any
if err := json.Unmarshal(raw, &decoded); err != nil {
t.Fatalf("unmarshal plan JSON %s: %v", raw, err)
}
if decoded["action"] != "refuse" {
t.Errorf("json action = %v, want refuse", decoded["action"])
}
// "blocked" is omitempty, so a false flag does not render as false — the
// key vanishes entirely and the consumer cannot tell this run from a
// successful one.
if decoded["blocked"] != true {
t.Errorf("json blocked = %v, want true; full plan JSON: %s", decoded["blocked"], raw)
}
if strings.Contains(string(raw), "\x1b[") {
t.Errorf("plan JSON carries ANSI escapes, which --json consumers must never receive: %s", raw)
}
}
// TestDetectBootstrapAction_RefusePlanDropsUnverifiedSyncRemote pins that a
// refusal honours SyncRemote's documented "empty on a Blocked plan" contract.
// A forge sync.remote with no Dolt data yet is recorded on the plan for the
// workspace bootstrap expected to create (planConfiguredSyncRemote keeps it
// and returns done=false), and the refusal is downstream of that — so without
// explicit clearing the credential-bearing URL rides out in --json for a run
// that wired up nothing, cloned nothing and pushed nothing.
func TestDetectBootstrapAction_RefusePlanDropsUnverifiedSyncRemote(t *testing.T) {
beadsDir := newForgeSyncRemoteWorkspace(t, "https://github.com/org/repo.git")
// Forge repo reachable, but no refs/dolt/data yet: sync.remote is recorded
// and bootstrap keeps looking rather than cloning.
stubProbeGitRemoteDoltData(t, func(string) (bool, error) { return false, nil })
cfg := configfile.DefaultConfig()
cfg.DoltMode = configfile.DoltModeServer
cfg.DoltDatabase = "mydb"
// Never created: a fresh clone has no local shadow directory.
cfg.DoltDataDir = filepath.Join(filepath.Dir(beadsDir), "dolt-data")
cfg.ProjectID = "proj-already-initialized-456"
t.Setenv("BEADS_DOLT_DATA_DIR", cfg.DoltDataDir)
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
return bootstrapServerDBCheck{Reachable: true, Exists: false}
}
defer func() { checkBootstrapServerDB = orig }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "refuse" {
t.Fatalf("action = %q (reason %q), want refuse", plan.Action, plan.Reason)
}
if !plan.Blocked {
t.Fatal("Blocked = false on a refuse plan")
}
if plan.SyncRemote != "" {
t.Errorf("SyncRemote = %q on a Blocked plan, want empty — the refusal creates no workspace, so nothing may be cloned from or pushed to that remote", plan.SyncRemote)
}
raw, err := json.Marshal(plan)
if err != nil {
t.Fatalf("json.Marshal(plan): %v", err)
}
var decoded map[string]any
if err := json.Unmarshal(raw, &decoded); err != nil {
t.Fatalf("unmarshal plan JSON %s: %v", raw, err)
}
if got, ok := decoded["sync_remote"]; ok {
t.Errorf("plan JSON carries sync_remote = %v on a Blocked plan; full JSON: %s", got, raw)
}
}
// TestPrintBootstrapPlan_RefusePrintsSummaryNotDetail covers the refuse arm of
// printBootstrapPlan, which no test reached. The full explanation is the error
// executeBootstrapPlan returns, so printing refusalDetail here too would render
// it twice — a regression a future edit could reintroduce silently.
func TestPrintBootstrapPlan_RefusePrintsSummaryNotDetail(t *testing.T) {
plan := BootstrapPlan{
Action: "refuse",
Database: "mydb",
Reason: `Database "mydb" not found on server at 127.0.0.1:3307; workspace already initialized (project_id set) — refusing to create an empty database`,
// A marker no production string can produce, so a match is proof the
// detail field itself was printed rather than wording that overlaps.
refusalDetail: "REFUSAL-DETAIL-MARKER: bd bootstrap will NOT create an empty database here",
Blocked: true,
}
out := captureStdout(t, func() error {
printBootstrapPlan(plan)
return nil
})
if !strings.Contains(out, "refuse — will NOT create a database") {
t.Errorf("output does not announce the refusal:\n%s", out)
}
if !strings.Contains(out, plan.Reason) {
t.Errorf("output omits the one-line reason:\n%s", out)
}
if strings.Contains(out, "REFUSAL-DETAIL-MARKER") {
t.Errorf("printBootstrapPlan printed refusalDetail; executeBootstrapPlan already returns it, so the operator would read the whole explanation twice:\n%s", out)
}
}
// TestExecuteBootstrapPlan_RefuseErrsWithoutPrompting pins that a refuse plan
// never reaches confirmPrompt or the workspace gates: it is a decision, not an
// action awaiting approval. Before this, the refusal was discovered inside
// executeInitAction — i.e. after the operator had already answered "Proceed?"
// to a plan that said the opposite.
func TestExecuteBootstrapPlan_RefuseErrsWithoutPrompting(t *testing.T) {
snapshotBootstrapEnv(t)
config.ResetForTesting()
t.Cleanup(config.ResetForTesting)
tmpDir := t.TempDir()
beadsDir := filepath.Join(tmpDir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
cfg := configfile.DefaultConfig()
cfg.DoltMode = configfile.DoltModeServer
cfg.DoltDatabase = "mydb"
cfg.ProjectID = "proj-existing-123"
probes := 0
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
probes++
return bootstrapServerDBCheck{Reachable: true, Exists: false}
}
defer func() { checkBootstrapServerDB = orig }()
plan := BootstrapPlan{
BeadsDir: beadsDir,
Database: "mydb",
Action: "refuse",
Reason: "short summary",
refusalDetail: "long refusal: bd bootstrap will NOT create an empty database here",
}
// nonInteractive=false so a confirmPrompt would be reached if one ran.
err := executeBootstrapPlan(plan, cfg, false)
if err == nil {
t.Fatal("executeBootstrapPlan returned nil for a refuse plan — bootstrap would exit 0 having done nothing, hiding the refusal")
}
if !strings.Contains(err.Error(), "will NOT create") {
t.Errorf("error = %q, want the refusalDetail text", err.Error())
}
if probes != 0 {
t.Errorf("probes = %d, want 0 — the decision was already made at plan time", probes)
}
}
// TestDetectBootstrapAction_FreshCloneServerNameMatchStillSyncs pins the
// POSITIVE half of the widened probe. Unlocking the server-side existence
// check for ProjectID-bearing workspaces also unlocked its Exists==true arm,
// and a reachable server merely holding a database of the configured NAME is
// not proof that this workspace is bound to it — nothing checks project_id or
// content. Before the widening such a clone never probed at all and always
// fell through to sync.remote, so a stale or unrelated same-named database
// (including one left behind by the very bug this guard fixes) must not
// silently settle the plan as "nothing to do" and suppress the configured
// recovery clone. The name match survives only as the fallback verdict, which
// TestDetectBootstrapAction_NoLocalShadowDirStillLiveChecksExisting pins.
func TestDetectBootstrapAction_FreshCloneServerNameMatchStillSyncs(t *testing.T) {
beadsDir, cfg := freshServerModeCloneFixture(t)
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
return bootstrapServerDBCheck{Reachable: true, Exists: true}
}
defer func() { checkBootstrapServerDB = orig }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "sync" {
t.Errorf("action = %q (reason %q), want sync — a server-side name match with no local evidence binding this workspace to that database must not mask configured sync.remote recovery", plan.Action, plan.Reason)
}
}
// TestDetectBootstrapAction_ShadowDirServerNameMatchSettlesNone pins the other
// half of the same gate: a populated local shadow directory IS evidence this
// workspace is bound to the database the server confirmed, so the Exists
// verdict must settle the plan immediately instead of being deferred behind
// sync.remote. Deferring it would re-clone over a database that already exists
// — GH#5037's Error 1007, which the comment above the settle gate exists to
// prevent — and the fixture configures a sync.remote precisely so the
// assertion discriminates: without the local-evidence half of
// settledOnNameAlone, sync.remote wins and the action becomes "sync". The
// Err-arm twin is TestDetectBootstrapAction_ShadowDirUnreachableServerStillReportsNone;
// this is the Exists-arm one, which nothing covered.
func TestDetectBootstrapAction_ShadowDirServerNameMatchSettlesNone(t *testing.T) {
beadsDir, cfg := freshServerModeCloneFixture(t)
if err := os.MkdirAll(filepath.Join(cfg.DoltDataDir, "mydb"), 0o750); err != nil {
t.Fatal(err)
}
orig := checkBootstrapServerDB
checkBootstrapServerDB = func(bootstrapServerProbeConfig) bootstrapServerDBCheck {
return bootstrapServerDBCheck{Reachable: true, Exists: true}
}
defer func() { checkBootstrapServerDB = orig }()
origDelay := bootstrapRetryDelay
bootstrapRetryDelay = func(time.Duration) {}
defer func() { bootstrapRetryDelay = origDelay }()
plan := detectBootstrapAction(beadsDir, cfg)
if plan.Action != "none" {
t.Errorf("action = %q (reason %q), want none — with local evidence binding this workspace to the database the server reports, re-cloning it is GH#5037's Error 1007", plan.Action, plan.Reason)
}
if !plan.HasExisting {
t.Error("HasExisting = false on a confirmed server-side database with local evidence")
}
// Discriminates the Exists arm from the Err arm's "Could not verify"
// settle, which the same populated shadow directory also unlocks.
if !strings.Contains(plan.Reason, "already exists on server") {
t.Errorf("reason = %q, want the Exists-arm wording — a 'Could not verify' reason here means the probe result, not the local evidence, is what settled the plan", plan.Reason)
}
}