Files
archie/internal/app/archied/setup.go
T
sam 89cfa44b5e feat(configuration): let setup reference a secret without carrying its value
A parameterised install could not configure a cloud provider without a terminal:
the only way a secret value entered was the prompt, so an unattended run was
limited to the keyless self-hosted provider. The missing piece is the reference
form.

A reference is not a secret. An engine name and a key name are not sensitive --
which is exactly why a reference may be a parameter while a value may not -- so
setup gains -forge-secret-ref, -provider-secret-ref and -telegram-secret-ref,
each taking engine:key, parsed by one new setup.ParseSecretRef. When a reference
is given the step writes it to TOML and asks nothing, and setup neither reads nor
stores the value, because the value is not its to hold. That is the difference
from the prompt path, where the operator supplies a value and setup writes it
into the env engine and references it there.

Engine names are identifiers, not paths: the shipped engines are registered as
age, sops and vault, so a reference like vault/openbao:KEY is refused rather than
written into a config that could never resolve it.

Two refusals guard the silent no-op. A reference naming a key for the keyless
self-hosted provider, or for a forge that is disabled, would sit in the config
looking configured while nothing read it -- the failure shape this flow exists to
remove -- so both are refused rather than written.

telegram keeps writing token_env for the prompt path, because that form names an
env var and the prompt path is the env engine; a supplied reference may name any
engine, which token_env cannot express, so the reference path writes the
preferred token = {engine, key} form. Noted as the one asymmetry.

Also folded stepCloudProvider's key handling into cloudKeyEdit and cloudModel.
That was a lint fix for nested blocks, but the split is the honest shape: the two
branches obtain a key edit by different means and then resolve a model the same
way.

Every new test was mutation-verified by reintroducing the absence: ignoring the
forge reference, making ParseSecretRef validate nothing, and dropping the keyless
-provider guard each fail the corresponding test.
2026-09-15 03:23:08 +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", filepath.Join(configHome(), "archie", "config.toml"), "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)
}