package main import ( "bytes" "encoding/json" "fmt" "net/url" "os" "strings" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/setup" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage" "github.com/spf13/cobra" "github.com/spf13/viper" ) // Portable config deliberately omits arbitrary command/hook/SSH option strings: // secrets may be embedded there, and cannot reliably be detected by key name. func portableConfig(c config.Config) map[string]any { cleanURL := func(raw string) string { u, err := url.Parse(raw) if err != nil { return "" } u.User = nil u.RawQuery = "" u.Fragment = "" return u.String() } sources := []map[string]any{} for _, s := range c.NetBoxes { sources = append(sources, map[string]any{"name": s.Name, "url": cleanURL(s.URL), "disable_prefix": s.DisablePrefix}) } hosts := []map[string]any{} for _, h := range c.Hosts { hosts = append(hosts, map[string]any{"name": h.Name, "address": h.Address, "user": h.User, "port": h.Port, "tags": h.Tags}) } rewrites := []map[string]string{} for _, r := range c.Shortcuts.Rewrites { rewrites = append(rewrites, map[string]string{"pattern": r.Pattern, "replace": r.Replace}) } out := map[string]any{ "hosts": hosts, "groups": c.Groups, "ssh": map[string]any{"default_user": c.SSH.DefaultUser, "default_port": c.SSH.DefaultPort}, "resolver": map[string]any{"strategies": c.Resolver.Strategies, "management_subnets": c.Resolver.ManagementSubnets, "interface_name": c.Resolver.InterfaceName, "hostname_domain": c.Resolver.HostnameDomain}, "shortcuts": map[string]any{"domains": c.Shortcuts.Domains, "rewrites": rewrites, "strip_hyphens": c.Shortcuts.StripHyphens, "show": c.Shortcuts.Show}, "completion": map[string]any{"max_results": c.Completion.MaxResults}, "tui": map[string]any{"history_limit": c.TUI.HistoryLimit}, } if len(sources) > 0 { out["netboxes"] = sources } else if c.NetBox.URL != "" { out["netbox"] = map[string]string{"url": cleanURL(c.NetBox.URL)} } return out } func decodePortable(data []byte) (config.Config, error) { v := viper.New() v.SetConfigType("yaml") v.SetDefault("tui.history_limit", 10) var c config.Config if err := v.ReadConfig(bytes.NewReader(data)); err != nil { return c, err } if err := v.Unmarshal(&c); err != nil { return c, err } // Strip executable settings and credentials even from externally edited files. safe, _ := json.Marshal(portableConfig(c)) v = viper.New() v.SetConfigType("json") if err := v.ReadConfig(bytes.NewReader(safe)); err != nil { return c, err } c = config.Config{} err := v.Unmarshal(&c) return c, err } func configCmd() *cobra.Command { cmd := &cobra.Command{Use: "config", Short: "Share configuration without credentials or executable settings"} export := &cobra.Command{Use: "export [FILE]", Short: "Export a secret-free JSON configuration (also valid YAML)", Args: cobra.MaximumNArgs(1), RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() if err != nil { return err } data, err := json.MarshalIndent(portableConfig(*cfg), "", " ") if err != nil { return err } if len(args) == 0 { fmt.Fprintln(cmd.OutOrStdout(), string(data)) return nil } return storage.WriteFile(args[0], append(data, '\n'), 0600) }} var yes, dry bool imp := &cobra.Command{Use: "import FILE", Short: "Import shared host settings; preserve matching local credentials and commands", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { data, err := os.ReadFile(args[0]) if err != nil { return err } incoming, err := decodePortable(data) if err != nil { return err } current, err := config.Load() if err != nil { return err } same := func(a, b string) bool { return strings.TrimRight(a, "/") == strings.TrimRight(b, "/") } for i := range incoming.NetBoxes { for _, old := range current.NetBoxes { s := &incoming.NetBoxes[i] if strings.EqualFold(s.Name, old.Name) && same(s.URL, old.URL) { s.Token = old.Token s.TokenVersion = old.TokenVersion s.SSH = old.SSH } } } if incoming.NetBox.URL != "" && same(incoming.NetBox.URL, current.NetBox.URL) { incoming.NetBox.Token = current.NetBox.Token incoming.NetBox.TokenVersion = current.NetBox.TokenVersion incoming.NetBox.SSH = current.NetBox.SSH } incoming.Commands = current.Commands incoming.Activity = current.Activity incoming.Cache = current.Cache incoming.Multi = current.Multi incoming.Shell = current.Shell incoming.SSH.SSHOptions = current.SSH.SSHOptions incoming.SSH.Rules = current.SSH.Rules for i := range incoming.Hosts { for _, old := range current.Hosts { if incoming.Hosts[i].Name == old.Name && incoming.Hosts[i].Address == old.Address { incoming.Hosts[i].SSH = old.SSH } } } for _, validate := range []func() error{incoming.ValidateNetBoxes, incoming.ValidateHosts, incoming.ValidateSSH, incoming.ValidateCommands, incoming.ValidateOperations, incoming.Shortcuts.Validate, incoming.ValidateMulti} { if err := validate(); err != nil { return err } } fmt.Fprintf(cmd.OutOrStdout(), "Import: %d named instances, %d static hosts. Local commands and matching credentials are retained.\n", len(incoming.NetBoxes), len(incoming.Hosts)) if dry { return nil } if err := confirmAction("Replace shared configuration settings", yes); err != nil { return err } if existing, err := os.ReadFile(config.Path()); err == nil { if err := storage.WriteFile(config.Path()+".before-import", existing, 0600); err != nil { return err } } return setup.Save(incoming) }} imp.Flags().BoolVar(&yes, "yes", false, "Approve replacing shared configuration settings") imp.Flags().BoolVar(&dry, "dry-run", false, "Validate and preview without writing") cmd.AddCommand(export, imp) return cmd }