Files
archie/internal/app/archied/setup.go
T
sam 856e2eef71 fix(configuration): resolve the default config path in one place
Four binaries derived the default with os.UserConfigDir while the daemon
resolved it from its own config home. The two agree on Linux with an
absolute XDG_CONFIG_HOME and diverge everywhere else, so one deployment
booted from a different config file depending on which binary started.

Move the rule into the package that owns configuration resolution
(internal/infrastructure/configuration, which already owns xdgDataHome and
DefaultWorkDir) as DefaultConfigDir/DefaultConfigPath, and have every
-config default take it from there: archie-gateway, archie-messaging,
archie-state-store (serve and recovery) and archie-ui, plus the daemon's
own parseArgs, setup generator and drain-marker path.

Fence the claim at the source, since the resolved value is only observable
by starting a process: no source under cmd/ or internal/app/archied may
call os.UserConfigDir, and every -config registration must default to the
helper.
2026-09-22 01:57:49 +10:00

315 lines
11 KiB
Go

package archied
import (
"context"
"errors"
"flag"
"fmt"
"io"
"os"
"os/signal"
"path/filepath"
"syscall"
configtemplate "github.com/samcharles93/archie-core"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/setup"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration/tomlwrite"
"github.com/samcharles93/archie-core/internal/infrastructure/terminalprompt"
)
// setupCommand is the argv[1] token that switches archied out of daemon
// mode and into the first-run configuration generator.
const setupCommand = "setup"
// defaultsParams is the known-valid unattended baseline --defaults supplies.
// Answering every prompt with its own default does NOT produce a loadable
// config (the provider step's first option is OpenAI, whose model prompt
// hard-errors on an empty answer), so this covers every required answer and
// leaves the optional ones to answer themselves as "skip": ollama is the
// only keyless provider, so an unattended install boots without a secret.
func defaultsParams() setup.Params {
return setup.Params{
BotUser: "archie-bot",
ForgeType: "github",
ForgeHost: "https://github.com",
Provider: "ollama",
Model: "llama3",
}
}
// IsSetupArgs reports whether args (os.Args[1:]) selects setup rather than
// the daemon.
func IsSetupArgs(args []string) bool {
return len(args) > 0 && args[0] == setupCommand
}
// setupFlags is the parameterised answer surface, kept apart from RunSetup so
// the flag definitions, the mapping into setup.Params and the flow stay
// independently readable. Nothing here reads a terminal or the environment:
// parameters and prompts are the only two ways an answer arrives, and no
// environment variable is consulted.
type setupFlags struct {
cfgPath string
defaults bool
botUser string
operator string
forgeType string
forgeHost string
provider string
model string
telegramUserIDs string
forgeSecretRef string
providerSecretRef string
telegramSecretRef string
}
func bindSetupFlags(fs *flag.FlagSet) *setupFlags {
f := &setupFlags{}
fs.StringVar(&f.cfgPath, "config", configuration.DefaultConfigPath(), "path to write config.toml")
fs.BoolVar(&f.defaults, "defaults", false, "write a known-valid unattended baseline config without prompting")
fs.StringVar(&f.botUser, "bot-user", "", "forge username for archied's commits and API calls")
fs.StringVar(&f.operator, "operator", "", "operator display name (optional)")
fs.StringVar(&f.forgeType, "forge-type", "", "forge type: github | gitea | none")
fs.StringVar(&f.forgeHost, "forge-host", "", "forge base URL")
fs.StringVar(&f.provider, "provider", "", "LLM provider class: openai | anthropic | openrouter | gemini | groq | deepseek | mistral | ollama")
fs.StringVar(&f.model, "model", "", "bare model name; the provider class prefix is added automatically")
fs.StringVar(&f.telegramUserIDs, "telegram-user-ids", "", "comma-separated allowed Telegram user IDs; configuring Telegram requires at least one")
// References, not values: engine:key names where a secret already lives, and
// neither part is sensitive. A value has no flag, deliberately -- see Params.
fs.StringVar(&f.forgeSecretRef, "forge-secret-ref", "", "engine:key naming where the forge token is stored (e.g. bws:ARCHIE_GITHUB_TOKEN); that engine must be configured")
fs.StringVar(&f.providerSecretRef, "provider-secret-ref", "", "engine:key naming where the provider API key is stored (e.g. bws:OPENAI_API_KEY); that engine must be configured")
fs.StringVar(&f.telegramSecretRef, "telegram-secret-ref", "", "engine:key naming where the Telegram bot token is stored (e.g. bws:TELEGRAM_BOT_TOKEN); that engine must be configured")
return f
}
// params folds the flags over the baseline. A flag always wins; without
// -defaults the baseline is empty, so only the flags pre-answer anything and
// every other question is prompted for.
func (f *setupFlags) params() (setup.Params, error) {
var params setup.Params
if f.defaults {
params = defaultsParams()
}
if f.botUser != "" {
params.BotUser = f.botUser
}
if f.operator != "" {
params.Operator = f.operator
}
if f.forgeType != "" {
params.ForgeType = f.forgeType
}
if f.forgeHost != "" {
params.ForgeHost = f.forgeHost
}
if f.provider != "" {
params.Provider = f.provider
}
if f.model != "" {
params.Model = f.model
}
// Parsed at the boundary, so a malformed reference fails before anything is
// rendered or written.
for _, ref := range []struct {
flag string
value string
dst *config.SecretRef
}{
{"-forge-secret-ref", f.forgeSecretRef, &params.ForgeTokenRef},
{"-provider-secret-ref", f.providerSecretRef, &params.ProviderAPIKeyRef},
{"-telegram-secret-ref", f.telegramSecretRef, &params.TelegramTokenRef},
} {
if ref.value == "" {
continue
}
parsed, err := setup.ParseSecretRef(ref.value)
if err != nil {
return setup.Params{}, fmt.Errorf("%s: %w", ref.flag, err)
}
*ref.dst = parsed
}
if f.telegramUserIDs != "" {
ids, err := setup.ParseTelegramUserIDs(f.telegramUserIDs)
if err != nil {
return setup.Params{}, fmt.Errorf("-telegram-user-ids: %w", err)
}
params.TelegramUserIDs = ids
}
return params, nil
}
// setupPrompter picks the answer surface. -defaults answers every remaining
// question with its own default and never touches a terminal; otherwise stdin
// must be a real terminal, and terminalprompt refuses it otherwise rather than
// silently generating a config nobody chose.
func setupPrompter(defaults bool, stdin *os.File, stdout io.Writer) (setup.Prompter, error) {
if defaults {
return setup.DefaultPrompter{}, nil
}
return terminalprompt.New(stdin, stdout)
}
// existingConfig reads the config being replaced, returning the bytes to apply
// edits to and the values worth prefilling prompts with. A missing file is a
// fresh install, not an error. A file that exists but does not load is still
// edited in place: tomlwrite only rewrites the lines it owns, and refusing
// would strand an operator whose config is malformed.
func existingConfig(loader *configuration.Loader, path string) ([]byte, setup.ExistingValues, error) {
base, err := os.ReadFile(path)
if errors.Is(err, os.ErrNotExist) {
return nil, setup.ExistingValues{}, nil
}
if err != nil {
return nil, setup.ExistingValues{}, fmt.Errorf("read existing config: %w", err)
}
var existing setup.ExistingValues
if doc, err := loader.File(path); err == nil {
existing = setup.ExistingValues{
BotUser: doc.Config.BotUser,
Operator: doc.Config.Chat.Operator,
ForgeHost: doc.Config.Forge.Host,
}
}
return base, existing, nil
}
// RunSetup generates (or re-generates) a config.toml, validates it through a
// real configuration.Loader, and only then writes it atomically with mode
// 0600 and commits any secrets to the env file beside it. --defaults uses a
// known-valid unattended baseline and never touches a terminal; without it,
// stdin must be a real TTY and the guided flow runs.
func RunSetup(args []string, stdin *os.File, stdout, stderr io.Writer) int {
fs := flag.NewFlagSet(setupCommand, flag.ContinueOnError)
fs.SetOutput(stderr)
flags := bindSetupFlags(fs)
if err := fs.Parse(args); err != nil {
return 2
}
if fs.NArg() > 0 {
fmt.Fprintf(stderr, "setup: unexpected argument %q\n", fs.Arg(0))
return 2
}
params, err := flags.params()
if err != nil {
fmt.Fprintf(stderr, "setup: %v\n", err)
return 2
}
p, err := setupPrompter(flags.defaults, stdin, stdout)
if err != nil {
fmt.Fprintf(stderr, "setup: %v\n", err)
return 1
}
cfgDir := filepath.Dir(flags.cfgPath)
if err := os.MkdirAll(cfgDir, 0o700); err != nil {
fmt.Fprintf(stderr, "setup: create config directory: %v\n", err)
return 1
}
sink := setup.NewEnvFileSink(filepath.Join(cfgDir, "env"))
loader := configuration.New(nil)
base, existing, err := existingConfig(loader, flags.cfgPath)
if err != nil {
fmt.Fprintf(stderr, "setup: %v\n", err)
return 1
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
edits, err := setup.RunParams(ctx, p, nil, sink, existing, params)
if err != nil {
fmt.Fprintf(stderr, "setup: %v\n", err)
return 1
}
var rendered []byte
if base != nil {
rendered, err = tomlwrite.Apply(base, edits)
} else {
rendered, err = tomlwrite.Generate(configtemplate.Example, edits)
}
if err != nil {
fmt.Fprintf(stderr, "setup: render config: %v\n", err)
return 1
}
if err := installValidatedConfig(loader, flags.cfgPath, sink, rendered); err != nil {
fmt.Fprintf(stderr, "setup: %v\n", err)
return 1
}
fmt.Fprintf(stdout, "setup: wrote %s\n", flags.cfgPath)
return 0
}
// installValidatedConfig proves rendered loads through a real Loader, then
// writes the config atomically with mode 0600 and only then commits the
// secret sink. A validation failure returns before either write, so a bad
// generated config never leaves a config file or a secret on disk, and a
// secret is never committed pointing at a config that was never written.
func installValidatedConfig(loader *configuration.Loader, path string, sink setup.SecretSink, rendered []byte) error {
if err := proveLoadable(loader, rendered); err != nil {
return err
}
if err := writeFileAtomicMode(path, rendered, 0o600); err != nil {
return fmt.Errorf("write config: %w", err)
}
if err := sink.Commit(); err != nil {
return fmt.Errorf("commit secrets: %w", err)
}
return nil
}
// proveLoadable decodes and validates rendered through a real
// configuration.Loader, the same check setup.Run's doc comment makes the
// caller's responsibility. The rendered bytes are staged in a temp file
// rather than the destination, so a load failure can never have already
// installed anything.
func proveLoadable(loader *configuration.Loader, rendered []byte) error {
tmp, err := os.CreateTemp("", "archie-setup-*.toml")
if err != nil {
return fmt.Errorf("prove config loads: %w", err)
}
name := tmp.Name()
defer os.Remove(name)
if err := tmp.Close(); err != nil {
return fmt.Errorf("prove config loads: %w", err)
}
if err := os.WriteFile(name, rendered, 0o600); err != nil {
return fmt.Errorf("prove config loads: %w", err)
}
if _, err := loader.File(name); err != nil {
return fmt.Errorf("generated config does not load: %w", err)
}
return nil
}
// writeFileAtomicMode writes data to path via a same-directory temp file and
// rename, so a concurrent reader never observes a truncated config.
func writeFileAtomicMode(path string, data []byte, mode os.FileMode) error {
tmp, err := os.CreateTemp(filepath.Dir(path), ".config-*.toml")
if err != nil {
return err
}
name := tmp.Name()
defer os.Remove(name) // no-op after a successful rename
if err := tmp.Chmod(mode); err != nil {
tmp.Close()
return err
}
if _, err := tmp.Write(data); err != nil {
tmp.Close()
return err
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return err
}
if err := tmp.Close(); err != nil {
return err
}
return os.Rename(name, path)
}