feat(apps): Add apps new dev server (#3923)

## Changes
<!-- Brief summary of your changes that is easy to understand -->

This PR introduces a new way to develop apps, that fully integrates with
the new Apps Kit. It works along with this other PR
https://github.com/databricks-eng/apps-sdk/pull/23 which is already
merged.

The idea is to provide an easy way of developing applications without
having to setup all the environment variables and all the dependencies.
This creates an hybrid between running the local frontend code + the
remote server.

It also provides integration with HMR, so when any change is make either
in the frontend code or query files, they will get reflected instantly
on the app. (Changes are not synced, but the user can see them)

### How does it work?

You can find a diagram of how this works in the other
[PR](https://github.com/databricks-eng/apps-sdk/pull/23)

## Why
<!-- Why are these changes needed? Provide the context that the reviewer
might be missing.
For example, were there any decisions behind the change that are not
reflected in the code itself? -->

This is a step towards making the experience of developing Databricks
apps a lot easier for users.

Basically with the CLI + the Apps Kit, having a first deployment of the
app into the Databricks environment, by simply running the new
`dev-remote` command in the project folder, now users can easily preview
their changes against the remote environment without setting anything
up.

## Tests
<!-- How have you tested the changes? -->
- Added some tests to verify some of the functionality, path parsing,
etc.
- Did a lot of manual testing to verify everything works as expected

<!-- If your PR needs to be included in the release notes for next
release,
add a separate entry in NEXT_CHANGELOG.md as part of your PR. -->

---------

Co-authored-by: MarioCadenas <[email protected]>

Author: MarioCadenas

cmd/workspace/apps/dev.go

@@ -0,0 +1,172 @@
+package apps
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/databricks/cli/cmd/root"
+	"github.com/databricks/cli/libs/cmdctx"
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/spf13/cobra"
+)
+
+//go:embed vite-server.js
+var viteServerScript []byte
+
+const (
+	vitePort               = 5173
+	viteReadyCheckInterval = 100 * time.Millisecond
+	viteReadyMaxAttempts   = 50
+)
+
+func isViteReady(port int) bool {
+	conn, err := net.DialTimeout("tcp", "localhost:"+strconv.Itoa(port), viteReadyCheckInterval)
+	if err != nil {
+		return false
+	}
+	conn.Close()
+	return true
+}
+
+func startViteDevServer(ctx context.Context, appURL string, port int) (*exec.Cmd, chan error, error) {
+	// Pass script through stdin, and pass arguments in order <appURL> <port (optional)>
+	viteCmd := exec.Command("node", "-", appURL, strconv.Itoa(port))
+	viteCmd.Stdin = bytes.NewReader(viteServerScript)
+	viteCmd.Stdout = os.Stdout
+	viteCmd.Stderr = os.Stderr
+
+	err := viteCmd.Start()
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to start Vite server: %w", err)
+	}
+
+	cmdio.LogString(ctx, fmt.Sprintf("🚀 Starting Vite development server on port %d...", port))
+
+	viteErr := make(chan error, 1)
+	go func() {
+		if err := viteCmd.Wait(); err != nil {
+			viteErr <- fmt.Errorf("vite server exited with error: %w", err)
+		} else {
+			viteErr <- errors.New("vite server exited unexpectedly")
+		}
+	}()
+
+	for range viteReadyMaxAttempts {
+		select {
+		case err := <-viteErr:
+			return nil, nil, err
+		default:
+			if isViteReady(port) {
+				return viteCmd, viteErr, nil
+			}
+			time.Sleep(viteReadyCheckInterval)
+		}
+	}
+
+	_ = viteCmd.Process.Kill()
+	return nil, nil, errors.New("timeout waiting for Vite server to be ready")
+}
+
+func newRunDevCommand() *cobra.Command {
+	var (
+		appName    string
+		clientPath string
+		port       int
+	)
+
+	cmd := &cobra.Command{}
+
+	cmd.Use = "dev-remote"
+	cmd.Hidden = true
+	cmd.Short = `Run Databricks app locally with WebSocket bridge to remote server.`
+	cmd.Long = `Run Databricks app locally with WebSocket bridge to remote server.
+
+  Starts a local development server and establishes a WebSocket bridge
+  to the remote Databricks app for development.
+    `
+
+	cmd.PreRunE = root.MustWorkspaceClient
+
+	cmd.Flags().StringVar(&appName, "app-name", "", "Name of the app to connect to (required)")
+	cmd.Flags().StringVar(&clientPath, "client-path", "./client", "Path to the Vite client directory")
+	cmd.Flags().IntVar(&port, "port", vitePort, "Port to run the Vite server on")
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		ctx := cmd.Context()
+		w := cmdctx.WorkspaceClient(ctx)
+
+		if appName == "" {
+			return errors.New("app name is required (use --app-name)")
+		}
+
+		if _, err := os.Stat(clientPath); os.IsNotExist(err) {
+			return fmt.Errorf("client directory not found: %s", clientPath)
+		}
+
+		bridge := NewViteBridge(ctx, w, appName, port)
+
+		appDomain, err := bridge.GetAppDomain()
+		if err != nil {
+			return fmt.Errorf("failed to get app domain: %w", err)
+		}
+
+		viteCmd, viteErr, err := startViteDevServer(ctx, appDomain.String(), port)
+		if err != nil {
+			return err
+		}
+
+		done := make(chan error, 1)
+		sigChan := make(chan os.Signal, 1)
+		signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
+
+		go func() {
+			done <- bridge.Start()
+		}()
+
+		select {
+		case err := <-viteErr:
+			bridge.Stop()
+			<-done
+			return err
+		case err := <-done:
+			cmdio.LogString(ctx, "Bridge stopped")
+			if viteCmd.Process != nil {
+				_ = viteCmd.Process.Signal(os.Interrupt)
+				<-viteErr
+			}
+			return err
+		case <-sigChan:
+			cmdio.LogString(ctx, "\n🛑 Shutting down...")
+			bridge.Stop()
+			<-done
+			if viteCmd.Process != nil {
+				if err := viteCmd.Process.Signal(os.Interrupt); err != nil {
+					cmdio.LogString(ctx, fmt.Sprintf("Failed to interrupt Vite: %v", err))
+					_ = viteCmd.Process.Kill()
+				}
+				<-viteErr
+			}
+			return nil
+		}
+	}
+
+	cmd.ValidArgsFunction = cobra.NoFileCompletions
+
+	return cmd
+}
+
+func init() {
+	cmdOverrides = append(cmdOverrides, func(cmd *cobra.Command) {
+		cmd.AddCommand(newRunDevCommand())
+	})
+}

cmd/workspace/apps/dev_test.go

@@ -0,0 +1,90 @@
+package apps
+
+import (
+	"context"
+	"net"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsViteReady(t *testing.T) {
+	t.Run("vite not running", func(t *testing.T) {
+		// Assuming nothing is running on port 5173
+		ready := isViteReady(5173)
+		assert.False(t, ready)
+	})
+
+	t.Run("vite is running", func(t *testing.T) {
+		// Start a mock server on the Vite port
+		listener, err := net.Listen("tcp", "localhost:5173")
+		require.NoError(t, err)
+		defer listener.Close()
+
+		// Accept connections in the background
+		go func() {
+			for {
+				conn, err := listener.Accept()
+				if err != nil {
+					return
+				}
+				conn.Close()
+			}
+		}()
+
+		// Give the listener a moment to start
+		time.Sleep(50 * time.Millisecond)
+
+		ready := isViteReady(5173)
+		assert.True(t, ready)
+	})
+}
+
+func TestViteServerScriptContent(t *testing.T) {
+	// Verify the embedded script is not empty
+	assert.NotEmpty(t, viteServerScript)
+
+	// Verify it's a JavaScript file with expected content
+	assert.Contains(t, string(viteServerScript), "startViteServer")
+}
+
+func TestStartViteDevServerNoNode(t *testing.T) {
+	// Skip this test if node is not available or in CI environments
+	if os.Getenv("CI") != "" {
+		t.Skip("Skipping node-dependent test in CI")
+	}
+
+	ctx := context.Background()
+	ctx = cmdio.MockDiscard(ctx)
+
+	// Create a temporary directory to act as project root
+	tmpDir := t.TempDir()
+	oldWd, err := os.Getwd()
+	require.NoError(t, err)
+	defer func() { _ = os.Chdir(oldWd) }()
+
+	err = os.Chdir(tmpDir)
+	require.NoError(t, err)
+
+	// Create a client directory
+	err = os.Mkdir("client", 0o755)
+	require.NoError(t, err)
+
+	// Try to start Vite server with invalid app URL (will fail fast)
+	// This test mainly verifies the function signature and error handling
+	_, _, err = startViteDevServer(ctx, "", 5173)
+	assert.Error(t, err)
+}
+
+func TestViteServerScriptEmbedded(t *testing.T) {
+	assert.NotEmpty(t, viteServerScript)
+
+	scriptContent := string(viteServerScript)
+	assert.Contains(t, scriptContent, "startViteServer")
+	assert.Contains(t, scriptContent, "createServer")
+	assert.Contains(t, scriptContent, "queriesHMRPlugin")
+}