diff --git a/CHANGELOG.md b/CHANGELOG.md index f761b8f..61e9676 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## v1.1.0 + +- Add local post-disconnect/post-command scripts, execution timeouts, cancellation, per-command confirmation and host restrictions. +- Add configurable recent-host count, persistent favorites/pins, a TUI command menu and cache/live/stale indicators. +- Add doctor/explain diagnostics, parallel batch commands with failed-host retry, and optional bounded local action history. +- Add configuration export/import that excludes credentials and executable settings while preserving matching local credentials. +- Preserve terminal behavior and process exit status during supervised execution; test Bash/Python scripts, process cancellation, concurrency and batch retries. + ## v1.0.0 - Consolidate the complete project into the initial v1 commit. diff --git a/README.md b/README.md index 6f6aa8a..6e9f9d9 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,7 @@ The same lookup drives `netssh sftp`, `netssh scp`, and `netssh tunnel`, the int - [Quick start](#quick-start) - [Configuration](#configuration) — [wizard](#interactive-wizard), [manual config](#manual-config), [reference](#configuration-reference), [environment variables](#environment-variables), [files](#files-and-directories), [multiple instances](#multiple-netbox-instances) - [Usage](#usage) — [command overview](#command-overview), [SSH options](#ssh-options), [pre-connect hook](#pre-connect-hook), [SFTP & SCP](#sftp-and-scp), [port forwarding](#port-forwarding), [static hosts](#static-hosts), [multiple servers](#multiple-servers-in-one-window), [shortcuts](#host-shortcuts), [TUI](#interactive-tui), [notes](#server-notes), [cache](#cache-management) +- [Operations](#operations) — post scripts, favorites, history, diagnostics, batch commands, configuration sharing - [Custom host commands](#custom-host-commands) — automatic aliases for mtr, ping, and other programs - [Hotkey cheat sheet](#hotkey-cheat-sheet) — search, editors, tmux and zellij - [Recipes](#recipes) @@ -36,7 +37,7 @@ The same lookup drives `netssh sftp`, `netssh scp`, and `netssh tunnel`, the int - **Flexible IP resolution** — configurable chain of strategies: management subnet, primary IP, named interface, or the hostname itself - **Static hosts** — add hosts that are not in NetBox (`netssh hosts add router 192.168.1.1`); they work everywhere, also without any NetBox - **Interactive TUI** — fuzzy search with live NetBox queries and 300 ms debouncing (start with `netssh`, no arguments) -- **Recently-used list** — TUI opens with your 10 most-recently-connected hosts, no typing needed +- **Recently-used list** — TUI opens with your most-recently-connected hosts (10 by default, configurable with `tui.history_limit`), no typing needed - **Tag/kind filter** — press `Ctrl+F` in the TUI to filter by `tag:prod` or `kind:vm` - **User/port override** — press `Ctrl+E` in the TUI to override the SSH user or port before connecting - **Server notes** — multiline local notes or optional NetBox comments, available in the TUI and CLI @@ -229,6 +230,10 @@ Every key, its default, and the section that explains it. Keys marked *layered* | `ssh.extra_args` | list | `[]` | *Layered.* Extra ssh arguments; accumulate across layers; ssh only. | | `ssh.options` | map | `{}` | *Layered.* `-o Key=Value`; per key, the more specific layer wins. | | `ssh.forwards` | map | `{}` | *Layered.* Named port forwards (`local`, `remote`, `dynamic`) — see [Port forwarding](#port-forwarding). | +| `ssh.post_disconnect` | string | — | *Layered.* Local shell command after the client exits; `none` disables inheritance. | +| `tui.history_limit` | integer | `10` | Recent hosts shown; `0` means all, favorites are additional. | +| `activity.enabled` | boolean | `false` | Enable local execution metadata history. | +| `activity.retention_days` / `activity.max_entries` | integer | `30` / `1000` | History retention limits; `0` disables the respective limit. | | `ssh.pre_connect` | string | — | *Layered.* Shell command run locally before connecting; a non-zero exit aborts; `none` disables an inherited one — see [Pre-connect hook](#pre-connect-hook). | | `ssh.rules[]` | list | `[]` | `match` (`tag`, `instance`, `kind`, `name`) plus any layered key. | | `shortcuts.domains` | list | `[]` | Suffixes stripped for shortcuts and tried when expanding a short name. | @@ -403,6 +408,10 @@ A hint is shown during `netssh configure` if a legacy v1 token is entered. | `netssh [--dry-run] [--jump HOST\|--no-jump] [--forward NAME]... [ssh options] HOST [command]` | Connect with ssh. | | `netssh sftp [netssh flags] [sftp options] HOST[:PATH]` | SFTP session — see [SFTP and SCP](#sftp-and-scp). | | `netssh scp [netssh flags] [scp options] SOURCE... TARGET` | Copy files — see [SFTP and SCP](#sftp-and-scp). | +| `netssh doctor [--online]` / `netssh explain HOST` | Diagnose configuration and explain effective settings. | +| `netssh favorites` / `netssh history` | Manage saved hosts and optional action records. | +| `netssh batch COMMAND HOST...` | Run a configured command with bounded parallelism and retry. | +| `netssh config export\|import FILE` | Share host configuration without secrets or executable settings. | | `netssh run [--dry-run] COMMAND HOST [-- EXTRA_ARGS...]` | Run a [custom host command](#custom-host-commands), e.g. mtr or ping, using the configured resolver. | | `netssh tunnel [netssh flags] [ssh options] HOST FORWARD...` | Port forwards without a shell — see [Port forwarding](#port-forwarding). | | `netssh hosts [list] \| add NAME ADDRESS [--user U] [--port P] [--tag T]... [--replace] \| remove NAME` | Manage static hosts — see [Static hosts](#static-hosts). | @@ -927,7 +936,7 @@ Run without arguments to open the interactive search: netssh ``` -The TUI opens with your 10 most-recently-connected hosts. Start typing to search all cached hosts or query NetBox live. +The TUI opens with your most-recently-connected hosts (10 by default, configurable with `tui.history_limit`). Start typing to search all cached hosts or query NetBox live. See the [hotkey cheat sheet](#hotkey-cheat-sheet) for all search and editor keys. @@ -1038,6 +1047,9 @@ in the search, while tmux uses `Ctrl+b` as its default prefix. | `Enter` | connect to selected host | | `Space` | mark/unmark the host; with marks, `Enter` opens them side by side (`netssh multi`) | | `Ctrl+A` | mark all listed hosts (again: unmark all) | +| `Ctrl+R` | choose SSH or a configured command; marked hosts run the command as a batch | +| `Ctrl+D` | toggle favorite for the selected host | +| `Ctrl+P` | toggle pin; pinning also adds the host to favorites | | `Ctrl+O` | open an SFTP session to the selected host | | `Ctrl+T` | start a tunnel: enter forward names or specs (`web, 8080:localhost:80`) | | `Ctrl+E` | open inline editor to override user/port before connecting | @@ -1113,6 +1125,188 @@ the whole tab. When starting a new zellij session, enable broadcast manually with `Ctrl+t` then `s`; `--sync` is applied automatically only inside an existing zellij session. +## Operations + +### Post scripts + +`ssh.post_disconnect` runs a local shell command after the SSH, SFTP, SCP or +tunnel process exits. Configure it globally, per NetBox instance, per static host +or in an SSH rule. More specific values override broader ones; `none` disables +an inherited hook. + +```yaml +ssh: + post_disconnect: /home/user/scripts/after-ssh.sh + rules: + - match: {tag: lab} + post_disconnect: none + +commands: + maintenance: + alias_prefix: maint + args: [bash, /home/user/scripts/maintenance.sh, "{address}"] + post_run: /home/user/scripts/after-maintenance.sh + match: {instance: prod, tag: router, name: "router*"} + confirm: true + timeout: 5m +``` + +Post scripts receive the existing `NETSSH_HOST`, `NETSSH_TARGET`, +`NETSSH_INSTANCE`, `NETSSH_IP`, `NETSSH_KIND`, `NETSSH_TAGS` and +`NETSSH_CLIENT` variables, plus `NETSSH_COMMAND` and `NETSSH_EXIT_CODE`. +They run after a started process succeeds, fails or is cancelled, but not after +a failed pre-connect hook, failed process start, or a dry run. Output goes to +stderr, stdin is closed, and post scripts have a 30-second timeout. + +A failing main process retains its exit code. If only the post script fails, +its exit code is returned. Hooks cannot run after the wrapper is forcibly killed +with SIGKILL. In multi-mode each connection runs its own post script. + +Without a post hook or activity logging, SSH still replaces netssh directly. +With either enabled, netssh waits for the client while preserving terminal I/O. + +### Favorites, pins and recent hosts + +```yaml +tui: + history_limit: 25 # default 10; 0 = all used hosts +``` + +Favorites remain on the TUI's opening screen independently of the recent-host +limit. Pins appear first, followed by favorites and recent hosts. `Ctrl+D` +toggles a favorite; `Ctrl+P` toggles a pin. Removing a favorite also unpins it. +A saved host missing from the cache is still shown and resolved when selected. + +```sh +netssh favorites +netssh favorites add prod/web01 +netssh favorites pin prod/router01 +netssh favorites unpin prod/router01 +netssh favorites remove prod/web01 +``` + +Favorites use canonical targets such as `prod/web01`, so identical hostnames in +different instances stay independent. Change the recent-host limit in +`netssh configure` → **History & activity logging**. + +The TUI labels results as `live`, `static` or `cache AGE`; expired cache entries +also show `stale`. A partial NetBox outage keeps available and cached results +visible and identifies failed instances in the warning. Cached results are not +proof of current reachability; normal resolution rules still apply on connect. + +### TUI actions, restrictions and confirmations + +Press `Ctrl+R` on a host to choose SSH or one of your configured commands, +including MTR, Ping and scripts. With marked hosts, SSH opens the existing +multi-session layout; custom commands run through `netssh batch`. + +A command's `match` uses the same `instance`, `tag`, `kind` and hostname +glob `name` selectors as SSH rules. All supplied selectors must match. +Restrictions apply to generated aliases, the TUI menu and execution itself. +The chosen command is checked again for every batch target. + +`confirm: true` asks before execution. Non-interactive callers must explicitly +pass `--yes`; a batch asks once for the entire selected set. For example: + +```sh +netssh run --yes maintenance prod/router01 +netssh run --status maintenance prod/router01 +``` + +The terminal shows elapsed runtime for custom commands; `--status` also +enables these messages when output is redirected. `timeout` accepts durations +such as `30s` or `5m`; no value means no timeout. Timeout exits with 124. +Ctrl+C cancels foreground commands. Background batch commands run in isolated +process groups; cancellation terminates their descendants, with a two-second +grace period before forced termination. Interactive programs retain foreground +terminal behavior. + +### Diagnostics + +```sh +netssh doctor # validate configuration, resolver, cache and programs +netssh doctor --online # additionally query each NetBox instance +netssh explain prod/web01 # resolve and print effective settings, without connecting +``` + +`explain` reports the chosen instance, address, cache/static/live source, +resolver order and recorded winning strategy, matching SSH rule numbers, +effective SSH options and hooks, and username/port defaults. It does not execute +hooks, mark the host as used or modify the cache. It can query NetBox if resolution +requires it. Older cache entries may lack the winning strategy; this is reported +explicitly. A cache refresh records that information for future explanations. + +### Batch commands and retry + +```sh +netssh batch --parallel 4 mtr prod/router01 prod/router02 -- --report +netssh batch --yes maintenance prod/router01 prod/router02 +netssh batch --dry-run maintenance prod/router01 prod/router02 +netssh batch --retry-failed --parallel 2 --yes +``` + +Batch mode accepts explicit host names and shortcuts. All targets are resolved +and checked before launching commands; duplicates are removed. Parallelism is +bounded (default 4, range 1–64). Output is grouped by host, with each exit code +and a final success/failure count. Batch commands receive no interactive stdin. + +The last non-dry-run batch saves its command name, extra arguments and failed +canonical targets in `~/.config/netssh/last-failed.json` with mode `0600`. +Retry uses only that failed subset and rechecks the current configuration and +confirmation requirement. A successful batch clears the retry targets. +Concurrent batches each run independently; the last one to finish owns the +retry file. Command output is held in temporary private files and removed at +completion. + +### Optional action history + +```yaml +activity: + enabled: true # default false + retention_days: 30 # 0 = unlimited age + max_entries: 1000 # 0 = unlimited count +``` + +```sh +netssh history +netssh history clear +``` + +History records host, command name, start time, total duration and final exit +code for custom commands and managed SSH/SFTP/SCP/tunnel sessions. It does not +record arguments, environment variables, API tokens or command output. +Retention is applied when writing records or showing history. + +Favorites, pins and action records live in `~/.config/netssh/activity.json` +(mode `0600`), with locking and atomic writes for simultaneous sessions. +`history clear` preserves favorites. `XDG_CONFIG_HOME` applies to both state +files. Configure logging and retention in **History & activity logging**. + +### Export and import without secrets + +```sh +netssh config export team.json +netssh config import team.json --dry-run +netssh config import team.json --yes +``` + +Export uses an allowlist: instance names/URLs, static hosts, groups, resolver +settings, shortcuts, completion, recent-host limit and SSH user/port defaults. +It excludes API tokens, credentials embedded in URLs, custom command definitions, +hooks, arbitrary SSH options/rules, local history, favorites and cache contents. +The output is JSON, which is also valid YAML. + +Import accepts JSON or YAML and strips credentials and executable settings even +if the supplied file contains them. It preserves local commands and global SSH +rules/options. Existing credentials and per-instance SSH options are retained +only when the instance name and URL match; static-host SSH options are retained +only for the same name/address. New instances require a local token afterward. + +Import validates before writing, requires confirmation (or `--yes`), and saves +the previous configuration as `netssh.yaml.before-import` with mode `0600`. +The preview does not modify files. Export/import is intended for shared host +configuration, not a complete backup of local executable settings or secrets. + ## Recipes **Everything through a bastion, except the bastion itself** diff --git a/cmd/netssh/batch.go b/cmd/netssh/batch.go new file mode 100644 index 0000000..b765465 --- /dev/null +++ b/cmd/netssh/batch.go @@ -0,0 +1,191 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "io" + "os" + "os/signal" + "path/filepath" + "sync" + "syscall" + "time" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/runner" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage" + "github.com/spf13/cobra" +) + +type batchRetry struct { + Command string + Hosts []string + Extra []string +} +type batchResult struct { + Host string + Code int +} + +var batchExecutable = os.Executable + +func batchPath() string { + return filepath.Join(filepath.Dir(config.Path()), "netssh", "last-failed.json") +} +func batchCmd() *cobra.Command { + var parallel int + var retry, yes, dry bool + cmd := &cobra.Command{Use: "batch COMMAND HOST... [-- EXTRA_ARGS...]", Short: "Run a configured command on hosts with bounded parallelism", RunE: func(cmd *cobra.Command, args []string) error { + if parallel < 1 || parallel > 64 { + return fmt.Errorf("parallel must be between 1 and 64") + } + cfg, err := config.Load() + if err != nil { + return err + } + work := batchRetry{} + if retry { + if len(args) > 0 { + return fmt.Errorf("--retry-failed takes no positional arguments") + } + data, err := os.ReadFile(batchPath()) + if err != nil { + return err + } + if err = json.Unmarshal(data, &work); err != nil { + return err + } + } else { + split := cmd.ArgsLenAtDash() + if split >= 0 { + work.Extra = args[split:] + args = args[:split] + } + if len(args) < 2 { + return fmt.Errorf("specify COMMAND and at least one HOST") + } + work.Command, work.Hosts = args[0], args[1:] + } + command, ok := cfg.Commands[work.Command] + if !ok { + return fmt.Errorf("unknown command %q", work.Command) + } + if len(work.Hosts) == 0 { + fmt.Fprintln(cmd.OutOrStdout(), "No failed hosts to retry.") + return nil + } + // Resolve and validate the entire list before launching any action. + var targets []string + seen := map[string]bool{} + for _, target := range work.Hosts { + h, err := resolveTargetE(cfg, target, false) + if err != nil { + return err + } + if !command.Allowed(commandHost(h)) { + return fmt.Errorf("%s is not allowed on %s", work.Command, h.Name) + } + if !seen[h.Name] { + targets = append(targets, h.Name) + seen[h.Name] = true + } + } + if command.Confirm && !dry { + if err := confirmAction(fmt.Sprintf("Run %s on %d hosts", work.Command, len(targets)), yes); err != nil { + return err + } + } + executable, err := batchExecutable() + if err != nil { + return err + } + // Temporary output files bound memory even for very verbose commands. + dir, err := os.MkdirTemp("", "netssh-batch-") + if err != nil { + return err + } + defer os.RemoveAll(dir) + ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer cancel() + jobs := make(chan int) + results := make(chan batchResult, len(targets)) + var wg sync.WaitGroup + var output sync.Mutex + for n := 0; n < parallel; n++ { + wg.Add(1) + go func() { + defer wg.Done() + for i := range jobs { + host := targets[i] + if ctx.Err() != nil { + results <- batchResult{host, 130} + continue + } + output.Lock() + fmt.Fprintf(cmd.OutOrStdout(), "[%s] starting\n", host) + output.Unlock() + f, err := os.CreateTemp(dir, "output-") + if err != nil { + results <- batchResult{host, 1} + continue + } + argv := []string{executable, "run", "--yes"} + if dry { + argv = append(argv, "--dry-run") + } + argv = append(argv, work.Command, "--", host) + argv = append(argv, work.Extra...) + r := runner.Run(ctx, argv, runner.Options{Stdout: f, Stderr: f}) + f.Close() + output.Lock() + fmt.Fprintf(cmd.OutOrStdout(), "[%s] exit=%d duration=%s\n", host, r.Code, r.Duration.Round(time.Millisecond)) + read, err := os.Open(f.Name()) + if err == nil { + _, _ = io.Copy(cmd.OutOrStdout(), read) + read.Close() + } + output.Unlock() + results <- batchResult{host, r.Code} + } + }() + } + for i := range targets { + jobs <- i + } + close(jobs) + wg.Wait() + close(results) + failed := map[string]bool{} + for r := range results { + if r.Code != 0 { + failed[r.Host] = true + } + } + work.Hosts = nil + for _, host := range targets { + if failed[host] { + work.Hosts = append(work.Hosts, host) + } + } + if !dry { + data, _ := json.Marshal(work) + if err := os.MkdirAll(filepath.Dir(batchPath()), 0700); err != nil { + return err + } + if err := storage.WriteFile(batchPath(), data, 0600); err != nil { + return err + } + } + fmt.Fprintf(cmd.OutOrStdout(), "%d succeeded, %d failed\n", len(targets)-len(failed), len(failed)) + if len(failed) > 0 { + return fmt.Errorf("batch failed; retry with netssh batch --retry-failed") + } + return nil + }} + cmd.Flags().IntVar(¶llel, "parallel", 4, "Maximum simultaneous hosts (1-64)") + cmd.Flags().BoolVar(&retry, "retry-failed", false, "Repeat failed targets from the last batch") + cmd.Flags().BoolVar(&yes, "yes", false, "Confirm the batch action") + cmd.Flags().BoolVar(&dry, "dry-run", false, "Resolve and print commands without running") + return cmd +} diff --git a/cmd/netssh/instances.go b/cmd/netssh/instances.go index bab2114..3cbd791 100644 --- a/cmd/netssh/instances.go +++ b/cmd/netssh/instances.go @@ -41,7 +41,7 @@ func shortcutAliases(entries []cache.Entry, cfg config.Config) map[string]string } plain := strings.NewReplacer(".", "_", "/", "_") for _, alias := range hook.BuildAliasEntries(append([]cache.Entry(nil), entries...), cfg) { - if alias.Host == "" { + if alias.Host == "" || alias.Command != "" { continue // the command alias for netssh itself } if alias.Name == plain.Replace(strings.ToLower(cfg.HostLabel(alias.Host))) { diff --git a/cmd/netssh/main.go b/cmd/netssh/main.go index 239cbf0..4bfbcac 100644 --- a/cmd/netssh/main.go +++ b/cmd/netssh/main.go @@ -17,6 +17,7 @@ import ( tea "charm.land/bubbletea/v2" "github.com/spf13/cobra" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/hook" @@ -30,6 +31,7 @@ import ( // managedSubcommands are dispatched to cobra; everything else is treated as SSH wrapper mode. var managedSubcommands = map[string]bool{ + "doctor": true, "explain": true, "favorites": true, "history": true, "batch": true, "config": true, "configure": true, "notes": true, "search": true, @@ -75,6 +77,10 @@ func main() { if managedSubcommands[args[0]] { if err := rootCmd().Execute(); err != nil { + var exit *commandExit + if errors.As(err, &exit) { + os.Exit(exit.code) + } os.Exit(1) } return @@ -208,25 +214,43 @@ func prependArgs(extra, args []string, dests []int) []string { // resolvedHost is a NetBox host with the address to connect to. type resolvedHost struct { - Name string // cache/selector name, may carry an instance prefix - Kind string - IP string - Tags []string + Origin string + Resolver string + CachedAt time.Time + Name string // cache/selector name, may carry an instance prefix + Kind string + IP string + Tags []string } // resolveTarget finds host in the cache (also by shortcut) or NetBox and // resolves its address. It exits on failure. func resolveTarget(cfg *config.Config, host string) resolvedHost { + result, err := resolveTargetE(cfg, host, true) + if err != nil { + fatalf("%v", err) + } + return result +} +func resolveTargetE(cfg *config.Config, host string, record bool) (resolvedHost, error) { c := newCache(cfg) _ = c.Load() - maybeBackgroundRefresh(cfg, c) + if record { + maybeBackgroundRefresh(cfg, c) + } source, _ := netbox.SplitTarget(host) useCache := len(cfg.NetBoxes) == 0 || source != "" used := func(entry cache.Entry) resolvedHost { - c.MarkUsed(entry.Name) - _ = c.Save() - return resolvedHost{Name: entry.Name, Kind: entry.Kind, IP: entry.IP, Tags: entry.Tags} + if record { + c.MarkUsed(entry.Name) + _ = c.Save() + } + origin := "cache" + if entry.Static { + origin = "static" + } + return resolvedHost{Name: entry.Name, Kind: entry.Kind, IP: entry.IP, Tags: entry.Tags, Origin: origin, Resolver: entry.Resolver, CachedAt: entry.CachedAt} } // Static hosts from the config win and need no NetBox. @@ -237,16 +261,16 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost { } entry, found, err := c.GetStatic(host, normalize) if err != nil { - fatalf("%v", err) + return resolvedHost{}, err } if found { - return used(entry) + return used(entry), nil } } // Cache hit with a fresh TTL — connect directly without querying NetBox. if entry, fresh := c.Get(host); fresh && useCache { - return used(entry) + return used(entry), nil } // Shortcut cache lookup: scan entries whose normalized name matches the input. @@ -257,11 +281,11 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost { normalize := normalizeTarget(cfg.Shortcuts, source != "") entry, found, fresh, err := c.GetByShortcut(lookupHost, normalize) if err != nil { - fatalf("%v", err) + return resolvedHost{}, err } if found { if fresh { - return used(entry) + return used(entry), nil } // Stale shortcut match — use canonical name for NetBox re-fetch. lookupHost = entry.Name @@ -269,7 +293,7 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost { } if !cfg.HasNetBox() { - fatalf("host %q is not in hosts: and no NetBox is configured (netssh configure)", host) + return resolvedHost{}, fmt.Errorf("host %q is not in hosts: and no NetBox is configured (netssh configure)", host) } nbClient := newNetBoxClient(cfg) @@ -280,33 +304,35 @@ func resolveTarget(cfg *config.Config, host string) resolvedHost { if errors.Is(err, netbox.ErrHostNotFound) && !useCache && shortcutsEnabled { entry, found, _, cacheErr := c.GetByShortcut(host, normalizeTarget(cfg.Shortcuts, false)) if cacheErr != nil { - fatalf("%v", cacheErr) + return resolvedHost{}, cacheErr } if found { target, err = findSSHHost(ctx, nbClient, entry.Name, cfg.Shortcuts.Domains) } } if err != nil { - fatalf("NetBox: %v", err) + return resolvedHost{}, fmt.Errorf("NetBox: %w", err) } if cached, fresh := c.Get(target.Target()); fresh && cached.Kind == target.Kind { - return used(cached) + return used(cached), nil } chain, err := resolver.New(cfg.Resolver) if err != nil { - fatalf("resolver: %v", err) + return resolvedHost{}, err } - ip, err := chain.Resolve(ctx, &target, nbClient) + ip, strategy, err := chain.ResolveWithStrategy(ctx, &target, nbClient) if err != nil { - fatalf("IP resolution for %q: %v", host, err) + return resolvedHost{}, fmt.Errorf("IP resolution for %q: %w", host, err) } - entry := cache.Entry{Name: target.Target(), IP: ip, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster} + entry := cache.Entry{Name: target.Target(), IP: ip, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster, Resolver: strategy} c.Upsert(entry) - return used(entry) + result := used(entry) + result.Origin = "live" + return result, nil } // findSSHHost uses the paginated, ambiguity-checking lookup for connection @@ -353,7 +379,24 @@ func connectHost(cfg *config.Config, client internalssh.Client, flags internalss fatalf("%v", err) } _, name := netbox.SplitTarget(host.Name) - execClient(client, client.Apply(args, dests, internalssh.Host{Name: name, IP: host.IP}, opts, flags), flags) + result := client.Apply(args, dests, internalssh.Host{Name: name, IP: host.IP}, opts, flags) + post := config.HookCommand(opts.PostDisconnect) + if flags.DryRun { + if post != "" { + fmt.Fprintf(os.Stderr, "# post_disconnect (skipped in --dry-run): %s\n", post) + } + } + if !flags.DryRun && (post != "" || cfg.Activity.Enabled) { + if result.Notice != "" { + fmt.Fprintln(os.Stderr, result.Notice) + } + code := supervise(cfg, host, client.Name, append([]string{client.Name}, result.Args...), post, 0, false, os.Stdin, os.Stdout, os.Stderr) + if code != 0 { + os.Exit(code) + } + return + } + execClient(client, result, flags) } // hostOptions merges the global, instance, and rule SSH options for host. @@ -391,6 +434,49 @@ func runTUI() { m := tui.New(nbClient, c, cfg.SSH.DefaultUser, cfg.SSH.DefaultPort) m.SetHostLabel(cfg.HostLabel) + m.SetHistoryLimit(cfg.TUI.HistoryLimit) + state, stateErr := activity.Read() + if stateErr != nil { + fmt.Fprintf(os.Stderr, "favorites: %v\n", stateErr) + } + m.SetPreferences(state.Favorites, state.Pinned, func(favorites, pinned map[string]bool) error { + err := activity.Update(func(s *activity.State) { + merge := func(dst, previous, next map[string]bool) { + for name, value := range next { + if previous[name] != value { + if value { + dst[name] = true + } else { + delete(dst, name) + } + } + } + for name, value := range previous { + if value && !next[name] { + delete(dst, name) + } + } + } + merge(s.Favorites, state.Favorites, favorites) + merge(s.Pinned, state.Pinned, pinned) + }) + if err == nil { + state.Favorites = favorites + state.Pinned = pinned + } + return err + }) + m.SetCommands(func(name, kind string, tags []string) []string { + var names []string + h := commandHost(resolvedHost{Name: name, Kind: kind, Tags: tags}) + for name, c := range cfg.Commands { + if c.Allowed(h) { + names = append(names, name) + } + } + sort.Strings(names) + return names + }) if cfg.Shortcuts.Show { aliases := shortcutAliases(c.All(), *cfg) m.SetAliases(func(target string) string { return aliases[strings.ToLower(target)] }) @@ -413,6 +499,22 @@ func runTUI() { if host == nil { return } + if host.Command != "" { + args := []string{"run", host.Command, "--", host.Name} + if len(host.Targets) > 0 { + args = append([]string{"batch", host.Command}, host.Targets...) + } + root := rootCmd() + root.SetArgs(args) + if err := root.Execute(); err != nil { + var exit *commandExit + if errors.As(err, &exit) { + os.Exit(exit.code) + } + fatalf("%v", err) + } + return + } if host.Action == tui.ActionMulti { if err := runMulti(cfg, host.Targets, multiFlags{}); err != nil { fatalf("%v", err) @@ -439,11 +541,12 @@ func runTUI() { if err != nil { fatalf("resolver: %v", err) } - host.IP, err = chain.Resolve(ctx, &target, nbClient) + var strategy string + host.IP, strategy, err = chain.ResolveWithStrategy(ctx, &target, nbClient) if err != nil { fatalf("IP resolution: %v", err) } - c.Upsert(cache.Entry{Name: target.Target(), IP: host.IP, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster}) + c.Upsert(cache.Entry{Name: target.Target(), IP: host.IP, Kind: target.Kind, Tags: target.Tags, Cluster: target.Cluster, Resolver: strategy}) tags = target.Tags } fmt.Fprintf(os.Stderr, "Connecting to %s (%s)…\n", host.Name, host.IP) @@ -529,7 +632,7 @@ func rootCmd() *cobra.Command { }, } - root.AddCommand(runCmd(), notesCmd(), configureCmd(), searchCmd(), cacheCmd(), aliasCmd(), hookCmd(), shellInitCmd(), versionCmd(), uninstallCmd(), sftpCmd(), scpCmd(), tunnelCmd(), hostsCmd(), multiCmd(), syncCmd()) + root.AddCommand(doctorCmd(), explainCmd(), favoritesCmd(), historyCmd(), batchCmd(), configCmd(), runCmd(), notesCmd(), configureCmd(), searchCmd(), cacheCmd(), aliasCmd(), hookCmd(), shellInitCmd(), versionCmd(), uninstallCmd(), sftpCmd(), scpCmd(), tunnelCmd(), hostsCmd(), multiCmd(), syncCmd()) // cobra builds the "completion" command lazily; force init so we can extend it. root.InitDefaultCompletionCmd() @@ -792,7 +895,7 @@ func cacheRefreshCmd() *cobra.Command { continue } - ip, err := chain.Resolve(ctx, e, nbClient) + ip, strategy, err := chain.ResolveWithStrategy(ctx, e, nbClient) if err != nil { // Do not turn a failed configured strategy into a fresh // primary-IP cache hit that bypasses the resolver. @@ -803,7 +906,7 @@ func cacheRefreshCmd() *cobra.Command { fmt.Fprintf(os.Stderr, "warning: skipping %s: %v\n", e.Name, err) continue } - c.Upsert(cache.Entry{Name: e.Target(), IP: ip, Kind: e.Kind, Tags: e.Tags, Cluster: e.Cluster}) + c.Upsert(cache.Entry{Name: e.Target(), IP: ip, Kind: e.Kind, Tags: e.Tags, Cluster: e.Cluster, Resolver: strategy}) written++ } diff --git a/cmd/netssh/operations.go b/cmd/netssh/operations.go new file mode 100644 index 0000000..ca891ad --- /dev/null +++ b/cmd/netssh/operations.go @@ -0,0 +1,193 @@ +package main + +import ( + "context" + "encoding/json" + "fmt" + "os" + "os/exec" + "sort" + "strings" + "time" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/resolver" + "github.com/spf13/cobra" +) + +func doctorCmd() *cobra.Command { + var online bool + cmd := &cobra.Command{Use: "doctor", Short: "Check configuration, programs, cache and optional NetBox connectivity", Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, _ []string) error { + cfg, err := config.Load() + if err != nil { + return err + } + failed := false + report := func(label string, err error) { + if err != nil { + failed = true + fmt.Fprintf(cmd.OutOrStdout(), "FAIL %s: %v\n", label, err) + } else { + fmt.Fprintf(cmd.OutOrStdout(), "OK %s\n", label) + } + } + report("configuration", nil) + _, err = resolver.New(cfg.Resolver) + report("resolver", err) + programs := map[string]bool{"ssh": true, "sftp": true, "scp": true} + for name, c := range cfg.Commands { + programs[c.Args[0]] = true + if len(c.Args) > 1 && !strings.HasPrefix(c.Args[1], "-") { + switch c.Args[0] { + case "bash", "sh", "python", "python3": + f, err := os.Open(c.Args[1]) + if err == nil { + f.Close() + } + report("script "+name, err) + } + } + } + var names []string + for p := range programs { + names = append(names, p) + } + sort.Strings(names) + for _, p := range names { + _, err := exec.LookPath(p) + report("program "+p, err) + } + report("cache", newCache(cfg).Load()) + if online { + sources := cfg.NetBoxes + if len(sources) == 0 && cfg.NetBox.URL != "" { + sources = []config.NetBoxConfig{cfg.NetBox} + } + for _, s := range sources { + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + _, err := netbox.NewClient(s.URL, s.Token, s.TokenVersion).Search(ctx, "", netbox.SearchOptions{}) + cancel() + report("NetBox "+s.Name, err) + } + } + if failed { + return fmt.Errorf("doctor found problems") + } + return nil + }} + cmd.Flags().BoolVar(&online, "online", false, "Also query every NetBox instance") + return cmd +} +func explainCmd() *cobra.Command { + return &cobra.Command{Use: "explain HOST", Short: "Explain actual host resolution and effective SSH settings without connecting", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + cfg, err := config.Load() + if err != nil { + return err + } + h, err := resolveTargetE(cfg, args[0], false) + if err != nil { + return err + } + selectors := commandHost(h) + user, port := hostDefaults(cfg, h) + opts := hostOptions(cfg, h) + var rules []int + for i, r := range cfg.SSH.Rules { + if r.Match.Matches(selectors) { + rules = append(rules, i+1) + } + } + strategy := h.Resolver + if strategy == "" { + if h.Origin == "static" { + strategy = "static address" + } else { + strategy = "not recorded in this cache entry" + } + } + return json.NewEncoder(cmd.OutOrStdout()).Encode(map[string]any{ + "target": h.Name, "instance": selectors.Instance, "address": h.IP, "source": h.Origin, "cached_at": h.CachedAt, + "resolver_order": cfg.Resolver.Strategies, "resolver_used": strategy, "matching_rules": rules, "user": user, "port": port, "ssh": opts, + }) + }} +} +func favoritesCmd() *cobra.Command { + cmd := &cobra.Command{Use: "favorites", Short: "List or change favorite and pinned hosts", RunE: func(cmd *cobra.Command, _ []string) error { + s, err := activity.Read() + if err != nil { + return err + } + var names []string + for n := range s.Favorites { + if s.Favorites[n] { + names = append(names, n) + } + } + sort.Strings(names) + for _, n := range names { + marker := "favorite" + if s.Pinned[n] { + marker = "pinned" + } + fmt.Fprintf(cmd.OutOrStdout(), "%s\t%s\n", n, marker) + } + return nil + }} + for _, action := range []string{"add", "remove", "pin", "unpin"} { + cmd.AddCommand(&cobra.Command{Use: action + " HOST", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + target := args[0] + if action == "add" || action == "pin" { + cfg, err := config.Load() + if err != nil { + return err + } + h, err := resolveTargetE(cfg, target, false) + if err != nil { + return err + } + target = h.Name + } + return activity.Update(func(s *activity.State) { + switch action { + case "add": + s.Favorites[target] = true + case "pin": + s.Favorites[target] = true + s.Pinned[target] = true + case "unpin": + delete(s.Pinned, target) + case "remove": + delete(s.Favorites, target) + delete(s.Pinned, target) + } + }) + }}) + } + return cmd +} +func historyCmd() *cobra.Command { + cmd := &cobra.Command{Use: "history", Short: "Show optional local action history", RunE: func(cmd *cobra.Command, _ []string) error { + cfg, err := config.Load() + if err != nil { + return err + } + if err := activity.Update(func(s *activity.State) { activity.Prune(s, cfg.Activity) }); err != nil { + return err + } + s, err := activity.Read() + if err != nil { + return err + } + for i := len(s.Records) - 1; i >= 0; i-- { + r := s.Records[i] + fmt.Fprintf(cmd.OutOrStdout(), "%s\t%s\t%s\texit=%d\t%s\n", r.Time.Format(time.RFC3339), r.Host, r.Command, r.Code, r.Duration.Round(time.Millisecond)) + } + return nil + }} + cmd.AddCommand(&cobra.Command{Use: "clear", Short: "Delete recorded actions, preserving favorites", Args: cobra.NoArgs, RunE: func(_ *cobra.Command, _ []string) error { + return activity.Update(func(s *activity.State) { s.Records = nil }) + }}) + return cmd +} diff --git a/cmd/netssh/operations_test.go b/cmd/netssh/operations_test.go new file mode 100644 index 0000000..d127434 --- /dev/null +++ b/cmd/netssh/operations_test.go @@ -0,0 +1,258 @@ +package main + +import ( + "bytes" + "encoding/json" + "fmt" + "os" + "os/exec" + "path/filepath" + "reflect" + "strings" + "testing" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" +) + +func writeOperationsConfig(t *testing.T, extra string) { + t.Helper() + prepareTransferTest(t) + data := `hosts: + - name: router + address: 192.0.2.1 + tags: [router] + - name: fail + address: 192.0.2.2 + - name: okay + address: 192.0.2.3 +resolver: + strategies: [primary_ip] +` + extra + if err := os.WriteFile(config.Path(), []byte(data), 0600); err != nil { + t.Fatal(err) + } +} +func TestPostHooksFiltersAndConfirmation(t *testing.T) { + dir := t.TempDir() + marker := filepath.Join(dir, "post") + writeOperationsConfig(t, fmt.Sprintf(` +commands: + success: + args: [sh, -c, "exit 0", "{host}"] + post_run: 'printf "%%s:%%s" "$NETSSH_HOST" "$NETSSH_EXIT_CODE" > %s' + failure: + args: [sh, -c, "exit 7", "{host}"] + post_run: 'printf "%%s" "$NETSSH_EXIT_CODE" > %s; exit 9' + postfail: + args: [sh, -c, "exit 0", "{host}"] + post_run: exit 9 + protected: + args: [sh, -c, "exit 0", "{host}"] + confirm: true + match: {tag: router, kind: static, name: "rou*"} + timeout: + args: [sh, -c, "sleep 20", "{host}"] + timeout: 50ms +activity: + enabled: true + retention_days: 30 + max_entries: 50 +`, marker, marker)) + if out, err := runNetssh(t, "run", "--dry-run", "success", "router"); err != nil { + t.Fatalf("%s %v", out, err) + } + if _, err := os.Stat(marker); !os.IsNotExist(err) { + t.Fatal("dry-run executed post hook") + } + if out, err := runNetssh(t, "run", "success", "router"); err != nil { + t.Fatalf("%s %v", out, err) + } + data, _ := os.ReadFile(marker) + if string(data) != "router:0" { + t.Fatal(string(data)) + } + for _, tc := range []struct { + name string + code int + }{{"failure", 7}, {"postfail", 9}, {"timeout", 124}} { + _, err := runNetssh(t, "run", tc.name, "router") + exit, ok := err.(*exec.ExitError) + if !ok || exit.ExitCode() != tc.code { + t.Fatalf("%s: %v", tc.name, err) + } + } + data, _ = os.ReadFile(marker) + if string(data) != "7" { + t.Fatal(string(data)) + } + if out, err := runNetssh(t, "run", "protected", "router"); err == nil || !strings.Contains(out, "--yes") { + t.Fatalf("%q %v", out, err) + } + if out, err := runNetssh(t, "run", "--yes", "protected", "router"); err != nil { + t.Fatalf("%q %v", out, err) + } + if out, err := runNetssh(t, "run", "--yes", "protected", "okay"); err == nil || !strings.Contains(out, "not allowed") { + t.Fatalf("%q %v", out, err) + } + state, err := activity.Read() + if err != nil || len(state.Records) != 5 { + t.Fatalf("%+v %v", state, err) + } +} +func TestSSHPostDisconnect(t *testing.T) { + dir := t.TempDir() + marker := filepath.Join(dir, "after") + writeOperationsConfig(t, fmt.Sprintf("ssh:\n post_disconnect: 'printf \"%%s\" \"$NETSSH_EXIT_CODE\" > %s'\n", marker)) + if err := os.WriteFile(filepath.Join(dir, "ssh"), []byte("#!/bin/sh\nexit 6\n"), 0700); err != nil { + t.Fatal(err) + } + t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH")) + _, err := runNetssh(t, "router") + exit, ok := err.(*exec.ExitError) + if !ok || exit.ExitCode() != 6 { + t.Fatal(err) + } + data, _ := os.ReadFile(marker) + if string(data) != "6" { + t.Fatalf("post: %s", data) + } +} +func TestExplainAndFavorites(t *testing.T) { + writeOperationsConfig(t, "tui:\n history_limit: 25\nssh:\n rules:\n - match: {tag: router}\n post_disconnect: echo done\n") + out, err := runNetssh(t, "explain", "router") + if err != nil { + t.Fatalf("%s %v", out, err) + } + var result map[string]any + if err := json.Unmarshal([]byte(out), &result); err != nil { + t.Fatal(err) + } + if result["source"] != "static" || result["address"] != "192.0.2.1" { + t.Fatal(result) + } + for _, args := range [][]string{{"favorites", "pin", "router"}, {"favorites", "add", "okay"}} { + if out, err := runNetssh(t, args...); err != nil { + t.Fatalf("%s %v", out, err) + } + } + state, err := activity.Read() + if err != nil || !state.Pinned["router"] || !state.Favorites["okay"] { + t.Fatalf("%+v %v", state, err) + } + if out, err := runNetssh(t, "favorites", "remove", "router"); err != nil { + t.Fatalf("%s %v", out, err) + } + state, _ = activity.Read() + if state.Pinned["router"] || state.Favorites["router"] { + t.Fatal(state) + } +} +func TestPortableConfigOmitsAllExecutableSecrets(t *testing.T) { + c := config.Config{ + NetBoxes: []config.NetBoxConfig{{Name: "prod", URL: "https://user:URLSECRET@netbox.example", Token: "TOKEN", SSH: config.SSHOptions{PreConnect: "HOOKSECRET"}}}, + SSH: config.SSHConfig{SSHOptions: config.SSHOptions{Options: map[string]string{"ProxyCommand": "OPTIONSECRET"}, PostDisconnect: "POSTSECRET"}}, + Commands: map[string]config.HostCommand{"check": {Args: []string{"echo", "COMMANDSECRET", "{host}"}}}, + Hosts: []config.StaticHost{{Name: "router", Address: "192.0.2.1", SSH: config.SSHOptions{PreConnect: "STATICSECRET"}}}, + TUI: config.TUIConfig{HistoryLimit: 25}, + } + data, err := json.Marshal(portableConfig(c)) + if err != nil { + t.Fatal(err) + } + for _, secret := range []string{"URLSECRET", "TOKEN", "HOOKSECRET", "OPTIONSECRET", "POSTSECRET", "COMMANDSECRET", "STATICSECRET"} { + if bytes.Contains(data, []byte(secret)) { + t.Fatalf("export leaked %s", secret) + } + } + parsed, err := decodePortable(data) + if err != nil { + t.Fatal(err) + } + if parsed.TUI.HistoryLimit != 25 || len(parsed.NetBoxes) != 1 || parsed.NetBoxes[0].URL != "https://netbox.example" { + t.Fatalf("%+v", parsed) + } + hostile := []byte("netbox:\n url: https://netbox.example\n token: bad\nssh:\n pre_connect: touch /tmp/never\ncommands:\n check:\n args: [sh, -c, evil]\n") + parsed, err = decodePortable(hostile) + if err != nil || parsed.NetBox.Token != "" || parsed.SSH.PreConnect != "" || len(parsed.Commands) != 0 { + t.Fatalf("%+v %v", parsed, err) + } +} +func TestBatchRetryFailedOnly(t *testing.T) { + bin := filepath.Join(t.TempDir(), "netssh") + build := exec.Command("go", "build", "-o", bin, ".") + if out, err := build.CombinedOutput(); err != nil { + t.Fatalf("build: %s %v", out, err) + } + old := batchExecutable + batchExecutable = func() (string, error) { return bin, nil } + t.Cleanup(func() { batchExecutable = old }) + dir := t.TempDir() + script := filepath.Join(dir, "check.sh") + ready := filepath.Join(dir, "ready") + if err := os.WriteFile(script, []byte(fmt.Sprintf("#!/bin/sh\nif [ \"$1\" = fail ] && [ ! -f %q ]; then exit 3; fi\nprintf 'ran %%s\\n' \"$1\"\n", ready)), 0700); err != nil { + t.Fatal(err) + } + writeOperationsConfig(t, fmt.Sprintf("commands:\n check:\n args: [%q, \"{host}\"]\n", script)) + run := func(args ...string) (string, error) { + cmd := batchCmd() + cmd.SetArgs(args) + var out bytes.Buffer + cmd.SetOut(&out) + cmd.SetErr(&out) + err := cmd.Execute() + return out.String(), err + } + out, err := run("--parallel", "2", "check", "router", "fail", "okay") + if err == nil || !strings.Contains(out, "2 succeeded, 1 failed") { + t.Fatalf("%s %v", out, err) + } + data, _ := os.ReadFile(batchPath()) + var retry batchRetry + if err := json.Unmarshal(data, &retry); err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(retry.Hosts, []string{"fail"}) { + t.Fatalf("%+v", retry) + } + if err := os.WriteFile(ready, nil, 0600); err != nil { + t.Fatal(err) + } + out, err = run("--retry-failed") + if err != nil || !strings.Contains(out, "1 succeeded, 0 failed") || strings.Contains(out, "ran router") { + t.Fatalf("%s %v", out, err) + } +} + +func TestImportPreservesOnlyMatchingCredentials(t *testing.T) { + writeOperationsConfig(t, "") + original := []byte("netboxes:\n - name: prod\n url: https://prod.example\n token: LOCALPROD\n - name: lab\n url: https://lab.example\n token: LOCALLAB\ncommands:\n local:\n args: [echo, \"{host}\"]\n") + if err := os.WriteFile(config.Path(), original, 0600); err != nil { + t.Fatal(err) + } + shared := filepath.Join(t.TempDir(), "shared.yaml") + if err := os.WriteFile(shared, []byte("netboxes:\n - name: prod\n url: https://prod.example\n token: UNTRUSTED\n - name: lab\n url: https://other.example\ntui:\n history_limit: 25\nssh:\n pre_connect: evil\n"), 0600); err != nil { + t.Fatal(err) + } + if out, err := runNetssh(t, "config", "import", shared, "--dry-run"); err != nil { + t.Fatalf("%s %v", out, err) + } + after, _ := os.ReadFile(config.Path()) + if !bytes.Equal(original, after) { + t.Fatal("preview changed config") + } + if out, err := runNetssh(t, "config", "import", shared, "--yes"); err != nil { + t.Fatalf("%s %v", out, err) + } + cfg, err := config.Load() + if err != nil { + t.Fatal(err) + } + if cfg.NetBoxes[0].Token != "LOCALPROD" || cfg.NetBoxes[1].Token != "" || cfg.SSH.PreConnect != "" || len(cfg.Commands) != 1 || cfg.TUI.HistoryLimit != 25 { + t.Fatalf("incorrect imported settings: names=%d tui=%d", len(cfg.NetBoxes), cfg.TUI.HistoryLimit) + } + backup, _ := os.ReadFile(config.Path() + ".before-import") + if !bytes.Equal(backup, original) { + t.Fatal("backup differs") + } +} diff --git a/cmd/netssh/portable.go b/cmd/netssh/portable.go new file mode 100644 index 0000000..9647a6a --- /dev/null +++ b/cmd/netssh/portable.go @@ -0,0 +1,164 @@ +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 +} diff --git a/cmd/netssh/run.go b/cmd/netssh/run.go index 1c23ac7..ce431c2 100644 --- a/cmd/netssh/run.go +++ b/cmd/netssh/run.go @@ -3,13 +3,13 @@ package main import ( "fmt" "os" - "os/exec" "sort" "strings" - "syscall" + "time" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" + "github.com/charmbracelet/x/term" "github.com/spf13/cobra" ) @@ -25,7 +25,7 @@ func expandHostCommand(command config.HostCommand, host resolvedHost, extra []st } func runCmd() *cobra.Command { - var dryRun bool + var dryRun, yes, status bool cmd := &cobra.Command{ Use: "run [--dry-run] COMMAND HOST [-- EXTRA_ARGS...]", Short: "Run a configured local command for a NetBox or static host", @@ -39,9 +39,18 @@ func runCmd() *cobra.Command { if !ok { return fmt.Errorf("unknown configured command %q", args[0]) } - host := resolveTarget(cfg, args[1]) + host, err := resolveTargetE(cfg, args[1], !dryRun) + if err != nil { + return err + } + if !command.Allowed(commandHost(host)) { + return fmt.Errorf("command %q is not allowed for %s", args[0], host.Name) + } argv := expandHostCommand(command, host, args[2:]) if dryRun { + if post := config.HookCommand(command.PostRun); post != "" { + fmt.Fprintf(cmd.ErrOrStderr(), "# post_run (skipped in --dry-run): %s\n", post) + } for i, arg := range argv { if i > 0 { fmt.Fprint(cmd.OutOrStdout(), " ") @@ -51,11 +60,19 @@ func runCmd() *cobra.Command { fmt.Fprintln(cmd.OutOrStdout()) return nil } - path, err := exec.LookPath(argv[0]) - if err != nil { - return fmt.Errorf("%s not found in PATH: %w", argv[0], err) + if command.Confirm { + if err := confirmAction("Run "+args[0]+" on "+host.Name, yes); err != nil { + return err + } } - return syscall.Exec(path, argv, os.Environ()) + timeout, _ := time.ParseDuration(command.Timeout) + code := supervise(cfg, host, args[0], argv, command.PostRun, timeout, status || term.IsTerminal(os.Stderr.Fd()), os.Stdin, cmd.OutOrStdout(), cmd.ErrOrStderr()) + if code != 0 { + cmd.SilenceErrors = true + cmd.SilenceUsage = true + return &commandExit{code} + } + return nil }, ValidArgsFunction: func(cmd *cobra.Command, args []string, prefix string) ([]string, cobra.ShellCompDirective) { if len(args) == 0 { @@ -78,6 +95,12 @@ func runCmd() *cobra.Command { return nil, cobra.ShellCompDirectiveNoFileComp }, } + cmd.Flags().BoolVar(&yes, "yes", false, "Approve an action requiring confirmation") + cmd.Flags().BoolVar(&status, "status", false, "Show elapsed runtime") cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Print the command without running it") return cmd } + +type commandExit struct{ code int } + +func (e *commandExit) Error() string { return fmt.Sprintf("command exited with status %d", e.code) } diff --git a/cmd/netssh/supervise.go b/cmd/netssh/supervise.go new file mode 100644 index 0000000..15a65e7 --- /dev/null +++ b/cmd/netssh/supervise.go @@ -0,0 +1,59 @@ +package main + +import ( + "bufio" + "context" + "fmt" + "io" + "os" + "strconv" + "strings" + "time" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/activity" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/runner" + "github.com/charmbracelet/x/term" +) + +func commandHost(h resolvedHost) config.SSHHost { + instance, name := netbox.SplitTarget(h.Name) + return config.SSHHost{Instance: instance, Name: name, Kind: h.Kind, Tags: h.Tags} +} +func confirmAction(message string, yes bool) error { + if yes { + return nil + } + if !term.IsTerminal(os.Stdin.Fd()) { + return fmt.Errorf("%s requires confirmation; use --yes for unattended execution", message) + } + fmt.Fprintf(os.Stderr, "%s? [y/N] ", message) + answer, err := bufio.NewReader(os.Stdin).ReadString('\n') + if err != nil { + return err + } + if strings.EqualFold(strings.TrimSpace(answer), "y") || strings.EqualFold(strings.TrimSpace(answer), "yes") { + return nil + } + return fmt.Errorf("cancelled") +} +func supervise(cfg *config.Config, h resolvedHost, name string, argv []string, post string, timeout time.Duration, status bool, stdin io.Reader, stdout, stderr io.Writer) int { + start := time.Now() + env := append(preConnectEnv(h, name), "NETSSH_COMMAND="+name) + result := runner.Run(context.Background(), argv, runner.Options{Stdin: stdin, Stdout: stdout, Stderr: stderr, Env: env, Timeout: timeout, Status: status, Label: name + " " + h.Name}) + code := result.Code + if result.Started && config.HookCommand(post) != "" { + hook := runner.Run(context.Background(), []string{"sh", "-c", post}, runner.Options{Stdin: nil, Stdout: stderr, Stderr: stderr, Env: append(env, "NETSSH_EXIT_CODE="+strconv.Itoa(code)), Timeout: 30 * time.Second}) + if hook.Code != 0 { + fmt.Fprintf(stderr, "post hook failed (exit %d)\n", hook.Code) + if code == 0 { + code = hook.Code + } + } + } + if err := activity.Append(cfg.Activity, activity.Record{Time: start, Host: h.Name, Command: name, Code: code, Duration: time.Since(start)}); err != nil { + fmt.Fprintf(stderr, "activity: %v\n", err) + } + return code +} diff --git a/cmd/netssh/testmain_test.go b/cmd/netssh/testmain_test.go new file mode 100644 index 0000000..b15aa67 --- /dev/null +++ b/cmd/netssh/testmain_test.go @@ -0,0 +1,14 @@ +package main + +import ( + "os" + "testing" +) + +// Integration helpers run this test binary as netssh. An automatic refresh +// would otherwise launch the test binary again with "cache refresh", rerunning +// the entire suite. Explicit cache-refresh tests still exercise the real command. +func TestMain(m *testing.M) { + _ = os.Setenv("NETSSH_NO_REFRESH", "1") + os.Exit(m.Run()) +} diff --git a/cmd/netssh/uninstall.go b/cmd/netssh/uninstall.go index 125e9cf..a72a106 100644 --- a/cmd/netssh/uninstall.go +++ b/cmd/netssh/uninstall.go @@ -204,10 +204,10 @@ func uninstallCmd() *cobra.Command { - netssh blocks and unmarked entries of older versions in bash, zsh, and fish profiles - shell completion files (bash, zsh, fish, oh-my-zsh cache, command alias) - the cache directory with hosts, aliases, and per-instance caches - - the config file (a private backup is kept) and local server notes + - the config file (a private backup is kept) and local notes, favorites, action history and batch retry state - the netssh binary -Use --keep-config to keep the config file and notes for a reinstall.`, +Use --keep-config to keep the config file and local state for a reinstall.`, Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { cfg, err := config.Load() @@ -244,7 +244,7 @@ Use --keep-config to keep the config file and notes for a reinstall.`, return err }, } - cmd.Flags().BoolVar(&keepConfig, "keep-config", false, "Keep the config file and local notes") + cmd.Flags().BoolVar(&keepConfig, "keep-config", false, "Keep the config file and local state") cmd.Flags().BoolVarP(&yes, "yes", "y", false, "Do not ask for confirmation") cmd.Flags().BoolVar(&dryRun, "dry-run", false, "Only show what would be removed") return cmd diff --git a/internal/activity/store.go b/internal/activity/store.go new file mode 100644 index 0000000..63cd27e --- /dev/null +++ b/internal/activity/store.go @@ -0,0 +1,94 @@ +// Package activity stores local preferences and optional execution metadata. +// No command arguments, environment variables, tokens or command output are logged. +package activity + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "sort" + "time" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/storage" + "golang.org/x/sys/unix" +) + +type Record struct { + Time time.Time `json:"time"` + Host string `json:"host"` + Command string `json:"command"` + Code int `json:"exit_code"` + Duration time.Duration `json:"duration_ns"` +} +type State struct { + Favorites map[string]bool `json:"favorites,omitempty"` + Pinned map[string]bool `json:"pinned,omitempty"` + Records []Record `json:"records,omitempty"` +} + +func Path() string { return filepath.Join(filepath.Dir(config.Path()), "netssh", "activity.json") } +func Read() (State, error) { + var s State + data, err := os.ReadFile(Path()) + if os.IsNotExist(err) { + err = nil + } else if err == nil { + err = json.Unmarshal(data, &s) + } + if s.Favorites == nil { + s.Favorites = map[string]bool{} + } + if s.Pinned == nil { + s.Pinned = map[string]bool{} + } + return s, err +} +func Update(change func(*State)) error { + p := Path() + if err := os.MkdirAll(filepath.Dir(p), 0700); err != nil { + return err + } + f, err := os.OpenFile(p+".lock", os.O_CREATE|os.O_RDWR, 0600) + if err != nil { + return err + } + defer f.Close() + if err = unix.Flock(int(f.Fd()), unix.LOCK_EX); err != nil { + return err + } + defer unix.Flock(int(f.Fd()), unix.LOCK_UN) + s, err := Read() + if err != nil { + return fmt.Errorf("local state: %w", err) + } + change(&s) + data, err := json.MarshalIndent(s, "", " ") + if err != nil { + return err + } + return storage.WriteFile(p, data, 0600) +} +func Prune(s *State, c config.ActivityConfig) { + if c.RetentionDays > 0 { + cutoff := time.Now().Add(-time.Duration(c.RetentionDays) * 24 * time.Hour) + keep := s.Records[:0] + for _, r := range s.Records { + if !r.Time.Before(cutoff) { + keep = append(keep, r) + } + } + s.Records = keep + } + sort.SliceStable(s.Records, func(i, j int) bool { return s.Records[i].Time.Before(s.Records[j].Time) }) + if c.MaxEntries > 0 && len(s.Records) > c.MaxEntries { + s.Records = s.Records[len(s.Records)-c.MaxEntries:] + } +} +func Append(c config.ActivityConfig, r Record) error { + if !c.Enabled { + return nil + } + return Update(func(s *State) { s.Records = append(s.Records, r); Prune(s, c) }) +} diff --git a/internal/activity/store_test.go b/internal/activity/store_test.go new file mode 100644 index 0000000..b0f3f93 --- /dev/null +++ b/internal/activity/store_test.go @@ -0,0 +1,59 @@ +package activity + +import ( + "fmt" + "os" + "sync" + "testing" + "time" + + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" +) + +func TestConcurrentActivityAndRetention(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + cfg := config.ActivityConfig{Enabled: true, RetentionDays: 1, MaxEntries: 10} + if err := Update(func(s *State) { + s.Favorites["prod/web"] = true + s.Pinned["prod/web"] = true + s.Records = []Record{{Time: time.Now().Add(-48 * time.Hour), Host: "old"}} + }); err != nil { + t.Fatal(err) + } + var wg sync.WaitGroup + for i := 0; i < 20; i++ { + wg.Add(1) + go func() { + defer wg.Done() + if err := Append(cfg, Record{Time: time.Now(), Host: fmt.Sprint(i), Command: "test"}); err != nil { + t.Error(err) + } + }() + } + wg.Wait() + s, err := Read() + if err != nil { + t.Fatal(err) + } + if len(s.Records) != 10 || !s.Favorites["prod/web"] || !s.Pinned["prod/web"] { + t.Fatalf("%+v", s) + } + for _, r := range s.Records { + if r.Host == "old" { + t.Fatal("expired record retained") + } + } + info, _ := os.Stat(Path()) + if info.Mode().Perm() != 0600 { + t.Fatal(info.Mode()) + } +} +func TestDisabledHistoryDoesNotWrite(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + if err := Append(config.ActivityConfig{}, Record{}); err != nil { + t.Fatal(err) + } + if _, err := os.Stat(Path()); !os.IsNotExist(err) { + t.Fatal("disabled history wrote data") + } +} diff --git a/internal/cache/cache.go b/internal/cache/cache.go index 7bf935d..5d40839 100644 --- a/internal/cache/cache.go +++ b/internal/cache/cache.go @@ -17,6 +17,7 @@ import ( ) type Entry struct { + Resolver string `json:"resolver,omitempty"` Name string `json:"name"` IP string `json:"ip"` Kind string `json:"kind"` diff --git a/internal/config/commands.go b/internal/config/commands.go index ea8f695..a290e2c 100644 --- a/internal/config/commands.go +++ b/internal/config/commands.go @@ -4,10 +4,15 @@ import ( "fmt" "regexp" "strings" + "time" ) // HostCommand defines a local command and the prefix of its generated host aliases. type HostCommand struct { + PostRun string `mapstructure:"post_run"` + Match SSHMatch `mapstructure:"match"` + Confirm bool `mapstructure:"confirm"` + Timeout string `mapstructure:"timeout"` AliasPrefix string `mapstructure:"alias_prefix" yaml:"alias_prefix"` Args []string `mapstructure:"args" yaml:"args"` } @@ -15,6 +20,20 @@ type HostCommand struct { func (c *Config) ValidateCommands() error { prefixes := make(map[string]bool) for name, command := range c.Commands { + if strings.ContainsRune(command.PostRun, 0) { + return fmt.Errorf("commands.%s.post_run contains NUL", name) + } + if command.Match != (SSHMatch{}) { + if err := command.Match.Validate("commands." + name); err != nil { + return err + } + } + if command.Timeout != "" { + d, err := time.ParseDuration(command.Timeout) + if err != nil || d <= 0 { + return fmt.Errorf("commands.%s.timeout requires a positive duration", name) + } + } if name == "" || ValidateCommandAlias(name) != nil { return fmt.Errorf("commands.%s: name must be a non-reserved shell identifier", name) } diff --git a/internal/config/config.go b/internal/config/config.go index 13904e4..ba830eb 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -11,6 +11,8 @@ import ( ) type Config struct { + TUI TUIConfig `mapstructure:"tui"` + Activity ActivityConfig `mapstructure:"activity"` Commands map[string]HostCommand `mapstructure:"commands"` Shell ShellConfig `mapstructure:"shell"` NetBox NetBoxConfig `mapstructure:"netbox"` @@ -113,6 +115,9 @@ func Load() (*Config, error) { v.SetDefault("resolver.strategies", []string{"management_subnet", "primary_ip"}) v.SetDefault("resolver.management_subnets", []string{}) v.SetDefault("cache.ttl", 3600) + v.SetDefault("tui.history_limit", 10) + v.SetDefault("activity.retention_days", 30) + v.SetDefault("activity.max_entries", 1000) configDir, err := os.UserConfigDir() if err == nil { @@ -126,7 +131,7 @@ func Load() (*Config, error) { v.SetEnvPrefix("NETSSH") v.SetEnvKeyReplacer(strings.NewReplacer(".", "_")) v.AutomaticEnv() - for _, key := range []string{"netbox.url", "netbox.token", "netbox.token_version", "resolver.strategies", "resolver.management_subnets", "resolver.interface_name", "resolver.hostname_domain", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shortcuts.show", "shell.alias", "ssh.proxy_jump", "ssh.pre_connect", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results", "multi.multiplexer", "multi.panes_per_window"} { + for _, key := range []string{"netbox.url", "netbox.token", "netbox.token_version", "resolver.strategies", "resolver.management_subnets", "resolver.interface_name", "resolver.hostname_domain", "cache.ttl", "cache.path", "ssh.default_user", "ssh.default_port", "shortcuts.domains", "shortcuts.strip_hyphens", "shortcuts.show", "shell.alias", "ssh.proxy_jump", "ssh.pre_connect", "ssh.post_disconnect", "tui.history_limit", "activity.enabled", "activity.retention_days", "activity.max_entries", "ssh.host_key_checking", "ssh.target", "ssh.address_family", "completion.max_results", "multi.multiplexer", "multi.panes_per_window"} { if err := v.BindEnv(key); err != nil { return nil, err } @@ -172,6 +177,9 @@ func Load() (*Config, error) { if err := cfg.ValidateHosts(); err != nil { return nil, err } + if err := cfg.ValidateOperations(); err != nil { + return nil, err + } if err := cfg.ValidateCommands(); err != nil { return nil, err } diff --git a/internal/config/operations.go b/internal/config/operations.go new file mode 100644 index 0000000..c2e1462 --- /dev/null +++ b/internal/config/operations.go @@ -0,0 +1,34 @@ +package config + +import ( + "fmt" + "strings" +) + +type TUIConfig struct { + HistoryLimit int `mapstructure:"history_limit"` +} +type ActivityConfig struct { + Enabled bool `mapstructure:"enabled"` + RetentionDays int `mapstructure:"retention_days"` + MaxEntries int `mapstructure:"max_entries"` +} + +func (c *Config) ValidateOperations() error { + if c.TUI.HistoryLimit < 0 { + return fmt.Errorf("tui.history_limit must be >= 0 (0 = all)") + } + if c.Activity.RetentionDays < 0 || c.Activity.MaxEntries < 0 { + return fmt.Errorf("activity retention_days and max_entries must be >= 0") + } + return nil +} +func (m SSHMatch) Matches(host SSHHost) bool { return m == (SSHMatch{}) || m.matches(host) } +func (c HostCommand) Allowed(host SSHHost) bool { return c.Match.Matches(host) } +func HookCommand(s string) string { + s = strings.TrimSpace(s) + if strings.EqualFold(s, "none") { + return "" + } + return s +} diff --git a/internal/config/operations_test.go b/internal/config/operations_test.go new file mode 100644 index 0000000..858ece1 --- /dev/null +++ b/internal/config/operations_test.go @@ -0,0 +1,55 @@ +package config + +import ( + "os" + "path/filepath" + "testing" +) + +func TestOperationsDefaultsEnvironmentAndValidation(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + if err := os.WriteFile(filepath.Join(os.Getenv("XDG_CONFIG_HOME"), "netssh.yaml"), []byte("hosts:\n - name: router\n address: 192.0.2.1\n"), 0600); err != nil { + t.Fatal(err) + } + cfg, err := Load() + if err != nil { + t.Fatal(err) + } + if cfg.TUI.HistoryLimit != 10 || cfg.Activity.Enabled || cfg.Activity.RetentionDays != 30 || cfg.Activity.MaxEntries != 1000 { + t.Fatalf("%+v %+v", cfg.TUI, cfg.Activity) + } + t.Setenv("NETSSH_TUI_HISTORY_LIMIT", "25") + t.Setenv("NETSSH_SSH_POST_DISCONNECT", "echo done") + cfg, err = Load() + if err != nil || cfg.TUI.HistoryLimit != 25 || cfg.SSH.PostDisconnect != "echo done" { + t.Fatalf("%+v %v", cfg, err) + } + cfg.TUI.HistoryLimit = -1 + if cfg.ValidateOperations() == nil { + t.Fatal("negative history accepted") + } + for _, timeout := range []string{"-1s", "0s", "invalid"} { + cfg.Commands = map[string]HostCommand{"check": {Args: []string{"echo", "{host}"}, Timeout: timeout}} + if cfg.ValidateCommands() == nil { + t.Fatalf("accepted %q", timeout) + } + } +} +func TestPostDisconnectLayering(t *testing.T) { + cfg := Config{ + SSH: SSHConfig{SSHOptions: SSHOptions{PostDisconnect: "global"}, Rules: []SSHRule{{Match: SSHMatch{Tag: "lab"}, SSHOptions: SSHOptions{PostDisconnect: "none"}}}}, + NetBoxes: []NetBoxConfig{{Name: "prod", SSH: SSHOptions{PostDisconnect: "instance"}}}, + } + for _, tc := range []struct { + host SSHHost + want string + }{ + {SSHHost{Name: "web"}, "global"}, + {SSHHost{Name: "web", Instance: "prod"}, "instance"}, + {SSHHost{Name: "web", Instance: "prod", Tags: []string{"lab"}}, ""}, + } { + if got := HookCommand(cfg.SSHOptionsFor(tc.host).PostDisconnect); got != tc.want { + t.Fatalf("%q want %q", got, tc.want) + } + } +} diff --git a/internal/config/ssh.go b/internal/config/ssh.go index d51e5b6..c0fdded 100644 --- a/internal/config/ssh.go +++ b/internal/config/ssh.go @@ -26,7 +26,8 @@ type SSHOptions struct { Forwards map[string]Forward `mapstructure:"forwards"` // PreConnect is a shell command run locally before connecting; a non-zero // exit aborts the connection. "none" disables a hook set by a broader layer. - PreConnect string `mapstructure:"pre_connect"` + PreConnect string `mapstructure:"pre_connect"` + PostDisconnect string `mapstructure:"post_disconnect"` } // PreConnectNone disables an inherited pre_connect hook. @@ -170,6 +171,9 @@ func (o SSHOptions) Validate(scope string) error { return fmt.Errorf("%s.options: invalid option %q", scope, key) } } + if strings.ContainsRune(o.PostDisconnect, 0) { + return fmt.Errorf("%s.post_disconnect must not contain NUL bytes", scope) + } if strings.ContainsRune(o.PreConnect, 0) { return fmt.Errorf("%s.pre_connect must not contain NUL bytes", scope) } @@ -239,6 +243,9 @@ func (o SSHOptions) merge(override SSHOptions) SSHOptions { if override.AddressFamily != "" { out.AddressFamily = override.AddressFamily } + if strings.TrimSpace(override.PostDisconnect) != "" { + out.PostDisconnect = override.PostDisconnect + } if strings.TrimSpace(override.PreConnect) != "" { out.PreConnect = override.PreConnect } diff --git a/internal/hook/aliases.go b/internal/hook/aliases.go index 245dbb6..9984147 100644 --- a/internal/hook/aliases.go +++ b/internal/hook/aliases.go @@ -165,6 +165,15 @@ func BuildAliasEntries(entries []cache.Entry, cfg config.Config) []AliasEntry { // Build from the final SSH aliases, preserving per-instance prefix and // collision handling. Never replace an existing SSH or command alias. hostAliases := append([]AliasEntry(nil), out...) + hostMetadata := map[string]config.SSHHost{} + for _, e := range entries { + instance, hostname, ok := strings.Cut(e.Name, "/") + if !ok { + hostname = instance + instance = "" + } + hostMetadata[e.Name] = config.SSHHost{Instance: instance, Name: hostname, Kind: e.Kind, Tags: e.Tags} + } var commands []string for name := range cfg.Commands { commands = append(commands, name) @@ -181,6 +190,9 @@ func BuildAliasEntries(entries []cache.Entry, cfg config.Config) []AliasEntry { if host.Host == "" { continue } + if !cfg.Commands[name].Allowed(hostMetadata[host.Host]) { + continue + } alias := prefix + host.Name commandCounts[alias]++ candidatesForCommands = append(candidatesForCommands, AliasEntry{Name: alias, Host: host.Host, Command: name}) diff --git a/internal/netbox/models.go b/internal/netbox/models.go index 7f958e3..df655a3 100644 --- a/internal/netbox/models.go +++ b/internal/netbox/models.go @@ -1,6 +1,9 @@ package netbox -import "strings" +import ( + "strings" + "time" +) // SearchOptions filters a Search or SearchAll query. // Zero value means no filtering (return all kinds, no tag filter). @@ -13,6 +16,9 @@ type SearchOptions struct { // HostEntry is a unified model for both devices and virtual machines from NetBox. type HostEntry struct { + Cached bool + CachedAt time.Time + Static bool Source string // named NetBox instance; empty for the legacy single-instance config ID int Name string diff --git a/internal/resolver/chain.go b/internal/resolver/chain.go index c5aca51..1d08092 100644 --- a/internal/resolver/chain.go +++ b/internal/resolver/chain.go @@ -28,19 +28,24 @@ func New(cfg config.ResolverConfig) (*Chain, error) { } func (c *Chain) Resolve(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) (string, error) { + address, _, err := c.ResolveWithStrategy(ctx, entry, client) + return address, err +} + +func (c *Chain) ResolveWithStrategy(ctx context.Context, entry *netbox.HostEntry, client *netbox.Client) (string, string, error) { for _, s := range c.strategies { ip, err := s.Resolve(ctx, entry, client) if err == nil { - return ip, nil + return ip, s.Name(), nil } // Only "this strategy has no address" moves on. After an API failure // the next strategy would connect to (and cache) a different address // than the configured order asks for. if !errors.Is(err, ErrNoIP) { - return "", fmt.Errorf("resolver strategy %q for %q: %w", s.Name(), entry.Name, err) + return "", "", fmt.Errorf("resolver strategy %q for %q: %w", s.Name(), entry.Name, err) } } - return "", fmt.Errorf("no strategy resolved an IP for %q", entry.Name) + return "", "", fmt.Errorf("no strategy resolved an IP for %q", entry.Name) } func newStrategy(name string, cfg config.ResolverConfig) (Strategy, error) { diff --git a/internal/runner/runner.go b/internal/runner/runner.go new file mode 100644 index 0000000..d0f3847 --- /dev/null +++ b/internal/runner/runner.go @@ -0,0 +1,146 @@ +// Package runner supervises local commands while retaining terminal I/O. +package runner + +import ( + "context" + "fmt" + "io" + "os" + "os/exec" + "os/signal" + "syscall" + "time" + + "github.com/charmbracelet/x/term" +) + +type Options struct { + Stdin io.Reader + Stdout, Stderr io.Writer + Env []string + Timeout time.Duration + Status bool + Label string +} +type Result struct { + Code int + Started bool + Duration time.Duration +} + +func Run(ctx context.Context, argv []string, o Options) Result { + if o.Stderr == nil { + o.Stderr = io.Discard + } + if o.Stdout == nil { + o.Stdout = io.Discard + } + start := time.Now() + result := Result{Code: 1} + if ctx.Err() != nil { + result.Code = 130 + return result + } + if len(argv) == 0 { + return result + } + cmd := exec.Command(argv[0], argv[1:]...) + cmd.Stdin, cmd.Stdout, cmd.Stderr = o.Stdin, o.Stdout, o.Stderr + cmd.Env = append(os.Environ(), o.Env...) + interactive := false + if f, ok := o.Stdin.(*os.File); ok { + interactive = term.IsTerminal(f.Fd()) + } + // Interactive SSH must share the foreground terminal process group. + // Background jobs get an isolated group so cancellation reaches descendants. + cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: !interactive} + if err := cmd.Start(); err != nil { + fmt.Fprintf(o.Stderr, "%s: %v\n", argv[0], err) + return result + } + result.Started = true + done := make(chan error, 1) + go func() { done <- cmd.Wait() }() + sigs := make(chan os.Signal, 4) + signal.Notify(sigs, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT) + defer signal.Stop(sigs) + var timeout <-chan time.Time + if o.Timeout > 0 { + timer := time.NewTimer(o.Timeout) + defer timer.Stop() + timeout = timer.C + } + ticker := time.NewTicker(time.Second) + defer ticker.Stop() + var killTimer *time.Timer + var kill <-chan time.Time + defer func() { + if killTimer != nil { + killTimer.Stop() + } + }() + send := func(sig syscall.Signal) { + if interactive { + _ = cmd.Process.Signal(sig) + } else { + _ = syscall.Kill(-cmd.Process.Pid, sig) + } + } + forced := 0 + cancelCh := ctx.Done() + stop := func(code int, sig syscall.Signal) { + if forced != 0 { + return + } + forced = code + send(sig) + killTimer = time.NewTimer(2 * time.Second) + kill = killTimer.C + } + for { + select { + case err := <-done: + result.Duration = time.Since(start) + result.Code = 0 + if err != nil { + result.Code = 1 + if e, ok := err.(*exec.ExitError); ok { + result.Code = e.ExitCode() + if s, ok := e.Sys().(syscall.WaitStatus); ok && s.Signaled() { + result.Code = 128 + int(s.Signal()) + } + } + } + if forced != 0 { + result.Code = forced + } + // Kill descendants left behind after cancellation even if the parent exited. + if forced != 0 && !interactive { + send(syscall.SIGKILL) + } + if o.Status { + fmt.Fprintf(o.Stderr, "[%s] finished in %s (exit %d)\n", o.Label, result.Duration.Round(time.Millisecond), result.Code) + } + return result + case sig := <-sigs: + s := sig.(syscall.Signal) + if interactive && (s == syscall.SIGINT || s == syscall.SIGQUIT) { + continue + } // terminal delivered it to child too + stop(128+int(s), s) + case <-cancelCh: + cancelCh = nil + stop(130, syscall.SIGTERM) + case <-timeout: + timeout = nil + stop(124, syscall.SIGTERM) + case <-kill: + kill = nil + send(syscall.SIGKILL) + case <-ticker.C: + if o.Status { + fmt.Fprintf(o.Stderr, "[%s] running %s (Ctrl+C cancels)\n", o.Label, time.Since(start).Round(time.Second)) + } + } + } +} diff --git a/internal/runner/runner_test.go b/internal/runner/runner_test.go new file mode 100644 index 0000000..b43d7df --- /dev/null +++ b/internal/runner/runner_test.go @@ -0,0 +1,43 @@ +package runner + +import ( + "bytes" + "context" + "io" + "strings" + "testing" + "time" +) + +func TestExitAndTimeout(t *testing.T) { + var out bytes.Buffer + r := Run(context.Background(), []string{"sh", "-c", "printf result; exit 7"}, Options{Stdout: &out, Stderr: io.Discard}) + if !r.Started || r.Code != 7 || out.String() != "result" { + t.Fatalf("%+v %q", r, out.String()) + } + start := time.Now() + r = Run(context.Background(), []string{"sh", "-c", "trap '' TERM; sleep 30 & wait"}, Options{Stdout: io.Discard, Stderr: io.Discard, Timeout: 50 * time.Millisecond}) + if r.Code != 124 || time.Since(start) > 4*time.Second { + t.Fatalf("timeout: %+v", r) + } +} +func TestCancellationAndNoStart(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + r := Run(ctx, []string{"sh", "-c", "exit 0"}, Options{Stderr: io.Discard}) + if r.Started || r.Code != 130 { + t.Fatalf("%+v", r) + } + var errOut bytes.Buffer + r = Run(context.Background(), []string{"/no/such/netssh-test-executable"}, Options{Stderr: &errOut}) + if r.Started || r.Code == 0 || !strings.Contains(errOut.String(), "no such") { + t.Fatalf("%+v %s", r, errOut.String()) + } + ctx, cancel = context.WithCancel(context.Background()) + defer cancel() + time.AfterFunc(50*time.Millisecond, cancel) + r = Run(ctx, []string{"sh", "-c", "sleep 30"}, Options{Stdout: io.Discard, Stderr: io.Discard}) + if r.Code != 130 { + t.Fatalf("%+v", r) + } +} diff --git a/internal/setup/commands.go b/internal/setup/commands.go index bc9478b..e96501c 100644 --- a/internal/setup/commands.go +++ b/internal/setup/commands.go @@ -64,6 +64,13 @@ func editCommands(cfg *config.Config) error { huh.NewInput().Title("Alias prefix").Description("m + host shortcut xg1 = mxg1. Empty disables automatic aliases.").Value(&command.AliasPrefix), huh.NewInput().Title("Program or executable script").Description("Use an absolute script path, or bash/python3 with the script path as the first argument.").Placeholder("mtr or /home/user/bin/check-host").Value(&binary), huh.NewText().Title("Arguments, one per line").Description("Use {address} for the resolved address, {host} for the hostname, {target} for instance/hostname. No shell quoting needed.").Lines(5).Value(&arguments), + huh.NewConfirm().Title("Confirm before running?").Value(&command.Confirm), + huh.NewInput().Title("Timeout").Description("Optional positive duration, e.g. 30s or 5m.").Value(&command.Timeout), + huh.NewInput().Title("Post-run script").Description("Local command after completion; receives NETSSH_EXIT_CODE.").Value(&command.PostRun), + huh.NewInput().Title("Only for tag").Value(&command.Match.Tag), + huh.NewInput().Title("Only for instance").Value(&command.Match.Instance), + huh.NewInput().Title("Only for kind").Description("device, vm or static; empty means all.").Value(&command.Match.Kind), + huh.NewInput().Title("Only for hostname pattern").Description("For example router*; all specified filters must match.").Value(&command.Match.Name), ).Title("Local command")).Run() if err != nil { return err diff --git a/internal/setup/operations.go b/internal/setup/operations.go new file mode 100644 index 0000000..494f879 --- /dev/null +++ b/internal/setup/operations.go @@ -0,0 +1,35 @@ +package setup + +import ( + "fmt" + "strconv" + + "charm.land/huh/v2" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/config" +) + +func editOperations(cfg *config.Config) error { + history, days, entries := strconv.Itoa(cfg.TUI.HistoryLimit), strconv.Itoa(cfg.Activity.RetentionDays), strconv.Itoa(cfg.Activity.MaxEntries) + enabled := cfg.Activity.Enabled + valid := func(s string) error { + n, err := strconv.Atoi(s) + if err != nil || n < 0 { + return fmt.Errorf("enter a non-negative number") + } + return nil + } + err := huh.NewForm(huh.NewGroup( + huh.NewInput().Title("Recent hosts shown").Description("10 by default; 0 shows all. Favorites are additional.").Value(&history).Validate(valid), + huh.NewConfirm().Title("Record local action history?").Description("Stores host, command name, duration and exit code; no arguments or output.").Value(&enabled), + huh.NewInput().Title("Retention in days").Description("0 = no age limit").Value(&days).Validate(valid), + huh.NewInput().Title("Maximum recorded actions").Description("0 = no count limit").Value(&entries).Validate(valid), + ).Title("History & activity")).Run() + if err != nil { + return err + } + cfg.TUI.HistoryLimit, _ = strconv.Atoi(history) + cfg.Activity.RetentionDays, _ = strconv.Atoi(days) + cfg.Activity.MaxEntries, _ = strconv.Atoi(entries) + cfg.Activity.Enabled = enabled + return nil +} diff --git a/internal/setup/ssh.go b/internal/setup/ssh.go index 9738699..64b9ebf 100644 --- a/internal/setup/ssh.go +++ b/internal/setup/ssh.go @@ -24,6 +24,7 @@ func editSSHOptions(title string, o config.SSHOptions) (config.SSHOptions, error options := formatOptions(o.Options) forwards := formatForwards(o.Forwards) preConnect := o.PreConnect + postDisconnect := o.PostDisconnect err := huh.NewForm(huh.NewGroup( huh.NewInput(). @@ -70,6 +71,7 @@ func editSSHOptions(title string, o config.SSHOptions) (config.SSHOptions, error _, err := parseForwards(s) return err }), + huh.NewInput().Title("Post-disconnect script").Description("Local command after the client exits; none disables inheritance.").Value(&postDisconnect), huh.NewInput(). Title("Pre-connect hook"). Description("Shell command run locally before connecting, e.g. vpn-check.sh \"$NETSSH_HOST\".\n"+ @@ -94,6 +96,7 @@ func editSSHOptions(title string, o config.SSHOptions) (config.SSHOptions, error ExtraArgs: parseLines(extraArgs), Options: parsed, PreConnect: strings.TrimSpace(preConnect), + PostDisconnect: strings.TrimSpace(postDisconnect), }, nil } diff --git a/internal/setup/wizard.go b/internal/setup/wizard.go index 32481d2..2defa3d 100644 --- a/internal/setup/wizard.go +++ b/internal/setup/wizard.go @@ -95,6 +95,7 @@ func runMenu(cfg *config.Config) error { huh.NewOption("Resolver & cache", "resolver"), huh.NewOption("Shortcuts & command alias", "shortcuts"), huh.NewOption("Custom commands — mtr, ping, scripts", "commands"), + huh.NewOption("History & activity logging", "operations"), huh.NewOption("Completion", "completion"), huh.NewOption("Save and exit", "save"), ). @@ -125,6 +126,8 @@ func runMenu(cfg *config.Config) error { err = editShortcuts(cfg) case "commands": err = editCommands(cfg) + case "operations": + err = editOperations(cfg) case "completion": err = editCompletion(cfg) case "save": @@ -382,6 +385,9 @@ func save(cfg config.Config) error { if err := cfg.ValidateHosts(); err != nil { return err } + if err := cfg.ValidateOperations(); err != nil { + return err + } if err := cfg.ValidateCommands(); err != nil { return err } @@ -552,9 +558,19 @@ func save(cfg config.Config) error { for _, arg := range command.Args { fmt.Fprintf(&b, " - %q\n", arg) } + fmt.Fprintf(&b, " confirm: %t\n timeout: %q\n post_run: %q\n", command.Confirm, command.Timeout, command.PostRun) + if command.Match != (config.SSHMatch{}) { + b.WriteString(" match:\n") + for _, pair := range [][2]string{{"tag", command.Match.Tag}, {"instance", command.Match.Instance}, {"kind", command.Match.Kind}, {"name", command.Match.Name}} { + if pair[1] != "" { + fmt.Fprintf(&b, " %s: %q\n", pair[0], pair[1]) + } + } + } } } + fmt.Fprintf(&b, "\ntui:\n history_limit: %d\nactivity:\n enabled: %t\n retention_days: %d\n max_entries: %d\n", cfg.TUI.HistoryLimit, cfg.Activity.Enabled, cfg.Activity.RetentionDays, cfg.Activity.MaxEntries) if cfg.Shell.Alias != "" { fmt.Fprintf(&b, "\nshell:\n alias: %q\n", cfg.Shell.Alias) } @@ -568,12 +584,12 @@ func save(cfg config.Config) error { } func sshOptionsEmpty(o config.SSHOptions) bool { - return o.ProxyJump == "" && o.HostKeyChecking == "" && o.Target == "" && o.AddressFamily == "" && len(o.ExtraArgs) == 0 && len(o.Options) == 0 && len(o.Forwards) == 0 && o.PreConnect == "" + return o.ProxyJump == "" && o.HostKeyChecking == "" && o.Target == "" && o.AddressFamily == "" && len(o.ExtraArgs) == 0 && len(o.Options) == 0 && len(o.Forwards) == 0 && o.PreConnect == "" && o.PostDisconnect == "" } // writeSSHOptions keeps settings the wizard does not ask for when it rewrites the config. func writeSSHOptions(b *strings.Builder, indent string, o config.SSHOptions) { - for _, field := range [][2]string{{"proxy_jump", o.ProxyJump}, {"host_key_checking", o.HostKeyChecking}, {"target", o.Target}, {"address_family", o.AddressFamily}, {"pre_connect", o.PreConnect}} { + for _, field := range [][2]string{{"proxy_jump", o.ProxyJump}, {"host_key_checking", o.HostKeyChecking}, {"target", o.Target}, {"address_family", o.AddressFamily}, {"pre_connect", o.PreConnect}, {"post_disconnect", o.PostDisconnect}} { if field[1] != "" { fmt.Fprintf(b, "%s%s: %q\n", indent, field[0], field[1]) } diff --git a/internal/setup/wizard_test.go b/internal/setup/wizard_test.go index dfa262f..36d319f 100644 --- a/internal/setup/wizard_test.go +++ b/internal/setup/wizard_test.go @@ -698,3 +698,24 @@ func TestSaveCommandsRoundTrip(t *testing.T) { t.Fatalf("commands lost: %+v", got.Commands) } } + +func TestOperationsRoundTrip(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + cfg := config.Config{ + NetBox: config.NetBoxConfig{URL: "https://netbox.example", Token: "token"}, + TUI: config.TUIConfig{HistoryLimit: 25}, + Activity: config.ActivityConfig{Enabled: true, RetentionDays: 7, MaxEntries: 50}, + SSH: config.SSHConfig{SSHOptions: config.SSHOptions{PostDisconnect: "echo done"}, Rules: []config.SSHRule{{Match: config.SSHMatch{Tag: "lab"}, SSHOptions: config.SSHOptions{PostDisconnect: "none"}}}}, + Commands: map[string]config.HostCommand{"mtr": {Args: []string{"mtr", "{address}"}, AliasPrefix: "m", Timeout: "10s", Confirm: true, PostRun: "echo done", Match: config.SSHMatch{Tag: "router", Instance: "prod"}}}, + } + if err := save(cfg); err != nil { + t.Fatal(err) + } + got, err := config.Load() + if err != nil { + t.Fatal(err) + } + if got.TUI != cfg.TUI || got.Activity != cfg.Activity || !reflect.DeepEqual(got.Commands, cfg.Commands) || !reflect.DeepEqual(got.SSH, cfg.SSH) { + t.Fatalf("round trip lost operations: %+v", got) + } +} diff --git a/internal/tui/model.go b/internal/tui/model.go index 942979e..c6eb641 100644 --- a/internal/tui/model.go +++ b/internal/tui/model.go @@ -22,6 +22,7 @@ import ( // SelectedHost is returned when the user confirms a host in the TUI. type SelectedHost struct { + Command string Kind string Name string IP string @@ -63,13 +64,15 @@ type searchResultMsg struct { // --- list item --- type hostItem struct { - label string // display only; name remains the canonical target - alias string // shortcut alias shown next to the name (shortcuts.show) - name string - id int - ip string - kind string - tags []string + provenance string + favorite, pinned bool + label string // display only; name remains the canonical target + alias string // shortcut alias shown next to the name (shortcuts.show) + name string + id int + ip string + kind string + tags []string } func (h hostItem) Title() string { @@ -102,7 +105,16 @@ func (d compactDelegate) Render(w io.Writer, m list.Model, index int, item list. if h.alias != "" { title += " " + lipgloss.NewStyle().Foreground(lipgloss.Color("109")).Render("→ "+h.alias) } - line := fmt.Sprintf(" %s%s %s", mark, title, lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(h.ip)) + badge := "" + if h.pinned { + badge = "◆ " + } else if h.favorite { + badge = "★ " + } + line := fmt.Sprintf(" %s%s %s", mark+badge, title, lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(h.ip)) + if h.provenance != "" { + line += " [" + h.provenance + "]" + } if index == m.Index() { line = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("86")).Render("> " + strings.TrimPrefix(line, " ")) } @@ -161,6 +173,14 @@ func applyFilter(entries []netbox.HostEntry, f filterOpts) []netbox.HostEntry { // --- Model --- type Model struct { + historyLimit int + favorites, pinned map[string]bool + savePreferences func(map[string]bool, map[string]bool) error + commandsFor func(string, string, []string) []string + actionHost *hostItem + actionNames []string + actionIndex int + noteErr error editHost *hostItem noteInput textarea.Model @@ -229,6 +249,7 @@ func New(client *netbox.Client, c *cache.Cache, defaultUser string, defaultPorts ni.CharLimit = 0 ni.SetHeight(10) return &Model{ + historyLimit: 10, favorites: map[string]bool{}, pinned: map[string]bool{}, noteInput: ni, defaultPort: port, input: ti, @@ -250,14 +271,40 @@ func (m *Model) Init() tea.Cmd { // loadRecent returns a Cmd that immediately resolves to the recently-used host list. func (m *Model) loadRecent() tea.Cmd { + favoriteNames, pinned, limit := copyBools(m.favorites), copyBools(m.pinned), m.historyLimit return func() tea.Msg { if m.cache == nil { return searchResultMsg{query: "", entries: nil, recent: true} } - recent := m.cache.RecentlyUsed(10) + recent := m.cache.RecentlyUsed(limit) + seen := map[string]bool{} + var favorites []cache.Entry + for name, enabled := range favoriteNames { + if !enabled { + continue + } + e, _ := m.cache.Get(name) + if e.Name == "" { + e.Name = name + } + favorites = append(favorites, e) + seen[name] = true + } + sort.Slice(favorites, func(i, j int) bool { + if pinned[favorites[i].Name] != pinned[favorites[j].Name] { + return pinned[favorites[i].Name] + } + return favorites[i].Name < favorites[j].Name + }) + for _, e := range recent { + if !seen[e.Name] { + favorites = append(favorites, e) + } + } + recent = favorites entries := make([]netbox.HostEntry, len(recent)) for i, e := range recent { - entries[i] = netbox.HostEntry{Name: e.Name, PrimaryIP4: e.IP, Kind: e.Kind, Tags: e.Tags} + entries[i] = netbox.HostEntry{Name: e.Name, PrimaryIP4: e.IP, Kind: e.Kind, Tags: e.Tags, Cached: true, CachedAt: e.CachedAt, Static: e.Static} } return searchResultMsg{query: "", entries: entries, recent: true} } @@ -294,6 +341,34 @@ func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { if msg.String() == "ctrl+c" { return m, tea.Quit } + + if m.actionHost != nil { + switch msg.String() { + case "esc": + m.actionHost = nil + case "up": + if m.actionIndex > 0 { + m.actionIndex-- + } + case "down": + if m.actionIndex+1 < len(m.actionNames) { + m.actionIndex++ + } + case "enter": + h := m.actionHost + if m.actionIndex == 0 { + if len(m.markOrder) > 0 { + m.selected = &SelectedHost{Action: ActionMulti, Targets: append([]string(nil), m.markOrder...)} + } else { + m.selected = &SelectedHost{Name: h.name, Kind: h.kind, IP: h.ip} + } + } else { + m.selected = &SelectedHost{Name: h.name, Kind: h.kind, IP: h.ip, Command: m.actionNames[m.actionIndex], Targets: append([]string(nil), m.markOrder...)} + } + return m, tea.Quit + } + return m, nil + } if m.noteMode { if m.noteBusy { return m, nil @@ -403,6 +478,43 @@ func (m *Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { case "ctrl+c", "esc": return m, tea.Quit + case "ctrl+r": + if h, ok := m.list.SelectedItem().(hostItem); ok { + m.actionHost = &h + m.actionIndex = 0 + m.actionNames = []string{"SSH"} + if m.commandsFor != nil { + m.actionNames = append(m.actionNames, m.commandsFor(h.name, h.kind, h.tags)...) + } + } + return m, nil + case "ctrl+d", "ctrl+p": + if h, ok := m.list.SelectedItem().(hostItem); ok { + favorites, pinned := copyBools(m.favorites), copyBools(m.pinned) + if msg.String() == "ctrl+p" { + pinned[h.name] = !pinned[h.name] + if pinned[h.name] { + favorites[h.name] = true + } + } else { + favorites[h.name] = !favorites[h.name] + if !favorites[h.name] { + delete(pinned, h.name) + } + } + if m.savePreferences != nil { + if err := m.savePreferences(favorites, pinned); err != nil { + m.err = err + return m, nil + } + } + m.favorites, m.pinned = favorites, pinned + m.updateListItems(m.lastResults) + if m.recentMode && m.input.Value() == "" { + return m, m.loadRecent() + } + } + return m, nil case "ctrl+f": m.filterOpen = true m.input.Blur() @@ -563,6 +675,24 @@ func (m *Model) View() tea.View { } func (m *Model) viewContent() string { + if m.actionHost != nil { + var out strings.Builder + fmt.Fprintf(&out, "Action for %s", m.actionHost.Title()) + if len(m.markOrder) > 0 { + fmt.Fprintf(&out, " (%d marked hosts)", len(m.markOrder)) + } + out.WriteString("\n\n") + for i, n := range m.actionNames { + marker := " " + if i == m.actionIndex { + marker = "> " + } + fmt.Fprintf(&out, "%s%s\n", marker, n) + } + out.WriteString("\n↑/↓ select enter run esc cancel\n") + return out.String() + } + if m.noteMode { target := "local" if m.noteRemote { @@ -623,7 +753,7 @@ func (m *Model) viewContent() string { sb.WriteString(m.editInput.View() + "\n") sb.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("240")).Render(" enter connect esc cancel") + "\n") } else { - hint := "ctrl+c quit enter connect space mark ctrl+o sftp ctrl+t forward ctrl+e edit ctrl+f filter ctrl+n notes ctrl+b NetBox" + hint := "ctrl+r actions ctrl+d favorite ctrl+p pin ctrl+c quit enter connect space mark ctrl+o sftp ctrl+t forward ctrl+e edit ctrl+f filter ctrl+n notes ctrl+b NetBox" if n := len(m.markOrder); n > 0 { hint = fmt.Sprintf("%d marked — enter open side by side space unmark ctrl+a all esc quit", n) } @@ -652,7 +782,7 @@ func (m *Model) doSearch(query string, seq int) tea.Cmd { if m.cache != nil { for _, entry := range m.cache.Search(query) { source, name := netbox.SplitTarget(entry.Name) - cached = append(cached, netbox.HostEntry{Source: source, Name: name, PrimaryIP4: entry.IP, Kind: entry.Kind, Tags: entry.Tags}) + cached = append(cached, netbox.HostEntry{Source: source, Name: name, PrimaryIP4: entry.IP, Kind: entry.Kind, Tags: entry.Tags, Cached: true, CachedAt: entry.CachedAt, Static: entry.Static}) } } if m.client == nil || (len(cached) > 0 && !m.client.MultipleSources()) { @@ -689,7 +819,19 @@ func (m *Model) netboxSearchOpts() netbox.SearchOptions { // updateListItems applies the active filter and sets the list items. func (m *Model) updateListItems(entries []netbox.HostEntry) { f := parseFilter(m.filterInput.Value()) - filtered := applyFilter(entries, f) + filtered := append([]netbox.HostEntry(nil), applyFilter(entries, f)...) + sort.SliceStable(filtered, func(i, j int) bool { + rank := func(e netbox.HostEntry) int { + if m.pinned[e.Target()] { + return 2 + } + if m.favorites[e.Target()] { + return 1 + } + return 0 + } + return rank(filtered[i]) > rank(filtered[j]) + }) items := make([]list.Item, len(filtered)) labels := make([]string, len(filtered)) counts := make(map[string]int, len(filtered)) @@ -718,7 +860,23 @@ func (m *Model) updateListItems(entries []netbox.HostEntry) { alias = "" } } - items[i] = hostItem{label: label, alias: alias, id: e.ID, name: e.Target(), ip: ip, kind: e.Kind, tags: e.Tags} + provenance := "live" + if e.Static { + provenance = "static" + } else if e.Cached { + if e.CachedAt.IsZero() { + provenance = "saved host; resolve on connect" + } else { + age := max(time.Duration(0), time.Since(e.CachedAt)).Round(time.Second) + provenance = "cache " + age.String() + if m.cache != nil { + if _, fresh := m.cache.Get(e.Target()); !fresh { + provenance += ", stale" + } + } + } + } + items[i] = hostItem{provenance: provenance, favorite: m.favorites[e.Target()], pinned: m.pinned[e.Target()], label: label, alias: alias, id: e.ID, name: e.Target(), ip: ip, kind: e.Kind, tags: e.Tags} } m.list.SetItems(items) m.resizeList() @@ -866,3 +1024,19 @@ func (m *Model) SetHostLabel(format func(string) string) { func (m *Model) SetAliases(aliasFor func(target string) string) { m.aliasFor = aliasFor } + +func copyBools(in map[string]bool) map[string]bool { + out := map[string]bool{} + for k, v := range in { + out[k] = v + } + return out +} +func (m *Model) SetHistoryLimit(limit int) { m.historyLimit = limit } +func (m *Model) SetPreferences(favorites, pinned map[string]bool, save func(map[string]bool, map[string]bool) error) { + m.favorites, m.pinned = copyBools(favorites), copyBools(pinned) + m.savePreferences = save +} +func (m *Model) SetCommands(commands func(string, string, []string) []string) { + m.commandsFor = commands +} diff --git a/internal/tui/operations_test.go b/internal/tui/operations_test.go new file mode 100644 index 0000000..87cbf0c --- /dev/null +++ b/internal/tui/operations_test.go @@ -0,0 +1,67 @@ +package tui + +import ( + "strings" + "testing" + "time" + + tea "charm.land/bubbletea/v2" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/cache" + "git.zb-server.de/Sebi/ssh-netbox-wrapper/internal/netbox" +) + +func TestFavoritesHistoryAndActions(t *testing.T) { + c := cache.New("", 3600) + for _, name := range []string{"a", "b", "pinned"} { + c.Upsert(cache.Entry{Name: name, IP: "10.0.0.1", Kind: "device"}) + c.MarkUsed(name) + } + m := New(nil, c, "") + m.SetHistoryLimit(1) + m.SetPreferences(map[string]bool{"pinned": true, "offline/missing": true}, map[string]bool{"pinned": true}, nil) + msg := m.loadRecent()().(searchResultMsg) + if len(msg.entries) < 2 || msg.entries[0].Target() != "pinned" { + t.Fatalf("%+v", msg.entries) + } + m.Update(msg) + m.Update(tea.WindowSizeMsg{Width: 160, Height: 30}) + if !strings.Contains(m.View().Content, "◆") || !strings.Contains(m.View().Content, "cache") { + t.Fatal(m.View().Content) + } + m.SetCommands(func(name, kind string, tags []string) []string { return []string{"mtr"} }) + m.Update(tea.KeyPressMsg{Code: 'r', Mod: tea.ModCtrl}) + m.Update(tea.KeyPressMsg{Code: tea.KeyDown}) + m.Update(tea.KeyPressMsg{Code: tea.KeyEnter}) + if m.Selected() == nil || m.Selected().Command != "mtr" || m.Selected().Name != "pinned" { + t.Fatalf("%+v", m.Selected()) + } +} +func TestHistoryLimitAndPreferencePersistence(t *testing.T) { + c := cache.New("", 3600) + for _, n := range []string{"a", "b", "c"} { + c.Upsert(cache.Entry{Name: n}) + c.MarkUsed(n) + } + m := New(nil, c, "") + m.SetHistoryLimit(2) + if got := len(m.loadRecent()().(searchResultMsg).entries); got != 2 { + t.Fatal(got) + } + m.SetHistoryLimit(0) + if got := len(m.loadRecent()().(searchResultMsg).entries); got != 3 { + t.Fatal(got) + } + saved := false + m.SetPreferences(nil, nil, func(f, p map[string]bool) error { saved = f["prod/web"] && p["prod/web"]; return nil }) + entries := []netbox.HostEntry{{Name: "web", Source: "prod", Cached: true, CachedAt: time.Now().Add(-2 * time.Hour)}} + m.lastResults = entries + m.updateListItems(entries) + m.Update(tea.KeyPressMsg{Code: 'p', Mod: tea.ModCtrl}) + if !saved { + t.Fatal("pin not persisted") + } + item := m.list.Items()[0].(hostItem) + if !strings.Contains(item.provenance, "stale") { + t.Fatal(item.provenance) + } +}