@fanduzi/deltascope-mcp 0.15.0 → 0.17.0

package/README.md

@@ -8,6 +8,16 @@ This package does not implement DeltaScope MCP tools itself. It downloads the ma
 
 The launcher verifies the downloaded archive against the official DeltaScope release checksums before it updates the local cache.
 
+## Supported Audit Surface
+
+The launched `deltascope-mcp` server exposes a unified `audit_sql` surface for:
+
+- MySQL offline audit
+- TiDB offline audit
+- PostgreSQL offline audit on the main PG-capable release binaries across the supported macOS and Linux platforms
+
+Connection-backed metadata-aware audit remains limited to MySQL/TiDB-compatible instances. PostgreSQL requests must stay offline-only on the MCP surface.
+
 ## Version Contract
 
 - npm package version should track the DeltaScope release version it boots

package/bin/deltascope-mcp.js

@@ -4,37 +4,45 @@ import fs from "node:fs/promises";
 import process from "node:process";
 
 import { downloadAndExtractBinary } from "../lib/download.js";
-import { ensureExecutable, formatBootstrapContext, spawnBinary } from "../lib/launcher.js";
+import {
+  ensureExecutable,
+  formatBootstrapContext,
+  spawnBinary,
+} from "../lib/launcher.js";
 import {
   resolveArchiveName,
   resolveArchiveURL,
   resolveChecksumsURL,
   resolveDeltaScopeVersion,
-  resolvePlatform
+  resolvePlatform,
 } from "../lib/releases.js";
 
 const packageJson = JSON.parse(
-  await fs.readFile(new URL("../package.json", import.meta.url), "utf8")
+  await fs.readFile(new URL("../package.json", import.meta.url), "utf8"),
 );
 const version = resolveDeltaScopeVersion({
   packageVersion: packageJson.version,
-  envVersion: process.env.DELTASCOPE_MCP_VERSION ?? ""
+  envVersion: process.env.DELTASCOPE_MCP_VERSION ?? "",
 });
 const platform = resolvePlatform();
 const archiveURL = resolveArchiveURL({
   baseURL: process.env.DELTASCOPE_MCP_BASE_URL ?? "",
   version,
   os: platform.os,
-  arch: platform.arch
+  arch: platform.arch,
 });
 const archiveName = resolveArchiveName({
   version,
   os: platform.os,
-  arch: platform.arch
+  arch: platform.arch,
 });
-const checksumsURL = resolveChecksumsURL({
-  version
+const checksumsURL = resolveChecksumsURL({ version });
+const preferredChecksumsURL = resolveChecksumsURL({
+  version,
+  os: platform.os,
+  arch: platform.arch,
 });
+const checksumsURLs = [...new Set([preferredChecksumsURL, checksumsURL])];
 
 function log(message) {
   process.stderr.write(`[deltascope-mcp-launcher] ${message}\n`);
@@ -52,33 +60,42 @@ const binaryPath = await ensureExecutable({
     (async () => {
       log(`cache miss; downloading ${archiveURL}`);
       log(`cache target ${destinationPath}`);
-      log(`verifying archive against ${checksumsURL}`);
+      log(
+        checksumsURLs.length > 1
+          ? `verifying archive against ${checksumsURLs[0]} (fallback ${checksumsURLs[1]})`
+          : `verifying archive against ${checksumsURLs[0]}`,
+      );
       try {
         const result = await downloadAndExtractBinary({
           archiveURL,
-          checksumsURL,
+          checksumsURL: preferredChecksumsURL,
+          checksumsURLs,
           archiveName,
-          destinationPath
+          destinationPath,
         });
-        log(`downloaded archive and staged native binary for ${destinationPath}`);
+        log(
+          `downloaded archive and staged native binary for ${destinationPath}`,
+        );
         return result;
       } catch (error) {
-        process.stderr.write(`${formatBootstrapContext({
-          version,
-          platform,
-          archiveURL,
-          destinationPath
-        })}\n`);
+        process.stderr.write(
+          `${formatBootstrapContext({
+            version,
+            platform,
+            archiveURL,
+            destinationPath,
+          })}\n`,
+        );
         throw error;
       }
-    })()
+    })(),
 });
 
 log(`launching native binary ${binaryPath}`);
 
 const child = spawnBinary(binaryPath, process.argv.slice(2), {
   stdio: "inherit",
-  env: process.env
+  env: process.env,
 });
 
 child.on("error", (error) => {

package/lib/download.js

@@ -44,6 +44,7 @@ function parseChecksums(text) {
 export async function downloadAndExtractBinary({
   archiveURL,
   checksumsURL,
+  checksumsURLs = [],
   archiveName,
   destinationPath,
   fetchImpl = globalThis.fetch
@@ -52,33 +53,51 @@ export async function downloadAndExtractBinary({
     throw new Error("fetch implementation is required");
   }
 
-  const [archiveResponse, checksumsResponse] = await Promise.all([
-    fetchImpl(archiveURL),
-    fetchImpl(checksumsURL)
-  ]);
+  const requestedChecksumsURLs = [
+    ...checksumsURLs,
+    ...(checksumsURL ? [checksumsURL] : [])
+  ].filter(Boolean);
+  const uniqueChecksumsURLs = [...new Set(requestedChecksumsURLs)];
+  if (uniqueChecksumsURLs.length === 0) {
+    throw new Error("at least one checksums URL is required");
+  }
+
+  const archiveResponse = await fetchImpl(archiveURL);
 
   if (!archiveResponse.ok) {
     throw new Error(`failed to download ${archiveURL}`);
   }
-  if (!checksumsResponse.ok) {
-    throw new Error(`failed to download ${checksumsURL}`);
-  }
 
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "deltascope-mcp-archive-"));
   const archivePath = path.join(tempDir, "archive.tar.gz");
   const extractDir = path.join(tempDir, "extract");
   const archiveBuffer = Buffer.from(await archiveResponse.arrayBuffer());
-  const checksums = parseChecksums(await checksumsResponse.text());
-  const expectedChecksum = checksums.get(archiveName);
   const actualChecksum = sha256(archiveBuffer);
 
-  try {
-    if (!expectedChecksum) {
-      throw new Error(`missing checksum for ${archiveName}`);
-    }
-    if (actualChecksum !== expectedChecksum) {
-      throw new Error(`checksum mismatch for ${archiveName}`);
+  const resolveExpectedChecksum = async () => {
+    let lastError = new Error(`missing checksum for ${archiveName}`);
+    for (const candidateURL of uniqueChecksumsURLs) {
+      const checksumsResponse = await fetchImpl(candidateURL);
+      if (!checksumsResponse.ok) {
+        lastError = new Error(`failed to download ${candidateURL}`);
+        continue;
+      }
+      const checksums = parseChecksums(await checksumsResponse.text());
+      const expectedChecksum = checksums.get(archiveName);
+      if (!expectedChecksum) {
+        lastError = new Error(`missing checksum for ${archiveName}`);
+        continue;
+      }
+      if (actualChecksum !== expectedChecksum) {
+        throw new Error(`checksum mismatch for ${archiveName}`);
+      }
+      return expectedChecksum;
     }
+    throw lastError;
+  };
+
+  try {
+    const expectedChecksum = await resolveExpectedChecksum();
     await fs.mkdir(extractDir, { recursive: true });
     await fs.writeFile(archivePath, archiveBuffer);
     await runTar(["-xzf", archivePath, "-C", extractDir]);

package/lib/releases.js

@@ -1,7 +1,11 @@
 import os from "node:os";
 
-export function resolvePlatform({ platform = os.platform(), arch = os.arch() } = {}) {
-  const resolvedPlatform = platform === "darwin" || platform === "linux" ? platform : null;
+export function resolvePlatform({
+  platform = os.platform(),
+  arch = os.arch(),
+} = {}) {
+  const resolvedPlatform =
+    platform === "darwin" || platform === "linux" ? platform : null;
   if (resolvedPlatform === null) {
     throw new Error(`unsupported platform: ${platform}`);
   }
@@ -39,11 +43,20 @@ export function resolveArchiveName({ version, os, arch }) {
   return `deltascope_${version.replace(/^v/, "")}_${os}_${arch}.tar.gz`;
 }
 
-export function resolveChecksumsName({ version }) {
-  return `deltascope_${version.replace(/^v/, "")}_checksums.txt`;
+export function resolveChecksumsName({ version, os = "", arch = "" }) {
+  const rawVersion = version.replace(/^v/, "");
+  if (os && arch) {
+    return `deltascope_${rawVersion}_${os}_${arch}_checksums.txt`;
+  }
+  return `deltascope_${rawVersion}_checksums.txt`;
 }
 
-export function resolveArchiveURL({ repo = "Fanduzi/DeltaScope", version, os, arch }) {
+export function resolveArchiveURL({
+  repo = "Fanduzi/DeltaScope",
+  version,
+  os,
+  arch,
+}) {
   const baseURL = arguments[0].baseURL ?? "";
   if (baseURL) {
     return `${baseURL.replace(/\/$/, "")}/${version}/${resolveArchiveName({ version, os, arch })}`;
@@ -51,6 +64,6 @@ export function resolveArchiveURL({ repo = "Fanduzi/DeltaScope", version, os, ar
   return `https://github.com/${repo}/releases/download/${version}/${resolveArchiveName({ version, os, arch })}`;
 }
 
-export function resolveChecksumsURL({ repo = "Fanduzi/DeltaScope", version }) {
-  return `https://github.com/${repo}/releases/download/${version}/${resolveChecksumsName({ version })}`;
+export function resolveChecksumsURL({ repo = "Fanduzi/DeltaScope", version, os = "", arch = "" }) {
+  return `https://github.com/${repo}/releases/download/${version}/${resolveChecksumsName({ version, os, arch })}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanduzi/deltascope-mcp",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Launcher package for the DeltaScope MCP stdio server",
   "type": "module",
   "repository": {