Add client daemon repo, server, and cmd

The commands added are:
boundary daemon start
boundary daemon stop
boundary daemon add-token
boundary daemon status
boundary search

If these actions are performed on a platform that doesn't support sqlite
natively in go an error is returned.

Besides some hooks into the cmd package all the significant logic
resides in internal/clientcache

feat (cmds/authenticate): output the token name when storing token

feat: update go-dbw which now uses pure go sqlite driver

refact (base.Command): export FlagOutputCurlString

Exporting FlagOutputCurlString allows other commands that embed
the base.Command to access the flag as needed

feat: add a cache Repository to manage cache storage

feat: add a "cache" CLI command

This new command will support both managing and searching the
local CLI cache daemon.

feat: start cache daemon as needed when issue CLI commands

Move files to new directories and add persona table (#3526)

* Add persona table and move files to new directories

Client daemon now uses unix sockets and update pathing (#3535)

* Add unix socket listen and dialers with file permissions applied

* Update the pathing to match RFC

Cache refreshing now uses all stored personas. (#3545)

Updating headers for LLB files

Decouple daemon and cache server (#3566)

* Separate daemon from server

* Add persona handler to daemon server (#3579)

Moved search to use mql and added tests for the search command (#3589)

* search uses hashicorp/mql

Windows support for client side daemon (#3618)

* exec.Command for background process

* Log to stderr when in foreground and file always

* Use pid files across platform for start and stop

Requests with version info must match the daemon's version (#3640)

* requests with version info must match daemons

Update dependencies and breakout cgo/pure go sqlite drivers  (#3657)

upgrade go-dbw deps and add cgo build tags

Enable graceful shutdown in windows (#3695)

* Enable graceful shutdown in windows

Co-authored-by: Jim <jlambert@hashicorp.com>

Targets delete when a persona changes address or user id (#3673)

* Handle cache refresh in repo

Add sessions to the client side cache (#3682)

* Add sessions to repository

* Search command supports sessions

* adding session related tests to db and refresh

Change cache schema from personas to tokens+users (#3737)

* Change from personas to tokens+users

* Separate keyring tokens from auth tokens

Add support for keyringless auth tokens (#3765)

* Add support for keyringless auth tokens

Remove expired auth tokens from cache (#3768)

* Remove expired auth tokens from cache

Complete the TODO of checking for inflight tx (#3779)

Delete tokens that the controller says are invalid (#3782)

fix search test with boundary token check (#3799)

Collect resource info in repository_<resource>s.go (#3769)

* Collect resource info in repository_<resource>s.go

* Move search logic into the domain (#3794)

Daemon and search restricted to supported platforms (#3801)

* Daemon and search restricted to supported platforms

Reorganize the clientcache packages (#3814)

* Refactor for self contained domain logic

* Put clientcache stuff under internal

internal/clientcache/cmd/daemon/command_wrapper.go

@@ -0,0 +1,73 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package daemon
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/hashicorp/boundary/internal/cmd/base"
+	"github.com/mitchellh/cli"
+)
+
+// CommandWrapper starts the boundary daemon after the command was Run and attempts
+// to send the current persona to any running daemon.
+type CommandWrapper struct {
+	cli.Command
+	ui cli.Ui
+}
+
+// Wrap returns a cli.CommandFactory that returns a command wrapped in the CommandWrapper.
+func Wrap(ui cli.Ui, wrapped cli.Command) cli.CommandFactory {
+	return func() (cli.Command, error) {
+		return &CommandWrapper{
+			Command: wrapped,
+			ui:      ui,
+		}, nil
+	}
+}
+
+// Run runs the wrapped command and then attempts to start the boundary daemon and send
+// the current persona
+func (w *CommandWrapper) Run(args []string) int {
+	r := w.Command.Run(args)
+
+	ctx := context.Background()
+	if w.startDaemon(ctx) {
+		w.addPersonaInCache(ctx)
+	}
+	return r
+}
+
+// startDaemon attempts to start a daemon and returns true if we have attempted to start
+// the daemon and either it was successful or it was already running.
+func (w *CommandWrapper) startDaemon(ctx context.Context) bool {
+	cmdName, err := os.Executable()
+	if err != nil {
+		w.ui.Error(fmt.Sprintf("unable to find boundary binary for daemon startup: %s", err.Error()))
+		return false
+	}
+
+	var stdErr bytes.Buffer
+	cmd := exec.Command(cmdName, "daemon", "start", "-background")
+	cmd.Stderr = &stdErr
+
+	// We use Run here instead of Start because the command spawns off a subprocess and returns.
+	// We do not want to send the request to add a persona to the cache until we know the daemon
+	// has started up.
+	err = cmd.Run()
+	return err == nil || strings.Contains(stdErr.String(), "already running")
+}
+
+// addPersonaInCache runs AddPersonaCommand
+func (w *CommandWrapper) addPersonaInCache(ctx context.Context) bool {
+	c := AddTokenCommand{Command: base.NewCommand(w.ui)}
+	c.Flags()
+	apiErr, err := c.Add(ctx)
+	return err == nil && apiErr == nil
+}