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/cli/build.gradle.kts

@@ -2407,7 +2407,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")
@@ -2429,10 +2429,29 @@ tasks {
     dependsOn(allSamplePackTasks)
   }
 
+  val prepareDbStudioResources by registering(Copy::class) {
+    group = "build"
+    description = "Prepare Database Studio resources for embedding in CLI"
+
+    // Copy API files
+    from(layout.projectDirectory.dir("src/db-studio/api")) {
+      into("api")
+      exclude("config.ts")  // Generated at runtime with injected config
+    }
+
+    // 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/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;

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

@@ -0,0 +1,176 @@
+/**
+ * Database API Layer
+ *
+ * Provides abstraction over database operations for the DB Studio.
+ * This layer isolates all database-specific logic, making it easy to:
+ * - Swap SQLite for other databases (PostgreSQL, MySQL, etc.)
+ * - Add caching, connection pooling, or other optimizations
+ * - Centralize error handling and validation
+ *
+ * NOTE: This module does NOT import "elide:sqlite" directly because Elide's
+ * module loader can only handle that special protocol in the entry point file.
+ * The Database class must be passed from index.ts.
+ */
+
+import type { Database, Statement } from "elide:sqlite";
+
+/**
+ * Log SQL queries to console
+ */
+function logQuery(sql: string, params?: unknown[]): void {
+  const timestamp = new Date().toISOString();
+  const paramsStr = params && params.length > 0 ? ` [${params.join(", ")}]` : "";
+  console.log(`[${timestamp}] SQL: ${sql}${paramsStr}`);
+}
+
+export interface DiscoveredDatabase {
+  path: string;
+  name: string;
+  size: number;
+  lastModified: number;
+}
+
+export interface TableInfo {
+  name: string;
+  rowCount: number;
+}
+
+export type TableData = {
+  name: string;
+  columns: string[];
+  rows: unknown[][];
+  totalRows: number;
+};
+
+export interface DatabaseInfo {
+  path: string;
+  name: string;
+  size: number;
+  lastModified: number;
+  tableCount: number;
+}
+
+interface TableNameRow {
+  name: string;
+}
+
+interface CountRow {
+  count: number;
+}
+
+/**
+ * Get list of tables in a database
+ */
+export function getTables(db: Database): TableInfo[] {
+  const sql = "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name";
+  logQuery(sql);
+  const query: Statement<TableNameRow> = db.query(sql);
+  const results = query.all();
+
+  return results.map(({ name }) => {
+    const tableName = name;
+    const countSql = `SELECT COUNT(*) as count FROM ${tableName}`;
+    logQuery(countSql);
+    const countQuery: Statement<CountRow> = db.query(countSql);
+    const countResult = countQuery.get();
+
+    return {
+      name: tableName,
+      rowCount: countResult?.count ?? 0,
+    };
+  });
+}
+
+
+interface ColumnNameRow {
+  name: string;
+}
+
+/**
+ * Get table data with schema and rows
+ */
+export function getTableData(db: Database, tableName: string, limit: number = 100, offset: number = 0): TableData {
+
+  // Get schema (column names)
+  const schemaSql = `SELECT name FROM pragma_table_info('${tableName}') ORDER BY cid`;
+  logQuery(schemaSql);
+  const schemaQuery: Statement<ColumnNameRow> = db.prepare(schemaSql);
+  const schemaResults = schemaQuery.all();
+  const columns = schemaResults.map((col) => col.name);
+
+  // Get data rows (unknown type since we don't know the schema)
+  const dataSql = `SELECT * FROM ${tableName} LIMIT ${limit} OFFSET ${offset}`;
+  logQuery(dataSql);
+  const dataQuery = db.query(dataSql);
+  const rows = dataQuery.all();
+
+  // Get total row count
+  const countSql = `SELECT COUNT(*) as count FROM ${tableName}`;
+  logQuery(countSql);
+  const countQuery: Statement<CountRow> = db.query(countSql);
+  const countResult = countQuery.get();
+  const totalRows = countResult?.count ?? 0;
+
+  return {
+    name: tableName,
+    columns,
+    rows: rows.map((row: unknown) => columns.map(col => (row as Record<string, unknown>)[col])),
+    totalRows,
+  };
+}
+
+/**
+ * Get database metadata
+ */
+export function getDatabaseInfo(db: Database, dbPath: string): DatabaseInfo {
+  const sql = "SELECT COUNT(*) as count FROM sqlite_master WHERE type='table'";
+  logQuery(sql);
+  const tablesQuery: Statement<CountRow> = db.query(sql);
+  const tablesResult = tablesQuery.get();
+
+  // Extract name from path
+  const pathParts = dbPath.split('/');
+  const name = pathParts[pathParts.length - 1];
+
+  return {
+    path: dbPath,
+    name,
+    size: 0, // Will be populated by calling code if available
+    lastModified: 0, // Will be populated by calling code if available
+    tableCount: tablesResult?.count ?? 0,
+  };
+}
+
+/**
+ * Execute a raw SQL query (for future query editor feature)
+ */
+export function executeQuery(db: Database, sql: string, limit: number = 100): { columns: string[], rows: unknown[][] } {
+  logQuery(sql);
+  const query = db.query(sql);
+  const results = query.all();
+
+  if (results.length === 0) {
+    return { columns: [], rows: [] };
+  }
+
+  const firstRow = results[0] as Record<string, unknown>;
+  const columns = Object.keys(firstRow);
+  const rows = results.map((row: unknown) => columns.map(col => (row as Record<string, unknown>)[col]));
+
+  return { columns, rows };
+}
+
+/**
+ * Validate that a database path is accessible
+ */
+export function validateDatabase(db: Database): boolean {
+  try {
+    // Try a simple query to verify the database is valid
+    const sql = "SELECT 1";
+    const query = db.query(sql);
+    query.get();
+    return true;
+  } catch (err) {
+    return false;
+  }
+}

packages/cli/src/db-studio/api/elide.pkl

@@ -0,0 +1,22 @@
+amends "elide:project.pkl"
+import "elide:JavaScript.pkl" as js
+
+name = "db-studio-api"
+version = "1.0.0"
+description = "Database Studio API Server"
+
+entrypoint {
+  "index.ts"
+}
+
+dependencies {
+  npm {
+    packages {
+      "zod@4"
+    }
+
+    devPackages {
+      "@elide-dev/[email protected]"
+    }
+  }
+}

packages/cli/src/db-studio/api/http/middleware.ts

@@ -0,0 +1,18 @@
+import type { ApiResponse, RouteContext, RouteHandler, DatabaseHandler } from "./types.ts";
+import { validateDatabaseIndex } from "../utils/validation.ts";
+
+/**
+ * Middleware that validates database index and provides database instance to handler
+ */
+export function withDatabase(handler: DatabaseHandler): RouteHandler {
+  return async (params: Record<string, string>, context: RouteContext, body: string): Promise<ApiResponse> => {
+    const result = validateDatabaseIndex(params.dbIndex, context.databases);
+    if ("error" in result) return result.error;
+
+    const { database } = result;
+    const db = new context.Database(database.path);
+
+    return handler(params, { ...context, database, db }, body);
+  };
+}
+

packages/cli/src/db-studio/api/http/responses.ts

@@ -0,0 +1,39 @@
+import type { ApiResponse } from "./types.ts";
+
+const SUCCESS_STATUS = 200;
+const ERROR_STATUS = 500;
+const NOT_FOUND_STATUS = 404;
+
+/**
+ * Create a JSON response
+ */
+export function jsonResponse(data: unknown, status: number = SUCCESS_STATUS): ApiResponse {
+  console.log("returning json response", data);
+  return {
+    status,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  };
+}
+
+/**
+ * Create an error response
+ */
+export function errorResponse(message: string, status: number = ERROR_STATUS): ApiResponse {
+  return jsonResponse({ error: message }, status);
+}
+
+/**
+ * Handle database operation errors
+ */
+export function handleDatabaseError(err: unknown, operation: string): ApiResponse {
+  const errorMessage = err instanceof Error ? err.message : "Unknown error";
+  return errorResponse(`Failed to ${operation}: ${errorMessage}`, ERROR_STATUS);
+}
+
+/**
+ * Creates a 404 Not Found response
+ */
+export function notFoundResponse(): ApiResponse {
+  return jsonResponse({ error: "Not Found" }, NOT_FOUND_STATUS);
+}