+
+
({
accessModeModal: null,
@@ -514,6 +534,9 @@ export default {
this.$refs.settings.showModal();
});
},
+ showDBModal() {
+ this.$refs.dbConfigModal.showModal();
+ },
toggleSidebar() {
this.isSidebarCollapsed = !this.isSidebarCollapsed;
window.dispatchEvent(new Event('resize'));
diff --git a/src/server/API.js b/src/server/API.js
index 44ef7d2..6d441bf 100644
--- a/src/server/API.js
+++ b/src/server/API.js
@@ -20,11 +20,13 @@ if (!isWasmMode) {
const importApi = require("./Import");
const gpt = require("./Gpt");
+ const dbConfig = require("./DBConfig");
router.use("/schema", schema);
router.use("/cypher", cypher);
router.use("/session", session);
router.use("/", state);
router.use("/gpt", gpt);
+ router.use("/db", dbConfig);
if (currentMode === MODES.READ_WRITE) {
router.use("/reset", reset);
router.use("/import", importApi);
diff --git a/src/server/DBConfig.js b/src/server/DBConfig.js
new file mode 100644
index 0000000..07bbe56
--- /dev/null
+++ b/src/server/DBConfig.js
@@ -0,0 +1,40 @@
+const express = require("express");
+const router = express.Router();
+const database = require("./utils/Database");
+const sshManager = require("./utils/SSHManager");
+
+function buildResponse() {
+ const dbConfig = database.getCurrentConfig();
+ const sshConfig = sshManager.getConfig();
+ const mode = sshConfig ? "ssh" : (dbConfig.isInMemory ? "memory" : "file");
+ return { ...dbConfig, mode, ssh: sshConfig };
+}
+
+router.get("/", (_, res) => {
+ try {
+ res.send(buildResponse());
+ } catch (err) {
+ res.status(500).send({ error: err.message });
+ }
+});
+
+router.post("/", async (req, res) => {
+ try {
+ const { mode, dbDir, dbFile, ssh } = req.body;
+
+ if (mode === "ssh") {
+ const { host, port = 22, user, password, privateKeyPath, remoteDir, remoteFile } = ssh;
+ const mountPoint = sshManager.mount({ host, port, user, password, privateKeyPath, remoteDir });
+ await database.reconfigure({ dbDir: mountPoint, dbFile: remoteFile || "database.kz", inMemory: false });
+ } else {
+ sshManager.unmountAll();
+ await database.reconfigure({ dbDir, dbFile, inMemory: mode === "memory" });
+ }
+
+ res.send(buildResponse());
+ } catch (err) {
+ res.status(400).send({ error: err.message });
+ }
+});
+
+module.exports = router;
diff --git a/src/server/utils/Database.js b/src/server/utils/Database.js
index bd6c3c4..7ef1b2d 100644
--- a/src/server/utils/Database.js
+++ b/src/server/utils/Database.js
@@ -185,6 +185,41 @@ class Database {
});
}
+ getCurrentConfig() {
+ const isInMemory = this.dbPath === ":memory:";
+ return {
+ dbPath: this.dbPath,
+ isInMemory,
+ dbDir: isInMemory ? "" : path.dirname(this.dbPath),
+ dbFile: isInMemory ? "" : path.basename(this.dbPath),
+ };
+ }
+
+ async reconfigure({ dbDir, dbFile, inMemory }) {
+ const isAllConnectionsReleased = this.connectionPool.every(
+ (conn) => conn.useCount === 0
+ );
+ if (!isAllConnectionsReleased) {
+ throw new Error("Please make sure no queries are running before reconfiguring.");
+ }
+ const oldConnectionPool = this.connectionPool;
+ const oldDb = this.db;
+ this.connectionPool = [];
+ this.db = null;
+ await Promise.all(oldConnectionPool.map((conn) => conn.connection.close()));
+ oldDb.close();
+ if (inMemory) {
+ this.dbPath = ":memory:";
+ } else {
+ if (!dbDir) {
+ throw new Error("dbDir is required for file-based mode.");
+ }
+ const fileName = dbFile || "database.kz";
+ this.dbPath = path.resolve(path.join(dbDir, fileName));
+ }
+ this.init();
+ }
+
async getSchema() {
const conn = this.getConnection();
try {
diff --git a/src/server/utils/SSHManager.js b/src/server/utils/SSHManager.js
new file mode 100644
index 0000000..ec8eb6c
--- /dev/null
+++ b/src/server/utils/SSHManager.js
@@ -0,0 +1,133 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const logger = require("./Logger");
+
+class SSHManager {
+ constructor() {
+ this.activeMountPoint = null;
+ this.activeConfig = null; // stored without password
+
+ const cleanup = () => {
+ this.unmountAll();
+ process.exit();
+ };
+ process.on("exit", () => this.unmountAll());
+ process.on("SIGINT", cleanup);
+ process.on("SIGTERM", cleanup);
+ }
+
+ isActive() {
+ return this.activeMountPoint !== null;
+ }
+
+ getConfig() {
+ return this.activeConfig ? { ...this.activeConfig } : null;
+ }
+
+ getMountPoint() {
+ return this.activeMountPoint;
+ }
+
+ _hasCmd(cmd) {
+ try {
+ execSync(`which ${cmd}`, { stdio: "pipe" });
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ mount({ host, port = 22, user, password, privateKeyPath, remoteDir }) {
+ if (!this._hasCmd("sshfs")) {
+ throw new Error(
+ "sshfs is not installed. Please install sshfs to use remote SSH databases."
+ );
+ }
+
+ // Unmount any existing mount first
+ if (this.activeMountPoint) {
+ this._doUnmount(this.activeMountPoint);
+ }
+
+ const mountPoint = fs.mkdtempSync(path.join(os.tmpdir(), "lbug-ssh-"));
+
+ const sshOpts = [
+ `port=${port}`,
+ "StrictHostKeyChecking=no",
+ "UserKnownHostsFile=/dev/null",
+ "reconnect",
+ ];
+
+ let cmd;
+ let passFile = null;
+
+ if (password) {
+ if (!this._hasCmd("sshpass")) {
+ try { fs.rmdirSync(mountPoint); } catch {}
+ throw new Error(
+ "sshpass is not installed. Install sshpass for password-based auth, or use a private key file instead."
+ );
+ }
+ passFile = path.join(os.tmpdir(), `lbug-pass-${Date.now()}`);
+ fs.writeFileSync(passFile, password, { mode: 0o600 });
+ cmd = `sshpass -f ${passFile} sshfs -o ${sshOpts.join(",")} ${user}@${host}:${remoteDir} ${mountPoint}`;
+ } else if (privateKeyPath) {
+ sshOpts.push(`IdentityFile=${privateKeyPath}`);
+ cmd = `sshfs -o ${sshOpts.join(",")} ${user}@${host}:${remoteDir} ${mountPoint}`;
+ } else {
+ try { fs.rmdirSync(mountPoint); } catch {}
+ throw new Error("Either password or privateKeyPath is required.");
+ }
+
+ try {
+ execSync(cmd, { stdio: "pipe" });
+ } catch (err) {
+ try { fs.rmdirSync(mountPoint); } catch {}
+ const stderr = err.stderr?.toString().trim() || err.message;
+ throw new Error(`SSHFS mount failed: ${stderr}`);
+ } finally {
+ if (passFile) try { fs.unlinkSync(passFile); } catch {}
+ }
+
+ this.activeMountPoint = mountPoint;
+ this.activeConfig = {
+ host,
+ port: Number(port),
+ user,
+ remoteDir,
+ authType: password ? "password" : "key",
+ privateKeyPath: password ? undefined : privateKeyPath,
+ };
+
+ logger.info(`SSH mounted: ${user}@${host}:${remoteDir} → ${mountPoint}`);
+ return mountPoint;
+ }
+
+ _doUnmount(mountPoint) {
+ try {
+ try {
+ execSync(`fusermount -u "${mountPoint}"`, { stdio: "pipe" });
+ } catch {
+ execSync(`umount "${mountPoint}"`, { stdio: "pipe" });
+ }
+ } catch (err) {
+ logger.warn(`Unmount warning for ${mountPoint}: ${err.message}`);
+ }
+ try { fs.rmdirSync(mountPoint); } catch {}
+ if (this.activeMountPoint === mountPoint) {
+ this.activeMountPoint = null;
+ this.activeConfig = null;
+ }
+ logger.info(`SSH unmounted: ${mountPoint}`);
+ }
+
+ unmountAll() {
+ if (this.activeMountPoint) {
+ this._doUnmount(this.activeMountPoint);
+ }
+ }
+}
+
+module.exports = new SSHManager();