wiring open, refresh, and copy. Using refresh to insert external node info

Author: patelspratik

pkg/cmd/copy/copy.go

@@ -8,6 +8,8 @@ import (
 	"strings"
 	"time"
 
+	nodev1 "buf.build/gen/go/brevdev/devplane/protocolbuffers/go/devplaneapi/v1"
+
 	"github.com/brevdev/brev-cli/pkg/cmd/cmderrors"
 	"github.com/brevdev/brev-cli/pkg/cmd/completions"
 	"github.com/brevdev/brev-cli/pkg/cmd/refresh"
@@ -77,7 +79,12 @@ func runCopyCommand(t *terminal.Terminal, cstore CopyStore, source, dest string,
 
 	workspace, err := prepareWorkspace(t, cstore, workspaceNameOrID)
 	if err != nil {
-		return breverrors.WrapAndTrace(err)
+		// Workspace not found — try external nodes.
+		node, nodeErr := util.FindExternalNode(cstore, workspaceNameOrID)
+		if nodeErr != nil || node == nil {
+			return breverrors.WrapAndTrace(err) // return original workspace error
+		}
+		return copyExternalNode(t, cstore, node, localPath, remotePath, isUpload)
 	}
 
 	sshName, err := setupSSHConnection(t, cstore, workspace, host)
@@ -287,6 +294,28 @@ func startWorkspaceIfStopped(t *terminal.Terminal, s *spinner.Spinner, tstore Co
 	return nil
 }
 
+func copyExternalNode(t *terminal.Terminal, cstore CopyStore, node *nodev1.ExternalNode, localPath, remotePath string, isUpload bool) error {
+	info, err := util.ResolveExternalNodeSSH(cstore, node)
+	if err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+	alias := info.SSHAlias()
+
+	// Ensure SSH config is up to date so the alias resolves.
+	refreshRes := refresh.RunRefreshAsync(cstore)
+	if err := refreshRes.Await(); err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+
+	s := t.NewSpinner()
+	err = waitForSSHToBeAvailable(alias, s)
+	if err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+
+	return runSCP(t, alias, localPath, remotePath, isUpload)
+}
+
 func pollUntil(s *spinner.Spinner, wsid string, state string, copyStore CopyStore, waitMsg string) error {
 	isReady := false
 	s.Suffix = waitMsg

pkg/cmd/open/open.go

@@ -10,6 +10,8 @@ import (
 	"strings"
 	"time"
 
+	nodev1 "buf.build/gen/go/brevdev/devplane/protocolbuffers/go/devplaneapi/v1"
+
 	"github.com/alessio/shellescape"
 	"github.com/brevdev/brev-cli/pkg/analytics"
 	"github.com/brevdev/brev-cli/pkg/cmd/cmderrors"
@@ -283,7 +285,16 @@ func runOpenCommand(t *terminal.Terminal, tstore OpenStore, wsIDOrName string, s
 	res := refresh.RunRefreshAsync(tstore)
 	workspace, err := util.GetUserWorkspaceByNameOrIDErr(tstore, wsIDOrName)
 	if err != nil {
-		return breverrors.WrapAndTrace(err)
+		// Workspace not found — try external nodes.
+		node, nodeErr := util.FindExternalNode(tstore, wsIDOrName)
+		if nodeErr != nil || node == nil {
+			return breverrors.WrapAndTrace(err) // return original workspace error
+		}
+		// Await refresh so SSH config entries are written for the node.
+		if awaitErr := res.Await(); awaitErr != nil {
+			return breverrors.WrapAndTrace(awaitErr)
+		}
+		return openExternalNode(t, tstore, node, directory, editorType)
 	}
 	if workspace.Status == "STOPPED" { // we start the env for the user
 		err = startWorkspaceIfStopped(t, tstore, wsIDOrName, workspace)
@@ -356,6 +367,36 @@ func runOpenCommand(t *terminal.Terminal, tstore OpenStore, wsIDOrName string, s
 	return nil
 }
 
+func openExternalNode(t *terminal.Terminal, tstore OpenStore, node *nodev1.ExternalNode, directory string, editorType string) error {
+	info, err := util.ResolveExternalNodeSSH(tstore, node)
+	if err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+	alias := info.SSHAlias()
+	path := info.HomePath()
+	if directory != "" {
+		path = directory
+	}
+
+	_ = hello.SetHasRunOpen(true)
+
+	s := t.NewSpinner()
+	s.Start()
+	s.Suffix = "  checking if your node is ready..."
+	err = waitForSSHToBeAvailable(t, s, alias)
+	if err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+
+	editorName := getEditorName(editorType)
+	s.Suffix = fmt.Sprintf(" Node is ready. Opening %s", editorName)
+	time.Sleep(250 * time.Millisecond)
+	s.Stop()
+	t.Vprintf("\n")
+
+	return openEditorByType(t, editorType, alias, path, tstore)
+}
+
 func pushOpenAnalytics(tstore OpenStore, workspace *entity.Workspace) error {
 	userID := ""
 	user, err := tstore.GetCurrentUser()

pkg/cmd/refresh/refresh.go

@@ -2,12 +2,19 @@
 package refresh
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"io/fs"
+	"log"
 	"sync"
 
+	nodev1 "buf.build/gen/go/brevdev/devplane/protocolbuffers/go/devplaneapi/v1"
+	"connectrpc.com/connect"
+
+	"github.com/brevdev/brev-cli/pkg/cmd/register"
 	"github.com/brevdev/brev-cli/pkg/cmdcontext"
+	"github.com/brevdev/brev-cli/pkg/config"
 	"github.com/brevdev/brev-cli/pkg/entity"
 	breverrors "github.com/brevdev/brev-cli/pkg/errors"
 	"github.com/brevdev/brev-cli/pkg/ssh"
@@ -22,6 +29,8 @@ type RefreshStore interface {
 	ssh.SSHConfigurerV2Store
 	GetCurrentUser() (*entity.User, error)
 	GetCurrentUserKeys() (*entity.UserKeys, error)
+	GetActiveOrganizationOrDefault() (*entity.Organization, error)
+	GetAccessToken() (string, error)
 	Chmod(string, fs.FileMode) error
 	MkdirAll(string, fs.FileMode) error
 	GetBrevCloudflaredBinaryPath() (string, error)
@@ -151,10 +160,70 @@ func GetConfigUpdater(store RefreshStore) (*ssh.ConfigUpdater, error) {
 	}
 
 	cu := ssh.NewConfigUpdater(store, configs, keys.PrivateKey)
+	cu.ExternalNodes = getExternalNodeSSHEntries(store)
 
 	return cu, nil
 }
 
+// getExternalNodeSSHEntries fetches external nodes and resolves their SSH details.
+// This is best-effort: if anything fails, it returns nil so workspace SSH config is unaffected.
+func getExternalNodeSSHEntries(store RefreshStore) []ssh.ExternalNodeSSHEntry {
+	org, err := store.GetActiveOrganizationOrDefault()
+	if err != nil {
+		log.Printf("external nodes: skipping (no org): %v", err)
+		return nil
+	}
+
+	user, err := store.GetCurrentUser()
+	if err != nil {
+		log.Printf("external nodes: skipping (no user): %v", err)
+		return nil
+	}
+
+	client := register.NewNodeServiceClient(store, config.GlobalConfig.GetBrevPublicAPIURL())
+	resp, err := client.ListNodes(context.Background(), connect.NewRequest(&nodev1.ListNodesRequest{
+		OrganizationId: org.ID,
+	}))
+	if err != nil {
+		log.Printf("external nodes: skipping (list failed): %v", err)
+		return nil
+	}
+
+	var entries []ssh.ExternalNodeSSHEntry
+	for _, node := range resp.Msg.GetItems() {
+		var linuxUser string
+		for _, access := range node.GetSshAccess() {
+			if access.GetUserId() == user.ID {
+				linuxUser = access.GetLinuxUser()
+				break
+			}
+		}
+		if linuxUser == "" {
+			continue
+		}
+
+		var sshPort *nodev1.Port
+		for _, p := range node.GetPorts() {
+			if p.GetProtocol() == nodev1.PortProtocol_PORT_PROTOCOL_SSH {
+				sshPort = p
+				break
+			}
+		}
+		if sshPort == nil || sshPort.GetHostname() == "" {
+			continue
+		}
+
+		entries = append(entries, ssh.ExternalNodeSSHEntry{
+			Alias:    ssh.SanitizeNodeName(node.GetName()),
+			Hostname: sshPort.GetHostname(),
+			Port:     sshPort.GetPortNumber(),
+			User:     linuxUser,
+		})
+	}
+
+	return entries
+}
+
 func GetCloudflare(refreshStore RefreshStore) store.Cloudflared {
 	cl := store.NewCloudflare(refreshStore)
 	return cl

pkg/cmd/revokessh/revokessh.go

@@ -9,7 +9,6 @@ import (
 
 	nodev1 "buf.build/gen/go/brevdev/devplane/protocolbuffers/go/devplaneapi/v1"
 	"connectrpc.com/connect"
-
 	"github.com/brevdev/brev-cli/pkg/cmd/register"
 	"github.com/brevdev/brev-cli/pkg/config"
 	breverrors "github.com/brevdev/brev-cli/pkg/errors"
@@ -125,13 +124,7 @@ func runRevokeSSH(ctx context.Context, t *terminal.Terminal, s RevokeSSHStore, d
 	}
 	t.Vprint("")
 
-	// Remove the key from authorized_keys first.
-	if err := deps.removeKeyLine(osUser, selectedKey.Line); err != nil {
-		return fmt.Errorf("failed to remove key from authorized_keys: %w", err)
-	}
-	t.Vprint("  Brev public key removed from authorized_keys.")
-
-	// If we know the user ID, also revoke server-side.
+	// revoke server-side, this will remove the key on the box, this allows this cmd to happen from anywhere
 	if selectedKey.UserID != "" {
 		client := deps.nodeClients.NewNodeClient(s, config.GlobalConfig.GetBrevPublicAPIURL())
 		_, err := client.RevokeNodeSSHAccess(ctx, connect.NewRequest(&nodev1.RevokeNodeSSHAccessRequest{
@@ -143,10 +136,10 @@ func runRevokeSSH(ctx context.Context, t *terminal.Terminal, s RevokeSSHStore, d
 			t.Vprintf("  %s\n", t.Yellow(fmt.Sprintf("Warning: server-side revocation failed: %v", err)))
 			t.Vprint("  The key was removed locally but the server may still show access.")
 		}
-	} else {
-		t.Vprint("  Key was old-format (no user ID); skipping server-side revocation.")
 	}
 
+	t.Vprint("  Brev public key removed from authorized_keys.")
+
 	t.Vprint("")
 	t.Vprint(t.Green("SSH key revoked."))
 	return nil

pkg/cmd/shell/shell.go

@@ -1,23 +1,18 @@
 package shell
 
 import (
-	"context"
 	"fmt"
 	"os"
 	"os/exec"
-	"strings"
 	"time"
 
 	nodev1 "buf.build/gen/go/brevdev/devplane/protocolbuffers/go/devplaneapi/v1"
-	"connectrpc.com/connect"
 
 	"github.com/brevdev/brev-cli/pkg/analytics"
 	"github.com/brevdev/brev-cli/pkg/cmd/completions"
 	"github.com/brevdev/brev-cli/pkg/cmd/hello"
 	"github.com/brevdev/brev-cli/pkg/cmd/refresh"
-	"github.com/brevdev/brev-cli/pkg/cmd/register"
 	"github.com/brevdev/brev-cli/pkg/cmd/util"
-	"github.com/brevdev/brev-cli/pkg/config"
 	"github.com/brevdev/brev-cli/pkg/entity"
 	breverrors "github.com/brevdev/brev-cli/pkg/errors"
 	"github.com/brevdev/brev-cli/pkg/store"
@@ -51,7 +46,6 @@ type ShellStore interface {
 	refresh.RefreshStore
 	GetOrganizations(options *store.GetOrganizationsOptions) ([]entity.Organization, error)
 	GetWorkspaces(organizationID string, options *store.GetWorkspacesOptions) ([]entity.Workspace, error)
-	GetAccessToken() (string, error)
 }
 
 func NewCmdShell(t *terminal.Terminal, store ShellStore, noLoginStartStore ShellStore) *cobra.Command {
@@ -87,7 +81,7 @@ func runShellCommand(t *terminal.Terminal, sstore ShellStore, workspaceNameOrID
 	workspace, err := util.GetUserWorkspaceByNameOrIDErr(sstore, workspaceNameOrID)
 	if err != nil {
 		// Workspace not found — try external nodes.
-		node, nodeErr := findExternalNode(sstore, workspaceNameOrID)
+		node, nodeErr := util.FindExternalNode(sstore, workspaceNameOrID)
 		if nodeErr != nil || node == nil {
 			return breverrors.WrapAndTrace(err) // return original workspace error
 		}
@@ -157,64 +151,14 @@ func runShellCommand(t *terminal.Terminal, sstore ShellStore, workspaceNameOrID
 	return nil
 }
 
-func findExternalNode(sstore ShellStore, name string) (*nodev1.ExternalNode, error) {
-	org, err := sstore.GetActiveOrganizationOrDefault()
-	if err != nil {
-		return nil, breverrors.WrapAndTrace(err)
-	}
-	client := register.NewNodeServiceClient(sstore, config.GlobalConfig.GetBrevPublicAPIURL())
-	resp, err := client.ListNodes(context.Background(), connect.NewRequest(&nodev1.ListNodesRequest{
-		OrganizationId: org.ID,
-	}))
-	if err != nil {
-		return nil, breverrors.WrapAndTrace(err)
-	}
-	for _, node := range resp.Msg.GetItems() {
-		if strings.EqualFold(node.GetName(), name) {
-			return node, nil
-		}
-	}
-	return nil, nil
-}
-
 func shellIntoExternalNode(t *terminal.Terminal, sstore ShellStore, node *nodev1.ExternalNode) error {
-	user, err := sstore.GetCurrentUser()
+	info, err := util.ResolveExternalNodeSSH(sstore, node)
 	if err != nil {
 		return breverrors.WrapAndTrace(err)
 	}
 
-	var linuxUser string
-	for _, access := range node.GetSshAccess() {
-		if access.GetUserId() == user.ID {
-			linuxUser = access.GetLinuxUser()
-			break
-		}
-	}
-	if linuxUser == "" {
-		return breverrors.New(fmt.Sprintf("you don't have SSH access to node %q — try running: brev grant-ssh", node.GetName()))
-	}
-
-	var sshPort *nodev1.Port
-	for _, p := range node.GetPorts() {
-		if p.GetProtocol() == nodev1.PortProtocol_PORT_PROTOCOL_SSH {
-			sshPort = p
-			break
-		}
-	}
-	if sshPort == nil {
-		return breverrors.New(fmt.Sprintf("no SSH port configured for node %q", node.GetName()))
-	}
-
-	hostname := sshPort.GetHostname()
-	if hostname == "" {
-		return breverrors.New(fmt.Sprintf("SSH port has no hostname for node %q", node.GetName()))
-	}
-	port := sshPort.GetPortNumber()
-
-	target := fmt.Sprintf("%s@%s", linuxUser, hostname)
-	t.Vprintf("Connecting to external node %q as %s on port %d...\n", node.GetName(), linuxUser, port)
-
-	return runSSHWithPort(target, port)
+	t.Vprintf("Connecting to external node %q as %s on port %d...\n", node.GetName(), info.LinuxUser, info.Port)
+	return runSSHWithPort(info.SSHTarget(), info.Port)
 }
 
 func runSSHWithPort(target string, port int32) error {