sqlite-hub 0.17.2 → 1.1.0

package/bin/sqlite-hub.js

@@ -3,9 +3,11 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
+const { DatabaseCommandService, getQueryTitle } = require('../server/services/databaseCommandService');
+const { buildAppInfo } = require('../server/services/appInfoService');
 
 const DEFAULT_PORT = 4173;
-const EXPORT_FORMATS = new Set(['csv', 'tsv', 'md']);
+const EXPORT_FORMATS = new Set(['csv', 'tsv', 'md', 'json']);
 
 function printHelp() {
     console.log(`SQLite Hub CLI
@@ -14,8 +16,10 @@ Usage:
   sqlite-hub [--port:4173]
   sqlite-hub --database
   sqlite-hub --database:"name" --tables
+  sqlite-hub --database:"name" --query:"SELECT * FROM table_name"
+  sqlite-hub --database:"name" --query:"SELECT * FROM table_name" --store:"Query Name"
   sqlite-hub --database:"name" --execute:"Saved Query"
-  sqlite-hub --database:"name" --query:"Saved Query"
+  sqlite-hub --database:"name" --saved-query:"Saved Query"
   sqlite-hub --database:"name" --notes:"Saved Query"
   sqlite-hub --database:"name" --export:"Saved Query" --format:csv
   sqlite-hub --database:"name" --documents
@@ -27,7 +31,7 @@ Usage:
 Options:
   --help, -h                         Show this help text.
   --version, -v                      Show the version number.
-  --config                           Show CLI port, URL, app version, and SQLite version.
+  --info                             Show port, URL, app version, SQLite version, and update status.
   --open                             Start/open SQLite Hub in the browser.
   --port:PORT                        Start the server on a custom port.
   --database, -d                     List all imported databases.
@@ -37,20 +41,18 @@ Options:
   --lastopened                       Print the selected database last-opened timestamp.
   --tables                           List tables in the selected database.
   --queries                          List saved SQL Editor queries for the selected database.
+  --query:"sql"                      Execute raw SQL and record it in query history.
+  --store:"name"                     Save a raw --query history item with this name.
   --execute:"query"                  Execute a saved SQL Editor query by name.
-  --query:"query"                    Print a saved SQL Editor query by name.
+  --saved-query:"query"              Print a saved SQL Editor query by name.
   --notes:"query"                    Print notes for a saved SQL Editor query by name.
   --export:"query"                   Export a saved query when --table is not set.
-  --format:csv|tsv|md                Export format for query exports. Defaults to csv.
+  --format:csv|tsv|md|json           Export format for query exports. Defaults to csv.
   --documents                        List Markdown documents for the selected database.
   --documents:"name"                 Print a document's Markdown content.
   --documents:"name" --export        Export a document as a Markdown file.
   --table:"table"                    Print table metadata.
   --table:"table" --export:"pk"      Export one row as JSON by primary key or rowid.
-
-Legacy aliases still work:
-  --database-path:name, --database-size:name, --database-lastopened:name
-  --database-tables:name, --database:name --sqleditor, --database:name --sqleditor:"query"
 `);
 }
 
@@ -142,7 +144,7 @@ function normalizeExportFormat(format) {
     const normalized = String(format ?? 'csv').toLowerCase();
 
     if (!EXPORT_FORMATS.has(normalized)) {
-        throw new Error(`Unsupported export format: ${format}. Use csv, tsv, or md.`);
+        throw new Error(`Unsupported export format: ${format}. Use csv, tsv, md, or json.`);
     }
 
     return normalized;
@@ -152,7 +154,7 @@ function parseCliArguments(argv) {
     const options = {
         help: false,
         version: false,
-        config: false,
+        info: false,
         open: false,
         port: undefined,
         databaseList: false,
@@ -163,6 +165,8 @@ function parseCliArguments(argv) {
         tables: false,
         queries: false,
         executeQuery: null,
+        rawQuery: null,
+        storeName: null,
         showQuery: null,
         showNotes: null,
         exportTarget: null,
@@ -187,8 +191,8 @@ function parseCliArguments(argv) {
             continue;
         }
 
-        if (flag === '--config') {
-            options.config = true;
+        if (flag === '--info' || flag === '--config') {
+            options.info = true;
             continue;
         }
 
@@ -295,6 +299,20 @@ function parseCliArguments(argv) {
         }
 
         if (flag === '--query') {
+            const parsed = takeFlagValue(flag, value, argv, index);
+            options.rawQuery = parsed.value;
+            index = parsed.nextIndex;
+            continue;
+        }
+
+        if (flag === '--store') {
+            const parsed = takeFlagValue(flag, value, argv, index);
+            options.storeName = parsed.value;
+            index = parsed.nextIndex;
+            continue;
+        }
+
+        if (flag === '--saved-query') {
             const parsed = takeFlagValue(flag, value, argv, index);
             options.showQuery = parsed.value;
             index = parsed.nextIndex;
@@ -375,18 +393,20 @@ function parseCliArguments(argv) {
 function hasDatabaseOperation(options) {
     return Boolean(
         options.pathInfo ||
-            options.sizeInfo ||
-            options.lastOpenedInfo ||
-            options.tables ||
-            options.queries ||
-            options.executeQuery ||
-            options.showQuery ||
-            options.showNotes ||
-            options.documents ||
-            options.documentName ||
-            options.documentExport ||
-            options.exportTarget ||
-            options.tableName,
+        options.sizeInfo ||
+        options.lastOpenedInfo ||
+        options.tables ||
+        options.queries ||
+        options.executeQuery ||
+        options.rawQuery ||
+        options.storeName ||
+        options.showQuery ||
+        options.showNotes ||
+        options.documents ||
+        options.documentName ||
+        options.documentExport ||
+        options.exportTarget ||
+        options.tableName,
     );
 }
 
@@ -421,14 +441,6 @@ function openInDefaultBrowser(url) {
     child.unref();
 }
 
-function findDatabaseByName(connections, name) {
-    const normalizedName = String(name ?? '').toLowerCase();
-
-    return connections.find(
-        conn => conn.label.toLowerCase() === normalizedName || conn.id.toLowerCase() === normalizedName,
-    );
-}
-
 function formatSize(bytes) {
     if (!bytes) return 'N/A';
     if (bytes < 1024) return `${bytes} B`;
@@ -436,20 +448,6 @@ function formatSize(bytes) {
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-function sanitizeFilenameBase(value, fallback = 'export') {
-    const sanitized = String(value ?? '')
-        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim()
-        .replace(/[. ]+$/g, '');
-
-    if (!sanitized) {
-        return fallback;
-    }
-
-    return sanitized.slice(0, 120);
-}
-
 function createAppStateStore() {
     const { resolveAppStatePaths } = require('../server/utils/appPaths');
     const { AppStateStore } = require('../server/services/storage/appStateStore');
@@ -459,39 +457,6 @@ function createAppStateStore() {
     return new AppStateStore(appStateDbPath);
 }
 
-function createReadOnlyRuntime(conn, appStateStore) {
-    const { ConnectionManager } = require('../server/services/sqlite/connectionManager');
-    const { DataBrowserService } = require('../server/services/sqlite/dataBrowserService');
-    const { ExportService } = require('../server/services/sqlite/exportService');
-    const { SqlExecutor } = require('../server/services/sqlite/sqlExecutor');
-
-    const connectionManager = new ConnectionManager({ appStateStore });
-
-    connectionManager.openConnection({
-        filePath: conn.path,
-        label: conn.label,
-        id: conn.id,
-        logoPath: conn.logoPath ?? null,
-        makeActive: false,
-        readOnly: true,
-    });
-
-    const sqlExecutor = new SqlExecutor({ connectionManager, appStateStore });
-    const exportService = new ExportService({ appStateStore, connectionManager, sqlExecutor });
-    const dataBrowserService = new DataBrowserService({ connectionManager });
-
-    return {
-        connectionManager,
-        db: connectionManager.getActiveDatabase(),
-        dataBrowserService,
-        exportService,
-        sqlExecutor,
-        close() {
-            connectionManager.closeCurrent();
-        },
-    };
-}
-
 function printDatabaseList(connections) {
     if (connections.length === 0) {
         console.log('No databases imported yet.');
@@ -538,72 +503,8 @@ function printTables(conn, tables) {
     console.log('');
 }
 
-function getQueryTitle(item) {
-    return item?.title || item?.displayTitle || item?.previewSql || item?.rawSql || '(untitled query)';
-}
-
-function findQueryByName(appStateStore, conn, queryName) {
-    const normalizedQueryName = String(queryName ?? '').trim().toLowerCase();
-
-    if (!normalizedQueryName) {
-        throw new Error('Query name is required.');
-    }
-
-    const collection = appStateStore.buildQueryHistoryCollection({
-        databaseKey: conn.id,
-        search: queryName,
-        onlySaved: false,
-        limit: 100,
-    });
-
-    return (
-        collection.items.find(item => {
-            const candidates = [item.id, item.title, item.displayTitle].filter(Boolean);
-
-            return candidates.some(candidate => String(candidate).toLowerCase() === normalizedQueryName);
-        }) ||
-        collection.items.find(item => String(item.rawSql ?? '').toLowerCase().includes(normalizedQueryName)) ||
-        null
-    );
-}
-
-function getSavedQueries(appStateStore, conn, limit = 100) {
-    return appStateStore.buildQueryHistoryCollection({
-        databaseKey: conn.id,
-        onlySaved: true,
-        limit,
-    });
-}
-
-function printAvailableQueries(appStateStore, conn) {
-    const allQueries = getSavedQueries(appStateStore, conn);
-
-    console.error('\nAvailable saved queries:');
-
-    if (allQueries.items.length > 0) {
-        allQueries.items.forEach(query => {
-            console.error(`  - ${getQueryTitle(query)}`);
-        });
-        return;
-    }
-
-    console.error('  (none)');
-}
-
-function requireMatchingQuery(appStateStore, conn, queryName) {
-    const matchingQuery = findQueryByName(appStateStore, conn, queryName);
-
-    if (!matchingQuery) {
-        console.error(`Saved query not found: ${queryName}`);
-        printAvailableQueries(appStateStore, conn);
-        process.exit(1);
-    }
-
-    return matchingQuery;
-}
-
-function listSavedQueries(appStateStore, conn) {
-    const savedQueries = getSavedQueries(appStateStore, conn);
+function listSavedQueries(databaseService, conn) {
+    const savedQueries = databaseService.listSavedQueries(conn.id);
 
     if (savedQueries.items.length === 0) {
         console.log(`No saved queries found for ${conn.label}.`);
@@ -664,28 +565,40 @@ function printExecutionResult(result) {
     });
 }
 
-function executeSavedQuery({ appStateStore, conn, sqlExecutor, queryName }) {
-    const matchingQuery = requireMatchingQuery(appStateStore, conn, queryName);
+function executeSavedQuery({ databaseService, conn, queryName }) {
+    const { query: matchingQuery, result } = databaseService.executeSavedQuery(conn.id, queryName);
 
     console.log(`\nExecuting: ${getQueryTitle(matchingQuery)}`);
     console.log(`SQL: ${matchingQuery.previewSql || matchingQuery.rawSql}`);
     console.log('─'.repeat(60));
 
-    const result = sqlExecutor.execute(matchingQuery.rawSql, {
-        persistHistory: false,
-    });
+    printExecutionResult(result);
+}
+
+function executeRawQuery({ databaseService, conn, sql, storeName = null }) {
+    const { result, storedQuery } = databaseService.executeRawQuery(conn.id, sql, { storeName });
 
+    console.log(`\nExecuting raw SQL against: ${conn.label}`);
+    console.log('─'.repeat(60));
     printExecutionResult(result);
+
+    if (result.historyId) {
+        console.log(`\nHistory ID: ${result.historyId}`);
+    }
+
+    if (storedQuery) {
+        console.log(`Stored query: ${getQueryTitle(storedQuery)}`);
+    }
 }
 
-function showSavedQuery({ appStateStore, conn, queryName }) {
-    const matchingQuery = requireMatchingQuery(appStateStore, conn, queryName);
+function showSavedQuery({ databaseService, conn, queryName }) {
+    const matchingQuery = databaseService.getSavedQuery(conn.id, queryName);
 
     console.log(matchingQuery.rawSql);
 }
 
-function showSavedQueryNotes({ appStateStore, conn, queryName }) {
-    const matchingQuery = requireMatchingQuery(appStateStore, conn, queryName);
+function showSavedQueryNotes({ databaseService, conn, queryName }) {
+    const matchingQuery = databaseService.getSavedQuery(conn.id, queryName);
     const notes = String(matchingQuery.notes ?? '').trim();
 
     if (notes) {
@@ -696,9 +609,8 @@ function showSavedQueryNotes({ appStateStore, conn, queryName }) {
     console.log(`No notes saved for: ${getQueryTitle(matchingQuery)}`);
 }
 
-function exportSavedQuery({ appStateStore, conn, exportService, queryName, format }) {
-    const matchingQuery = requireMatchingQuery(appStateStore, conn, queryName);
-    const result = exportService.exportQuery(matchingQuery.rawSql, { format });
+function exportSavedQuery({ databaseService, conn, queryName, format }) {
+    const { query: matchingQuery, result } = databaseService.exportSavedQuery(conn.id, queryName, format);
     const outputPath = path.resolve(process.cwd(), result.filename);
 
     fs.writeFileSync(outputPath, result.content, 'utf8');
@@ -709,66 +621,8 @@ function exportSavedQuery({ appStateStore, conn, exportService, queryName, forma
     console.log(`File: ${outputPath}`);
 }
 
-function getDocumentTitle(document) {
-    return document?.filename || document?.title || document?.id || '(untitled document)';
-}
-
-function printAvailableDocuments(appStateStore, conn) {
-    const documents = appStateStore.listDatabaseDocuments(conn.id);
-
-    console.error('\nAvailable documents:');
-
-    if (documents.length > 0) {
-        documents.forEach(document => {
-            console.error(`  - ${getDocumentTitle(document)}`);
-        });
-        return;
-    }
-
-    console.error('  (none)');
-}
-
-function findDocumentByName(appStateStore, conn, documentName) {
-    const normalizedDocumentName = String(documentName ?? '').trim().toLowerCase();
-
-    if (!normalizedDocumentName) {
-        throw new Error('Document name is required.');
-    }
-
-    const documents = appStateStore.listDatabaseDocuments(conn.id);
-    const exactMatch = documents.find(document => {
-        const candidates = [document.id, document.filename, document.title].filter(Boolean);
-
-        return candidates.some(candidate => String(candidate).toLowerCase() === normalizedDocumentName);
-    });
-
-    if (exactMatch) {
-        return appStateStore.getDatabaseDocument(conn.id, exactMatch.id);
-    }
-
-    const partialMatch = documents.find(document => {
-        const candidates = [document.filename, document.title].filter(Boolean);
-
-        return candidates.some(candidate => String(candidate).toLowerCase().includes(normalizedDocumentName));
-    });
-
-    return partialMatch ? appStateStore.getDatabaseDocument(conn.id, partialMatch.id) : null;
-}
-
-function requireMatchingDocument(appStateStore, conn, documentName) {
-    const matchingDocument = findDocumentByName(appStateStore, conn, documentName);
-
-    if (!matchingDocument) {
-        console.error(`Document not found: ${documentName}`);
-        printAvailableDocuments(appStateStore, conn);
-        process.exit(1);
-    }
-
-    return matchingDocument;
-}
-
-function listDocuments(appStateStore, conn) {
-    const documents = appStateStore.listDatabaseDocuments(conn.id);
+function listDocuments(databaseService, conn) {
+    const documents = databaseService.listDocuments(conn.id);
 
     if (documents.length === 0) {
         console.log(`No documents found for ${conn.label}.`);
@@ -787,156 +641,27 @@ function listDocuments(appStateStore, conn) {
     console.log('');
 }
 
-function showDocumentMarkdown({ appStateStore, conn, documentName }) {
-    const matchingDocument = requireMatchingDocument(appStateStore, conn, documentName);
+function showDocumentMarkdown({ databaseService, conn, documentName }) {
+    const matchingDocument = databaseService.getDocument(conn.id, documentName);
 
     console.log(matchingDocument.content ?? '');
 }
 
-function normalizeMarkdownExportFilename(filename, fallback = 'document.md') {
-    let normalizedFilename = String(filename ?? '')
-        .replace(/[\u0000-\u001f\u007f]/g, ' ')
-        .replace(/[<>:"/\\|?*]+/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim()
-        .replace(/^\.+/, '')
-        .replace(/[. ]+$/g, '');
-
-    if (!normalizedFilename) {
-        normalizedFilename = fallback;
-    }
-
-    if (!/\.md$/i.test(normalizedFilename)) {
-        normalizedFilename = `${normalizedFilename}.md`;
-    }
-
-    if (normalizedFilename.length > 160) {
-        normalizedFilename = `${normalizedFilename.slice(0, 157)}.md`;
-    }
-
-    return normalizedFilename;
-}
-
-function exportDocumentMarkdown({ appStateStore, conn, documentName }) {
-    const matchingDocument = requireMatchingDocument(appStateStore, conn, documentName);
-    const filename = normalizeMarkdownExportFilename(matchingDocument.filename, `${matchingDocument.title || 'document'}.md`);
-    const outputPath = path.resolve(process.cwd(), filename);
+function exportDocumentMarkdown({ databaseService, conn, documentName }) {
+    const result = databaseService.exportDocument(conn.id, documentName);
+    const outputPath = path.resolve(process.cwd(), result.filename);
 
-    fs.writeFileSync(outputPath, matchingDocument.content ?? '', 'utf8');
+    fs.writeFileSync(outputPath, result.content, 'utf8');
 
-    console.log(`Exported document: ${matchingDocument.filename}`);
-    console.log(`Characters: ${matchingDocument.contentLength}`);
+    console.log(`Exported document: ${result.document.filename}`);
+    console.log(`Characters: ${result.document.contentLength}`);
     console.log(`File: ${outputPath}`);
 }
+function exportTableRowAsJson({ databaseService, conn, tableName, exportTarget }) {
+    const result = databaseService.getTableRow(conn.id, tableName, exportTarget);
+    const outputPath = path.resolve(process.cwd(), result.filename);
 
-function coerceIdentityValue(column, value) {
-    const text = String(value ?? '');
-    const affinity = String(column?.affinity ?? '').toUpperCase();
-
-    if ((affinity === 'INTEGER' || affinity === 'REAL' || affinity === 'NUMERIC') && text.trim() !== '') {
-        const numberValue = Number(text);
-
-        if (Number.isFinite(numberValue)) {
-            return numberValue;
-        }
-    }
-
-    return value;
-}
-
-function parseCompositePrimaryKeyValue(rawValue) {
-    try {
-        const parsed = JSON.parse(rawValue);
-
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    } catch (error) {
-        // Fall through to the clearer error below.
-    }
-
-    throw new Error('Composite primary key export requires a JSON object, for example --export:\'{"id":1,"locale":"en"}\'.');
-}
-
-function buildIdentityFromExportTarget(tableDetail, exportTarget) {
-    if (tableDetail.identityStrategy?.type === 'rowid') {
-        const numberValue = Number(exportTarget);
-        const rowid = Number.isInteger(numberValue) ? numberValue : exportTarget;
-
-        return {
-            kind: 'rowid',
-            values: {
-                rowid,
-            },
-        };
-    }
-
-    if (tableDetail.identityStrategy?.type === 'primaryKey') {
-        const columns = tableDetail.identityStrategy.columns ?? [];
-
-        if (columns.length === 1) {
-            const columnName = columns[0];
-            const column = tableDetail.columns.find(candidate => candidate.name === columnName);
-
-            return {
-                kind: 'primaryKey',
-                columns,
-                values: {
-                    [columnName]: coerceIdentityValue(column, exportTarget),
-                },
-            };
-        }
-
-        const parsed = parseCompositePrimaryKeyValue(exportTarget);
-
-        return {
-            kind: 'primaryKey',
-            columns,
-            values: Object.fromEntries(
-                columns.map(columnName => {
-                    if (!Object.prototype.hasOwnProperty.call(parsed, columnName)) {
-                        throw new Error(`Missing primary key value for ${columnName}.`);
-                    }
-
-                    const column = tableDetail.columns.find(candidate => candidate.name === columnName);
-
-                    return [columnName, coerceIdentityValue(column, parsed[columnName])];
-                }),
-            ),
-        };
-    }
-
-    throw new Error(`Table ${tableDetail.name} has no stable row identity.`);
-}
-
-function buildDataRowEditorJsonObject({ row, columns = [] } = {}) {
-    const names = columns
-        .map(column => String(typeof column === 'object' ? column?.name : column ?? '').trim())
-        .filter(name => name && name !== '__identity');
-    const sourceNames = names.length
-        ? names
-        : Object.keys(row ?? {}).filter(name => name !== '__identity');
-
-    return Object.fromEntries(
-        sourceNames
-            .map(name => [name, Object.prototype.hasOwnProperty.call(row ?? {}, name) ? row[name] : undefined])
-            .filter(([, value]) => value !== undefined),
-    );
-}
-
-function exportTableRowAsJson({ dataBrowserService, db, tableName, exportTarget }) {
-    const { getTableDetail } = require('../server/services/sqlite/introspection');
-    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
-    const identity = buildIdentityFromExportTarget(tableDetail, exportTarget);
-    const { row } = dataBrowserService.getTableRow(tableName, { identity });
-    const rowObject = buildDataRowEditorJsonObject({
-        row,
-        columns: tableDetail.columns.filter(column => column.visible),
-    });
-    const filenameBase = sanitizeFilenameBase(`${tableName}-${exportTarget}`, `${tableName}-row`);
-    const outputPath = path.resolve(process.cwd(), `${filenameBase}.json`);
-
-    fs.writeFileSync(outputPath, `${JSON.stringify(rowObject, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(outputPath, `${JSON.stringify(result.data, null, 2)}\n`, 'utf8');
 
     console.log(`Exported row: ${tableName}`);
     console.log(`Key: ${exportTarget}`);
@@ -997,28 +722,51 @@ function printTableInfo(tableDetail) {
         console.log(`Indexes: ${tableDetail.indexes.length}`);
         tableDetail.indexes.forEach(index => {
             const unique = index.unique ? ' UNIQUE' : '';
-            const columns = index.columns.map(column => column.name).filter(Boolean).join(', ') || 'expression';
+            const columns =
+                index.columns
+                    .map(column => column.name)
+                    .filter(Boolean)
+                    .join(', ') || 'expression';
             console.log(`  - ${index.name}${unique}: ${columns}`);
         });
     }
 }
 
-function printConfig(port) {
-    const Database = require('better-sqlite3');
-    const { version } = require('../package.json');
-    const db = new Database(':memory:');
+function formatVersionStatus(versionCheck) {
+    if (!versionCheck || versionCheck.status === 'unknown') {
+        return `unknown${versionCheck?.error?.message ? ` (${versionCheck.error.message})` : ''}`;
+    }
+
+    if (versionCheck.updateAvailable) {
+        return `update available (${versionCheck.currentVersion} -> ${versionCheck.latestVersion})`;
+    }
 
-    try {
-        const sqliteVersion = db.prepare('SELECT sqlite_version() AS version').get().version;
-        const url = `http://127.0.0.1:${port}`;
-
-        console.log('SQLite Hub config');
-        console.log(`Port: ${port}`);
-        console.log(`URL: ${url}`);
-        console.log(`App version: ${version}`);
-        console.log(`SQLite version: ${sqliteVersion}`);
-    } finally {
-        db.close();
+    if (versionCheck.status === 'ahead') {
+        return `ahead of npm latest (${versionCheck.currentVersion} > ${versionCheck.latestVersion})`;
+    }
+
+    return `current (${versionCheck.currentVersion})`;
+}
+
+async function printInfo(port, options = {}) {
+    const infoService = options.appInfoService ?? buildAppInfo;
+    const url = `http://127.0.0.1:${port}`;
+    const info = await infoService({ port, url });
+
+    console.log('SQLite Hub info');
+    console.log(`Port: ${info.port}`);
+    console.log(`URL: ${info.url}`);
+    console.log(`Package: ${info.packageName}`);
+    console.log(`App version: ${info.appVersion}`);
+    console.log(`SQLite version: ${info.sqliteVersion}`);
+    console.log(`Version status: ${formatVersionStatus(info.versionCheck)}`);
+
+    if (info.versionCheck?.latestVersion) {
+        console.log(`Latest version: ${info.versionCheck.latestVersion}`);
+    }
+
+    if (info.versionCheck?.releaseUrl) {
+        console.log(`Release URL: ${info.versionCheck.releaseUrl}`);
     }
 }
 
@@ -1049,8 +797,8 @@ function requireDatabaseName(options) {
     return options.databaseName;
 }
 
-async function main() {
-    const options = parseCliArguments(process.argv.slice(2));
+async function main(argv = process.argv.slice(2), dependencies = {}) {
+    const options = parseCliArguments(argv);
     const port = options.port ?? DEFAULT_PORT;
 
     if (options.help) {
@@ -1064,8 +812,8 @@ async function main() {
         return;
     }
 
-    if (options.config) {
-        printConfig(port);
+    if (options.info) {
+        await printInfo(port, dependencies);
         return;
     }
 
@@ -1074,8 +822,16 @@ async function main() {
         return;
     }
 
-    const appStateStore = createAppStateStore();
-    const connections = appStateStore.getRecentConnections();
+    if (options.storeName && !options.rawQuery) {
+        throw new Error('--store requires --query:"sql".');
+    }
+
+    const databaseService =
+        dependencies.databaseService ??
+        new DatabaseCommandService({
+            appStateStore: dependencies.appStateStore ?? createAppStateStore(),
+        });
+    const connections = databaseService.listDatabases();
 
     if (options.databaseList && !options.databaseName && !hasDatabaseOperation(options)) {
         printDatabaseList(connections);
@@ -1084,24 +840,19 @@ async function main() {
 
     if (options.databaseName || hasDatabaseOperation(options)) {
         const dbName = requireDatabaseName(options);
-        const conn = findDatabaseByName(connections, dbName);
-
-        if (!conn) {
-            console.error(`Database not found: ${dbName}`);
-            process.exit(1);
-        }
+        const conn = databaseService.getDatabase(dbName);
 
         if (options.documents) {
             if (options.documentName) {
                 if (options.documentExport) {
                     exportDocumentMarkdown({
-                        appStateStore,
+                        databaseService,
                         conn,
                         documentName: options.documentName,
                     });
                 } else {
                     showDocumentMarkdown({
-                        appStateStore,
+                        databaseService,
                         conn,
                         documentName: options.documentName,
                     });
@@ -1109,73 +860,82 @@ async function main() {
                 return;
             }
 
-            listDocuments(appStateStore, conn);
+            listDocuments(databaseService, conn);
             return;
         }
 
-        if (options.tableName || options.tables || options.queries || options.executeQuery || options.showQuery || options.showNotes || options.exportTarget) {
-            const runtime = createReadOnlyRuntime(conn, appStateStore);
-
-            try {
-                if (options.tableName) {
-                    const { getTableDetail } = require('../server/services/sqlite/introspection');
-
-                    if (options.exportTarget) {
-                        exportTableRowAsJson({
-                            dataBrowserService: runtime.dataBrowserService,
-                            db: runtime.db,
-                            tableName: options.tableName,
-                            exportTarget: options.exportTarget,
-                        });
-                    } else {
-                        printTableInfo(getTableDetail(runtime.db, options.tableName));
-                    }
-
-                    return;
-                }
-
+        if (
+            options.tableName ||
+            options.tables ||
+            options.queries ||
+            options.executeQuery ||
+            options.rawQuery ||
+            options.showQuery ||
+            options.showNotes ||
+            options.exportTarget
+        ) {
+            if (options.tableName) {
                 if (options.exportTarget) {
-                    exportSavedQuery({
-                        appStateStore,
+                    exportTableRowAsJson({
+                        databaseService,
                         conn,
-                        exportService: runtime.exportService,
-                        queryName: options.exportTarget,
-                        format: options.exportFormat,
+                        tableName: options.tableName,
+                        exportTarget: options.exportTarget,
                     });
-                    return;
+                } else {
+                    printTableInfo(databaseService.getTable(conn.id, options.tableName));
                 }
 
-                if (options.executeQuery) {
-                    executeSavedQuery({
-                        appStateStore,
-                        conn,
-                        sqlExecutor: runtime.sqlExecutor,
-                        queryName: options.executeQuery,
-                    });
-                    return;
-                }
+                return;
+            }
 
-                if (options.showQuery) {
-                    showSavedQuery({ appStateStore, conn, queryName: options.showQuery });
-                    return;
-                }
+            if (options.exportTarget) {
+                exportSavedQuery({
+                    databaseService,
+                    conn,
+                    queryName: options.exportTarget,
+                    format: options.exportFormat,
+                });
+                return;
+            }
 
-                if (options.showNotes) {
-                    showSavedQueryNotes({ appStateStore, conn, queryName: options.showNotes });
-                    return;
-                }
+            if (options.executeQuery) {
+                executeSavedQuery({
+                    databaseService,
+                    conn,
+                    queryName: options.executeQuery,
+                });
+                return;
+            }
 
-                if (options.queries) {
-                    listSavedQueries(appStateStore, conn);
-                    return;
-                }
+            if (options.rawQuery) {
+                executeRawQuery({
+                    databaseService,
+                    conn,
+                    sql: options.rawQuery,
+                    storeName: options.storeName,
+                });
+                return;
+            }
 
-                if (options.tables) {
-                    printTables(conn, runtime.dataBrowserService.listTables());
-                    return;
-                }
-            } finally {
-                runtime.close();
+            if (options.showQuery) {
+                showSavedQuery({ databaseService, conn, queryName: options.showQuery });
+                return;
+            }
+
+            if (options.showNotes) {
+                showSavedQueryNotes({ databaseService, conn, queryName: options.showNotes });
+                return;
+            }
+
+            if (options.queries) {
+                listSavedQueries(databaseService, conn);
+                return;
+            }
+
+            if (options.tables) {
+                printTables(conn, databaseService.listTables(conn.id));
+                return;
             }
         }
 
@@ -1215,7 +975,9 @@ if (require.main === module) {
 
 module.exports = {
     main,
+    formatVersionStatus,
     normalizeExportFormat,
     openInDefaultBrowser,
     parseCliArguments,
+    printInfo,
 };