@dbx-app/cli 0.4.34 → 0.4.37

package/README.md

@@ -17,7 +17,31 @@ brew tap t8y2/dbx
 brew install dbx-cli
 ```
 
-Requires Node.js 22.13.0 or newer.
+The npm package installs the native CLI for the current platform automatically. Node.js 18.18.0 or newer is only needed for the npm launcher; direct native distributions do not require Node.js.
+
+### Native downloads
+
+The `packages-v*` GitHub Release also provides standalone native CLI archives:
+
+| Platform | Archive |
+| --- | --- |
+| macOS Apple Silicon | `dbx-cli-darwin-arm64.tar.gz` |
+| macOS Intel | `dbx-cli-darwin-x64.tar.gz` |
+| Linux glibc ARM64 | `dbx-cli-linux-arm64-gnu.tar.gz` |
+| Linux glibc x64 | `dbx-cli-linux-x64-gnu.tar.gz` |
+| Windows ARM64 | `dbx-cli-win32-arm64.zip` |
+| Windows x64 | `dbx-cli-win32-x64.zip` |
+
+Verify the downloaded archive with `CLI-SHA256SUMS`, extract it, and run the native binary directly:
+
+```bash
+tar -xzf dbx-cli-linux-x64-gnu.tar.gz
+chmod +x dbx
+./dbx --version
+./dbx connections list --json
+```
+
+Standalone binaries do not require Node.js. They read the same DBX connection storage as the desktop application; set `DBX_DATA_DIR` when using a custom or portable data directory.
 
 ## Usage
 
@@ -90,23 +114,19 @@ Some CLI commands can run without DBX Desktop:
 - `query`
 - `context`
 
-Direct execution currently supports PostgreSQL/Redshift, MySQL-compatible databases (MySQL, Doris, StarRocks), and SQLite. Other database types use the DBX Desktop bridge until their drivers are added to `@dbx-app/node-core`.
+Direct execution supports PostgreSQL/Redshift, MySQL-compatible databases (MySQL, Doris, StarRocks), and SQLite. Other database types use the DBX Desktop bridge or DBX Agent/JDBC infrastructure.
 
 Use `dbx doctor` to check whether the DBX connection database, connection table, native SQLite loader, and desktop bridge are available. Use `dbx capabilities` to list direct-query and bridge-required database types.
 
-If `dbx doctor` reports a `NODE_MODULE_VERSION` mismatch after switching Node.js versions, rebuild the native dependencies with the Node.js version you use to run `dbx`:
-
-```bash
-pnpm rebuild better-sqlite3 keytar --pending
-```
-
-For global npm installs, reinstall the CLI with the same Node.js version:
+If the optional platform package was not installed, reinstall without `--no-optional`:
 
 ```bash
 npm uninstall -g @dbx-app/cli
 npm install -g @dbx-app/cli
 ```
 
+The native CLI does not require `better-sqlite3` and is not coupled to the Node.js ABI.
+
 ## Error Codes
 
 CLI JSON errors use stable codes:

package/bin/dbx.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const platformPackages = {
+  "darwin-arm64": "@dbx-app/cli-darwin-arm64",
+  "darwin-x64": "@dbx-app/cli-darwin-x64",
+  "linux-arm64": "@dbx-app/cli-linux-arm64-gnu",
+  "linux-x64": "@dbx-app/cli-linux-x64-gnu",
+  "win32-arm64": "@dbx-app/cli-win32-arm64",
+  "win32-x64": "@dbx-app/cli-win32-x64",
+};
+
+const platformKey = `${process.platform}-${process.arch}`;
+const packageName = platformPackages[platformKey];
+if (!packageName) {
+  console.error(`Unsupported platform: ${platformKey}`);
+  process.exit(1);
+}
+
+let binary;
+try {
+  const packageJson = require.resolve(`${packageName}/package.json`);
+  binary = join(dirname(packageJson), "bin", process.platform === "win32" ? "dbx.exe" : "dbx");
+} catch {
+  console.error(`The optional package ${packageName} was not installed. Reinstall @dbx-app/cli without --no-optional.`);
+  process.exit(1);
+}
+
+if (!existsSync(binary)) {
+  console.error(`DBX CLI binary was not found at ${binary}`);
+  process.exit(1);
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit", env: process.env });
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbx-app/cli",
-  "version": "0.4.34",
+  "version": "0.4.37",
   "description": "Command line interface for DBX database connections, schema, and safe queries",
   "keywords": [
     "ai-agent",
@@ -21,26 +21,26 @@
     "directory": "packages/cli"
   },
   "bin": {
-    "dbx": "dist/cli.js"
+    "dbx": "bin/dbx.js"
   },
   "files": [
-    "dist"
+    "bin"
   ],
   "type": "module",
-  "dependencies": {
-    "@dbx-app/node-core": "^0.4.34"
-  },
-  "devDependencies": {
-    "@types/node": "^22.15.21",
-    "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+  "optionalDependencies": {
+    "@dbx-app/cli-darwin-arm64": "0.4.37",
+    "@dbx-app/cli-darwin-x64": "0.4.37",
+    "@dbx-app/cli-linux-arm64-gnu": "0.4.37",
+    "@dbx-app/cli-linux-x64-gnu": "0.4.37",
+    "@dbx-app/cli-win32-arm64": "0.4.37",
+    "@dbx-app/cli-win32-x64": "0.4.37"
   },
   "engines": {
-    "node": ">=22.13.0"
+    "node": ">=18.18.0"
   },
   "scripts": {
-    "start": "tsx src/cli.ts",
-    "test": "pnpm --filter @dbx-app/node-core build && vitest run --config vitest.config.ts",
-    "build": "pnpm --filter @dbx-app/node-core build && tsc"
+    "start": "cargo run -p dbx-cli --no-default-features --",
+    "test": "cargo test -p dbx-cli --no-default-features",
+    "build": "cargo build -p dbx-cli --release --no-default-features"
   }
 }

package/dist/cli-format.d.ts

@@ -1,20 +0,0 @@
-import { formatCell, mdTable, type ConnectionConfig } from "@dbx-app/node-core";
-export { formatCell, mdTable };
-export interface ConnectionSummary {
-    name: string;
-    type: string;
-    host: string;
-    port: number;
-    database?: string;
-}
-export declare function connectionSummary(connection: ConnectionConfig): ConnectionSummary;
-export interface ErrorPayload {
-    error: {
-        code: string;
-        message: string;
-        hint?: string;
-    };
-}
-export declare function errorPayload(code: string, message: string): ErrorPayload;
-export declare function formatErrorMessage(code: string, message: string): string;
-export declare function csvTable<T extends object>(headers: string[], rows: T[]): string;

package/dist/cli-format.js

@@ -1,41 +0,0 @@
-import { formatCell, mdTable } from "@dbx-app/node-core";
-export { formatCell, mdTable };
-export function connectionSummary(connection) {
-    return {
-        name: connection.name,
-        type: connection.db_type,
-        host: connection.host,
-        port: connection.port,
-        database: connection.database || undefined,
-    };
-}
-export function errorPayload(code, message) {
-    const hint = errorHint(code, message);
-    return { error: hint ? { code, message, hint } : { code, message } };
-}
-export function formatErrorMessage(code, message) {
-    const hint = errorHint(code, message);
-    return hint ? `${message}\n\nHint: ${hint}` : message;
-}
-function errorHint(code, message) {
-    if (code === "CONNECTION_STORE_ERROR" && /NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(message)) {
-        return "Rebuild DBX CLI native dependencies with your active Node.js: pnpm rebuild better-sqlite3 keytar --pending, or reinstall the package with the same Node.js version you use to run dbx.";
-    }
-    return undefined;
-}
-export function csvTable(headers, rows) {
-    const lines = [headers.map(csvCell).join(",")];
-    for (const row of rows) {
-        const values = row;
-        lines.push(headers.map((header) => csvCell(values[header])).join(","));
-    }
-    return `${lines.join("\n")}\n`;
-}
-function csvCell(value) {
-    if (value === null || value === undefined)
-        return "";
-    const text = typeof value === "object" ? JSON.stringify(value) : String(value);
-    if (/[",\r\n]/.test(text))
-        return `"${text.replace(/"/g, '""')}"`;
-    return text;
-}

package/dist/cli.d.ts

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-import { type Backend, type DbxDiagnostics } from "@dbx-app/node-core";
-export interface CliResult {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-}
-interface RunOptions {
-    backend?: Backend;
-    backendFactory?: (env?: NodeJS.ProcessEnv) => Promise<Backend>;
-    env?: NodeJS.ProcessEnv;
-    diagnostics?: () => Promise<DbxDiagnostics>;
-}
-export declare function runCli(argv: string[], options?: RunOptions): Promise<CliResult>;
-export {};

package/dist/cli.js

@@ -1,352 +0,0 @@
-#!/usr/bin/env node
-import { readFile } from "node:fs/promises";
-import { buildSchemaContext, createBackend, DIRECT_QUERY_TYPES, BRIDGE_REQUIRED_TYPES, evaluateSqlSafety, formatSchemaContext, getDbxDiagnostics, isMainModule, postBridge, supportsHashLineComments } from "@dbx-app/node-core";
-import { connectionSummary, csvTable, errorPayload, formatCell, formatErrorMessage, mdTable } from "./cli-format.js";
-class CliError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-}
-export async function runCli(argv, options = {}) {
-    const env = options.env ?? process.env;
-    let ownedBackend;
-    try {
-        const flags = parseFlags(argv);
-        const args = flags.args;
-        if (flags.version) {
-            return ok(`${await packageVersion()}\n`);
-        }
-        if (args.length === 0 || flags.help || args[0] === "help") {
-            return ok(`${usage()}\n`);
-        }
-        const backendFactory = options.backendFactory ?? createBackend;
-        const backend = options.backend ?? (ownedBackend = await backendFactory(env));
-        if (args[0] === "doctor") {
-            ensureArgCount(args, 1, "dbx doctor");
-            const diagnostics = await (options.diagnostics ?? getDbxDiagnostics)();
-            if (flags.format === "json")
-                return okJson(diagnostics);
-            if (flags.format === "csv") {
-                return ok(csvTable(["check", "value"], [
-                    { check: "appDataDir", value: diagnostics.appDataDir },
-                    { check: "dbPath", value: diagnostics.dbPath },
-                    { check: "dbPathExists", value: diagnostics.dbPathExists },
-                    { check: "connectionsTableExists", value: diagnostics.connectionsTableExists },
-                    { check: "connectionRowCount", value: diagnostics.connectionRowCount },
-                    { check: "loadConnectionsOk", value: diagnostics.loadConnectionsOk },
-                    { check: "loadedConnectionCount", value: diagnostics.loadedConnectionCount },
-                    { check: "loadConnectionsError", value: diagnostics.loadConnectionsError ?? "" },
-                    { check: "loadConnectionsHint", value: diagnostics.loadConnectionsHint ?? "" },
-                    { check: "bridgePortFile", value: diagnostics.bridgePortFile },
-                    { check: "bridgePortFileExists", value: diagnostics.bridgePortFileExists },
-                    { check: "bridgeUrl", value: diagnostics.bridgeUrl ?? "" },
-                ]));
-            }
-            return ok(formatDoctor(diagnostics));
-        }
-        if (args[0] === "capabilities") {
-            ensureArgCount(args, 1, "dbx capabilities");
-            const payload = {
-                directQueryTypes: [...DIRECT_QUERY_TYPES],
-                bridgeRequiredTypes: [...BRIDGE_REQUIRED_TYPES],
-            };
-            if (flags.format === "json")
-                return okJson(payload);
-            if (flags.format === "csv") {
-                return ok(csvTable(["mode", "type"], [...payload.directQueryTypes.map((type) => ({ mode: "direct", type })), ...payload.bridgeRequiredTypes.map((type) => ({ mode: "bridge", type }))]));
-            }
-            return ok(`${mdTable(["Mode", "Types"], [
-                ["Direct", payload.directQueryTypes.join(", ")],
-                ["Requires DBX Desktop", payload.bridgeRequiredTypes.join(", ")],
-            ])}\n`);
-        }
-        if (args[0] === "connections" && args[1] === "list") {
-            ensureArgCount(args, 2, "dbx connections list");
-            const connections = (await backend.loadConnections()).map(connectionSummary);
-            if (flags.format === "json")
-                return okJson({ connections });
-            if (flags.format === "csv")
-                return ok(csvTable(["name", "type", "host", "port", "database"], connections));
-            return ok(`${mdTable(["Name", "Type", "Host", "Port", "Database"], connections.map((c) => [c.name, c.type, c.host, String(c.port), c.database ?? ""]))}\n`);
-        }
-        if (args[0] === "schema" && args[1] === "list") {
-            ensureArgCount(args, 3, "dbx schema list");
-            const connectionName = required(args[2], "Connection name is required.");
-            const config = await findConnectionOrThrow(backend, connectionName);
-            const tables = await backend.listTables(config, flags.schema);
-            if (flags.format === "json")
-                return okJson({ connection: connectionName, schema: flags.schema, tables });
-            if (flags.format === "csv")
-                return ok(csvTable(["name", "type"], tables));
-            return ok(`${mdTable(["Table", "Type"], tables.map((t) => [t.name, t.type]))}\n`);
-        }
-        if (args[0] === "schema" && args[1] === "describe") {
-            ensureArgCount(args, 4, "dbx schema describe");
-            const connectionName = required(args[2], "Connection name is required.");
-            const table = required(args[3], "Table name is required.");
-            const config = await findConnectionOrThrow(backend, connectionName);
-            const columns = await backend.describeTable(config, table, flags.schema);
-            if (flags.format === "json")
-                return okJson({ connection: connectionName, schema: flags.schema, table, columns });
-            if (flags.format === "csv") {
-                return ok(csvTable(["name", "data_type", "is_nullable", "is_primary_key", "column_default", "comment"], columns));
-            }
-            return ok(`${mdTable(["Column", "Type", "Nullable", "Default", "Comment"], columns.map((c) => [c.is_primary_key ? `${c.name} (PK)` : c.name, c.data_type, c.is_nullable ? "YES" : "NO", c.column_default ?? "", c.comment ?? ""]))}\n`);
-        }
-        if (args[0] === "query") {
-            const usesDefaultConnection = !!env.DBX_CONNECTION && args.length === (flags.file ? 1 : 2);
-            ensureArgCount(args, usesDefaultConnection ? (flags.file ? 1 : 2) : flags.file ? 2 : 3, "dbx query");
-            const connectionName = usesDefaultConnection ? env.DBX_CONNECTION : required(args[1], "Connection name is required.");
-            if (flags.file && args[2]) {
-                throw new CliError("INVALID_ARGUMENT", "Provide SQL either inline or with --file, not both.");
-            }
-            const sqlArg = usesDefaultConnection ? args[1] : args[2];
-            const sql = flags.file ? await readFile(flags.file, "utf-8") : required(sqlArg, "SQL string or --file is required.");
-            const config = await findConnectionOrThrow(backend, connectionName);
-            const envSafety = sqlSafetyFromCliEnv(env);
-            if (flags.allowDangerous && !flags.allowWrites && !envSafety.allowWrites) {
-                throw new CliError("INVALID_OPTION", "--allow-dangerous-sql requires --allow-writes.");
-            }
-            const safetyOptions = {
-                allowWrites: flags.allowWrites || envSafety.allowWrites,
-                allowDangerous: flags.allowDangerous || envSafety.allowDangerous,
-                hashLineComments: supportsHashLineComments(config.db_type),
-            };
-            const safety = evaluateSqlSafety(sql, safetyOptions);
-            if (!safety.allowed)
-                return fail("SQL_BLOCKED", safety.reason ?? "SQL blocked.", flags.json);
-            const result = await backend.executeQuery(config, sql, { maxRows: flags.maxRows, timeoutMs: flags.timeoutMs });
-            if (flags.format === "json") {
-                return okJson({ connection: connectionName, columns: result.columns, rows: result.rows, row_count: result.row_count });
-            }
-            if (flags.format === "csv")
-                return ok(csvTable(result.columns, result.rows));
-            if (result.columns.length === 0)
-                return ok(`Query executed. ${result.row_count} row(s) affected.\n`);
-            return ok(`${mdTable(result.columns, result.rows.map((row) => result.columns.map((column) => formatCell(row[column]))))}\n\n${result.row_count} row(s)\n`);
-        }
-        if (args[0] === "context") {
-            const usesDefaultConnection = !!env.DBX_CONNECTION && args.length === 1;
-            ensureArgCount(args, usesDefaultConnection ? 1 : 2, "dbx context");
-            const connectionName = usesDefaultConnection ? env.DBX_CONNECTION : required(args[1], "Connection name is required.");
-            const config = await findConnectionOrThrow(backend, connectionName);
-            const context = await buildSchemaContext(backend, config, {
-                schema: flags.schema,
-                tables: flags.tables,
-                maxTables: flags.maxTables,
-            });
-            if (flags.format === "json")
-                return okJson(context);
-            if (flags.format === "csv")
-                throw new CliError("INVALID_OPTION", "CSV format is not supported for dbx context.");
-            return ok(`${formatSchemaContext(context)}\n`);
-        }
-        if (args[0] === "open") {
-            ensureArgCount(args, 3, "dbx open");
-            const connectionName = required(args[1], "Connection name is required.");
-            const table = required(args[2], "Table name is required.");
-            const response = await postBridge("/open-table", {
-                connection_name: connectionName,
-                table,
-                schema: flags.schema,
-                database: flags.database,
-            });
-            if (!response.ok) {
-                return fail("DBX_NOT_RUNNING", response.text || "DBX is not running. Please start DBX first.", flags.json);
-            }
-            if (flags.format === "json")
-                return okJson({ opened: true, connection: connectionName, table, schema: flags.schema, database: flags.database });
-            if (flags.format === "csv")
-                throw new CliError("INVALID_OPTION", "CSV format is not supported for dbx open.");
-            return ok(`Opened ${table} in DBX\n`);
-        }
-        return fail("USAGE", usage(), flags.json);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const code = error instanceof CliError ? error.code : typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "ERROR";
-        const wantsJson = argv.includes("--json");
-        return fail(code, message, wantsJson);
-    }
-    finally {
-        await ownedBackend?.close?.().catch(() => { });
-    }
-}
-function parseFlags(argv) {
-    const args = [];
-    const flags = {
-        args,
-        json: false,
-        format: "table",
-        allowWrites: false,
-        allowDangerous: false,
-        help: false,
-        version: false,
-    };
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (arg === "--") {
-            args.push(...argv.slice(i + 1));
-            break;
-        }
-        if (arg === "--json") {
-            flags.json = true;
-            flags.format = "json";
-        }
-        else if (arg === "--format")
-            flags.format = parseFormat(readOptionValue(argv, ++i, "--format"));
-        else if (arg === "--help" || arg === "-h")
-            flags.help = true;
-        else if (arg === "--version" || arg === "-V")
-            flags.version = true;
-        else if (arg === "--schema")
-            flags.schema = readOptionValue(argv, ++i, "--schema");
-        else if (arg === "--database")
-            flags.database = readOptionValue(argv, ++i, "--database");
-        else if (arg === "--tables")
-            flags.tables = splitCsv(readOptionValue(argv, ++i, "--tables"));
-        else if (arg === "--max-tables")
-            flags.maxTables = parsePositiveInt(readOptionValue(argv, ++i, "--max-tables"), "--max-tables");
-        else if (arg === "--limit")
-            flags.maxRows = parsePositiveInt(readOptionValue(argv, ++i, "--limit"), "--limit");
-        else if (arg === "--timeout")
-            flags.timeoutMs = parseDurationMs(readOptionValue(argv, ++i, "--timeout"), "--timeout");
-        else if (arg === "--file")
-            flags.file = readOptionValue(argv, ++i, "--file");
-        else if (arg === "--allow-writes")
-            flags.allowWrites = true;
-        else if (arg === "--allow-dangerous-sql")
-            flags.allowDangerous = true;
-        else if (arg.startsWith("-"))
-            throw new CliError("UNKNOWN_OPTION", `Unknown option: ${arg}`);
-        else
-            args.push(arg);
-    }
-    return flags;
-}
-function parseFormat(value) {
-    if (value === "table" || value === "json" || value === "csv")
-        return value;
-    throw new CliError("INVALID_OPTION", "--format must be one of: table, json, csv.");
-}
-function ensureArgCount(args, count, command) {
-    if (args.length !== count) {
-        throw new CliError("INVALID_ARGUMENT", `${command} expects ${count - 1} argument(s); received ${args.length - 1}.`);
-    }
-}
-function readOptionValue(argv, index, option) {
-    const value = argv[index];
-    if (!value || value.startsWith("-")) {
-        throw new CliError("INVALID_OPTION", `${option} requires a value.`);
-    }
-    return value;
-}
-function parsePositiveInt(value, option) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < 1) {
-        throw new CliError("INVALID_OPTION", `${option} must be a positive integer.`);
-    }
-    return parsed;
-}
-function parseDurationMs(value, option) {
-    const match = value.match(/^(\d+)(ms|s|m)?$/);
-    if (!match) {
-        throw new CliError("INVALID_OPTION", `${option} must be a positive duration such as 500ms, 10s, or 1m.`);
-    }
-    const amount = Number(match[1]);
-    if (!Number.isInteger(amount) || amount < 1) {
-        throw new CliError("INVALID_OPTION", `${option} must be a positive duration such as 500ms, 10s, or 1m.`);
-    }
-    const unit = match[2] ?? "ms";
-    if (unit === "ms")
-        return amount;
-    if (unit === "s")
-        return amount * 1000;
-    return amount * 60_000;
-}
-function parseBooleanEnv(value) {
-    if (value === undefined)
-        return false;
-    const normalized = value.trim().toLowerCase();
-    return normalized === "1" || normalized === "true";
-}
-function sqlSafetyFromCliEnv(env) {
-    return {
-        allowWrites: parseBooleanEnv(env.DBX_MCP_ALLOW_WRITES),
-        allowDangerous: parseBooleanEnv(env.DBX_MCP_ALLOW_DANGEROUS_SQL),
-    };
-}
-function splitCsv(value) {
-    return (value ?? "")
-        .split(",")
-        .map((part) => part.trim())
-        .filter(Boolean);
-}
-async function findConnectionOrThrow(backend, name) {
-    const config = await backend.findConnection(name);
-    if (!config)
-        throw new CliError("CONNECTION_NOT_FOUND", `Connection "${name}" not found.`);
-    return config;
-}
-function required(value, message) {
-    if (!value)
-        throw new Error(message);
-    return value;
-}
-function ok(stdout) {
-    return { exitCode: 0, stdout, stderr: "" };
-}
-function okJson(payload) {
-    return ok(`${JSON.stringify(payload, null, 2)}\n`);
-}
-function fail(code, message, json) {
-    const text = json ? `${JSON.stringify(errorPayload(code, message), null, 2)}\n` : `${formatErrorMessage(code, message)}\n`;
-    return { exitCode: 1, stdout: "", stderr: text };
-}
-function usage() {
-    return [
-        "Usage:",
-        "  dbx doctor [--json]",
-        "  dbx capabilities [--json]",
-        "  dbx connections list [--json]",
-        "  dbx schema list <connection> [--schema name] [--json]",
-        "  dbx schema describe <connection> <table> [--schema name] [--json]",
-        "  dbx query <connection> <sql> [--file path] [--limit n] [--timeout 10s] [--allow-writes] [--allow-dangerous-sql] [--json]",
-        "  dbx context <connection> [--schema name] [--tables a,b] [--max-tables n] [--json]",
-        "  dbx open <connection> <table> [--schema name] [--database name] [--json]",
-    ].join("\n");
-}
-function formatDoctor(diagnostics) {
-    const rows = [
-        ["App data directory", diagnostics.appDataDir],
-        ["DBX database", diagnostics.dbPathExists ? `found (${diagnostics.dbPath})` : `missing (${diagnostics.dbPath})`],
-        ["Connections table", diagnostics.connectionsTableExists ? `${diagnostics.connectionRowCount} row(s)` : "missing"],
-        ["Connection loading", diagnostics.loadConnectionsOk ? `ok (${diagnostics.loadedConnectionCount} loaded)` : `failed (${diagnostics.loadConnectionsError ?? "unknown error"})`],
-        ...(diagnostics.loadConnectionsHint ? [["Connection fix", diagnostics.loadConnectionsHint]] : []),
-        ["Desktop bridge", diagnostics.bridgePortFileExists ? `available (${diagnostics.bridgeUrl ?? diagnostics.bridgePortFile})` : "not running"],
-        ["Direct query types", diagnostics.directQueryTypes.join(", ")],
-        ["Bridge-required types", diagnostics.bridgeRequiredTypes.join(", ")],
-    ];
-    return `${mdTable(["Check", "Value"], rows)}\n`;
-}
-async function packageVersion() {
-    const packageJson = await readFile(new URL("../package.json", import.meta.url), "utf-8");
-    const parsed = JSON.parse(packageJson);
-    return parsed.version ?? "0.0.0";
-}
-async function main() {
-    const result = await runCli(process.argv.slice(2));
-    if (result.stdout)
-        process.stdout.write(result.stdout);
-    if (result.stderr)
-        process.stderr.write(result.stderr);
-    process.exitCode = result.exitCode;
-}
-if (isMainModule(import.meta.url, process.argv[1])) {
-    main().catch((error) => {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exitCode = 1;
-    });
-}