feat(cli): add elide db studio command

.gitignore

@@ -4,6 +4,7 @@
 .dev/dependencies
 .dev/coverage
 .dev/artifacts
+.dev/db-studio
 */.dev/artifacts
 */.dev/coverage
 */.dev/dependencies

packages/builder/api/builder.api

@@ -2704,14 +2704,16 @@ public final class elide/tooling/runner/ProcessRunner {
 }
 
 public final class elide/tooling/runner/ProcessRunner$ProcessOptions : java/lang/Record {
-	public fun <init> (Lelide/tooling/runner/ProcessRunner$ProcessShell;)V
+	public fun <init> (Lelide/tooling/runner/ProcessRunner$ProcessShell;Ljava/nio/file/Path;)V
 	public final fun component1 ()Lelide/tooling/runner/ProcessRunner$ProcessShell;
-	public final fun copy (Lelide/tooling/runner/ProcessRunner$ProcessShell;)Lelide/tooling/runner/ProcessRunner$ProcessOptions;
-	public static synthetic fun copy$default (Lelide/tooling/runner/ProcessRunner$ProcessOptions;Lelide/tooling/runner/ProcessRunner$ProcessShell;ILjava/lang/Object;)Lelide/tooling/runner/ProcessRunner$ProcessOptions;
+	public final fun component2 ()Ljava/nio/file/Path;
+	public final fun copy (Lelide/tooling/runner/ProcessRunner$ProcessShell;Ljava/nio/file/Path;)Lelide/tooling/runner/ProcessRunner$ProcessOptions;
+	public static synthetic fun copy$default (Lelide/tooling/runner/ProcessRunner$ProcessOptions;Lelide/tooling/runner/ProcessRunner$ProcessShell;Ljava/nio/file/Path;ILjava/lang/Object;)Lelide/tooling/runner/ProcessRunner$ProcessOptions;
 	public fun equals (Ljava/lang/Object;)Z
 	public fun hashCode ()I
 	public final fun shell ()Lelide/tooling/runner/ProcessRunner$ProcessShell;
 	public fun toString ()Ljava/lang/String;
+	public final fun workingDirectory ()Ljava/nio/file/Path;
 }
 
 public abstract interface class elide/tooling/runner/ProcessRunner$ProcessShell {

packages/builder/src/main/kotlin/elide/tooling/runner/ProcessRunner.kt

@@ -42,6 +42,7 @@ public object ProcessRunner {
    */
   @JvmRecord public data class ProcessOptions(
     public val shell: ProcessShell,
+    public val workingDirectory: Path,
   )
 
   /**
@@ -128,6 +129,9 @@ public object ProcessRunner {
       }
     }
     val procBuilder = ProcessBuilder(resolvedArgs).apply {
+      // handle working directory
+      directory(task.options.workingDirectory.toFile())
+
       // handle task environment
       when (task.env) {
         // inject host environment
@@ -185,7 +189,10 @@ public object ProcessRunner {
     val mutEnv = env.toMutable()
     var executablePath: Path = exec
     var effectiveStreams: StdStreams = streams ?: StdStreams.Defaults
-    var effectiveOptions: ProcessOptions = options ?: ProcessOptions(ProcessShell.None)
+    var effectiveOptions: ProcessOptions = options ?: ProcessOptions(
+      shell = ProcessShell.None,
+      workingDirectory = Path.of(System.getProperty("user.dir")),
+    )
 
     return object : ProcessTaskBuilder {
       override var executable: Path = executablePath

packages/builder/src/test/kotlin/elide/tooling/runner/ProcessRunnerTest.kt

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2024-2025 Elide Technologies, Inc.
+ *
+ * Licensed under the MIT license (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   https://opensource.org/license/mit/
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under the License.
+ */
+package elide.tooling.runner
+
+import java.nio.file.Path
+import kotlin.test.*
+import elide.tooling.runner.ProcessRunner.ProcessOptions
+import elide.tooling.runner.ProcessRunner.ProcessShell
+
+class ProcessRunnerTest {
+  @Test fun `ProcessOptions should allow specifying a custom working directory`() {
+    val customDir = Path.of("/tmp")
+    val options = ProcessOptions(
+      shell = ProcessShell.None,
+      workingDirectory = customDir,
+    )
+
+    assertEquals(customDir, options.workingDirectory)
+  }
+
+  @Test fun `ProcessRunner build should accept a custom working directory`() {
+    val customDir = Path.of("/tmp")
+    val exec = Path.of("/bin/ls")
+
+    val builder = ProcessRunner.build(exec) {
+      options = ProcessOptions(
+        shell = ProcessShell.None,
+        workingDirectory = customDir,
+      )
+    }
+
+    assertEquals(customDir, builder.options.workingDirectory)
+    assertEquals(exec, builder.executable)
+  }
+
+  @Test fun `ProcessRunner build should allow changing the working directory after building`() {
+    val initialDir = Path.of("/tmp")
+    val newDir = Path.of("/var")
+    val exec = Path.of("/bin/echo")
+
+    val builder = ProcessRunner.build(exec) {
+      options = ProcessOptions(
+        shell = ProcessShell.None,
+        workingDirectory = initialDir,
+      )
+    }
+
+    assertEquals(initialDir, builder.options.workingDirectory)
+
+    // Change the working directory
+    builder.options = ProcessOptions(
+      shell = ProcessShell.None,
+      workingDirectory = newDir,
+    )
+
+    assertEquals(newDir, builder.options.workingDirectory)
+  }
+
+  @Test fun `ProcessRunner buildFrom should use current working directory by default`() {
+    val exec = Path.of("/bin/echo")
+    val args = elide.tooling.Arguments.empty()
+    val env = elide.tooling.Environment.empty()
+
+    val builder = ProcessRunner.buildFrom(exec, args, env)
+
+    assertNotNull(builder.options.workingDirectory)
+    assertEquals(Path.of(System.getProperty("user.dir")), builder.options.workingDirectory)
+  }
+
+  @Test fun `ProcessRunner buildFrom should accept custom working directory`() {
+    val exec = Path.of("/bin/echo")
+    val args = elide.tooling.Arguments.empty()
+    val env = elide.tooling.Environment.empty()
+    val customDir = Path.of("/tmp")
+    val customOptions = ProcessOptions(
+      shell = ProcessShell.None,
+      workingDirectory = customDir,
+    )
+
+    val builder = ProcessRunner.buildFrom(exec, args, env, options = customOptions)
+
+    assertEquals(customDir, builder.options.workingDirectory)
+  }
+}

packages/cli/build.gradle.kts

@@ -2414,7 +2414,7 @@ tasks {
   val allSamples = layout.projectDirectory.dir("src/projects")
     .asFile
     .listFiles()
-    .filter { it.isDirectory() }
+    .filter { it.isDirectory() && it.name != "db-studio" }
     .map { it.toPath() to it.name }
 
   val builtSamples = layout.buildDirectory.dir("packed-samples")
@@ -2436,10 +2436,30 @@ tasks {
     dependsOn(allSamplePackTasks)
   }
 
+  val prepareDbStudioResources by registering(Copy::class) {
+    group = "build"
+    description = "Prepare Database Studio resources for embedding in CLI"
+
+    from(layout.projectDirectory.dir("src/db-studio/api")) {
+      into("api")
+      exclude("config.ts")        // Generated at runtime with injected config
+      exclude(".dev/**")          // Exclude development-only dependencies directory
+      exclude("node_modules/**")  // Dependencies installed at runtime
+    }
+
+    // Copy built UI (dist/ folder only, not source or node_modules)
+    from(layout.projectDirectory.dir("src/db-studio/ui/dist")) {
+      into("ui")
+    }
+
+    into(layout.buildDirectory.dir("resources/main/META-INF/elide/db-studio"))
+  }
+
   processResources {
     dependsOn(
       ":packages:graalvm:buildRustNativesForHostDebug",
       prepKotlinResources,
+      prepareDbStudioResources,
       packSamples,
       allSamplePackTasks,
     )

packages/cli/src/db-studio/README.md

@@ -0,0 +1,44 @@
+# Database Studio
+
+Web-based database management UI that runs on the Elide runtime. At the moment it only supports SQLite with Elide's `elide:sqlite` js bindings. We assume that an existing valid database file exists for the `elide db studio` command to find. If you need a database file to run this on, [Northwind](https://github.com/jpwhite3/northwind-SQLite3) and [Chinook](https://github.com/lerocha/chinook-database/releases) are some good prepopulated examples.
+
+## Directory Structure
+
+```
+db-studio/
+├── api/              # TypeScript REST API server
+│   ├── ...
+│   ├── index.ts      # Server entrypoint
+│   └── elide.pkl
+└── ui/               # React frontend application
+    ├── src/
+    └── dist/         # Vite production build
+```
+
+## Running Locally
+
+### Using the Gradle Command
+
+The best way to run this locally is through the CLI in JVM mode. Simply passing `db studio` as args.
+
+**Note:** In order to see UI changes you've made, you'll need to run `pnpm build` in the `ui/` directory first.
+
+```bash
+# Build the UI
+cd packages/cli/src/db-studio/ui
+pnpm build
+
+# Go back to the elide repo root
+# Then run the db studio command
+./gradlew :packages:cli:run --args="db studio"
+
+# With a specific database
+./gradlew :packages:cli:run --args="db studio path/to/database.db"
+```
+
+### Running api or ui independently
+
+Database Studio consists of two separate projects that can be run independently:
+
+- `api`: run directly by calling `elide run index.ts` within the directory.
+- `ui`: using `pnpm dev` within the directory.

packages/cli/src/db-studio/api/.dev/dependencies/npm/package-lock.kdl

@@ -0,0 +1 @@
+/Users/francis/code/millpointlabs/elide/elide/packages/cli/src/db-studio/api/package-lock.kdl

packages/cli/src/db-studio/api/.dev/dependencies/npm/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "db-studio-api",
+    "version": "1.0.0",
+    "description": "Database Studio API Server",
+    "main": "index.ts",
+    "scripts": {},
+    "dependencies": {
+        "zod": "4"
+    },
+    "devDependencies": {
+        "@elide-dev/types": "1.0.0-beta10"
+    }
+}

packages/cli/src/db-studio/api/config.ts

@@ -0,0 +1,22 @@
+import type { DiscoveredDatabase } from "./database.ts";
+
+/**
+ * Database Studio Configuration
+ *
+ * This is a sample configuration file. In production, this would be
+ * generated by DbStudioCommand.kt based on discovered databases.
+ */
+
+const config = {
+  port: 4984,
+  databases: [
+    {
+      path: "./sample.db",
+      name: "sample.db",
+      size: 0,
+      lastModified: Date.now(),
+    }
+  ] as DiscoveredDatabase[],
+};
+
+export default config;