25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import { execFileSync } from "node:child_process";
import { randomBytes, X509Certificate } from "node:crypto";
import { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
import { homedir } from "node:os";
import path from "node:path";
export const developmentIdentifier = "com.dbx.app.development";
export function signingDirectory() {
return path.join(homedir(), "Library", "Application Support", "DBX", "development-signing");
}
function command(executable, args, options = {}) {
try {
return execFileSync(executable, args, {
encoding: "utf8",
stdio: ["ignore", "pipe", "pipe"],
...options,
});
} catch (error) {
throw new Error(`Development signing: ${path.basename(executable)} ${args[0]} failed (${error.status ?? error.code}).`);
}
}
function privatePath(file, directory = false) {
const metadata = lstatSync(file);
if (metadata.isSymbolicLink() || (directory ? !metadata.isDirectory() : !metadata.isFile()) || metadata.uid !== process.getuid()) {
throw new Error(`Development signing refuses an unsafe path: ${file}`);
}
chmodSync(file, directory ? 0o700 : 0o600);
}
function keychainSearchList() {
const output = command("/usr/bin/security", ["list-keychains", "-d", "user"]);
return [...output.matchAll(/"([^"\n]+)"/g)].map((match) => match[1]);
}
function canonicalKeychain(keychain) {
return existsSync(keychain) ? realpathSync.native(keychain) : keychain;
}
function includeKeychain(keychain) {
const canonical = canonicalKeychain(keychain);
const keychains = keychainSearchList();
const updated = [...keychains.filter((entry) => canonicalKeychain(entry) !== canonical), canonical];
if (JSON.stringify(updated) !== JSON.stringify(keychains)) {
command("/usr/bin/security", ["list-keychains", "-d", "user", "-s", ...updated]);
}
}
export function removeSigningKeychain(keychain) {
const canonical = canonicalKeychain(keychain);
const keychains = keychainSearchList();
const updated = keychains.filter((entry) => canonicalKeychain(entry) !== canonical);
if (updated.length !== keychains.length) {
command("/usr/bin/security", ["list-keychains", "-d", "user", "-s", ...updated]);
}
command("/usr/bin/security", ["delete-keychain", canonical]);
}
export function designatedRequirement(fingerprint) {
if (!/^[A-F0-9]{40}$/.test(fingerprint)) {
throw new Error("Invalid development certificate fingerprint.");
}
return `identifier "${developmentIdentifier}" and certificate leaf = H"${fingerprint}"`;
}
export function loadSigningIdentity(directory = signingDirectory()) {
privatePath(directory, true);
directory = realpathSync.native(directory);
const configPath = path.join(directory, "identity.json");
const certificatePath = path.join(directory, "certificate.pem");
const keychain = path.join(directory, "development.keychain-db");
for (const file of [configPath, certificatePath, keychain]) privatePath(file);
let identity;
try {
identity = JSON.parse(readFileSync(configPath, "utf8"));
} catch {
throw new Error("Invalid development signing configuration; the existing identity was preserved.");
}
if (identity?.version !== 1 || !/^[a-f0-9]{64}$/.test(identity.password)) {
throw new Error("Invalid development signing configuration; do not delete or regenerate an existing identity automatically.");
}
designatedRequirement(identity.fingerprint);
const certificate = new X509Certificate(readFileSync(certificatePath));
if (certificate.fingerprint.replaceAll(":", "") !== identity.fingerprint || Date.parse(certificate.validTo) <= Date.now()) {
throw new Error("The development certificate is mismatched or expired; replace it explicitly and authorize the new identity once.");
}
return { ...identity, keychain };
}
export function ensureSigningIdentity(directory = signingDirectory()) {
mkdirSync(directory, { recursive: true, mode: 0o700 });
privatePath(directory, true);
directory = realpathSync.native(directory);
const configPath = path.join(directory, "identity.json");
if (existsSync(configPath)) return loadSigningIdentity(directory);
const lockPath = path.join(directory, "setup.lock");
let lock;
try {
lock = openSync(lockPath, "wx", 0o600);
} catch {
throw new Error(`Development signing setup is already running or was interrupted. Check ${lockPath} before retrying.`);
}
const keychain = path.join(directory, "development.keychain-db");
let temporary;
let createdKeychain = false;
try {
if (existsSync(configPath)) return loadSigningIdentity(directory);
if (existsSync(keychain) || existsSync(path.join(directory, "certificate.pem"))) {
throw new Error(`Incomplete development signing setup in ${directory}; refusing to replace an existing identity.`);
}
temporary = mkdtempSync(path.join(directory, "setup-"));
const password = randomBytes(32).toString("hex");
const config = path.join(temporary, "openssl.cnf");
const privateKey = path.join(temporary, "private.pem");
const certificatePath = path.join(temporary, "certificate.pem");
const bundle = path.join(temporary, "identity.p12");
writeFileSync(config, ["[req]", "prompt=no", "distinguished_name=subject", "x509_extensions=extensions", "[subject]", "CN=DBX Local Development", "[extensions]", "basicConstraints=critical,CA:FALSE", "keyUsage=critical,digitalSignature", "extendedKeyUsage=critical,codeSigning", ""].join("\n"), {
mode: 0o600,
flag: "wx",
});
command("/usr/bin/openssl", ["req", "-x509", "-newkey", "rsa:3072", "-nodes", "-sha256", "-days", "3650", "-config", config, "-keyout", privateKey, "-out", certificatePath]);
command("/usr/bin/openssl", ["pkcs12", "-export", "-inkey", privateKey, "-in", certificatePath, "-out", bundle, "-passout", "env:DBX_DEV_SIGNING_PASSWORD"], {
env: { ...process.env, DBX_DEV_SIGNING_PASSWORD: password },
});
command("/usr/bin/security", ["create-keychain", "-p", password, keychain]);
createdKeychain = true;
command("/usr/bin/security", ["set-keychain-settings", "-lut", "21600", keychain]);
command("/usr/bin/security", ["unlock-keychain", "-p", password, keychain]);
command("/usr/bin/security", ["import", bundle, "-k", keychain, "-P", password, "-T", "/usr/bin/codesign"]);
command("/usr/bin/security", ["set-key-partition-list", "-S", "apple-tool:,apple:", "-s", "-k", password, keychain]);
includeKeychain(keychain);
const certificate = readFileSync(certificatePath);
const fingerprint = new X509Certificate(certificate).fingerprint.replaceAll(":", "");
writeFileSync(path.join(directory, "certificate.pem"), certificate, { mode: 0o600, flag: "wx" });
writeFileSync(configPath, JSON.stringify({ version: 1, fingerprint, password }) + "\n", { mode: 0o600, flag: "wx" });
console.error("Created a local DBX development signing identity; release certificates and connection keys were not changed.");
return loadSigningIdentity(directory);
} catch (error) {
if (createdKeychain && !existsSync(configPath)) {
removeSigningKeychain(keychain);
rmSync(path.join(directory, "certificate.pem"), { force: true });
}
throw error;
} finally {
if (temporary) rmSync(temporary, { recursive: true, force: true });
closeSync(lock);
rmSync(lockPath);
}
}
export function signDevelopmentBinary(binary, directory = signingDirectory()) {
const identity = loadSigningIdentity(directory);
const requirement = designatedRequirement(identity.fingerprint);
command("/usr/bin/security", ["unlock-keychain", "-p", identity.password, identity.keychain]);
includeKeychain(identity.keychain);
command("/usr/bin/codesign", ["--force", "--sign", identity.fingerprint, "--keychain", identity.keychain, "--identifier", developmentIdentifier, "--requirements", `=designated => ${requirement}`, "--preserve-metadata=entitlements", "--timestamp=none", binary]);
command("/usr/bin/codesign", ["--verify", "--strict", "-R", `=${requirement}`, binary]);
}