Merge branch 'main' into codedor/register/hardware_profiler

Author: patelspratik

.agents/skills/brev-cli/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: brev-cli
-description: Manage GPU and CPU cloud instances with the Brev CLI. Use when users want to create instances, search for GPUs or CPUs, SSH into instances, open editors, copy files, port forward, manage organizations, or work with cloud compute. Trigger keywords - brev, gpu, cpu, instance, create instance, ssh, vram, vcpu, A100, H100, cloud gpu, cloud cpu, remote machine.
+description: Manage GPU and CPU cloud instances with the Brev CLI for ML workloads and general compute. Use when users want to create instances, search for GPUs or CPUs, SSH into instances, open editors, copy files, port forward, manage organizations, or work with cloud compute. Supports fine-tuning, reinforcement learning, training, inference, batch processing, and other ML/AI workloads. Trigger keywords - brev, gpu, cpu, instance, create instance, ssh, vram, vcpu, A100, H100, cloud gpu, cloud cpu, remote machine, finetune, fine-tune, RL, RLHF, training, inference, deploy model, serve model, batch job.
 allowed-tools: Bash, Read, AskUserQuestion
-argument-hint: [create|search|shell|exec|open|ls|delete] [instance-name]
+argument-hint: "[create|search|shell|exec|open|ls|delete] [instance-name]"
 ---
 <!--
 Token Budget:

pkg/cmd/agentskill/agentskill.go

@@ -116,7 +116,7 @@ func newCmdUninstall(t *terminal.Terminal, store AgentSkillStore) *cobra.Command
 
 // installDirs are the parent directories under $HOME where skills are installed.
 // We install to both so the skill works with Claude Code (~/.claude) and other agents (~/.agent).
-var installDirs = []string{".claude", ".agents"}
+var installDirs = []string{".claude", ".agents", ".codex"}
 
 // GetSkillDirs returns all paths where the skill should be installed
 func GetSkillDirs(homeDir string) []string {

pkg/cmd/cmd.go

@@ -58,6 +58,7 @@ import (
 	"github.com/brevdev/brev-cli/pkg/cmd/workspacegroups"
 	"github.com/brevdev/brev-cli/pkg/cmd/writeconnectionevent"
 	"github.com/brevdev/brev-cli/pkg/config"
+	"github.com/brevdev/brev-cli/pkg/entity"
 	"github.com/brevdev/brev-cli/pkg/featureflag"
 	"github.com/brevdev/brev-cli/pkg/files"
 	"github.com/brevdev/brev-cli/pkg/remoteversion"
@@ -257,8 +258,20 @@ func NewBrevCommand() *cobra.Command { //nolint:funlen,gocognit,gocyclo // defin
 	cmds.SetUsageTemplate(usageTemplate)
 
 	// In-memory auth for external node commands — never touches credentials.json.
-	memAuthStore := store.NewMemoryAuthStore()
-	memAuthenticator := auth.StandardLogin("", "", nil)
+	// Pre-fill the cached email so the user sees a confirmation prompt instead of
+	// having to type it from scratch every time.
+	cachedEmail, _ := fsStore.GetCachedEmail()
+	memAuthenticator := auth.StandardLogin("", cachedEmail, nil)
+	if cachedEmail != "" {
+		if kas, ok := memAuthenticator.(auth.KasAuthenticator); ok {
+			kas.ShouldPromptEmail = true
+			memAuthenticator = kas
+		}
+	}
+	memAuthStore := &emailCachingAuthStore{
+		MemoryAuthStore: store.NewMemoryAuthStore(),
+		fileStore:       fsStore,
+	}
 	memLoginAuth := auth.NewLoginAuth(memAuthStore, memAuthenticator)
 	memLoginAuth.WithShouldLogin(func() (bool, error) { return true, nil })
 
@@ -555,4 +568,22 @@ var (
 	_ store.Auth     = auth.NoLoginAuth{}
 	_ auth.AuthStore = store.FileStore{}
 	_ auth.AuthStore = &store.MemoryAuthStore{}
+	_ auth.AuthStore = &emailCachingAuthStore{}
 )
+
+// emailCachingAuthStore wraps MemoryAuthStore and persists the login email
+// to ~/.brev/cached-email after each successful authentication.
+type emailCachingAuthStore struct {
+	*store.MemoryAuthStore
+	fileStore *store.FileStore
+}
+
+func (e *emailCachingAuthStore) SaveAuthTokens(tokens entity.AuthTokens) error {
+	if err := e.MemoryAuthStore.SaveAuthTokens(tokens); err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+	if email := auth.GetEmailFromToken(tokens.AccessToken); email != "" {
+		_ = e.fileStore.SaveCachedEmail(email)
+	}
+	return nil
+}

pkg/cmd/cmd_test.go

@@ -0,0 +1,75 @@
+package cmd
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"testing"
+
+	"github.com/brevdev/brev-cli/pkg/entity"
+	"github.com/brevdev/brev-cli/pkg/store"
+	"github.com/spf13/afero"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// fakeJWT builds an unsigned JWT with the given claims (header.payload.signature).
+func fakeJWT(t *testing.T, claims map[string]interface{}) string {
+	t.Helper()
+	header := base64.RawURLEncoding.EncodeToString([]byte(`{"alg":"none","typ":"JWT"}`))
+	payload, err := json.Marshal(claims)
+	require.NoError(t, err)
+	return header + "." + base64.RawURLEncoding.EncodeToString(payload) + "."
+}
+
+func newTestFileStore(t *testing.T) *store.FileStore {
+	t.Helper()
+	fs := afero.NewMemMapFs()
+	err := fs.MkdirAll("/home/testuser/.brev", 0o755)
+	require.NoError(t, err)
+	return store.NewBasicStore().WithFileSystem(fs).WithUserHomeDirGetter(
+		func() (string, error) { return "/home/testuser", nil },
+	)
+}
+
+func TestEmailCachingAuthStore_SaveCachesEmail(t *testing.T) {
+	fs := newTestFileStore(t)
+	s := &emailCachingAuthStore{
+		MemoryAuthStore: store.NewMemoryAuthStore(),
+		fileStore:       fs,
+	}
+
+	token := fakeJWT(t, map[string]interface{}{"email": "user@example.com"})
+	err := s.SaveAuthTokens(entity.AuthTokens{AccessToken: token})
+	require.NoError(t, err)
+
+	cached, err := fs.GetCachedEmail()
+	require.NoError(t, err)
+	assert.Equal(t, "user@example.com", cached)
+}
+
+func TestEmailCachingAuthStore_NoEmailInToken(t *testing.T) {
+	fs := newTestFileStore(t)
+	s := &emailCachingAuthStore{
+		MemoryAuthStore: store.NewMemoryAuthStore(),
+		fileStore:       fs,
+	}
+
+	token := fakeJWT(t, map[string]interface{}{"sub": "12345"})
+	err := s.SaveAuthTokens(entity.AuthTokens{AccessToken: token})
+	require.NoError(t, err)
+
+	cached, err := fs.GetCachedEmail()
+	require.NoError(t, err)
+	assert.Equal(t, "", cached)
+}
+
+func TestEmailCachingAuthStore_EmptyAccessToken(t *testing.T) {
+	fs := newTestFileStore(t)
+	s := &emailCachingAuthStore{
+		MemoryAuthStore: store.NewMemoryAuthStore(),
+		fileStore:       fs,
+	}
+
+	err := s.SaveAuthTokens(entity.AuthTokens{AccessToken: ""})
+	require.Error(t, err)
+}

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"
@@ -75,7 +77,15 @@ func runCopyCommand(t *terminal.Terminal, cstore CopyStore, source, dest string,
 		}
 	}
 
-	workspace, err := prepareWorkspace(t, cstore, workspaceNameOrID)
+	target, err := util.ResolveWorkspaceOrNode(cstore, workspaceNameOrID)
+	if err != nil {
+		return breverrors.WrapAndTrace(err)
+	}
+	if target.Node != nil {
+		return copyExternalNode(t, cstore, target.Node, localPath, remotePath, isUpload)
+	}
+
+	workspace, err := prepareWorkspace(t, cstore, target.Workspace)
 	if err != nil {
 		return breverrors.WrapAndTrace(err)
 	}
@@ -116,26 +126,22 @@ func parseCopyArguments(source, dest string) (workspaceNameOrID, remotePath, loc
 	return destWorkspace, destPath, source, true, nil
 }
 
-func prepareWorkspace(t *terminal.Terminal, cstore CopyStore, workspaceNameOrID string) (*entity.Workspace, error) {
+func prepareWorkspace(t *terminal.Terminal, cstore CopyStore, workspace *entity.Workspace) (*entity.Workspace, error) {
 	s := t.NewSpinner()
-	workspace, err := util.GetUserWorkspaceByNameOrIDErr(cstore, workspaceNameOrID)
-	if err != nil {
-		return nil, breverrors.WrapAndTrace(err)
-	}
 
 	if workspace.Status == "STOPPED" {
-		err = startWorkspaceIfStopped(t, s, cstore, workspaceNameOrID, workspace)
+		err := startWorkspaceIfStopped(t, s, cstore, workspace.Name, workspace)
 		if err != nil {
 			return nil, breverrors.WrapAndTrace(err)
 		}
 	}
 
-	err = pollUntil(s, workspace.ID, "RUNNING", cstore, " waiting for instance to be ready...")
+	err := pollUntil(s, workspace.ID, "RUNNING", cstore, " waiting for instance to be ready...")
 	if err != nil {
 		return nil, breverrors.WrapAndTrace(err)
 	}
 
-	workspace, err = util.GetUserWorkspaceByNameOrIDErr(cstore, workspaceNameOrID)
+	workspace, err = util.GetUserWorkspaceByNameOrIDErr(cstore, workspace.Name)
 	if err != nil {
 		return nil, breverrors.WrapAndTrace(err)
 	}
@@ -287,6 +293,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/copy/copy_test.go

@@ -0,0 +1,90 @@
+package copy
+
+import (
+	"testing"
+)
+
+func TestParseCopyArguments_Upload(t *testing.T) {
+	ws, remotePath, localPath, isUpload, err := parseCopyArguments("./local.txt", "my-node:/tmp/dest")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if ws != "my-node" {
+		t.Errorf("expected workspace my-node, got %s", ws)
+	}
+	if remotePath != "/tmp/dest" {
+		t.Errorf("expected remotePath /tmp/dest, got %s", remotePath)
+	}
+	if localPath != "./local.txt" {
+		t.Errorf("expected localPath ./local.txt, got %s", localPath)
+	}
+	if !isUpload {
+		t.Error("expected isUpload=true")
+	}
+}
+
+func TestParseCopyArguments_Download(t *testing.T) {
+	ws, remotePath, localPath, isUpload, err := parseCopyArguments("my-node:/tmp/file", "./local.txt")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if ws != "my-node" {
+		t.Errorf("expected workspace my-node, got %s", ws)
+	}
+	if remotePath != "/tmp/file" {
+		t.Errorf("expected remotePath /tmp/file, got %s", remotePath)
+	}
+	if localPath != "./local.txt" {
+		t.Errorf("expected localPath ./local.txt, got %s", localPath)
+	}
+	if isUpload {
+		t.Error("expected isUpload=false")
+	}
+}
+
+func TestParseCopyArguments_BothLocal(t *testing.T) {
+	_, _, _, _, err := parseCopyArguments("./a", "./b")
+	if err == nil {
+		t.Fatal("expected error when both paths are local")
+	}
+}
+
+func TestParseCopyArguments_BothRemote(t *testing.T) {
+	_, _, _, _, err := parseCopyArguments("ws1:/a", "ws2:/b")
+	if err == nil {
+		t.Fatal("expected error when both paths are remote")
+	}
+}
+
+func TestParseWorkspacePath_Local(t *testing.T) {
+	ws, fp, err := parseWorkspacePath("/tmp/local/file")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if ws != "" {
+		t.Errorf("expected empty workspace, got %s", ws)
+	}
+	if fp != "/tmp/local/file" {
+		t.Errorf("expected /tmp/local/file, got %s", fp)
+	}
+}
+
+func TestParseWorkspacePath_Remote(t *testing.T) {
+	ws, fp, err := parseWorkspacePath("my-instance:/remote/path")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if ws != "my-instance" {
+		t.Errorf("expected my-instance, got %s", ws)
+	}
+	if fp != "/remote/path" {
+		t.Errorf("expected /remote/path, got %s", fp)
+	}
+}
+
+func TestParseWorkspacePath_InvalidMultipleColons(t *testing.T) {
+	_, _, err := parseWorkspacePath("ws:path:extra")
+	if err == nil {
+		t.Fatal("expected error for multiple colons")
+	}
+}

pkg/cmd/deregister/deregister_test.go

@@ -91,8 +91,9 @@ type mockNetBirdManager struct {
 	err    error
 }
 
-func (m *mockNetBirdManager) Install() error   { return m.err }
-func (m *mockNetBirdManager) Uninstall() error { m.called = true; return m.err }
+func (m *mockNetBirdManager) Install() error       { return m.err }
+func (m *mockNetBirdManager) Uninstall() error     { m.called = true; return m.err }
+func (m *mockNetBirdManager) EnsureRunning() error { return m.err }
 
 type mockNodeClientFactory struct {
 	serverURL string

pkg/cmd/gpucreate/gpucreate.go

@@ -18,6 +18,7 @@ import (
 	"github.com/brevdev/brev-cli/pkg/entity"
 	breverrors "github.com/brevdev/brev-cli/pkg/errors"
 	"github.com/brevdev/brev-cli/pkg/featureflag"
+	"github.com/brevdev/brev-cli/pkg/names"
 	"github.com/brevdev/brev-cli/pkg/store"
 	"github.com/brevdev/brev-cli/pkg/terminal"
 	"github.com/spf13/cobra"
@@ -194,8 +195,8 @@ func NewCmdGPUCreate(t *terminal.Terminal, gpuCreateStore GPUCreateStore) *cobra
 				}
 			}
 
-			if name == "" {
-				return breverrors.NewValidationError("name is required (as argument or --name flag)")
+			if err := names.ValidateNodeName(name); err != nil {
+				return breverrors.WrapAndTrace(err)
 			}
 
 			if count < 1 {

pkg/cmd/notebook/notebook.go

@@ -25,7 +25,7 @@ type WorkspaceResult struct {
 	Err       error
 }
 
-func NewCmdNotebook(store NotebookStore, _ *terminal.Terminal) *cobra.Command {
+func NewCmdNotebook(store NotebookStore, t *terminal.Terminal) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     "notebook",
 		Short:   "Open a notebook on your Brev machine",
@@ -66,7 +66,7 @@ func NewCmdNotebook(store NotebookStore, _ *terminal.Terminal) *cobra.Command {
 			hello.TypeItToMeUnskippable27("\nClick here to go to your Jupyter notebook:\n\t 👉" + urlType("http://localhost:8888") + "👈\n\n\n")
 
 			// Port forward on 8888
-			err2 := portforward.RunPortforward(store, args[0], "8888:8888", false)
+			err2 := portforward.RunPortforward(t, store, args[0], "8888:8888", false)
 			if err2 != nil {
 				return breverrors.WrapAndTrace(err2)
 			}