@dbstudio/cli 0.1.7

package/dist/index.js

@@ -0,0 +1,1372 @@
+#!/usr/bin/env bun
+
+// src/index.ts
+import "dotenv/config";
+import chalk4 from "chalk";
+import { program } from "commander";
+
+// src/commands/connect.ts
+import fs3 from "fs";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import prompts from "prompts";
+
+// src/agents/index.ts
+import fs2 from "fs";
+import { createServer } from "net";
+import os from "os";
+import path from "path";
+import { Client } from "ssh2";
+import WebSocket from "ws";
+
+// src/drivers/libsql.ts
+import { createClient } from "@libsql/client";
+var LibSQLDriver = class {
+  client = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (!this.config.url) {
+      throw new Error("libSQL requires a connection URL");
+    }
+    this.client = createClient({
+      url: this.config.url,
+      authToken: this.config.authToken
+    });
+    await this.client.execute("SELECT 1");
+  }
+  async disconnect() {
+    if (this.client) {
+      this.client.close();
+      this.client = null;
+    }
+  }
+  async query(sql, params) {
+    if (!this.client) throw new Error("Not connected");
+    const start = Date.now();
+    const result = await this.client.execute({
+      sql,
+      args: params || []
+    });
+    const executionTimeMs = Date.now() - start;
+    return {
+      columns: result.columns,
+      rows: result.rows.map((row) => {
+        const obj = {};
+        result.columns.forEach((col, i) => {
+          obj[col] = row[i];
+        });
+        return obj;
+      }),
+      rowCount: result.rows.length,
+      affectedRows: result.rowsAffected,
+      executionTimeMs
+    };
+  }
+  async getTables() {
+    if (!this.client) throw new Error("Not connected");
+    const result = await this.client.execute(
+      `SELECT name FROM sqlite_master 
+       WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+       ORDER BY name`
+    );
+    const tables = [];
+    for (const row of result.rows) {
+      const tableName = row[0];
+      try {
+        const tableInfo = await this.getTableSchema(tableName);
+        tables.push(tableInfo);
+      } catch (error) {
+        console.error(`Failed to get schema for table ${tableName}:`, error);
+      }
+    }
+    return tables;
+  }
+  async getTableSchema(table) {
+    if (!this.client) throw new Error("Not connected");
+    const columnsResult = await this.client.execute(
+      `PRAGMA table_info("${table}")`
+    );
+    const columns = columnsResult.rows.map((row) => ({
+      name: row[1],
+      type: row[2],
+      nullable: row[3] === 0,
+      defaultValue: row[4] || void 0,
+      isPrimaryKey: row[5] === 1,
+      isForeignKey: false
+      // Will be updated by relations
+    }));
+    const countResult = await this.client.execute(
+      `SELECT COUNT(*) as count FROM "${table}"`
+    );
+    const rowCount = countResult.rows[0][0];
+    const indexListResult = await this.client.execute(
+      `PRAGMA index_list("${table}")`
+    );
+    const indexes = await Promise.all(
+      indexListResult.rows.map(async (row) => {
+        const indexName = row[1];
+        const isUnique = row[2] === 1;
+        const indexInfoResult = await this.client.execute(
+          `PRAGMA index_info("${indexName}")`
+        );
+        return {
+          name: indexName,
+          unique: isUnique,
+          columns: indexInfoResult.rows.map((r) => r[2])
+        };
+      })
+    );
+    const fkListResult = await this.client.execute(
+      `PRAGMA foreign_key_list("${table}")`
+    );
+    const relations = fkListResult.rows.map((row) => ({
+      name: `${table}_${row[3]}_fk`,
+      type: "belongsTo",
+      fromTable: table,
+      fromColumn: row[3],
+      toTable: row[2],
+      toColumn: row[4]
+    }));
+    for (const rel of relations) {
+      const col = columns.find((c) => c.name === rel.fromColumn);
+      if (col) col.isForeignKey = true;
+    }
+    return {
+      name: table,
+      schema: "main",
+      columns,
+      rowCount,
+      indexes,
+      relations
+    };
+  }
+  async insertRow(table, data) {
+    if (!this.client) throw new Error("Not connected");
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    return this.query(sql, values);
+  }
+  async updateRow(table, data, where) {
+    if (!this.client) throw new Error("Not connected");
+    const setClauses = Object.keys(data).map((c) => `"${c}" = ?`).join(", ");
+    const whereClauses = Object.keys(where).map((c) => `"${c}" = ?`).join(" AND ");
+    const values = [...Object.values(data), ...Object.values(where)];
+    const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+    return this.query(sql, values);
+  }
+};
+
+// src/drivers/mysql.ts
+import mysql from "mysql2/promise";
+var MySQLDriver = class {
+  connection = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.config.url) {
+      this.connection = await mysql.createConnection(this.config.url);
+    } else {
+      this.connection = await mysql.createConnection({
+        host: this.config.host,
+        port: this.config.port,
+        database: this.config.database,
+        user: this.config.username,
+        password: this.config.password,
+        ssl: this.config.ssl ? {} : void 0
+      });
+    }
+  }
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.end();
+      this.connection = null;
+    }
+  }
+  async query(sql, params) {
+    if (!this.connection) throw new Error("Not connected");
+    const start = Date.now();
+    const [rows, fields] = await this.connection.execute(sql, params);
+    const executionTimeMs = Date.now() - start;
+    const isResultSet = Array.isArray(rows);
+    return {
+      columns: fields ? fields.map((f) => f.name) : [],
+      rows: isResultSet ? rows : [],
+      rowCount: isResultSet ? rows.length : 0,
+      affectedRows: !isResultSet ? rows.affectedRows : void 0,
+      executionTimeMs
+    };
+  }
+  async getTables(schema) {
+    if (!this.connection) throw new Error("Not connected");
+    const db = schema || this.config.database;
+    const [rows] = await this.connection.execute(
+      `SELECT table_name 
+       FROM information_schema.tables 
+       WHERE table_schema = ? AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,
+      [db]
+    );
+    const tables = [];
+    for (const row of rows) {
+      const tableInfo = await this.getTableSchema(
+        row.TABLE_NAME || row.table_name,
+        db
+      );
+      tables.push(tableInfo);
+    }
+    return tables;
+  }
+  async getTableSchema(table, schema) {
+    if (!this.connection) throw new Error("Not connected");
+    const db = schema || this.config.database;
+    const [columnsRows] = await this.connection.execute(
+      `SELECT 
+        COLUMN_NAME as column_name,
+        DATA_TYPE as data_type,
+        IS_NULLABLE as is_nullable,
+        COLUMN_DEFAULT as column_default,
+        COLUMN_KEY as column_key
+       FROM information_schema.columns
+       WHERE table_schema = ? AND table_name = ?
+       ORDER BY ordinal_position`,
+      [db, table]
+    );
+    const columns = columnsRows.map((row) => ({
+      name: row.column_name,
+      type: row.data_type,
+      nullable: row.is_nullable === "YES",
+      defaultValue: row.column_default,
+      isPrimaryKey: row.column_key === "PRI",
+      isForeignKey: row.column_key === "MUL"
+    }));
+    const [countRows] = await this.connection.execute(
+      `SELECT COUNT(*) as count FROM \`${db}\`.\`${table}\``
+    );
+    const [indexesRows] = await this.connection.execute(
+      `SHOW INDEX FROM \`${table}\` FROM \`${db}\``
+    );
+    const indexesMap = /* @__PURE__ */ new Map();
+    indexesRows.forEach((row) => {
+      if (!indexesMap.has(row.Key_name)) {
+        indexesMap.set(row.Key_name, {
+          name: row.Key_name,
+          columns: [],
+          unique: row.Non_unique === 0
+        });
+      }
+      indexesMap.get(row.Key_name).columns.push(row.Column_name);
+    });
+    const indexes = Array.from(indexesMap.values());
+    const [relationsRows] = await this.connection.execute(
+      `SELECT 
+        CONSTRAINT_NAME as constraint_name,
+        COLUMN_NAME as column_name,
+        REFERENCED_TABLE_NAME as referenced_table_name,
+        REFERENCED_COLUMN_NAME as referenced_column_name
+       FROM information_schema.KEY_COLUMN_USAGE
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND REFERENCED_TABLE_NAME IS NOT NULL`,
+      [db, table]
+    );
+    const relations = relationsRows.map((row) => ({
+      name: row.constraint_name,
+      type: "belongsTo",
+      fromTable: table,
+      fromColumn: row.column_name,
+      toTable: row.referenced_table_name,
+      toColumn: row.referenced_column_name
+    }));
+    return {
+      name: table,
+      schema: db,
+      columns,
+      rowCount: Number.parseInt(countRows[0].count, 10),
+      indexes,
+      relations
+    };
+  }
+  async insertRow(table, data) {
+    if (!this.connection) throw new Error("Not connected");
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map(() => "?").join(", ");
+    const sql = `INSERT INTO \`${table}\` (${columns.map((c) => `\`${c}\``).join(", ")}) VALUES (${placeholders})`;
+    return this.query(sql, values);
+  }
+  async updateRow(table, data, where) {
+    if (!this.connection) throw new Error("Not connected");
+    const setClauses = Object.keys(data).map((c) => `\`${c}\` = ?`).join(", ");
+    const whereClauses = Object.keys(where).map((c) => `\`${c}\` = ?`).join(" AND ");
+    const values = [...Object.values(data), ...Object.values(where)];
+    const sql = `UPDATE \`${table}\` SET ${setClauses} WHERE ${whereClauses}`;
+    return this.query(sql, values);
+  }
+};
+
+// src/drivers/postgres.ts
+import pg from "pg";
+var { Pool } = pg;
+var PostgresDriver = class {
+  pool = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.config.url) {
+      this.pool = new Pool({
+        connectionString: this.config.url,
+        ssl: this.config.ssl ? { rejectUnauthorized: false } : void 0
+      });
+    } else {
+      this.pool = new Pool({
+        host: this.config.host,
+        port: this.config.port,
+        database: this.config.database,
+        user: this.config.username,
+        password: this.config.password || "",
+        ssl: this.config.ssl ? { rejectUnauthorized: false } : void 0
+      });
+    }
+    const client = await this.pool.connect();
+    client.release();
+  }
+  async disconnect() {
+    const pool = this.pool;
+    this.pool = null;
+    if (pool) {
+      await pool.end();
+    }
+  }
+  async query(sql, params) {
+    if (!this.pool) throw new Error("Not connected");
+    const start = Date.now();
+    const result = await this.pool.query(sql, params);
+    const executionTimeMs = Date.now() - start;
+    return {
+      columns: result.fields.map((f) => f.name),
+      rows: result.rows,
+      rowCount: result.rows.length,
+      affectedRows: result.rowCount ?? void 0,
+      executionTimeMs
+    };
+  }
+  async getTables(schema = "public") {
+    if (!this.pool) throw new Error("Not connected");
+    const result = await this.pool.query(
+      `SELECT table_name 
+       FROM information_schema.tables 
+       WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,
+      [schema]
+    );
+    const tables = [];
+    for (const row of result.rows) {
+      const tableInfo = await this.getTableSchema(row.table_name, schema);
+      tables.push(tableInfo);
+    }
+    return tables;
+  }
+  async getTableSchema(table, schema = "public") {
+    if (!this.pool) throw new Error("Not connected");
+    const columnsResult = await this.pool.query(
+      `SELECT 
+        column_name,
+        data_type,
+        is_nullable,
+        column_default
+       FROM information_schema.columns
+       WHERE table_schema = $1 AND table_name = $2
+       ORDER BY ordinal_position`,
+      [schema, table]
+    );
+    const constraintsResult = await this.pool.query(
+      `SELECT 
+        ccu.column_name,
+        tc.constraint_type
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.constraint_column_usage ccu 
+         ON tc.constraint_name = ccu.constraint_name 
+         AND tc.table_schema = ccu.table_schema
+       WHERE tc.table_schema = $1 AND tc.table_name = $2`,
+      [schema, table]
+    );
+    const columnConstraints = /* @__PURE__ */ new Map();
+    for (const row of constraintsResult.rows) {
+      if (!columnConstraints.has(row.column_name)) {
+        columnConstraints.set(row.column_name, []);
+      }
+      columnConstraints.get(row.column_name)?.push(row.constraint_type);
+    }
+    const columns = columnsResult.rows.map((row) => {
+      const constraints = columnConstraints.get(row.column_name) || [];
+      return {
+        name: row.column_name,
+        type: row.data_type,
+        nullable: row.is_nullable === "YES",
+        defaultValue: row.column_default,
+        isPrimaryKey: constraints.includes("PRIMARY KEY"),
+        isForeignKey: constraints.includes("FOREIGN KEY")
+      };
+    });
+    const indexesResult = await this.pool.query(
+      `SELECT indexname, indexdef 
+       FROM pg_indexes 
+       WHERE schemaname = $1 AND tablename = $2`,
+      [schema, table]
+    );
+    const indexes = indexesResult.rows.map((row) => ({
+      name: row.indexname,
+      columns: [],
+      // Parsing columns from indexdef is complex, leaving empty for now or need regex
+      unique: row.indexdef.includes("UNIQUE")
+    }));
+    const relationsResult = await this.pool.query(
+      `SELECT
+        tc.constraint_name,
+        tc.constraint_type,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1 AND tc.table_name = $2`,
+      [schema, table]
+    );
+    const relations = relationsResult.rows.map((row) => ({
+      name: row.constraint_name,
+      type: "belongsTo",
+      fromTable: table,
+      fromColumn: row.column_name,
+      toTable: row.foreign_table_name,
+      toColumn: row.foreign_column_name
+    }));
+    const countResult = await this.pool.query(
+      `SELECT COUNT(*) as count FROM "${schema}"."${table}"`
+    );
+    return {
+      name: table,
+      schema,
+      columns,
+      rowCount: Number.parseInt(countResult.rows[0].count, 10),
+      indexes,
+      relations
+    };
+  }
+  async insertRow(table, data) {
+    if (!this.pool) throw new Error("Not connected");
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map((_, i) => `$${i + 1}`).join(", ");
+    const sql = `INSERT INTO "${table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    return this.query(sql, values);
+  }
+  async updateRow(table, data, where) {
+    if (!this.pool) throw new Error("Not connected");
+    const setClauses = Object.keys(data).map((c, i) => `"${c}" = $${i + 1}`).join(", ");
+    const whereClauses = Object.keys(where).map((c, i) => `"${c}" = $${Object.keys(data).length + i + 1}`).join(" AND ");
+    const values = [...Object.values(data), ...Object.values(where)];
+    const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+    return this.query(sql, values);
+  }
+};
+
+// src/drivers/sqlite.ts
+import { Database } from "bun:sqlite";
+import fs from "fs";
+var SQLiteDriver = class {
+  db = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (!this.config.filepath) {
+      throw new Error("SQLite requires filepath");
+    }
+    if (!fs.existsSync(this.config.filepath)) {
+      throw new Error(`Database file not found: ${this.config.filepath}`);
+    }
+    this.db = new Database(this.config.filepath);
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  async query(sql, params) {
+    if (!this.db) throw new Error("Not connected");
+    const start = Date.now();
+    const isSelect = sql.trim().toUpperCase().startsWith("SELECT");
+    let result;
+    if (isSelect) {
+      const stmt = this.db.prepare(sql);
+      const rows = params ? stmt.all(...params) : stmt.all();
+      result = {
+        columns: rows.length > 0 ? Object.keys(rows[0]) : [],
+        rows,
+        rowCount: rows.length,
+        executionTimeMs: Date.now() - start
+      };
+    } else {
+      const stmt = this.db.prepare(sql);
+      const info = params ? stmt.run(...params) : stmt.run();
+      result = {
+        columns: [],
+        rows: [],
+        rowCount: 0,
+        affectedRows: info.changes,
+        executionTimeMs: Date.now() - start
+      };
+    }
+    return result;
+  }
+  async getTables() {
+    if (!this.db) throw new Error("Not connected");
+    const rows = this.db.prepare(
+      `SELECT name FROM sqlite_master 
+         WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+         ORDER BY name`
+    ).all();
+    const tables = [];
+    for (const row of rows) {
+      try {
+        const tableInfo = await this.getTableSchema(row.name);
+        tables.push(tableInfo);
+      } catch (error) {
+        console.error(`Failed to get schema for table ${row.name}:`, error);
+      }
+    }
+    return tables;
+  }
+  async getTableSchema(table) {
+    if (!this.db) throw new Error("Not connected");
+    const columnsRows = this.db.prepare(`PRAGMA table_info("${table}")`).all();
+    const columns = columnsRows.map((row) => ({
+      name: row.name,
+      type: row.type,
+      nullable: row.notnull === 0,
+      defaultValue: row.dflt_value ?? void 0,
+      isPrimaryKey: row.pk === 1,
+      isForeignKey: false
+    }));
+    const countRow = this.db.prepare(`SELECT COUNT(*) as count FROM "${table}"`).get();
+    const indexesRows = this.db.prepare(`PRAGMA index_list("${table}")`).all();
+    const indexes = await Promise.all(
+      indexesRows.map(async (idx) => {
+        const info = this.db.prepare(
+          `PRAGMA index_info("${idx.name}")`
+        ).all();
+        return {
+          name: idx.name,
+          unique: idx.unique === 1,
+          columns: info.map((i) => i.name)
+        };
+      })
+    );
+    const fkRows = this.db.prepare(`PRAGMA foreign_key_list("${table}")`).all();
+    const relations = fkRows.map((fk) => ({
+      name: `${table}_${fk.from}_fk`,
+      type: "belongsTo",
+      fromTable: table,
+      fromColumn: fk.from,
+      toTable: fk.table,
+      toColumn: fk.to
+    }));
+    return {
+      name: table,
+      schema: "main",
+      columns,
+      rowCount: countRow.count,
+      indexes,
+      relations
+    };
+  }
+  async insertRow(table, data) {
+    if (!this.db) throw new Error("Not connected");
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map(() => "?").join(", ");
+    const sql = `INSERT INTO "${table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    return this.query(sql, values);
+  }
+  async updateRow(table, data, where) {
+    if (!this.db) throw new Error("Not connected");
+    const setClauses = Object.keys(data).map((c) => `"${c}" = ?`).join(", ");
+    const whereClauses = Object.keys(where).map((c) => `"${c}" = ?`).join(" AND ");
+    const values = [...Object.values(data), ...Object.values(where)];
+    const sql = `UPDATE "${table}" SET ${setClauses} WHERE ${whereClauses}`;
+    return this.query(sql, values);
+  }
+};
+
+// src/drivers/index.ts
+function createDriver(config) {
+  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}`);
+  }
+}
+
+// src/agents/index.ts
+var CONFIG_DIR = path.join(os.homedir(), ".dbstudio");
+var STATUS_FILE = path.join(CONFIG_DIR, "status.json");
+var Agent = class {
+  ws = null;
+  driver = null;
+  config;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  pingInterval = null;
+  sshClient = null;
+  tunnelServer = null;
+  isReconnecting = false;
+  reconnectTimeout = null;
+  constructor(config) {
+    this.config = config;
+    this.ensureConfigDir();
+  }
+  ensureConfigDir() {
+    if (!fs2.existsSync(CONFIG_DIR)) {
+      fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+  }
+  async connect() {
+    if (this.config.dbConfig.ssh) {
+      await this.setupSshTunnel();
+    }
+    this.driver = createDriver(this.config.dbConfig);
+    await this.driver.connect();
+    await this.connectWebSocket();
+    this.saveStatus("connected");
+  }
+  async setupSshTunnel() {
+    const { ssh, host, port, type } = this.config.dbConfig;
+    if (!ssh) return;
+    return new Promise((resolve, reject) => {
+      this.sshClient = new Client();
+      this.sshClient.on("ready", () => {
+        this.tunnelServer = createServer((sock) => {
+          this.sshClient?.forwardOut(
+            "127.0.0.1",
+            sock.remotePort || 0,
+            host || "localhost",
+            port || (type === "postgresql" ? 5432 : 3306),
+            (err, stream) => {
+              if (err) {
+                sock.end();
+                return;
+              }
+              sock.pipe(stream).pipe(sock);
+            }
+          );
+        });
+        this.tunnelServer.listen(0, "127.0.0.1", () => {
+          const addr = this.tunnelServer?.address();
+          if (addr && typeof addr !== "string") {
+            this.config.dbConfig.host = "127.0.0.1";
+            this.config.dbConfig.port = addr.port;
+            console.log(
+              `SSH Tunnel established: 127.0.0.1:${addr.port} -> ${host}:${port || (type === "postgresql" ? 5432 : 3306)}`
+            );
+            resolve();
+          } else {
+            reject(new Error("Failed to get tunnel address"));
+          }
+        });
+        this.tunnelServer.on("error", reject);
+      }).on("error", reject).connect({
+        host: ssh.host,
+        port: ssh.port || 22,
+        username: ssh.username,
+        password: ssh.password,
+        privateKey: ssh.privateKey,
+        passphrase: ssh.passphrase
+      });
+    });
+  }
+  async connectWebSocket() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.config.serverUrl);
+      this.ws.on("open", () => {
+        console.log("WebSocket connected, authenticating...");
+        this.authenticate();
+        this.startPingInterval();
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data.toString());
+      });
+      this.ws.on("close", () => {
+        console.log("WebSocket closed");
+        this.stopPingInterval();
+        this.handleReconnect();
+      });
+      this.ws.on("error", (error) => {
+        console.error("WebSocket error:", error.message);
+        reject(error);
+      });
+    });
+  }
+  authenticate() {
+    const authMessage = {
+      id: crypto.randomUUID(),
+      type: "auth",
+      timestamp: Date.now(),
+      payload: {
+        token: this.config.token,
+        connectionId: crypto.randomUUID(),
+        dbConfig: this.config.dbConfig
+      }
+    };
+    this.send(authMessage);
+  }
+  async handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case "auth_success":
+          console.log("Authenticated successfully");
+          break;
+        case "auth_error":
+          console.error("Authentication failed:", message.payload.error);
+          await this.disconnect();
+          break;
+        case "ping":
+          this.send({ id: message.id, type: "pong", timestamp: Date.now() });
+          break;
+        case "pong":
+          break;
+        case "query":
+          await this.handleQuery(message);
+          break;
+        case "get_tables":
+          await this.handleGetTables(message);
+          break;
+        case "get_table_schema":
+          await this.handleGetTableSchema(message);
+          break;
+        case "insert_row":
+          await this.handleInsertRow(message);
+          break;
+        case "update_row":
+          await this.handleUpdateRow(message);
+          break;
+        default:
+          console.log("Unknown message type:", message.type);
+      }
+    } catch (error) {
+      console.error("Error handling message:", error);
+    }
+  }
+  async handleQuery(message) {
+    if (!this.driver) return;
+    try {
+      const result = await this.driver.query(
+        message.payload.sql,
+        message.payload.params
+      );
+      this.send({
+        id: message.id,
+        type: "query_result",
+        timestamp: Date.now(),
+        payload: result
+      });
+    } catch (error) {
+      this.send({
+        id: message.id,
+        type: "query_error",
+        timestamp: Date.now(),
+        payload: {
+          message: error instanceof Error ? error.message : "Query failed",
+          code: error?.code
+        }
+      });
+    }
+  }
+  async handleGetTables(message) {
+    if (!this.driver) return;
+    try {
+      const tables = await this.driver.getTables(message.payload.schema);
+      this.send({
+        id: message.id,
+        type: "tables_result",
+        timestamp: Date.now(),
+        payload: { tables }
+      });
+    } catch (error) {
+      console.error("Error in handleGetTables:", error);
+      this.send({
+        id: message.id,
+        type: "query_error",
+        timestamp: Date.now(),
+        payload: {
+          message: error instanceof Error ? error.message : "Failed to get tables"
+        }
+      });
+    }
+  }
+  async handleGetTableSchema(message) {
+    if (!this.driver) return;
+    try {
+      const schema = await this.driver.getTableSchema(
+        message.payload.table,
+        message.payload.schema
+      );
+      this.send({
+        id: message.id,
+        type: "table_schema_result",
+        timestamp: Date.now(),
+        payload: schema
+      });
+    } catch (error) {
+      this.send({
+        id: message.id,
+        type: "query_error",
+        timestamp: Date.now(),
+        payload: {
+          message: error instanceof Error ? error.message : "Failed to get schema"
+        }
+      });
+    }
+  }
+  async handleInsertRow(message) {
+    if (!this.driver) return;
+    try {
+      const result = await this.driver.insertRow(
+        message.payload.table,
+        message.payload.data
+      );
+      this.send({
+        id: message.id,
+        type: "query_result",
+        timestamp: Date.now(),
+        payload: result
+      });
+    } catch (error) {
+      this.send({
+        id: message.id,
+        type: "query_error",
+        timestamp: Date.now(),
+        payload: {
+          message: error instanceof Error ? error.message : "Failed to insert row"
+        }
+      });
+    }
+  }
+  async handleUpdateRow(message) {
+    if (!this.driver) return;
+    try {
+      const result = await this.driver.updateRow(
+        message.payload.table,
+        message.payload.data,
+        message.payload.where
+      );
+      this.send({
+        id: message.id,
+        type: "query_result",
+        timestamp: Date.now(),
+        payload: result
+      });
+    } catch (error) {
+      this.send({
+        id: message.id,
+        type: "query_error",
+        timestamp: Date.now(),
+        payload: {
+          message: error instanceof Error ? error.message : "Failed to update row"
+        }
+      });
+    }
+  }
+  send(message) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+  startPingInterval() {
+    this.pingInterval = setInterval(() => {
+      this.send({
+        id: crypto.randomUUID(),
+        type: "ping",
+        timestamp: Date.now()
+      });
+    }, 3e4);
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  clearReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    this.isReconnecting = false;
+  }
+  async handleReconnect() {
+    if (this.isReconnecting) return;
+    this.isReconnecting = true;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnect attempts reached");
+      this.saveStatus("error");
+      this.isReconnecting = false;
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * 2 ** this.reconnectAttempts, 3e4);
+    console.log(`Reconnecting in ${delay / 1e3}s...`);
+    this.saveStatus("connecting");
+    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    this.reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.connectWebSocket();
+        this.reconnectAttempts = 0;
+        this.saveStatus("connected");
+      } catch (_error) {
+      } finally {
+        this.isReconnecting = false;
+        this.reconnectTimeout = null;
+      }
+    }, delay);
+  }
+  async disconnect() {
+    this.stopPingInterval();
+    this.clearReconnect();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    if (this.driver) {
+      await this.driver.disconnect();
+      this.driver = null;
+    }
+    if (this.tunnelServer) {
+      this.tunnelServer.close();
+      this.tunnelServer = null;
+    }
+    if (this.sshClient) {
+      this.sshClient.end();
+      this.sshClient = null;
+    }
+    this.saveStatus("disconnected");
+    this.removeStatus();
+  }
+  saveStatus(status) {
+    const statusData = {
+      status,
+      database: this.config.dbConfig.database || this.config.dbConfig.filepath,
+      type: this.config.dbConfig.type,
+      connectedAt: Date.now(),
+      pid: process.pid
+    };
+    fs2.writeFileSync(STATUS_FILE, JSON.stringify(statusData, null, 2));
+  }
+  removeStatus() {
+    if (fs2.existsSync(STATUS_FILE)) {
+      fs2.unlinkSync(STATUS_FILE);
+    }
+  }
+};
+
+// src/commands/connect.ts
+var 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 = {
+    type: options.type,
+    url: options.url,
+    host: options.host,
+    port: options.port ? Number.parseInt(options.port, 10) : void 0,
+    database: options.database,
+    username: options.user,
+    password: options.password,
+    filepath: options.file,
+    ssl: options.ssl,
+    authToken: options.authToken
+  };
+  if (options.database?.includes("://") && !config.url) {
+    config.url = options.database;
+    config.database = void 0;
+  }
+  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 ? fs3.readFileSync(options.sshKey, "utf8") : void 0,
+      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 ? fs3.readFileSync(response.sshKeyPath, "utf8") : void 0
+        };
+      } catch (err) {
+        spinner.fail(
+          chalk.red(
+            `Failed to read SSH key: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        process.exit(1);
+      }
+    }
+  }
+  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 {
+    if (!["postgresql", "mysql", "sqlite", "libsql"].includes(config.type)) {
+      spinner.fail(chalk.red(`Invalid database type: ${config.type}`));
+      process.exit(1);
+    }
+    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...";
+    const agent = new Agent({
+      serverUrl: options.server,
+      token: options.token,
+      dbConfig: config
+    });
+    await agent.connect();
+    spinner.succeed(chalk.green("Connected to DBStudio!"));
+    console.log(
+      chalk.gray("\nAgent is running. Press Ctrl+C to disconnect.\n")
+    );
+    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}
+`));
+    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);
+    process.on("SIGINT", async () => {
+      console.log(chalk.yellow("\n\nDisconnecting..."));
+      await agent.disconnect();
+      console.log(chalk.green("Disconnected."));
+      process.exit(0);
+    });
+    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);
+  }
+});
+
+// src/commands/disconnect.ts
+import fs4 from "fs";
+import os2 from "os";
+import path2 from "path";
+import chalk2 from "chalk";
+import { Command as Command2 } from "commander";
+var CONFIG_DIR2 = path2.join(os2.homedir(), ".dbstudio");
+var STATUS_FILE2 = path2.join(CONFIG_DIR2, "status.json");
+var disconnectCommand = new Command2("disconnect").description("Disconnect the running DBStudio agent").action(() => {
+  try {
+    if (!fs4.existsSync(STATUS_FILE2)) {
+      console.log(chalk2.yellow("No active connection to disconnect."));
+      return;
+    }
+    const status = JSON.parse(fs4.readFileSync(STATUS_FILE2, "utf-8"));
+    if (status.pid) {
+      try {
+        process.kill(status.pid, "SIGINT");
+        console.log(chalk2.green("Sent disconnect signal to agent."));
+      } catch (_error) {
+        console.log(chalk2.yellow("Agent process not found. Cleaning up..."));
+      }
+    }
+    fs4.unlinkSync(STATUS_FILE2);
+    console.log(chalk2.green("Disconnected successfully."));
+  } catch (error) {
+    console.log(chalk2.red("Error disconnecting"));
+    console.error(error instanceof Error ? error.message : "Unknown error");
+  }
+});
+
+// src/commands/status.ts
+import fs5 from "fs";
+import os3 from "os";
+import path3 from "path";
+import chalk3 from "chalk";
+import { Command as Command3 } from "commander";
+var CONFIG_DIR3 = path3.join(os3.homedir(), ".dbstudio");
+var STATUS_FILE3 = path3.join(CONFIG_DIR3, "status.json");
+var statusCommand = new Command3("status").description("Check the status of the DBStudio agent").action(() => {
+  try {
+    if (!fs5.existsSync(STATUS_FILE3)) {
+      console.log(chalk3.yellow("No active connection."));
+      console.log(chalk3.gray("Run 'dbstudio connect' to start an agent."));
+      return;
+    }
+    const status = JSON.parse(fs5.readFileSync(STATUS_FILE3, "utf-8"));
+    console.log(chalk3.cyan("Connection Status"));
+    console.log(chalk3.gray("\u2500".repeat(40)));
+    console.log(chalk3.white("Status:"), getStatusBadge(status.status));
+    console.log(chalk3.white("Database:"), status.database);
+    console.log(chalk3.white("Type:"), status.type);
+    console.log(
+      chalk3.white("Connected at:"),
+      new Date(status.connectedAt).toLocaleString()
+    );
+    if (status.pid) {
+      console.log(chalk3.white("Process ID:"), status.pid);
+    }
+  } catch (_error) {
+    console.log(chalk3.red("Error reading status"));
+    console.log(chalk3.gray("Run 'dbstudio connect' to start an agent."));
+  }
+});
+function getStatusBadge(status) {
+  switch (status) {
+    case "connected":
+      return chalk3.green("\u25CF Connected");
+    case "connecting":
+      return chalk3.yellow("\u25D0 Connecting...");
+    case "disconnected":
+      return chalk3.gray("\u25CB Disconnected");
+    case "error":
+      return chalk3.red("\u2715 Error");
+    default:
+      return chalk3.gray("Unknown");
+  }
+}
+
+// src/index.ts
+var logo = `
+${chalk4.green("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+${chalk4.green("\u2551")}  ${chalk4.bold.white("DBStudio")} ${chalk4.gray("CLI Agent")}               ${chalk4.green("\u2551")}
+${chalk4.green("\u2551")}  ${chalk4.gray("Connect your database to the cloud")}  ${chalk4.green("\u2551")}
+${chalk4.green("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+program.name("dbstudio").description("DBStudio CLI - Connect local databases to DBStudio cloud").version("0.1.0").hook("preAction", () => {
+  console.log(logo);
+});
+program.addCommand(connectCommand);
+program.addCommand(statusCommand);
+program.addCommand(disconnectCommand);
+program.parse(process.argv);