@dbx-tools/projen 0.9.150 → 0.9.152

package/README.md

@@ -25,6 +25,9 @@ generated-file cleanup and watch tasks.
 
 Every `src`-bearing folder under the configured roots becomes a
 `DBXToolsTypeScriptProject`. Folder path drives package name and runtime tags.
+Use `packageDefaults` for native options shared by every discovered package,
+such as `{ publishable: false }`; reserve `resolvePackageOptions` for genuine
+per-package differences.
 
 Use `DBXToolsTypeScriptProject` itself as the root when one package needs the
 same Bun workspace, repository, task, and release defaults without a separate
@@ -310,8 +313,34 @@ parameter to `Project`). Drop to `mixin.create(predicate, fn)` +
 `project.with(...)` only when you need a predicate the filters cannot express.
 
 Built-in tag mixins set runtime defaults for `shared`, `node`, `cli`, `server`,
-and `ui`. Repo-specific mixins layer package-specific dependencies,
-scripts, and generated files on top.
+`ui`, and `app`. Repo-specific mixins layer package-specific dependencies,
+scripts, and generated files on top. `ui` is for reusable React component
+libraries. `app` owns a Bun-built browser application.
+
+AppKit mode defaults to `auto`: when the workspace has both `app` and `server`
+packages, the engine adds the AppKit, Vite, React plugin, and Tailwind
+dependencies to the package that uses each one. It also disables AppKit's
+package migration, includes the Vite and generated-type inputs in the browser
+tsconfig, adds `appkit:sync`, and ignores local Databricks state. Set
+`appkit: false` to disable this ownership. Set `appkit: true` to require AppKit
+and fail synthesis when either package role or its required entry files are
+missing. Keep application-specific UI and server dependencies in the consuming
+`.projenrc.ts`. A workspace with one `server` package also receives standard
+`check`, `dev`, and `start` tasks unless the repository defines them.
+
+The generated `deploy` task validates with the native Bun build, then delegates
+to `appkit:deploy` unless the repository already owns `deploy`. The AppKit task
+runs `databricks apps deploy --skip-validation` with all forwarded arguments
+from an isolated source snapshot, so the Databricks CLI never runs npm locally.
+Because the remote builder selects npm when no portable pnpm lockfile is
+uploaded, the snapshot replaces `catalog:` and `workspace:` dependency protocols
+with concrete versions and keeps every manifest stable through upload. The
+generated working tree is never modified. The task passes an explicit profile,
+using the supplied flag or resolving one through `@dbx-tools/auth`, and fails
+before staging when neither profile nor complete environment credentials are
+available. A repository-owned deployment flow can run its own Bun checks and
+spawn `appkit:deploy` for the upload step instead of maintaining staging or
+materialization code.
 
 Every workspace root exposes a generic development watcher:
 

package/index.ts

@@ -3,7 +3,8 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.9.150";
+export const PACKAGE_VERSION = "0.9.152";
+export * as appkitWorkspace from "./src/appkit-workspace.ts";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -36,7 +37,10 @@ export * as tsconfig from "./src/tsconfig.ts";
 export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
 export * as workspaceLock from "./src/workspace-lock.ts";
+export * as workspaceManifest from "./src/workspace-manifest.ts";
 export * as workspaceVersion from "./src/workspace-version.ts";
+export { AppKitWorkspace } from "./src/appkit-workspace.ts";
+export type { AppKitWorkspaceMode, AppKitWorkspaceOptions } from "./src/appkit-workspace.ts";
 export { BUN_DEV_OVERRIDE, BUN_BUILD_OVERRIDE, BUN_APP_OVERRIDES, RootBunfigFile, BunfigFile, BunDevServerFile, BunBuildFile } from "./src/bun-app.ts";
 export { BUN_VERSION, MINIMUM_BUN_VERSION, BUN_VERSION_CHECK_SCRIPT } from "./src/bun-workflow.ts";
 export { DBXToolsConfigDataSchema, DBXToolsConfig } from "./src/dbx-tools-config.ts";

package/package.json

@@ -30,10 +30,11 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/cli-args": "^0.9.150",
-    "@dbx-tools/core": "^0.9.150",
-    "@dbx-tools/path": "^0.9.150",
-    "@dbx-tools/shared-core": "^0.9.150",
+    "@dbx-tools/auth": "^0.9.152",
+    "@dbx-tools/cli-args": "^0.9.152",
+    "@dbx-tools/core": "^0.9.152",
+    "@dbx-tools/path": "^0.9.152",
+    "@dbx-tools/shared-core": "^0.9.152",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -55,7 +56,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.150",
+  "version": "0.9.152",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/appkit-workspace.ts

@@ -0,0 +1,146 @@
+/**
+ * AppKit workspace conventions for paired browser and server packages.
+ *
+ * @module
+ */
+import { existsSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { Component, type Task, javascript, typescript } from "projen";
+
+/** AppKit workspace discovery and validation mode. */
+export type AppKitWorkspaceMode = "auto" | boolean;
+
+/** Projects configured by the AppKit workspace owner. */
+export interface AppKitWorkspaceOptions {
+  /** Browser application packages carrying the `app` tag. */
+  readonly apps: readonly javascript.NodeProject[];
+  /** AppKit backend packages carrying the `server` tag. */
+  readonly servers: readonly javascript.NodeProject[];
+  /** Fail synthesis when an AppKit package or required entry file is missing. */
+  readonly validate?: boolean;
+}
+
+/**
+ * Own the dependencies and generated configuration shared by AppKit workspaces.
+ */
+export class AppKitWorkspace extends Component {
+  private readonly deployTask: Task;
+  private readonly serverEntrypoint?: string;
+
+  constructor(project: javascript.NodeProject, options: AppKitWorkspaceOptions) {
+    super(project);
+
+    if (options.validate) validateWorkspace(options);
+    project.gitignore.addPatterns(".databricks");
+    project.addTask("appkit:sync", {
+      description: "Synchronize installed AppKit plugin metadata",
+      exec: "appkit plugin sync --write --silent",
+    });
+    this.deployTask = project.addTask("appkit:deploy", {
+      description: "Deploy the AppKit workspace from an npm-compatible source snapshot",
+      execArgs: ["bun", "node_modules/@dbx-tools/projen/tasks/appkit-deploy.ts"],
+      receiveArgs: true,
+    });
+
+    for (const app of options.apps) configureApp(app);
+    for (const server of options.servers) configureServer(server);
+    if (options.servers.length === 1) {
+      const server = options.servers[0]!;
+      const entrypoint = serverEntrypoint(server);
+      this.serverEntrypoint = relative(project.outdir, join(server.outdir, entrypoint))
+        .split(sep)
+        .join("/");
+    }
+  }
+
+  public override preSynthesize(): void {
+    let check = this.project.tasks.tryFind("check");
+    if (!check) {
+      check = this.project.addTask("check", {
+        description: "Validate the generated workspace with Bun",
+      });
+      check.spawn(this.project.buildTask);
+    }
+    if (!this.project.tasks.tryFind("deploy")) {
+      const deploy = this.project.addTask("deploy", {
+        description: "Validate with Bun and deploy the AppKit workspace",
+      });
+      deploy.spawn(check);
+      deploy.spawn(this.deployTask);
+    }
+    if (!this.serverEntrypoint) return;
+    if (!this.project.tasks.tryFind("dev")) {
+      this.project.addTask("dev", {
+        description: "Run the AppKit server in development mode",
+        env: { NODE_ENV: "development" },
+        exec: `bun --watch ${this.serverEntrypoint}`,
+        receiveArgs: true,
+      });
+    }
+    if (!this.project.tasks.tryFind("start")) {
+      this.project.addTask("start", {
+        description: "Run the AppKit server in production mode",
+        env: { NODE_ENV: "production" },
+        exec: `bun ${this.serverEntrypoint}`,
+        receiveArgs: true,
+      });
+    }
+  }
+}
+
+/** Validate the explicit AppKit convention before generating dependent config. */
+function validateWorkspace(options: AppKitWorkspaceOptions): void {
+  const missing: string[] = [];
+  if (options.apps.length === 0) missing.push("an `app` package");
+  if (options.servers.length === 0) missing.push("a `server` package");
+  for (const app of options.apps) {
+    for (const file of ["index.html", "vite.config.ts"]) {
+      if (!existsSync(join(app.outdir, file))) missing.push(`${app.name}/${file}`);
+    }
+  }
+  for (const server of options.servers) {
+    const entrypoint = serverEntrypoint(server);
+    if (!existsSync(join(server.outdir, entrypoint))) {
+      missing.push(`${server.name}/${entrypoint}`);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(`appkit: true requires ${missing.join(", ")}`);
+  }
+}
+
+/** Configure one AppKit browser application without broadening React libraries. */
+function configureApp(project: javascript.NodeProject): void {
+  project.package.addField("appkit", { autoMigrate: false });
+  project.addDeps(
+    "@databricks/appkit-ui@catalog:",
+    "@tailwindcss/vite@catalog:",
+    "tailwindcss@catalog:",
+  );
+  project.addDevDeps("vite@catalog:");
+
+  if (!(project instanceof typescript.TypeScriptProject)) return;
+  project.tsconfig?.file.addOverride("compilerOptions.rootDir", ".");
+  project.tsconfig?.addInclude("vite.config.ts");
+  project.tsconfig?.addInclude("shared/appkit-types");
+}
+
+/** Configure one AppKit server with the runtime dependency its Vite loader imports. */
+function configureServer(project: javascript.NodeProject): void {
+  const entrypoint = serverEntrypoint(project);
+  if (entrypoint !== project.package.manifest.main) {
+    project.package.addField("main", entrypoint);
+    project.package.addField("types", entrypoint);
+  }
+  project.addDeps("@databricks/appkit@catalog:", "@vitejs/plugin-react@catalog:");
+}
+
+/** Prefer the canonical AppKit server entry when a package still has its default barrel. */
+function serverEntrypoint(project: javascript.NodeProject): string {
+  const configured =
+    typeof project.package.manifest.main === "string" ? project.package.manifest.main : "index.ts";
+  const canonical = "src/server.ts";
+  return configured === "index.ts" && existsSync(join(project.outdir, canonical))
+    ? canonical
+    : configured;
+}

package/src/dbx-tools-config.ts

@@ -73,6 +73,7 @@ export class DBXToolsConfig {
     this.tags = [...(options.tags ?? [])];
     this.codegenInputs = [...(options.codegenInputs ?? [])];
     this.publishable = options.publishable ?? true;
+    project.package.addField("private", () => (this.publishable ? undefined : true));
     project.package.addField(CONFIG_KEY, () => {
       const data = this.data();
       return Object.keys(data).length === 0 ? undefined : data;

package/src/pnpm-workspace.ts

@@ -62,6 +62,10 @@ const DEFAULT_CATALOG: Catalog = {
   "react-dom": "~19.2.4",
   "@types/react": "^19.2.2",
   "@types/react-dom": "^19.2.2",
+  tailwindcss: "^4.3.2",
+  "@tailwindcss/vite": "^4.3.2",
+  vite: "^7.2.4",
+  "@vitejs/plugin-react": "^5.1.1",
   // Tailwind v4 compiler for bun's dev server + `Bun.build` (the `app` tag).
   "bun-plugin-tailwind": "^0.1.2",
   "@types/node": "^24.6.0",

package/src/project-js.ts

@@ -15,6 +15,7 @@ import { type IConstruct } from "constructs";
 import { Component, LogLevel, Project, type Task, TextFile, javascript, typescript } from "projen";
 import { JobPermission, type JobStep } from "projen/lib/github/workflows-model";
 import type { ReleaseProjectOptions } from "projen/lib/release";
+import { AppKitWorkspace, type AppKitWorkspaceMode } from "./appkit-workspace.ts";
 import { generateBarrels, isGeneratedBarrel } from "./barrels.ts";
 
 import { BUN_APP_OVERRIDES, RootBunfigFile } from "./bun-app.ts";
@@ -603,6 +604,8 @@ export type DBXToolsJavaScriptProjectOptions = CommonProjectOptions &
      * disable. Defaults to `"node"`.
      */
     readonly omitRelativePrefix?: OneOrMany<string>;
+    /** Native defaults merged into every filesystem-discovered package. */
+    readonly packageDefaults?: Omit<DiscoveredTypeScriptPackageOptions, "name">;
     /** Resolve native constructor fields before a discovered package is constructed. */
     readonly resolvePackageOptions?: (
       pkg: DiscoveredPackage,
@@ -620,6 +623,11 @@ export type DBXToolsJavaScriptProjectOptions = CommonProjectOptions &
      * a list = only those tags.
      */
     readonly defaultTagMixins?: false | PackageTag[];
+    /**
+     * Apply AppKit conventions to `app` and `server` packages. Defaults to
+     * `auto`; `true` also validates the required package roles and entry files.
+     */
+    readonly appkit?: AppKitWorkspaceMode;
     /**
      * Extra repo-root paths that trigger a full re-synth during `sync --watch`
      * (alongside `.projenrc.ts`). Repo-relative, e.g. `".example.projenrc.ts"`.
@@ -679,7 +687,7 @@ export class DBXToolsNodeProject
   readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;
-  pnpmWorkspace?: PnpmWorkspaceState;
+  pnpmWorkspace: PnpmWorkspaceState;
   rootTsconfig?: DBXToolsRootTsconfig;
   readonly extraWorkspaceMembers: readonly string[];
   readonly releaseBranch: string;
@@ -1007,7 +1015,10 @@ class WorkspaceValidationTasks extends Component {
       return;
     }
     project.compileTask.execArgs(taskCommand("compile-workspace.ts"));
-    project.testTask.spawn(project.tasks.tryFind("test:all")!);
+    const testAll = project.tasks.tryFind("test:all")!;
+    const pythonTests = project.tasks.tryFind("py:test");
+    if (pythonTests) testAll.spawn(pythonTests);
+    project.testTask.spawn(testAll);
   }
 }
 
@@ -1281,7 +1292,14 @@ function initProject(
   // What the dot group was actually earning here, named explicitly: secrets and
   // local editor state. Both ignore CONTENTS (`.idea/*`) rather than the
   // directory, so a later `!` negation can still reach a file inside.
-  project.gitignore.addPatterns(".env", ".env.*", "!.env.example", "!.env.sample", ".idea/*");
+  project.gitignore.addPatterns(
+    ".env",
+    ".env.*",
+    "!.env.example",
+    "!.env.sample",
+    ".idea/*",
+    ".npmrc",
+  );
   for (const root of roots) {
     project.annotateGenerated(`/${root}/**/index.ts`);
     project.annotateGenerated(`/${root}/**/src/generated/**`);
@@ -1396,9 +1414,11 @@ function initProject(
       continue;
     }
     const defaultPackageName = packageNameFor(project.scope, p.relPath, omitPrefixes);
-    const packageOptions =
-      options.resolvePackageOptions?.(p, { name: defaultPackageName }) ??
-      ({ name: defaultPackageName } satisfies DiscoveredTypeScriptPackageOptions);
+    const defaults = {
+      name: defaultPackageName,
+      ...options.packageDefaults,
+    } satisfies DiscoveredTypeScriptPackageOptions;
+    const packageOptions = options.resolvePackageOptions?.(p, defaults) ?? defaults;
     new DBXToolsTypeScriptProject({
       parent: project,
       outdir: p.memberPath,
@@ -1417,6 +1437,25 @@ function initProject(
   if (enabledTagMixins.length) {
     project.with(...enabledTagMixins.map((t) => PACKAGE_TAG_MIXINS[t]));
   }
+  const appkitMode = options.appkit ?? "auto";
+  if (appkitMode !== false) {
+    const projects = [project, ...project.subprojects].filter(
+      (candidate): candidate is DBXToolsNodeProject | DBXToolsTypeScriptProject =>
+        candidate instanceof DBXToolsNodeProject || candidate instanceof DBXToolsTypeScriptProject,
+    );
+    const apps = projects.filter((candidate) => candidate.dbxToolsConfig.tags.includes("app"));
+    const servers = projects.filter((candidate) =>
+      candidate.dbxToolsConfig.tags.includes("server"),
+    );
+    const enabled = appkitMode === true || (apps.length > 0 && servers.length > 0);
+    if (enabled) {
+      new AppKitWorkspace(project, {
+        apps,
+        servers,
+        validate: appkitMode === true,
+      });
+    }
+  }
 
   new WorkspaceValidationTasks(project);
   new PrettierIgnoreGenerated(project);

package/src/tsconfig.ts

@@ -56,8 +56,9 @@ export class DBXToolsRootTsconfig extends Component {
       compilerOptions: {
         lib: ["ESNext"],
         types: ["node", "bun"],
+        jsx: javascript.TypeScriptJsxMode.REACT_JSX,
       },
-      include: [".projenrc.ts"],
+      include: [".projenrc.ts", "test/**/*.ts", "test/**/*.tsx"],
       exclude: ["node_modules", "**/dist", "**/node_modules"],
     });
   }

package/src/workspace-manifest.ts

@@ -0,0 +1,173 @@
+/**
+ * Workspace dependency protocol materialization for external npm consumers.
+ *
+ * @module
+ */
+import {
+  chmodSync,
+  copyFileSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import * as exec from "@dbx-tools/core/exec";
+
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies",
+] as const;
+
+interface StoredManifest {
+  readonly path: string;
+  readonly mode: number;
+  readonly text: string;
+}
+
+/** Replace workspace and catalogue protocols with concrete registry ranges. */
+export function materializeWorkspaceManifest(
+  source: Readonly<Record<string, unknown>>,
+  workspace: Readonly<Record<string, unknown>>,
+): Readonly<Record<string, unknown>> {
+  const manifest = structuredClone(source) as Record<string, unknown>;
+  const version = workspace.version;
+  const catalog =
+    workspace.catalog && typeof workspace.catalog === "object"
+      ? (workspace.catalog as Readonly<Record<string, unknown>>)
+      : {};
+  if (typeof version !== "string" || !version) {
+    throw new Error("Workspace manifest has no version");
+  }
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencies = manifest[field];
+    if (!dependencies || typeof dependencies !== "object") continue;
+    manifest[field] = Object.fromEntries(
+      Object.entries(dependencies).map(([name, value]) => [
+        name,
+        materializeDependency(name, value, version, catalog),
+      ]),
+    );
+  }
+  return manifest;
+}
+
+/**
+ * Materialize every generated workspace manifest for one external command and
+ * restore exact bytes and permissions afterward.
+ */
+export async function withMaterializedWorkspaceManifests<T>(
+  root: string,
+  callback: () => Promise<T>,
+): Promise<T> {
+  const rootManifestPath = resolve(root, "package.json");
+  const rootManifest = readManifest(rootManifestPath);
+  const workspaces = Array.isArray(rootManifest.workspaces)
+    ? rootManifest.workspaces.filter((value): value is string => typeof value === "string")
+    : [];
+  const originals = [
+    rootManifestPath,
+    ...workspaces.map((workspace) => resolve(root, workspace, "package.json")),
+  ].map(storeManifest);
+
+  try {
+    for (const original of originals) {
+      const source = JSON.parse(original.text) as Record<string, unknown>;
+      writeManifest(original.path, materializeWorkspaceManifest(source, rootManifest));
+    }
+    return await callback();
+  } finally {
+    for (const original of originals) restoreManifest(original);
+  }
+}
+
+/**
+ * Copy tracked and non-ignored source into a temporary directory, materialize
+ * its manifests, and keep that snapshot stable for one external command.
+ */
+export async function withStagedWorkspaceManifests<T>(
+  root: string,
+  callback: (stage: string) => Promise<T>,
+): Promise<T> {
+  const stage = mkdtempSync(join(tmpdir(), "dbx-tools-app-deploy-"));
+  try {
+    const listed = exec.spawnSync(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
+      {
+        cwd: root,
+        stdin: "ignore",
+        stdout: "capture",
+        stderr: "capture",
+      },
+    );
+    if (listed.exitCode !== 0) {
+      throw new Error(`Could not enumerate app source: ${listed.stderr}`);
+    }
+    for (const relativePath of listed.stdout.split("\0").filter(Boolean)) {
+      const source = resolve(root, relativePath);
+      if (!existsSync(source)) continue;
+      const destination = resolve(stage, relativePath);
+      mkdirSync(dirname(destination), { recursive: true });
+      copyFileSync(source, destination);
+      chmodSync(destination, statSync(source).mode & 0o777);
+    }
+    const bundleState = resolve(root, ".databricks");
+    if (existsSync(bundleState)) {
+      cpSync(bundleState, resolve(stage, ".databricks"), { recursive: true });
+    }
+    return await withMaterializedWorkspaceManifests(stage, () => callback(stage));
+  } finally {
+    rmSync(stage, { recursive: true, force: true });
+  }
+}
+
+function materializeDependency(
+  name: string,
+  value: unknown,
+  version: string,
+  catalog: Readonly<Record<string, unknown>>,
+): unknown {
+  if (value === "catalog:") {
+    const resolved = catalog[name];
+    if (typeof resolved !== "string" || !resolved) {
+      throw new Error(`Workspace catalog has no version for ${name}`);
+    }
+    return resolved;
+  }
+  if (typeof value !== "string" || !value.startsWith("workspace:")) return value;
+  const selector = value.slice("workspace:".length);
+  if (selector === "*" || !selector) return version;
+  if (selector === "^" || selector === "~") return `${selector}${version}`;
+  return selector;
+}
+
+function readManifest(path: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+}
+
+function storeManifest(path: string): StoredManifest {
+  return {
+    path,
+    mode: statSync(path).mode & 0o777,
+    text: readFileSync(path, "utf8"),
+  };
+}
+
+function writeManifest(path: string, manifest: Readonly<Record<string, unknown>>): void {
+  chmodSync(path, 0o644);
+  writeFileSync(path, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+
+function restoreManifest(manifest: StoredManifest): void {
+  chmodSync(manifest.path, 0o644);
+  writeFileSync(manifest.path, manifest.text);
+  chmodSync(manifest.path, manifest.mode);
+}

package/tasks/appkit-deploy.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env -S bun
+/** Deploy an AppKit workspace through npm-compatible temporary manifests. */
+import { profile } from "@dbx-tools/auth";
+import * as exec from "@dbx-tools/core/exec";
+import { runTaskMain } from "./cli.ts";
+import { withStagedWorkspaceManifests } from "../src/workspace-manifest.ts";
+
+/** Effects accepted by the AppKit deploy task for focused tests. */
+export interface AppKitDeployDependencies {
+  readonly environment?: NodeJS.ProcessEnv;
+  readonly root?: string;
+  readonly resolveProfile?: () => string | undefined;
+  readonly run?: (args: readonly string[], cwd: string) => Promise<{ readonly exitCode: number }>;
+}
+
+/** Run Databricks Apps deploy while generated workspace manifests are materialized. */
+export async function deployApp(
+  args: readonly string[],
+  dependencies: AppKitDeployDependencies = {},
+): Promise<void> {
+  const root = dependencies.root ?? process.cwd();
+  const deployArgs = resolveDeployArgs(args, dependencies);
+  const run =
+    dependencies.run ??
+    ((deployArgs: readonly string[], cwd: string) =>
+      exec.spawn("databricks", ["apps", "deploy", ...deployArgs], {
+        cwd,
+        env: dependencies.environment ?? process.env,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+      }));
+  await withStagedWorkspaceManifests(root, async (stage) => {
+    const result = await run(deployArgs, stage);
+    if (result.exitCode !== 0) {
+      throw new Error(`databricks apps deploy exited with code ${result.exitCode}`);
+    }
+  });
+}
+
+function resolveDeployArgs(
+  args: readonly string[],
+  dependencies: AppKitDeployDependencies,
+): readonly string[] {
+  const environment = dependencies.environment ?? process.env;
+  const hasProfile = args.some(
+    (argument) =>
+      argument === "--profile" || argument === "-p" || argument.startsWith("--profile="),
+  );
+  const hasEnvironmentAuth =
+    Boolean(environment.DATABRICKS_HOST) &&
+    (Boolean(environment.DATABRICKS_TOKEN) ||
+      (Boolean(environment.DATABRICKS_CLIENT_ID) && Boolean(environment.DATABRICKS_CLIENT_SECRET)));
+  const resolvedProfile =
+    hasProfile || hasEnvironmentAuth
+      ? undefined
+      : (dependencies.resolveProfile ?? (() => profile.resolveProfile()?.name))();
+  if (!hasProfile && !hasEnvironmentAuth && !resolvedProfile) {
+    throw new Error(
+      "Select a Databricks profile with --profile or configure Databricks environment credentials",
+    );
+  }
+  return [
+    ...(args.includes("--skip-validation") ? [] : ["--skip-validation"]),
+    ...args,
+    ...(resolvedProfile ? ["--profile", resolvedProfile] : []),
+  ];
+}
+
+await runTaskMain(import.meta, () => deployApp(process.argv.slice(2)));

package/tasks/compile-workspace.ts

@@ -50,7 +50,8 @@ function hasLifecycle(task: TaskSpec | undefined): boolean {
 /** Read the root's concrete workspace paths on every run, including newly added members. */
 export function compilePlan(root: string): CompilePlan {
   const workspace = readJson<PackageManifest>(join(root, "package.json"));
-  const typescriptConfigs: string[] = [];
+  const rootConfig = join(root, "tsconfig.json");
+  const typescriptConfigs: string[] = existsSync(rootConfig) ? [rootConfig] : [];
   const customPackages: CompilePlan["customPackages"] = [];
   for (const member of workspace.workspaces ?? []) {
     const directory = resolve(root, member);

package/tasks/publish-npm.ts

@@ -20,6 +20,9 @@ import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
 import { TaskConcurrencyOptionSchema, TaskDryRunOptionSchema } from "./options.ts";
 import { runTaskCommandAsync } from "../src/_task-command.ts";
+import { materializeWorkspaceManifest } from "../src/workspace-manifest.ts";
+
+export { materializeWorkspaceManifest } from "../src/workspace-manifest.ts";
 
 const DEFAULT_REGISTRY = "https://registry.npmjs.org";
 const DEFAULT_PUBLISH_CONCURRENCY = 4;
@@ -52,60 +55,6 @@ export type NpmArchiveManifestTransform = (
 
 /** Entry-point fields projected from publishConfig into a packed manifest. */
 const PUBLISH_CONFIG_ENTRY_FIELDS = ["main", "types", "bin", "exports"] as const;
-const DEPENDENCY_FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "peerDependencies",
-] as const;
-
-/** Replace workspace and catalogue protocols with publishable registry ranges. */
-export function materializeWorkspaceManifest(
-  source: Readonly<Record<string, unknown>>,
-  workspace: Readonly<Record<string, unknown>>,
-): Readonly<Record<string, unknown>> {
-  const manifest = structuredClone(source) as Record<string, unknown>;
-  const version = workspace.version;
-  const catalog =
-    workspace.catalog && typeof workspace.catalog === "object"
-      ? (workspace.catalog as Readonly<Record<string, unknown>>)
-      : {};
-  if (typeof version !== "string" || !version) {
-    throw new Error("Workspace manifest has no version");
-  }
-  for (const field of DEPENDENCY_FIELDS) {
-    const dependencies = manifest[field];
-    if (!dependencies || typeof dependencies !== "object") continue;
-    manifest[field] = Object.fromEntries(
-      Object.entries(dependencies).map(([name, value]) => [
-        name,
-        materializeDependency(name, value, version, catalog),
-      ]),
-    );
-  }
-  return manifest;
-}
-
-function materializeDependency(
-  name: string,
-  value: unknown,
-  version: string,
-  catalog: Readonly<Record<string, unknown>>,
-): unknown {
-  if (value === "catalog:") {
-    const resolved = catalog[name];
-    if (typeof resolved !== "string" || !resolved) {
-      throw new Error(`Workspace catalog has no version for ${name}`);
-    }
-    return resolved;
-  }
-  if (typeof value !== "string" || !value.startsWith("workspace:")) return value;
-  const selector = value.slice("workspace:".length);
-  if (selector === "*" || !selector) return version;
-  if (selector === "^" || selector === "~") return `${selector}${version}`;
-  return selector;
-}
-
 /**
  * Fold compiled publish entry points onto an archive manifest without changing
  * the source checkout.

package/tasks/test-workspace.ts

@@ -167,6 +167,8 @@ function selectedTests(
 ): string[] {
   const all = [
     ...graph.packages.flatMap((pkg) => testFiles(join(root, pkg.path, "test"))),
+    ...testFiles(join(root, "test")),
+    ...testFiles(join(root, "scripts")),
     ...testFiles(join(root, "docs/scripts")),
   ];
   if (mode === "unit") return all.filter((path) => !integrationTest(path));