Add apps new dev server

Author: MarioCadenas

cmd/workspace/apps/dev.go

@@ -0,0 +1,194 @@
+package apps
+
+import (
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"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
+
+// TODO: Handle multiple ports
+const vitePort = "5173"
+
+func isViteReady() bool {
+	conn, err := net.DialTimeout("tcp", "localhost:"+vitePort, 100*time.Millisecond)
+	if err != nil {
+		return false
+	}
+	conn.Close()
+	return true
+}
+
+func createViteServerScript() (string, error) {
+	tmpFile, err := os.CreateTemp("", "vite-server-*.js")
+	if err != nil {
+		return "", fmt.Errorf("failed to create temporary file for vite-server.js: %w", err)
+	}
+	defer tmpFile.Close()
+
+	if _, err := tmpFile.Write(viteServerScript); err != nil {
+		os.Remove(tmpFile.Name())
+		return "", fmt.Errorf("failed to write vite-server.js: %w", err)
+	}
+
+	return tmpFile.Name(), nil
+}
+
+func startViteDevServer(ctx context.Context, appURL string) (*exec.Cmd, string, chan error, error) {
+	scriptPath, err := createViteServerScript()
+	if err != nil {
+		return nil, "", nil, err
+	}
+
+	// Arguments: node vite-server.js <appURL>
+	viteCmd := exec.Command("node", scriptPath, appURL)
+	viteCmd.Stdout = os.Stdout
+	viteCmd.Stderr = os.Stderr
+
+	err = viteCmd.Start()
+	if err != nil {
+		os.Remove(scriptPath)
+		return nil, "", nil, fmt.Errorf("failed to start Vite server: %w", err)
+	}
+
+	cmdio.LogString(ctx, "🚀 Starting Vite development server...")
+
+	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")
+		}
+	}()
+
+	maxAttempts := 50
+
+	for range maxAttempts {
+		select {
+		case err := <-viteErr:
+			os.Remove(scriptPath)
+			return nil, "", nil, err
+		default:
+			if isViteReady() {
+				return viteCmd, scriptPath, viteErr, nil
+			}
+			time.Sleep(100 * time.Millisecond)
+		}
+	}
+
+	viteCmd.Process.Kill()
+	os.Remove(scriptPath)
+	return nil, "", nil, errors.New("timeout waiting for Vite server to be ready")
+}
+
+func newRunDevCommand() *cobra.Command {
+	var (
+		appName    string
+		clientPath string
+	)
+
+	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.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)
+
+		appDomain, err := bridge.GetAppDomain()
+		if err != nil {
+			return fmt.Errorf("failed to get app domain: %w", err)
+		}
+
+		viteCmd, scriptPath, viteErr, err := startViteDevServer(ctx, appDomain.String())
+		if err != nil {
+			return err
+		}
+
+		defer func() {
+			time.Sleep(100 * time.Millisecond)
+			os.Remove(scriptPath)
+		}()
+
+		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/vite-server.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+const path = require("node:path");
+const fs = require("node:fs");
+
+async function startViteServer() {
+  const vitePath = safeViteResolve();
+
+  if (!vitePath) {
+    console.log(
+      "\n❌ Vite needs to be installed in the current directory. Run `npm install vite`.\n"
+    );
+    process.exit(1);
+  }
+
+  const { createServer, loadConfigFromFile, mergeConfig } = require(vitePath);
+
+  const clientPath = path.join(process.cwd(), "client");
+  const appUrl = process.argv[2] || "";
+
+  if (!fs.existsSync(clientPath)) {
+    console.error("client folder doesn't exist.");
+    process.exit(1);
+  }
+
+  if (!appUrl) {
+    console.error("App URL is required");
+    process.exit(1);
+  }
+
+  try {
+    const domain = new URL(appUrl);
+
+    const loadedConfig = await loadConfigFromFile(
+      {
+        mode: "development",
+        command: "serve",
+      },
+      undefined,
+      clientPath
+    );
+    const userConfig = loadedConfig?.config ?? {};
+    const coreConfig = {
+      configFile: false,
+      root: clientPath,
+      server: {
+        open: `${domain.origin}?dev=true`,
+        // TODO: Handle multiple ports
+        port: 5173,
+        hmr: {
+          overlay: true,
+          path: `/dev-hmr`,
+        },
+        middlewareMode: false,
+      },
+    };
+    const mergedConfigs = mergeConfig(userConfig, coreConfig);
+    const server = await createServer(mergedConfigs);
+
+    await server.listen();
+
+    console.log(`\n✅ Vite dev server started successfully!`);
+    console.log(`\nPress Ctrl+C to stop the server\n`);
+
+    const shutdown = async () => {
+      await server.close();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (error) {
+    console.error(`❌ Failed to start Vite server:`, error.message);
+    if (error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+function safeViteResolve() {
+  try {
+    const vitePath = require.resolve("vite", { paths: [process.cwd()] });
+
+    return vitePath;
+  } catch (error) {
+    return null;
+  }
+}
+
+// Start the server
+startViteServer().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});