@dbstudio/cli 0.1.7

package/src/commands/connect.ts

@@ -0,0 +1,418 @@
+import fs from "node:fs";
+import type { DatabaseConfig, DatabaseType } from "@dbstudio/types";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import prompts from "prompts";
+import { Agent } from "../agents/index";
+
+export const connectCommand = new Command("connect")
+	.description("Connect to a database and bridge to DBStudio cloud")
+	.requiredOption("-t, --token <token>", "DBStudio connection token")
+	.option("--type <type>", "Database type: postgresql, mysql, sqlite, libsql")
+	.option("-h, --host <host>", "Database host", "localhost")
+	.option("-p, --port <port>", "Database port")
+	.option("-d, --database <database>", "Database name")
+	.option("-u, --user <user>", "Database username")
+	.option("--password <password>", "Database password")
+	.option("-a, --auth-token <token>", "Turso/libSQL auth token")
+	.option("-f, --file <filepath>", "SQLite database file path")
+	.option(
+		"--url <url>",
+		"Database connection URL (replaces host/port/db/user/pass)",
+	)
+	.option("--ssh-host <host>", "SSH tunnel host")
+	.option("--ssh-port <port>", "SSH tunnel port", "22")
+	.option("--ssh-user <user>", "SSH tunnel username")
+	.option("--ssh-password <password>", "SSH tunnel password")
+	.option("--ssh-key <path>", "SSH tunnel private key path")
+	.option("--ssh-passphrase <passphrase>", "SSH tunnel private key passphrase")
+	.option("--ssl", "Enable SSL connection", false)
+	.option("--workspace <id>", "Legacy workspace ID (deprecated)", "")
+	.option(
+		"--server <url>",
+		"DBStudio server URL",
+		process.env.DBSTUDIO_SERVER_URL || "wss://api.dbstudio.tech/ws/agent",
+	)
+	.action(async (options) => {
+		let config: DatabaseConfig = {
+			type: options.type as DatabaseType,
+			url: options.url,
+			host: options.host,
+			port: options.port ? Number.parseInt(options.port, 10) : undefined,
+			database: options.database,
+			username: options.user,
+			password: options.password,
+			filepath: options.file,
+			ssl: options.ssl,
+			authToken: options.authToken,
+		};
+
+		// --- Smart URL Detection ---
+		// If --database contains a URL-like string, move it to config.url
+		if (options.database?.includes("://") && !config.url) {
+			config.url = options.database;
+			config.database = undefined;
+		}
+
+		if (options.sshHost) {
+			config.ssh = {
+				host: options.sshHost,
+				port: options.sshPort ? Number.parseInt(options.sshPort, 10) : 22,
+				username: options.sshUser,
+				password: options.sshPassword,
+				privateKey: options.sshKey
+					? fs.readFileSync(options.sshKey, "utf8")
+					: undefined,
+				passphrase: options.sshPassphrase,
+			};
+		}
+
+		const spinner = ora("Initializing connection...");
+		if (
+			!config.type &&
+			!config.database &&
+			!config.filepath &&
+			!config.url &&
+			!config.authToken
+		) {
+			console.log(chalk.cyan("Welcome to DBStudio CLI Setup!"));
+			console.log(chalk.gray("Let's connect your database.\n"));
+
+			const response = await prompts(
+				[
+					{
+						type: "select",
+						name: "type",
+						message: "Database Type",
+						choices: [
+							{ title: "PostgreSQL", value: "postgresql" },
+							{ title: "MySQL", value: "mysql" },
+							{ title: "SQLite", value: "sqlite" },
+							{ title: "Turso (libSQL)", value: "libsql" },
+						],
+					},
+					{
+						type: (prev) => {
+							if (prev === "sqlite") return "text";
+							if (prev === "libsql") return null;
+							return "select";
+						},
+						name: "methodOrPath",
+						message: (_prev, values) =>
+							values.type === "sqlite"
+								? "Database File Path"
+								: "Connection Method",
+						choices: (_prev, values) =>
+							values.type === "sqlite"
+								? []
+								: [
+										{ title: "Host / Port / Database", value: "params" },
+										{ title: "Connection URL", value: "url" },
+									],
+						initial: (_prev, values) =>
+							values.type === "sqlite" ? "./local.db" : 0,
+					},
+					{
+						type: (_prev, values) =>
+							values.type === "libsql" || values.methodOrPath === "url"
+								? "text"
+								: null,
+						name: "url",
+						message: (_prev, values) =>
+							values.type === "libsql" ? "libSQL/Turso URL" : "Connection URL",
+						initial: (_prev, values) =>
+							values.type === "libsql"
+								? "libsql://[your-db].turso.io"
+								: values.type === "postgresql"
+									? "postgresql://user:pass@localhost:5432/db"
+									: "mysql://user:pass@localhost:3306/db",
+					},
+					{
+						type: (_prev, values) => (values.type === "libsql" ? "text" : null),
+						name: "authToken",
+						message: "Auth Token (optional for local libsql)",
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" &&
+							values.type !== "libsql" &&
+							values.methodOrPath === "params"
+								? "text"
+								: null,
+						name: "host",
+						message: "Host",
+						initial: "localhost",
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" &&
+							values.type !== "libsql" &&
+							values.methodOrPath === "params"
+								? "number"
+								: null,
+						name: "port",
+						message: "Port",
+						initial: (_prev, values) =>
+							values.type === "postgresql" ? 5432 : 3306,
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" &&
+							values.type !== "libsql" &&
+							values.methodOrPath === "params"
+								? "text"
+								: null,
+						name: "database",
+						message: "Database Name",
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" &&
+							values.type !== "libsql" &&
+							values.methodOrPath === "params"
+								? "text"
+								: null,
+						name: "username",
+						message: "Username",
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" &&
+							values.type !== "libsql" &&
+							values.methodOrPath === "params"
+								? "password"
+								: null,
+						name: "password",
+						message: "Password",
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" && values.type !== "libsql"
+								? "confirm"
+								: null,
+						name: "useSsh",
+						message: "Use SSH Tunnel?",
+						initial: false,
+					},
+					{
+						type: (_prev, values) => (values.useSsh ? "text" : null),
+						name: "sshHost",
+						message: "SSH Host",
+					},
+					{
+						type: (_prev, values) => (values.useSsh ? "number" : null),
+						name: "sshPort",
+						message: "SSH Port",
+						initial: 22,
+					},
+					{
+						type: (_prev, values) => (values.useSsh ? "text" : null),
+						name: "sshUser",
+						message: "SSH Username",
+					},
+					{
+						type: (_prev, values) => (values.useSsh ? "select" : null),
+						name: "sshAuthType",
+						message: "SSH Auth Type",
+						choices: [
+							{ title: "Password", value: "password" },
+							{ title: "Private Key", value: "key" },
+						],
+					},
+					{
+						type: (_prev, values) =>
+							values.sshAuthType === "password" ? "password" : null,
+						name: "sshPassword",
+						message: "SSH Password",
+					},
+					{
+						type: (_prev, values) =>
+							values.sshAuthType === "key" ? "text" : null,
+						name: "sshKeyPath",
+						message: "SSH Key Path",
+						initial: "~/.ssh/id_rsa",
+					},
+					{
+						type: (_prev, values) =>
+							values.type !== "sqlite" && values.type !== "libsql"
+								? "confirm"
+								: null,
+						name: "ssl",
+						message: "Enable SSL?",
+						initial: false,
+					},
+				],
+				{
+					onCancel: () => {
+						console.log(chalk.yellow("\nSetup cancelled."));
+						process.exit(0);
+					},
+				},
+			);
+
+			config = {
+				type: response.type,
+				url: response.url,
+				host: response.host,
+				port: response.port,
+				database: response.database,
+				username: response.username,
+				password: response.password,
+				filepath: response.methodOrPath, // If type was sqlite, methodOrPath holds the filepath
+				authToken: response.authToken,
+				ssl: response.ssl,
+			};
+
+			if (response.type === "sqlite") {
+				config.filepath = response.methodOrPath;
+			}
+
+			if (response.useSsh) {
+				try {
+					config.ssh = {
+						host: response.sshHost,
+						port: response.sshPort,
+						username: response.sshUser,
+						password: response.sshPassword,
+						privateKey: response.sshKeyPath
+							? fs.readFileSync(response.sshKeyPath, "utf8")
+							: undefined,
+					};
+				} catch (err) {
+					spinner.fail(
+						chalk.red(
+							`Failed to read SSH key: ${err instanceof Error ? err.message : String(err)}`,
+						),
+					);
+					process.exit(1);
+				}
+			}
+		}
+
+		// --- Password Prompt check ---
+		// If flags were used but password is missing for non-sqlite/libsql/url connections, prompt for it
+		if (
+			config.type !== "sqlite" &&
+			config.type !== "libsql" &&
+			!config.url &&
+			config.host &&
+			!config.password
+		) {
+			const response = await prompts({
+				type: "password",
+				name: "password",
+				message: `Password for ${config.username || "user"}@${config.host}`,
+			});
+			if (response.password) {
+				config.password = response.password;
+			}
+		}
+
+		spinner.start();
+
+		try {
+			// Validation
+			if (!["postgresql", "mysql", "sqlite", "libsql"].includes(config.type)) {
+				spinner.fail(chalk.red(`Invalid database type: ${config.type}`));
+				process.exit(1);
+			}
+
+			// Set default ports if missing and not sqlite/libsql
+			if (
+				config.type !== "sqlite" &&
+				config.type !== "libsql" &&
+				!config.port &&
+				!config.url
+			) {
+				config.port = config.type === "postgresql" ? 5432 : 3306;
+			}
+
+			if (config.type === "sqlite" && !config.filepath) {
+				spinner.fail(chalk.red("SQLite requires --file option or input"));
+				process.exit(1);
+			}
+
+			if (config.type === "libsql" && !config.url) {
+				spinner.fail(chalk.red("libSQL requires a connection URL"));
+				process.exit(1);
+			}
+
+			if (
+				config.type !== "sqlite" &&
+				config.type !== "libsql" &&
+				!config.database &&
+				!config.url
+			) {
+				spinner.fail(chalk.red("Database name or URL is required"));
+				process.exit(1);
+			}
+
+			spinner.text = "Connecting to database...";
+
+			// Create and start agent
+			const agent = new Agent({
+				serverUrl: options.server,
+				token: options.token,
+				dbConfig: config as any,
+			});
+
+			await agent.connect();
+			spinner.succeed(chalk.green("Connected to DBStudio!"));
+
+			console.log(
+				chalk.gray("\nAgent is running. Press Ctrl+C to disconnect.\n"),
+			);
+
+			// Print equivalent command for next time
+			let cmd = `dbstudio connect --token "${options.token}" --type ${config.type}`;
+			if (config.url) {
+				cmd += ` --url "${config.url}"`;
+			}
+			if (config.authToken) {
+				cmd += ` --auth-token "${config.authToken}"`;
+			}
+			if (config.type === "sqlite") {
+				cmd += ` --file "${config.filepath}"`;
+			}
+			if (!config.url && config.type !== "sqlite" && config.type !== "libsql") {
+				if (config.host) cmd += ` --host "${config.host}"`;
+				if (config.port) cmd += ` --port ${config.port}`;
+				if (config.database) cmd += ` --database "${config.database}"`;
+				if (config.username) cmd += ` --user "${config.username}"`;
+				if (config.password) cmd += ` --password "${config.password}"`;
+				if (config.ssl) cmd += " --ssl";
+			}
+
+			if (config.ssh) {
+				cmd += ` --ssh-host "${config.ssh.host}" --ssh-user "${config.ssh.username}"`;
+				if (config.ssh.port !== 22) cmd += ` --ssh-port ${config.ssh.port}`;
+			}
+			console.log(chalk.gray("To skip prompts next time, run:"));
+			console.log(chalk.cyan(`${cmd}\n`));
+
+			console.log(
+				chalk.cyan("Database:"),
+				config.database || config.filepath || config.url,
+			);
+			console.log(chalk.cyan("Type:"), config.type);
+			console.log(chalk.cyan("Server:"), options.server);
+
+			// Handle graceful shutdown
+			process.on("SIGINT", async () => {
+				console.log(chalk.yellow("\n\nDisconnecting..."));
+				await agent.disconnect();
+				console.log(chalk.green("Disconnected."));
+				process.exit(0);
+			});
+
+			// Keep process alive
+			await new Promise(() => {});
+		} catch (error) {
+			spinner.fail(chalk.red("Connection failed"));
+			console.error(
+				chalk.red(error instanceof Error ? error.message : "Unknown error"),
+			);
+			process.exit(1);
+		}
+	});

package/src/commands/disconnect.ts

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+
+const CONFIG_DIR = path.join(os.homedir(), ".dbstudio");
+const STATUS_FILE = path.join(CONFIG_DIR, "status.json");
+
+export const disconnectCommand = new Command("disconnect")
+	.description("Disconnect the running DBStudio agent")
+	.action(() => {
+		try {
+			if (!fs.existsSync(STATUS_FILE)) {
+				console.log(chalk.yellow("No active connection to disconnect."));
+				return;
+			}
+
+			const status = JSON.parse(fs.readFileSync(STATUS_FILE, "utf-8"));
+
+			if (status.pid) {
+				try {
+					process.kill(status.pid, "SIGINT");
+					console.log(chalk.green("Sent disconnect signal to agent."));
+				} catch (_error) {
+					console.log(chalk.yellow("Agent process not found. Cleaning up..."));
+				}
+			}
+
+			// Clean up status file
+			fs.unlinkSync(STATUS_FILE);
+			console.log(chalk.green("Disconnected successfully."));
+		} catch (error) {
+			console.log(chalk.red("Error disconnecting"));
+			console.error(error instanceof Error ? error.message : "Unknown error");
+		}
+	});

package/src/commands/status.ts

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+
+const CONFIG_DIR = path.join(os.homedir(), ".dbstudio");
+const STATUS_FILE = path.join(CONFIG_DIR, "status.json");
+
+export const statusCommand = new Command("status")
+	.description("Check the status of the DBStudio agent")
+	.action(() => {
+		try {
+			if (!fs.existsSync(STATUS_FILE)) {
+				console.log(chalk.yellow("No active connection."));
+				console.log(chalk.gray("Run 'dbstudio connect' to start an agent."));
+				return;
+			}
+
+			const status = JSON.parse(fs.readFileSync(STATUS_FILE, "utf-8"));
+
+			console.log(chalk.cyan("Connection Status"));
+			console.log(chalk.gray("─".repeat(40)));
+			console.log(chalk.white("Status:"), getStatusBadge(status.status));
+			console.log(chalk.white("Database:"), status.database);
+			console.log(chalk.white("Type:"), status.type);
+			console.log(
+				chalk.white("Connected at:"),
+				new Date(status.connectedAt).toLocaleString(),
+			);
+
+			if (status.pid) {
+				console.log(chalk.white("Process ID:"), status.pid);
+			}
+		} catch (_error) {
+			console.log(chalk.red("Error reading status"));
+			console.log(chalk.gray("Run 'dbstudio connect' to start an agent."));
+		}
+	});
+
+function getStatusBadge(status: string): string {
+	switch (status) {
+		case "connected":
+			return chalk.green("● Connected");
+		case "connecting":
+			return chalk.yellow("◐ Connecting...");
+		case "disconnected":
+			return chalk.gray("○ Disconnected");
+		case "error":
+			return chalk.red("✕ Error");
+		default:
+			return chalk.gray("Unknown");
+	}
+}

package/src/drivers/index.ts

@@ -0,0 +1,58 @@
+import type { DatabaseConfig, QueryResult, TableInfo } from "@dbstudio/types";
+import { LibSQLDriver } from "./libsql";
+import { MySQLDriver } from "./mysql";
+import { PostgresDriver } from "./postgres";
+import { SQLiteDriver } from "./sqlite";
+
+/**
+ * Common interface for all database drivers
+ */
+export interface DatabaseDriver {
+	/** Connect to the database */
+	connect(): Promise<void>;
+
+	/** Disconnect from the database */
+	disconnect(): Promise<void>;
+
+	/** Execute a query and return results */
+	query(sql: string, params?: unknown[]): Promise<QueryResult>;
+
+	/** Get list of tables in the database */
+	getTables(schema?: string): Promise<TableInfo[]>;
+
+	/** Get detailed schema for a specific table */
+	/** Get detailed schema for a specific table */
+	getTableSchema(table: string, schema?: string): Promise<TableInfo>;
+
+	/** Insert a row into a table */
+	insertRow(table: string, data: Record<string, unknown>): Promise<QueryResult>;
+
+	/** Update a row in a table */
+	updateRow(
+		table: string,
+		data: Record<string, unknown>,
+		where: Record<string, unknown>,
+	): Promise<QueryResult>;
+}
+
+/**
+ * Factory function to create the appropriate driver based on config
+ */
+export function createDriver(config: DatabaseConfig): DatabaseDriver {
+	switch (config.type) {
+		case "postgresql":
+			return new PostgresDriver(config);
+		case "mysql":
+			return new MySQLDriver(config);
+		case "sqlite":
+			return new SQLiteDriver(config);
+		case "libsql":
+			return new LibSQLDriver(config);
+		default:
+			throw new Error(`Unsupported database type: ${config.type}`);
+	}
+}
+
+export { MySQLDriver } from "./mysql";
+export { PostgresDriver } from "./postgres";
+export { SQLiteDriver } from "./sqlite";