Appkit cli commands

cmd/experimental/experimental.go

@@ -2,6 +2,7 @@ package experimental
 
 import (
 	mcp "github.com/databricks/cli/experimental/aitools/cmd"
+	dev "github.com/databricks/cli/experimental/dev/cmd"
 	"github.com/spf13/cobra"
 )
 
@@ -20,6 +21,7 @@ These commands provide early access to new features that are still under
 development. They may change or be removed in future versions without notice.`,
 	}
 
+	cmd.AddCommand(dev.New())
 	cmd.AddCommand(mcp.NewMcpCmd())
 
 	return cmd

cmd/workspace/apps/overrides.go

@@ -23,6 +23,9 @@ func listDeploymentsOverride(listDeploymentsCmd *cobra.Command, listDeploymentsR
 }
 
 func createOverride(createCmd *cobra.Command, createReq *apps.CreateAppRequest) {
+	createCmd.Short = `Create an app in your workspace.`
+	createCmd.Long = `Create an app in your workspace.`
+
 	originalRunE := createCmd.RunE
 	createCmd.RunE = func(cmd *cobra.Command, args []string) error {
 		err := originalRunE(cmd, args)

experimental/aitools/templates/appkit/databricks_template_schema.json

@@ -10,6 +10,7 @@
       "sql_warehouse_id": {
         "type": "string",
         "description": "SQL Warehouse ID",
+        "default": "",
         "order": 2
       },
       "profile": {

experimental/aitools/templates/appkit/template/{{.project_name}}/.env.tmpl

@@ -1,5 +1,5 @@
 {{if ne .profile ""}}DATABRICKS_CONFIG_PROFILE={{.profile}}{{else}}DATABRICKS_HOST={{workspace_host}}{{end}}
 DATABRICKS_WAREHOUSE_ID={{.sql_warehouse_id}}
 DATABRICKS_APP_PORT=8000
-DATABRICKS_APP_NAME=minimal
+DATABRICKS_APP_NAME={{.project_name}}
 FLASK_RUN_HOST=0.0.0.0

experimental/aitools/templates/appkit/template/{{.project_name}}/package.json

@@ -12,15 +12,16 @@
     "typecheck": "tsc -p ./tsconfig.server.json --noEmit && tsc -p ./tsconfig.client.json --noEmit",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "lint:ast-grep": "tsx scripts/lint-ast-grep.ts",
+    "lint:ast-grep": "appkit-lint",
     "format": "prettier --check .",
     "format:fix": "prettier --write .",
     "test": "vitest run && npm run test:smoke",
     "test:e2e": "playwright test",
     "test:e2e:ui": "playwright test --ui",
     "test:smoke": "playwright install chromium && playwright test tests/smoke.spec.ts",
     "clean": "rm -rf client/dist dist build node_modules .smoke-test test-results playwright-report",
-    "typegen": "tsx scripts/generate-types.ts"
+    "typegen": "appkit-generate-types",
+    "setup": "appkit-setup --write"
   },
   "keywords": [],
   "author": "",

experimental/dev/cmd/app/app.go

@@ -0,0 +1,24 @@
+package app
+
+import (
+	"github.com/spf13/cobra"
+)
+
+func New() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "app",
+		Short: "Manage Databricks applications",
+		Long: `Manage Databricks applications.
+
+Provides a streamlined interface for creating, managing, and monitoring
+full-stack Databricks applications built with TypeScript, React, and
+Tailwind CSS.`,
+	}
+
+	cmd.AddCommand(newInitCmd())
+	cmd.AddCommand(newImportCmd())
+	cmd.AddCommand(newDeployCmd())
+	cmd.AddCommand(newDevRemoteCmd())
+
+	return cmd
+}

experimental/dev/cmd/app/deploy.go

@@ -0,0 +1,228 @@
+package app
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"sync"
+
+	"github.com/databricks/cli/bundle"
+	"github.com/databricks/cli/bundle/resources"
+	"github.com/databricks/cli/bundle/run"
+	"github.com/databricks/cli/cmd/bundle/utils"
+	"github.com/databricks/cli/cmd/root"
+	"github.com/databricks/cli/libs/cmdio"
+	"github.com/databricks/cli/libs/log"
+	"github.com/spf13/cobra"
+)
+
+func newDeployCmd() *cobra.Command {
+	var (
+		force     bool
+		skipBuild bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "deploy",
+		Short: "Build, deploy the AppKit application and run it",
+		Long: `Build, deploy the AppKit application and run it.
+
+This command runs a deployment pipeline:
+1. Builds the frontend (npm run build)
+2. Deploys the bundle to the workspace
+3. Runs the app
+
+Examples:
+  # Deploy to default target
+  databricks experimental dev app deploy
+
+  # Deploy to a specific target
+  databricks experimental dev app deploy --target prod
+
+  # Skip frontend build (if already built)
+  databricks experimental dev app deploy --skip-build
+
+  # Force deploy (override git branch validation)
+  databricks experimental dev app deploy --force
+
+  # Set bundle variables
+  databricks experimental dev app deploy --var="warehouse_id=abc123"`,
+		Args: root.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runDeploy(cmd, force, skipBuild)
+		},
+	}
+
+	cmd.Flags().StringP("target", "t", "", "Deployment target (e.g., dev, prod)")
+	cmd.Flags().BoolVar(&force, "force", false, "Force-override Git branch validation")
+	cmd.Flags().BoolVar(&skipBuild, "skip-build", false, "Skip npm build step")
+	cmd.Flags().StringSlice("var", []string{}, `Set values for variables defined in bundle config. Example: --var="key=value"`)
+
+	return cmd
+}
+
+func runDeploy(cmd *cobra.Command, force, skipBuild bool) error {
+	ctx := cmd.Context()
+
+	// Check for bundle configuration
+	if _, err := os.Stat("databricks.yml"); os.IsNotExist(err) {
+		return errors.New("no databricks.yml found; run this command from a bundle directory")
+	}
+
+	// Step 1: Build frontend (unless skipped)
+	if !skipBuild {
+		if err := runNpmTypegen(ctx); err != nil {
+			return err
+		}
+		if err := runNpmBuild(ctx); err != nil {
+			return err
+		}
+	}
+
+	// Step 2: Deploy bundle
+	cmdio.LogString(ctx, "Deploying bundle...")
+	b, err := utils.ProcessBundle(cmd, utils.ProcessOptions{
+		InitFunc: func(b *bundle.Bundle) {
+			b.Config.Bundle.Force = force
+		},
+		AlwaysPull:   true,
+		FastValidate: true,
+		Build:        true,
+		Deploy:       true,
+	})
+	if err != nil {
+		return fmt.Errorf("deploy failed: %w", err)
+	}
+	log.Infof(ctx, "Deploy completed")
+
+	// Step 3: Detect and run app
+	appKey, err := detectApp(b)
+	if err != nil {
+		return err
+	}
+
+	log.Infof(ctx, "Running app: %s", appKey)
+	if err := runApp(ctx, b, appKey); err != nil {
+		cmdio.LogString(ctx, "✔ Deployment succeeded, but failed to start app")
+		return fmt.Errorf("failed to run app: %w", err)
+	}
+
+	cmdio.LogString(ctx, "✔ Deployment complete!")
+	return nil
+}
+
+// syncBuffer is a thread-safe buffer for capturing command output.
+type syncBuffer struct {
+	mu  sync.Mutex
+	buf bytes.Buffer
+}
+
+func (b *syncBuffer) Write(p []byte) (n int, err error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.buf.Write(p)
+}
+
+func (b *syncBuffer) String() string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.buf.String()
+}
+
+// runNpmTypegen runs npm run typegen in the current directory.
+func runNpmTypegen(ctx context.Context) error {
+	if _, err := exec.LookPath("npm"); err != nil {
+		return errors.New("npm not found: please install Node.js")
+	}
+
+	var output syncBuffer
+
+	err := RunWithSpinnerCtx(ctx, "Generating types...", func() error {
+		cmd := exec.CommandContext(ctx, "npm", "run", "typegen")
+		cmd.Stdout = &output
+		cmd.Stderr = &output
+		return cmd.Run()
+	})
+	if err != nil {
+		out := output.String()
+		if out != "" {
+			return fmt.Errorf("typegen failed:\n%s", out)
+		}
+		return fmt.Errorf("typegen failed: %w", err)
+	}
+	return nil
+}
+
+// runNpmBuild runs npm run build in the current directory.
+func runNpmBuild(ctx context.Context) error {
+	if _, err := exec.LookPath("npm"); err != nil {
+		return errors.New("npm not found: please install Node.js")
+	}
+
+	var output syncBuffer
+
+	err := RunWithSpinnerCtx(ctx, "Building frontend...", func() error {
+		cmd := exec.CommandContext(ctx, "npm", "run", "build")
+		cmd.Stdout = &output
+		cmd.Stderr = &output
+		return cmd.Run()
+	})
+	if err != nil {
+		out := output.String()
+		if out != "" {
+			return fmt.Errorf("build failed:\n%s", out)
+		}
+		return fmt.Errorf("build failed: %w", err)
+	}
+	return nil
+}
+
+// detectApp finds the single app in the bundle configuration.
+func detectApp(b *bundle.Bundle) (string, error) {
+	apps := b.Config.Resources.Apps
+
+	if len(apps) == 0 {
+		return "", errors.New("no apps found in bundle configuration")
+	}
+
+	if len(apps) > 1 {
+		return "", errors.New("multiple apps found in bundle, cannot auto-detect")
+	}
+
+	for key := range apps {
+		return key, nil
+	}
+
+	return "", errors.New("unexpected error detecting app")
+}
+
+// runApp runs the specified app using the runner interface.
+func runApp(ctx context.Context, b *bundle.Bundle, appKey string) error {
+	ref, err := resources.Lookup(b, appKey, run.IsRunnable)
+	if err != nil {
+		return fmt.Errorf("failed to lookup app: %w", err)
+	}
+
+	runner, err := run.ToRunner(b, ref)
+	if err != nil {
+		return fmt.Errorf("failed to create runner: %w", err)
+	}
+
+	output, err := runner.Run(ctx, &run.Options{})
+	if err != nil {
+		return fmt.Errorf("failed to run app: %w", err)
+	}
+
+	if output != nil {
+		resultString, err := output.String()
+		if err != nil {
+			return err
+		}
+		log.Infof(ctx, "App output: %s", resultString)
+	}
+
+	return nil
+}