#7671 fences graph workspaces in cmd/bd: command admission, the store factories and the other CLI paths refuse one, and #7722 extends that fence to a .beads holding the graph-preview-format marker whatever its metadata says. But the public library opens (beads.OpenBestAvailable, OpenBestAvailableWith, OpenFromConfig, OpenGated) and the Dolt store's metadata-driven constructors (NewFromConfig, NewFromConfigWithOptions, NewFromConfigWithCLIOptions) still opened either kind of graph workspace as an Issue store and ran Issue schema migrations into the graph database (or, with no metadata beside the marker, created an Issue database inside the graph workspace). - Move the typed refusal into internal/configfile (UnsupportedWorkspaceFormatError with BeadsDir, GraphMode and FormatMarker; CheckWorkspaceFormat; GraphFormatMarkerFile; HasGraphFormatMarker) with byte-identical text and hints for both the graph_mode and the marker refusal, and move cmd/bd's discovery pre-checks there as LoadAndCheckWorkspaceFormat and CheckDiscoveredWorkspaceFormat (LoadForDiscovery, which never migrates a legacy config.json; unreadable metadata beside the marker is refused as the marker's format). cmd/bd's checkWorkspaceFormat, loadAndCheckWorkspaceFormat, hasGraphFormatMarker and checkDiscoveredWorkspaceFormat become thin delegates, so the CLI keeps its behaviour (exit 16 with the same hints) and every caller of them is unchanged; bootstrap's ancestor walk builds the configfile type. - Every public metadata-driven open runs CheckDiscoveredWorkspaceFormat as its first statement: before OpenGated takes its gates and before OpenBestAvailableWith's Load can migrate config.json. A refused open leaves the workspace byte-identical. The type is exported as beads.UnsupportedWorkspaceFormatError. - The Dolt constructors run CheckDiscoveredWorkspaceFormat before configfile.Load, so a graph workspace marked only by a legacy config.json, or by the marker beside stripped, missing or unparseable metadata, is refused before Load can migrate it into metadata.json (and drop graph_* keys this build does not know). requireDoltBackend re-checks the loaded config as a backstop, so they also refuse before resolving a server or writing a port file or Dolt root. Tests: configfile unit tests for both refusals (exact marker text and hint, graph_mode winning over the marker, unparseable metadata with and without the marker); the public opens and the three Dolt constructors against graph_mode workspaces and against marker-only, stripped (metadata.json and legacy config.json), server, explicit dependency and unparseable-metadata marker workspaces, each refused with the typed error and the workspace left unchanged. Agent-Signature: claude-code-claude-opus-5-5-unknown-reasoning on behalf of Julian Knutsen Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
108 lines
4.5 KiB
Go
108 lines
4.5 KiB
Go
//go:build cgo
|
|
|
|
package beads
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/steveyegge/beads/internal/configfile"
|
|
"github.com/steveyegge/beads/internal/storage/backends"
|
|
"github.com/steveyegge/beads/internal/storage/dolt"
|
|
"github.com/steveyegge/beads/internal/storage/embeddeddolt"
|
|
)
|
|
|
|
// OpenBestAvailable opens a beads database using the best available backend
|
|
// for the given .beads directory. It reads metadata.json to determine the
|
|
// configured mode:
|
|
//
|
|
// - Embedded Dolt (default): Opens via the CGo embedded Dolt engine.
|
|
// - Dolt server: Connects to a dolt sql-server via OpenFromConfig.
|
|
//
|
|
// The returned Storage must be closed when no longer needed.
|
|
//
|
|
// beadsDir is the path to the .beads directory.
|
|
//
|
|
// OpenBestAvailable is OpenBestAvailableWith with a zero OpenOptions; see that
|
|
// function for per-open injections into a registered backend.
|
|
func OpenBestAvailable(ctx context.Context, beadsDir string) (Storage, error) {
|
|
return OpenBestAvailableWith(ctx, beadsDir, OpenOptions{})
|
|
}
|
|
|
|
// OpenBestAvailableWith is OpenBestAvailable plus per-open injections
|
|
// (Credential, HTTPClient, UserAgent) for a registered backend that
|
|
// implements Backend.OpenWith. It exists for an embedder whose single
|
|
// process serves many workspaces with distinct credentials (gc, Gas City is
|
|
// the motivating case) against a backend whose dialer would otherwise be
|
|
// process-global, making per-workspace credentials impossible through plain
|
|
// OpenBestAvailable.
|
|
//
|
|
// A zero OpenOptions behaves IDENTICALLY to OpenBestAvailable for every
|
|
// backend, registered or not: Dolt and embedded Dolt have no OpenWith and
|
|
// never see opts; a registered backend without OpenWith falls back to its
|
|
// Open exactly as OpenBestAvailable always has. The one exception across
|
|
// every path is a non-nil opts.Credential, non-nil opts.HTTPClient, or
|
|
// non-empty opts.UserAgent with nothing able to honor it — that is always a
|
|
// typed refusal (the matching ErrXWithoutOpenWith sentinel), never a silent
|
|
// open with the field ignored.
|
|
func OpenBestAvailableWith(ctx context.Context, beadsDir string, opts OpenOptions) (Storage, error) {
|
|
// Before Load, which can migrate a legacy config.json, and before any
|
|
// backend is chosen, as the CLI store factories do.
|
|
if err := configfile.CheckDiscoveredWorkspaceFormat(beadsDir); err != nil {
|
|
return nil, err
|
|
}
|
|
cfg, err := configfile.Load(beadsDir)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("loading storage metadata: %w", err)
|
|
}
|
|
if cfg == nil {
|
|
cfg = configfile.DefaultConfig()
|
|
}
|
|
if !configfile.IsSupportedBackend(cfg.Backend) {
|
|
return nil, configuredBackendUnavailable(cfg.Backend, beadsDir, cfg)
|
|
}
|
|
|
|
// Dispatch to a registered extension backend before any Dolt path, mirroring
|
|
// the CLI store factories so SDK callers get the backend they registered
|
|
// instead of a silently-opened embedded Dolt store. OpenWithOptions calls
|
|
// OpenWith when the backend has one, else falls back to Open — except a
|
|
// non-nil Credential, non-nil HTTPClient, or non-empty UserAgent, which it
|
|
// refuses rather than silently drops.
|
|
if backend, ok := backends.Lookup(cfg.GetBackend()); ok {
|
|
return backend.OpenWithOptions(ctx, beadsDir, opts)
|
|
}
|
|
|
|
// No registered backend claims this workspace: it is plain Dolt
|
|
// (embedded or server), which has no per-open seam at all. Silently
|
|
// dropping a caller-supplied Credential, HTTPClient, or UserAgent here
|
|
// would be the same silent-loss hazard OpenWithOptions refuses for a
|
|
// registered backend without OpenWith (L2: fail closed on all three,
|
|
// not just Credential).
|
|
if opts.Credential != nil {
|
|
return nil, fmt.Errorf("beads: OpenOptions.Credential is not supported for backend %q (Dolt has no per-open credential seam): %w", cfg.GetBackend(), backends.ErrCredentialWithoutOpenWith)
|
|
}
|
|
if opts.HTTPClient != nil {
|
|
return nil, fmt.Errorf("beads: OpenOptions.HTTPClient is not supported for backend %q (Dolt has no per-open transport seam): %w", cfg.GetBackend(), backends.ErrHTTPClientWithoutOpenWith)
|
|
}
|
|
if opts.UserAgent != "" {
|
|
return nil, fmt.Errorf("beads: OpenOptions.UserAgent is not supported for backend %q (Dolt has no per-open transport seam): %w", cfg.GetBackend(), backends.ErrUserAgentWithoutOpenWith)
|
|
}
|
|
|
|
if cfg.IsDoltServerMode() {
|
|
store, err := dolt.NewFromConfig(ctx, beadsDir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return store, nil
|
|
}
|
|
|
|
database := configfile.DefaultDoltDatabase
|
|
if cfg != nil {
|
|
database = cfg.GetDoltDatabase()
|
|
}
|
|
store, err := embeddeddolt.Open(ctx, beadsDir, database, "main")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return store, nil
|
|
}
|