@metabase/rde 0.1.9 → 0.1.11

package/README.md

@@ -41,7 +41,7 @@ The wizard shows its checklist first (`✓` done, `○` to do, `–` not applica
 – Connect a git repository
 ○ Summary
 │
-●  Running npm install -g @metabase/cli@alpha-fix-transform-test-ee-path
+●  Running npm install -g @metabase/cli@alpha-release-65-integration-branch
 ```
 
 The steps up to the license run without a question, save one: `mb` is installed with the package manager that installed `rde`, the skill goes to the coding agents you pick from the ones found on the machine (at a terminal; without one, to every agent found), Metabase runs in Docker when Docker is there (the jar with your Java otherwise), on the first free port from 3100 up, with an admin user whose password is generated and kept in `~/.rde`, `mb` is logged in under its `default` profile (the one question here comes when `default` already points at another Metabase), and a Postgres sample database comes up in a second container, connected to Metabase as a place transforms can write. Each of those choices is printed as it is made and can be overridden with a flag. The prompts that remain are the license token (Enter skips it), a connection string for your own database (Enter skips it), and, with a license that includes remote sync, where the git repository lives and which remote it uses.
@@ -53,8 +53,8 @@ The git step reads `–` until a license with remote sync is active; it is check
 | Step | What it does |
 | --- | --- |
 | Check this machine | Platform, Node version, git, and a reachable Docker daemon or a Java 21+ runtime |
-| Install the Metabase CLI | `@metabase/cli` (`mb`) at the `alpha-fix-transform-test-ee-path` dist-tag, with the package manager that installed `rde` |
-| Install the rde and data-app skills | The data-app skills (`metabase-data-app-setup`, `-routing`, `-actions`, `-semantic-layer`) from `metabase/metabase/skills#master`, then the `rde` and `rde-data-apps` skills from the `rde-generic-skills` branch of `metabase/agent-skills` (the rde skill hands an explicit app request to `rde-data-apps`, which hands the build to the data-app skills), for the coding agents you pick at a terminal, from the ones found on this machine (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Windsurf). When none is found, the step is skipped and says how to add the skills once an agent is installed; `rde` installs no agent. Without a terminal, or with `--yes`, every agent found gets the skills; `--agents` picks a set ahead of time (the skills are installed for them whether or not they are on the machine yet), `--skip-agents` none; `RDE_SKILL_SOURCE` installs the two rde skills from another URL or a local checkout of `metabase/agent-skills` |
+| Install the Metabase CLI | `@metabase/cli` (`mb`) at the `alpha-release-65-integration-branch` dist-tag, with the package manager that installed `rde` |
+| Install the rde and data-app skills | The data-app skills (`metabase-data-app-setup`, `-routing`, `-actions`, `-semantic-layer`) from `metabase/metabase/skills#master`, then the `rde` and `rde-data-apps` skills from the `main` branch of `metabase/agent-skills` (the rde skill hands an explicit app request to `rde-data-apps`, which hands the build to the data-app skills), for the coding agents you pick at a terminal, from the ones found on this machine (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Windsurf). When none is found, the step is skipped and says how to add the skills once an agent is installed; `rde` installs no agent. Without a terminal, or with `--yes`, every agent found gets the skills; `--agents` picks a set ahead of time (the skills are installed for them whether or not they are on the machine yet), `--skip-agents` none; `RDE_SKILL_SOURCE` installs the two rde skills from another URL or a local checkout of `metabase/agent-skills` |
 | Install Metabase | **Docker** when it is available: pulls `metabase/metabase-enterprise-head:latest` (or `--image`) and creates the container. **Jar** otherwise, or with `--runtime jar`: downloads the latest enterprise release (or the tag or `.jar` path given as `--jar`) into `~/.rde/jars/` and runs it with your Java. Either way on port 3100, or the first free port above it, or `--port` |
 | Start Metabase | Starts the container or the jar and waits for `/api/health`, showing Metabase's own progress |
 | Create the admin user | `admin@metabase.local` with a generated password that `rde credentials` shows, or your own with `--admin prompted`, see [Credentials](#credentials) |
@@ -350,29 +350,3 @@ Start Docker (or `colima start`), or install Java, and run `rde init` again. `rd
 **The agent follows an old copy of the skill.** The `rde skill copies` row lists every copy of the skill the `skills` CLI knows, global and in the current directory's project, with where it came from, and fails when one did not come from rde's source (the branch is read from the `skills` lock file; against a local `RDE_SKILL_SOURCE` the copy's `SKILL.md` is compared with the checkout's `skills/rde/SKILL.md`). With several copies it says which one Claude Code started in that directory loads (a personal skill wins over a project one). `rde init --only agents-skills` reinstalls the global copy; restart the agent session afterwards.
 
 **The license token is rejected.** Activation ends with `Metabase reports the token as invalid` (or another status Metabase returned). Check the token, and check that the container can reach `token-check.metabase.com`: activation needs outbound network access. Run `rde init --from license` to try again; press Enter at the prompt to skip the license and carry on without remote sync.
-
-## Development
-
-```sh
-bun install
-bun run check                 # tsc, oxlint + boundary linter, oxfmt, unit tests
-bin/rde-dev init              # runs from source with RDE_HOME and the mb config under .dev-state/
-RDE_SKILL_SOURCE=~/agent-skills bin/rde-dev init --only agents-skills   # the rde skills from a local checkout
-```
-
-The end-to-end lane runs the built binary against real Docker: a seeded Postgres 16 sidecar on `127.0.0.1:15432` (`RDE_E2E_PG_PORT` to change it) and a fresh instance under `.e2e-state/`, with a fake `HOME` so the skill installer never touches your agents. `bun run build` must precede `bun run test:e2e`, and `python3` must be on `PATH`: the lane answers one `init` question through a pseudo-terminal it opens with Python's `pty` module. With `RDE_E2E_JAR` pointing at a Metabase jar (a local build) the lane also runs the jar runtime through init, doctor, stop, start, and uninstall with the host's Java; without it those tests are reported as skipped.
-
-```sh
-bun run build && bun run e2e:up && bun run test:e2e
-bun run e2e:down
-```
-
-With the database stack up, the lane also connects one container per engine Metabase supports and Docker can run (Postgres, MySQL, MariaDB, ClickHouse, SQL Server, Oracle, Trino, MongoDB), each in its URL and JDBC forms, without a terminal, and waits for its first sync. These cases live in `tests/e2e/databases.e2e.test.ts`, which sets up its own instance and has one `describe` block per service in `tests/e2e/databases.compose.yml`, so `-t` picks the engines to run. CI (`.github/workflows/test.yml`) runs the unit gate, the main lane, and one job per database service, in parallel, on every pull request.
-
-```sh
-bun run e2e:databases:up mysql mongo              # any of the services; Oracle and SQL Server are large
-bun run test:e2e:databases -t '^(mysql|mongo) '   # or no -t for every service
-bun run e2e:databases:down
-```
-
-With `MB_PREMIUM_EMBEDDING_TOKEN` in the environment the lane also activates the license and connects a local git remote; without it that test is reported as skipped.

package/dist/cli.mjs

@@ -2170,7 +2170,7 @@ function adminUserStep(options, deps = hostDeps$12) {
 //#endregion
 //#region src/tools/mb.ts
 const MB = "mb";
-const MB_INSTALL_SPEC = `@metabase/cli@alpha-fix-transform-test-ee-path`;
+const MB_INSTALL_SPEC = `@metabase/cli@alpha-release-65-integration-branch`;
 const GLOBAL_INSTALL = {
 	npm: {
 		command: "npm",
@@ -2826,12 +2826,18 @@ const MAPPERS = {
 			...leftoverOptions(parsed, ["db", "warehouse"])
 		});
 	},
-	sparksql: (parsed) => build(parsed.database, {
-		host: parsed.host ?? param(parsed, "Server"),
-		port: portNumber(parsed.port),
-		dbname: parsed.database,
-		...leftoverOptions(parsed, ["Server"], "jdbc-flags")
-	}),
+	sparksql: (parsed) => {
+		const user = paramIgnoringCase(parsed, ["user"]);
+		const password = paramIgnoringCase(parsed, ["password"]);
+		return build(parsed.database, {
+			host: parsed.host ?? param(parsed, "Server"),
+			port: portNumber(parsed.port),
+			dbname: parsed.database,
+			user: user?.value ?? null,
+			password: password?.value ?? null,
+			...leftoverOptions(parsed, ["Server", ...keysOf(user, password)], "jdbc-flags")
+		});
+	},
 	sqlite: (parsed) => build(null, { db: parsed.path }),
 	sqlserver: (parsed) => {
 		const database = parsed.database ?? param(parsed, "databaseName");
@@ -2878,9 +2884,12 @@ const MAPPERS = {
 		...leftoverOptions(parsed, ["user", "password"])
 	})
 };
+const DRUID_SCHEME = /url=(?<scheme>https?:\/\/)/i;
+const DRUID_DEFAULT_SCHEME = "http://";
 function mapDruid(parsed) {
+	const scheme = DRUID_SCHEME.exec(parsed.uri)?.groups?.["scheme"] ?? DRUID_DEFAULT_SCHEME;
 	return build(null, {
-		host: parsed.host,
+		host: parsed.host === null ? null : `${scheme}${parsed.host}`,
 		port: portNumber(parsed.port)
 	});
 }
@@ -5060,7 +5069,7 @@ function gitSyncStep(deps = hostDeps$10) {
 //#region src/tools/skills-cli.ts
 const NPX = "npx";
 const SKILLS_PACKAGE = "skills@latest";
-const DEFAULT_RDE_SKILL_SOURCE = "https://github.com/metabase/agent-skills/tree/rde-generic-skills";
+const DEFAULT_RDE_SKILL_SOURCE = "https://github.com/metabase/agent-skills/tree/main";
 const RDE_SOURCE_SKILL_NAMES = ["rde", "rde-data-apps"];
 const DATA_APP_SKILLS_SOURCE = "metabase/metabase/skills#master";
 const DATA_APP_SKILL_NAMES = [
@@ -5310,7 +5319,7 @@ function agentsSkillsStep(options, deps = hostDeps$9) {
 				agents,
 				output: ctx.ui.childOutput
 			});
-			const from = resolved.skillSource === "https://github.com/metabase/agent-skills/tree/rde-generic-skills" ? "" : ` from ${resolved.skillSource}`;
+			const from = resolved.skillSource === "https://github.com/metabase/agent-skills/tree/main" ? "" : ` from ${resolved.skillSource}`;
 			ctx.ui.info(`Installing the rde skills ${forWhom}${from}`);
 			await skills.add({
 				source: resolved.skillSource,
@@ -10194,7 +10203,7 @@ const upgradeCommand = defineRdeCommand({
 const main = defineCommand({
 	meta: {
 		name: "rde",
-		version: "0.1.9",
+		version: "0.1.11",
 		description: "Prepares a local machine for data-engineering work with Metabase and coding agents"
 	},
 	subCommands: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metabase/rde",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Prepares a local machine for data-engineering work with Metabase and coding agents",
   "license": "AGPL-3.0",
   "bin": {