update changelog

update claude and readme
refactor CLI to use shared clients from context
2026-01-18 17:08:27 -05:00 · 2026-01-18 17:06:55 -05:00 · 2026-01-18 17:03:35 -05:00
10 changed files with 295 additions and 118 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,24 @@

 All notable changes to this project will be documented in this file.

+## v0.4.0 - 2026-01-18
+### Added
+- CLI tool (`cmd/`) for quick device queries using cobra
+  - `get device <name>` - fetch info from a single device
+  - `get devices` - fetch info from all configured devices in parallel
+  - YAML/JSON config file support with environment variable overlay
+  - Pretty print and colorized YAML output options
+- `Login(ctx, host)` method to both toughswitch and edgeos clients for explicit pre-authentication
+- Context helpers for storing/retrieving clients (`ToughSwitchClientFromContext`, `EdgeOSClientFromContext`)
+
+### Changed
+- CLI uses zerolog's built-in context methods for logger storage
+- CLI prerun creates shared clients from config and stores in context
+- Updated documentation (README.md, CLAUDE.md) with CLI usage and new Login method
+
+### Fixed
+- Config default flag handling in CLI
+
 ## v0.3.0 - 2026-01-14
 ### Changed
 - Renamed project from toughswitch to ubiquiti-clients
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -15,9 +15,6 @@ go build ./cmd/...
 go test ./...

 # Run tests for a specific package
-go test ./pkg/toughswitch/...
-
-# Run a single test
 go test ./pkg/toughswitch/... -run TestClient_AddDel

 # Tidy module dependencies
@@ -26,17 +23,17 @@ go mod tidy

 ## Architecture

-This repository provides Go client libraries for interacting with Ubiquiti network devices via reverse-engineered REST APIs.
+This repository provides Go client libraries for interacting with Ubiquiti network devices via reverse-engineered REST APIs, plus a CLI tool.

 ### Package Structure

 - `pkg/toughswitch/` - Client for ToughSwitch devices (e.g., TS-8-PRO)
 - `pkg/edgeos/` - Client for EdgeOS devices (EdgeRouter, EdgeSwitch)
- `cmd/` - Optional CLI tool using cobra (work in progress)
+- `cmd/` - CLI tool using cobra

-### Client Design Pattern
+### Library Client Design Pattern

-Both packages follow the same multi-device client pattern:
+Both `pkg/toughswitch` and `pkg/edgeos` follow the same multi-device client pattern:

 1. **Client** - Top-level struct holding a map of `deviceClient` instances keyed by host
 2. **deviceClient** - Per-device HTTP client with authentication state (token for ToughSwitch, cookies for EdgeOS)
@@ -45,16 +42,28 @@ Both packages follow the same multi-device client pattern:
 Key characteristics:
 - Thread-safe: Uses `sync.RWMutex` for device map access and `sync.Mutex` for per-device operations
 - Auto-login: Automatically authenticates on 401 responses and retries the request
+- Explicit login: `Login(ctx, host)` can be called to pre-authenticate
 - Concurrent multi-device: `GetAll*` methods use `sync.WaitGroup.Go()` for parallel queries

-### API Pattern
-
-Each package exposes:
+API pattern for each package:
 - `MustNew(ctx, []Config)` - Constructor that accepts multiple device configs
+- `Login(ctx, host)` - Explicit authentication (also happens automatically on 401)
 - `Add(cfg)` / `Del(host)` - Dynamic device management
 - `Get<Resource>(ctx, host)` - Single device query
 - `GetAll<Resources>(ctx)` - Parallel query across all devices, returns `map[string]*Resource`

+### CLI Architecture (`cmd/`)
+
+The CLI uses cobra with a prerun chain pattern:
+
+- `cmd/cmd/root.go` - Root command with `PersistentPreRunE` hook
+- `cmd/cmd/prerun.go` - Prerun functions executed in order: `validateConfigFile` → `prepareConfig` → `prepareLogger` → `setEnvironment` → `prepareClients`
+- `cmd/cmd/client.go` - Shared `fetchDevice()` helper that retrieves clients from context
+- `cmd/internal/util/context.go` - Context helpers for config, logger, and clients
+- `cmd/internal/config/config.go` - Config loading from YAML/JSON files with env overlay
+
+Context flow: Prerun creates clients based on config and stores them in context. Commands retrieve clients via `util.ToughSwitchClientFromContext(ctx)` / `util.EdgeOSClientFromContext(ctx)`.
+
 ### Authentication

 - **ToughSwitch**: Token-based via `x-auth-token` header from `/api/v1.0/user/login`
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # ubiquiti-clients

-Go client libraries for interacting with Ubiquiti network devices via their REST APIs.
+Go client libraries for interacting with Ubiquiti network devices via their REST APIs, plus a CLI tool.

 **⚠️ Disclaimer: These libraries are based on reverse-engineered API calls. They are not official Ubiquiti products and are subject to change if the device firmware changes.**

@@ -13,7 +13,7 @@ ToughSwitch POE Pro (TS-8-PRO)) via their internal REST API.

 #### Features

- **Authentication**: Handles login and session token management automatically.
+- **Authentication**: Handles login and session token management automatically (or explicitly via `Login`).
 - **Multi-Device Support**: Manage multiple devices with a single client instance.
 - **Data Retrieval**:
  - **System Information**: Hostname, uptime, firmware version, etc.
@@ -29,7 +29,7 @@ A client library for interacting with Ubiquiti EdgeOS devices (EdgeRouter, EdgeS

 #### Features

- **Authentication**: Handles login and session management automatically.
+- **Authentication**: Handles login and session management automatically (or explicitly via `Login`).
 - **Multi-Device Support**: Manage multiple devices with a single client instance.
 - **Data Retrieval**:
  - **System Configuration**: Hostname, domain name, and other system settings.
@@ -37,17 +37,70 @@ A client library for interacting with Ubiquiti EdgeOS devices (EdgeRouter, EdgeS
  - **VLAN Configuration**: VLAN assignments, PVID, and tagged VLANs.
  - **Device Information**: Model, ports, PoE capabilities, and features.

-## Installation
+## CLI Tool
+
+A command-line tool is included for quick device queries.
+
+### Installation
+
+```bash
+go install gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd@latest
+```
+
+### Configuration
+
+Create a config file (YAML or JSON):
+
+```yaml
+logLevel: info
+logFormat: console
+
+clients:
+  - name: switch1
+    type: toughswitch
+    host: 192.168.1.1
+    user: ubnt
+    pass: password
+    insecure: true
+    timeout: 10s
+
+  - name: router1
+    type: edgeos
+    host: 192.168.1.2
+    user: ubnt
+    pass: password
+    insecure: true
+    timeout: 10s
+```
+
+Environment variables can also be used (and take priority over config file):
+- `LOG_LEVEL`, `LOG_FORMAT` for top-level settings
+- `CLIENT_0_NAME`, `CLIENT_0_HOST`, `CLIENT_0_TYPE`, etc. for client array
+
+### Usage
+
+```bash
+# Get info from a single device
+cmd --config config.yaml get device switch1
+
+# Get info from all configured devices
+cmd --config config.yaml get devices
+
+# With flags
+cmd --config config.yaml get device switch1 --pretty --color
+```
+
+## Library Installation

 ```bash
 # For ToughSwitch
-go get gitea.libretechconsulting.com/rmcguire/toughswitch-client/pkg/toughswitch
+go get gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/toughswitch

 # For EdgeOS
-go get gitea.libretechconsulting.com/rmcguire/toughswitch-client/pkg/edgeos
+go get gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/edgeos
 ```

-## Usage
+## Library Usage

 ### ToughSwitch Basic Example

@@ -60,7 +113,7 @@ import (
 	"log"
 	"time"

-	"gitea.libretechconsulting.com/rmcguire/toughswitch-client/pkg/toughswitch"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/toughswitch"
 )

 func main() {
@@ -80,6 +133,11 @@ func main() {
 	// Initialize the client
 	client := toughswitch.MustNew(ctx, configs)

+	// Optionally pre-authenticate (otherwise happens automatically on first request)
+	if err := client.Login(ctx, "192.168.1.1"); err != nil {
+		log.Fatalf("Failed to login: %v", err)
+	}
+
 	// Fetch system information
 	deviceHost := "192.168.1.1"
 	system, err := client.GetSystem(ctx, deviceHost)
@@ -116,7 +174,7 @@ import (
 	"log"
 	"time"

-	"gitea.libretechconsulting.com/rmcguire/toughswitch-client/pkg/edgeos"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/edgeos"
 )

 func main() {
@@ -136,6 +194,11 @@ func main() {
 	// Initialize the client
 	client := edgeos.MustNew(ctx, configs)

+	// Optionally pre-authenticate (otherwise happens automatically on first request)
+	if err := client.Login(ctx, "192.168.1.1"); err != nil {
+		log.Fatalf("Failed to login: %v", err)
+	}
+
 	// Fetch device information
 	deviceHost := "192.168.1.1"
 	authInfo, err := client.GetAuthInfo(ctx, deviceHost)
@@ -240,6 +303,7 @@ for host, cfg := range allConfigs {

 | Method | Description |
 |--------|-------------|
+| `Login` | Explicit authentication (also happens automatically on 401) |
 | `GetSystem` | General system configuration and status |
 | `GetInterfaces` | Interface configuration and status |
 | `GetVLANs` | VLAN and Trunk configuration |
@@ -248,18 +312,19 @@ for host, cfg := range allConfigs {
 | `GetNeighbors` | Discovered UBNT neighbors |
 | `GetDevice` | Hardware and capabilities info |

-All methods have corresponding `GetAll*` variants for multi-device operations.
+All `Get*` methods have corresponding `GetAll*` variants for multi-device operations.

 ### EdgeOS

 | Method | Description |
 |--------|-------------|
+| `Login` | Explicit authentication (also happens automatically on 401) |
 | `GetConfig` | Complete device configuration |
 | `GetAuthInfo` | Device authentication and feature information |
 | `GetInterfaces` | Interface configuration (ethernet and switch) |
 | `GetSystem` | System configuration (hostname, domain) |

-All methods have corresponding `GetAll*` variants for multi-device operations.
+All `Get*` methods have corresponding `GetAll*` variants for multi-device operations.

 ## License

--- a/cmd/cmd/client.go
+++ b/cmd/cmd/client.go
@@ -0,0 +1,48 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/config"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/util"
+)
+
+// fetchDevice retrieves device data using the pre-configured clients from context.
+// It handles both ToughSwitch and EdgeOS device types.
+func fetchDevice(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
+	switch clientConf.Type {
+	case config.TypeToughSwitch:
+		return fetchToughSwitchDevice(ctx, clientConf)
+	case config.TypeEdgeOS:
+		return fetchEdgeOSDevice(ctx, clientConf)
+	default:
+		return nil, fmt.Errorf("unknown device type: %s", clientConf.Type)
+	}
+}
+
+func fetchToughSwitchDevice(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
+	client := util.ToughSwitchClientFromContext(ctx)
+	if client == nil {
+		return nil, fmt.Errorf("toughswitch client not initialized")
+	}
+
+	if err := client.Login(ctx, clientConf.Host); err != nil {
+		return nil, fmt.Errorf("login failed: %w", err)
+	}
+
+	return client.GetDevice(ctx, clientConf.Host)
+}
+
+func fetchEdgeOSDevice(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
+	client := util.EdgeOSClientFromContext(ctx)
+	if client == nil {
+		return nil, fmt.Errorf("edgeos client not initialized")
+	}
+
+	if err := client.Login(ctx, clientConf.Host); err != nil {
+		return nil, fmt.Errorf("login failed: %w", err)
+	}
+
+	return client.GetConfig(ctx, clientConf.Host)
+}
--- a/cmd/cmd/get_device.go
+++ b/cmd/cmd/get_device.go
@@ -1,14 +1,10 @@
 package cmd

 import (
-	"context"
 	"fmt"
 	"os"

-	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/config"
 	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/util"
-	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/edgeos"
-	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/toughswitch"
 	"github.com/spf13/cobra"
 )

@@ -54,49 +50,10 @@ func runGetDevice(cmd *cobra.Command, args []string) error {

 	logger.Debug().Str("device", deviceName).Str("type", string(clientConf.Type)).Msg("fetching device info")

-	var result any
-	var err error
-
-	switch clientConf.Type {
-	case config.TypeToughSwitch:
-		result, err = getToughSwitchDevice(ctx, clientConf)
-	case config.TypeEdgeOS:
-		result, err = getEdgeOSDevice(ctx, clientConf)
-	default:
-		return fmt.Errorf("unknown device type: %s", clientConf.Type)
-	}
-
+	result, err := fetchDevice(ctx, clientConf)
 	if err != nil {
 		return fmt.Errorf("failed to get device info: %w", err)
 	}

 	return util.YAMLOutput(os.Stdout, result, pretty, colorize)
 }
-
-func getToughSwitchDevice(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
-	cfg := toughswitch.Config{
-		Host:     clientConf.Host,
-		Scheme:   clientConf.Scheme,
-		Insecure: clientConf.Insecure,
-		Username: clientConf.User,
-		Password: clientConf.Pass,
-		Timeout:  clientConf.Timeout,
-	}
-
-	client := toughswitch.MustNew(ctx, []toughswitch.Config{cfg})
-	return client.GetDevice(ctx, clientConf.Host)
-}
-
-func getEdgeOSDevice(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
-	cfg := edgeos.Config{
-		Host:     clientConf.Host,
-		Scheme:   clientConf.Scheme,
-		Insecure: clientConf.Insecure,
-		Username: clientConf.User,
-		Password: clientConf.Pass,
-		Timeout:  clientConf.Timeout,
-	}
-
-	client := edgeos.MustNew(ctx, []edgeos.Config{cfg})
-	return client.GetConfig(ctx, clientConf.Host)
-}
--- a/cmd/cmd/get_devices.go
+++ b/cmd/cmd/get_devices.go
@@ -1,15 +1,12 @@
 package cmd

 import (
-	"context"
 	"fmt"
 	"os"
 	"sync"

 	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/config"
 	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/util"
-	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/edgeos"
-	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/toughswitch"
 	"github.com/spf13/cobra"
 )

@@ -63,18 +60,7 @@ func runGetDevices(cmd *cobra.Command, args []string) error {
 				Host: cc.Host,
 			}

-			var data any
-			var err error
-
-			switch cc.Type {
-			case config.TypeToughSwitch:
-				data, err = fetchToughSwitch(ctx, &cc)
-			case config.TypeEdgeOS:
-				data, err = fetchEdgeOS(ctx, &cc)
-			default:
-				err = fmt.Errorf("unknown device type: %s", cc.Type)
-			}
-
+			data, err := fetchDevice(ctx, &cc)
 			if err != nil {
 				result.Error = err.Error()
 				result.Failed = true
@@ -93,31 +79,3 @@ func runGetDevices(cmd *cobra.Command, args []string) error {

 	return util.YAMLOutput(os.Stdout, results, pretty, colorize)
 }
-
-func fetchToughSwitch(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
-	cfg := toughswitch.Config{
-		Host:     clientConf.Host,
-		Scheme:   clientConf.Scheme,
-		Insecure: clientConf.Insecure,
-		Username: clientConf.User,
-		Password: clientConf.Pass,
-		Timeout:  clientConf.Timeout,
-	}
-
-	client := toughswitch.MustNew(ctx, []toughswitch.Config{cfg})
-	return client.GetDevice(ctx, clientConf.Host)
-}
-
-func fetchEdgeOS(ctx context.Context, clientConf *config.ClientConfig) (any, error) {
-	cfg := edgeos.Config{
-		Host:     clientConf.Host,
-		Scheme:   clientConf.Scheme,
-		Insecure: clientConf.Insecure,
-		Username: clientConf.User,
-		Password: clientConf.Pass,
-		Timeout:  clientConf.Timeout,
-	}
-
-	client := edgeos.MustNew(ctx, []edgeos.Config{cfg})
-	return client.GetConfig(ctx, clientConf.Host)
-}
--- a/cmd/cmd/prerun.go
+++ b/cmd/cmd/prerun.go
@@ -8,6 +8,8 @@ import (

 	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/config"
 	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/util"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/edgeos"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/toughswitch"
 	"github.com/rs/zerolog"
 	"github.com/spf13/cobra"
 )
@@ -20,6 +22,8 @@ var preRunFuncs = []preRunFunc{
 	validateConfigFile,
 	prepareConfig,
 	prepareLogger,
+	setEnvironment,
+	prepareClients,
 }

 // preRun executes all registered pre-run functions in order.
@@ -32,6 +36,24 @@ func preRun(cmd *cobra.Command, args []string) error {
 	return nil
 }

+func setEnvironment(cmd *cobra.Command, _ []string) error {
+	conf := util.ConfigFromContext(cmd.Context())
+	if conf == nil {
+		zerolog.Ctx(cmd.Context()).Fatal().Msg("unconfigured, nothing to do")
+	}
+
+	for _, device := range conf.Clients {
+		if device.Type == config.TypeToughSwitch {
+			zerolog.Ctx(cmd.Context()).Debug().
+				Msg("setting GODEBUG=x509negativeserial=1 for toughswitch devices")
+			os.Setenv("GODEBUG", "x509negativeserial=1")
+			return nil
+		}
+	}
+
+	return nil
+}
+
 func prepareConfig(cmd *cobra.Command, _ []string) error {
 	configFile, _ := cmd.Root().PersistentFlags().GetString(util.FLAG_CONFIG_FILE)
 	conf, err := config.LoadConfig(&configFile)
@@ -84,3 +106,52 @@ func validateConfigFile(cmd *cobra.Command, args []string) error {

 	return nil
 }
+
+// prepareClients creates toughswitch and edgeos clients based on the configuration.
+// Clients are only created if there are devices of that type in the config.
+func prepareClients(cmd *cobra.Command, _ []string) error {
+	ctx := cmd.Context()
+	conf := util.ConfigFromContext(ctx)
+	logger := zerolog.Ctx(ctx)
+
+	var tsConfigs []toughswitch.Config
+	var eosConfigs []edgeos.Config
+
+	for _, clientConf := range conf.Clients {
+		switch clientConf.Type {
+		case config.TypeToughSwitch:
+			tsConfigs = append(tsConfigs, toughswitch.Config{
+				Host:     clientConf.Host,
+				Scheme:   clientConf.Scheme,
+				Insecure: clientConf.Insecure,
+				Username: clientConf.User,
+				Password: clientConf.Pass,
+				Timeout:  clientConf.Timeout,
+			})
+		case config.TypeEdgeOS:
+			eosConfigs = append(eosConfigs, edgeos.Config{
+				Host:     clientConf.Host,
+				Scheme:   clientConf.Scheme,
+				Insecure: clientConf.Insecure,
+				Username: clientConf.User,
+				Password: clientConf.Pass,
+				Timeout:  clientConf.Timeout,
+			})
+		}
+	}
+
+	if len(tsConfigs) > 0 {
+		logger.Debug().Int("count", len(tsConfigs)).Msg("creating toughswitch client")
+		tsClient := toughswitch.MustNew(ctx, tsConfigs)
+		ctx = util.ContextWithToughSwitchClient(ctx, tsClient)
+	}
+
+	if len(eosConfigs) > 0 {
+		logger.Debug().Int("count", len(eosConfigs)).Msg("creating edgeos client")
+		eosClient := edgeos.MustNew(ctx, eosConfigs)
+		ctx = util.ContextWithEdgeOSClient(ctx, eosClient)
+	}
+
+	cmd.SetContext(ctx)
+	return nil
+}
--- a/cmd/internal/util/context.go
+++ b/cmd/internal/util/context.go
@@ -4,22 +4,25 @@ import (
 	"context"

 	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/cmd/internal/config"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/edgeos"
+	"gitea.libretechconsulting.com/rmcguire/ubiquiti-clients/pkg/toughswitch"
 	"github.com/rs/zerolog"
 )

-type CmdContextVal uint8
+type ctxKey uint8

 const (
-	CTX_CONFIG CmdContextVal = iota
-	CTX_LOGGER
+	ctxConfig ctxKey = iota
+	ctxToughSwitchClient
+	ctxEdgeOSClient
 )

 func ContextWithConfig(baseCtx context.Context, config *config.ClientsConfig) context.Context {
-	return context.WithValue(baseCtx, CTX_CONFIG, config)
+	return context.WithValue(baseCtx, ctxConfig, config)
 }

 func ConfigFromContext(ctx context.Context) *config.ClientsConfig {
-	val := ctx.Value(CTX_CONFIG)
+	val := ctx.Value(ctxConfig)
 	conf, ok := val.(*config.ClientsConfig)
 	if !ok {
 		return nil
@@ -28,16 +31,42 @@ func ConfigFromContext(ctx context.Context) *config.ClientsConfig {
 	return conf
 }

+// ContextWithLogger stores the logger in context using zerolog's built-in method.
 func ContextWithLogger(baseCtx context.Context, logger *zerolog.Logger) context.Context {
-	return context.WithValue(baseCtx, CTX_LOGGER, logger)
+	return logger.WithContext(baseCtx)
 }

+// LoggerFromContext retrieves the logger from context using zerolog's built-in method.
 func LoggerFromContext(ctx context.Context) *zerolog.Logger {
-	val := ctx.Value(CTX_LOGGER)
-	logger, ok := val.(*zerolog.Logger)
+	return zerolog.Ctx(ctx)
+}
+
+// ContextWithToughSwitchClient stores a toughswitch client in the context.
+func ContextWithToughSwitchClient(baseCtx context.Context, client *toughswitch.Client) context.Context {
+	return context.WithValue(baseCtx, ctxToughSwitchClient, client)
+}
+
+// ToughSwitchClientFromContext retrieves the toughswitch client from context.
+func ToughSwitchClientFromContext(ctx context.Context) *toughswitch.Client {
+	val := ctx.Value(ctxToughSwitchClient)
+	client, ok := val.(*toughswitch.Client)
 	if !ok {
 		return nil
 	}
-
-	return logger
+	return client
+}
+
+// ContextWithEdgeOSClient stores an edgeos client in the context.
+func ContextWithEdgeOSClient(baseCtx context.Context, client *edgeos.Client) context.Context {
+	return context.WithValue(baseCtx, ctxEdgeOSClient, client)
+}
+
+// EdgeOSClientFromContext retrieves the edgeos client from context.
+func EdgeOSClientFromContext(ctx context.Context) *edgeos.Client {
+	val := ctx.Value(ctxEdgeOSClient)
+	client, ok := val.(*edgeos.Client)
+	if !ok {
+		return nil
+	}
+	return client
 }
--- a/pkg/edgeos/client.go
+++ b/pkg/edgeos/client.go
@@ -119,6 +119,17 @@ func (c *Client) getDeviceByHost(host string) (*deviceClient, error) {
 	return d, nil
 }

+// Login authenticates with the device at the given host.
+// This is called automatically on 401 responses, but can be called explicitly
+// to pre-authenticate before making requests.
+func (c *Client) Login(ctx context.Context, host string) error {
+	d, err := c.getDeviceByHost(host)
+	if err != nil {
+		return err
+	}
+	return d.login(ctx)
+}
+
 func (d *deviceClient) login(ctx context.Context) error {
 	d.mu.Lock()
 	defer d.mu.Unlock()
--- a/pkg/toughswitch/client.go
+++ b/pkg/toughswitch/client.go
@@ -120,6 +120,17 @@ func (c *Client) getDeviceByHost(host string) (*deviceClient, error) {
 	return d, nil
 }

+// Login authenticates with the device at the given host.
+// This is called automatically on 401 responses, but can be called explicitly
+// to pre-authenticate before making requests.
+func (c *Client) Login(ctx context.Context, host string) error {
+	d, err := c.getDeviceByHost(host)
+	if err != nil {
+		return err
+	}
+	return d.login(ctx)
+}
+
 func (d *deviceClient) login(ctx context.Context) error {
 	d.mu.Lock()
 	defer d.mu.Unlock()