bi-agent-kit 0.1.0

package/lib/doctor.js

@@ -0,0 +1,247 @@
+import path from "node:path";
+import { readManifest, ManifestCorruptError } from "./manifest.js";
+import { resolveTargets } from "./targets.js";
+import { readFileIfExists } from "./atomic-fs.js";
+import { readJsonServers } from "./json-adapter.js";
+import { readTomlServers } from "./toml-adapter.js";
+import { hashValue } from "./hash.js";
+import { loadTemplates } from "./commands.js";
+import { isBinaryOnPath } from "./prereq-check.js";
+
+const PLACEHOLDER_TOKEN_PATTERN = /REPLACE_[A-Z0-9_]+/;
+const LOCKFILE_NAME = ".kae-bi-kit.lock";
+
+function finding(level, area, message) {
+  return { level, area, message };
+}
+
+function resolveGroupForEntry(entry, groups) {
+  const byPath = groups.find((g) => g.absPath === entry.absPath);
+  if (byPath) return byPath;
+  // Fall back to shape inference by extension when the entry's absPath no longer
+  // matches any currently-resolved target (e.g. platform/homedir changed since install).
+  const shape = entry.absPath.toLowerCase().endsWith(".toml") ? "toml" : "json";
+  return { absPath: entry.absPath, shape, rootKey: "mcpServers" };
+}
+
+function readServersForGroup(group, fileText) {
+  if (group.shape === "toml") return readTomlServers(fileText);
+  return readJsonServers(fileText, group.rootKey);
+}
+
+function containsPlaceholderToken(value) {
+  if (typeof value === "string") return PLACEHOLDER_TOKEN_PATTERN.test(value);
+  if (Array.isArray(value)) return value.some(containsPlaceholderToken);
+  if (value && typeof value === "object") {
+    return Object.values(value).some(containsPlaceholderToken);
+  }
+  return false;
+}
+
+async function checkLockfile(dir, findings) {
+  const lockPath = path.join(dir, LOCKFILE_NAME);
+  const text = await readFileIfExists(lockPath);
+  if (text === null) {
+    findings.push(finding("ok", "lockfile", "No stale lockfile present."));
+    return;
+  }
+  let pid = "unknown";
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && parsed.pid !== undefined) pid = parsed.pid;
+  } catch {
+    // fall through with pid "unknown"
+  }
+  findings.push(
+    finding(
+      "warn",
+      "lockfile",
+      "A lockfile exists at " + lockPath + " from pid " + pid +
+        ". If no bi-agent-kit run is currently in progress, delete it and try again."
+    )
+  );
+}
+
+async function checkEntry(entry, group, findings, counters) {
+  const fileText = await readFileIfExists(entry.absPath);
+  if (fileText === null) {
+    findings.push(
+      finding(
+        "warn",
+        "target-file",
+        "Target file " + entry.absPath + " for " + entry.serverKey + " no longer exists."
+      )
+    );
+    return;
+  }
+  counters.filesPresent++;
+
+  let servers;
+  try {
+    servers = readServersForGroup(group, fileText);
+  } catch (err) {
+    findings.push(
+      finding(
+        "error",
+        "parse",
+        "Target file " + entry.absPath + " is malformed and could not be parsed: " + err.message
+      )
+    );
+    return;
+  }
+  counters.filesParsed++;
+
+  const value = servers[entry.serverKey];
+  if (value === undefined) {
+    findings.push(
+      finding(
+        "warn",
+        "server-key",
+        "The " + entry.serverKey + " entry in " + entry.absPath +
+          " was removed by hand (bi-agent-kit still thinks it is installed)."
+      )
+    );
+    return;
+  }
+  counters.keysPresent++;
+
+  const currentHash = hashValue(value);
+  if (currentHash !== entry.contentHash) {
+    findings.push(
+      finding(
+        "warn",
+        "drift",
+        "The " + entry.serverKey + " entry in " + entry.absPath +
+          " was edited outside bi-agent-kit and will be skipped on removal."
+      )
+    );
+    return;
+  }
+  counters.hashesMatch++;
+
+  if (containsPlaceholderToken(value)) {
+    findings.push(
+      finding(
+        "warn",
+        "placeholder",
+        "The " + entry.serverKey + " entry in " + entry.absPath +
+          " still has an unfilled REPLACE_ placeholder and will not launch."
+      )
+    );
+    return;
+  }
+  counters.placeholdersClean++;
+
+  counters.healthy++;
+}
+
+async function checkRequiredBinaries(manifest, findings) {
+  const templates = await loadTemplates();
+  const templatesById = new Map(templates.map((t) => [t.id, t]));
+  const requiredBinaries = new Map();
+  for (const entry of manifest.entries) {
+    const templateId = entry.templateId || entry.serverKey;
+    const template = templatesById.get(templateId);
+    if (!template || !template.requiresBinary) continue;
+    if (!requiredBinaries.has(template.requiresBinary)) {
+      requiredBinaries.set(template.requiresBinary, []);
+    }
+    requiredBinaries.get(template.requiresBinary).push(entry.serverKey);
+  }
+
+  if (requiredBinaries.size === 0) {
+    findings.push(finding("ok", "binary", "No installed server requires a binary on PATH."));
+    return;
+  }
+
+  let allPresent = true;
+  for (const [binaryName, serverIds] of requiredBinaries) {
+    const onPath = await isBinaryOnPath(binaryName);
+    if (!onPath) {
+      allPresent = false;
+      findings.push(
+        finding(
+          "warn",
+          "binary",
+          "Required binary \"" + binaryName + "\" (for " + serverIds.join(", ") +
+            ") was not found on PATH."
+        )
+      );
+    }
+  }
+  if (allPresent) {
+    findings.push(
+      finding(
+        "ok",
+        "binary",
+        requiredBinaries.size + " required binary(ies) checked and found on PATH."
+      )
+    );
+  }
+}
+
+function pushEntrySummaries(findings, counters, total) {
+  if (counters.filesPresent === total) {
+    findings.push(finding("ok", "target-file", total + " target file(s) present."));
+  }
+  if (counters.filesParsed === counters.filesPresent && counters.filesPresent > 0) {
+    findings.push(finding("ok", "parse", counters.filesParsed + " target file(s) parsed successfully."));
+  }
+  if (counters.keysPresent === counters.filesParsed && counters.filesParsed > 0) {
+    findings.push(finding("ok", "server-key", counters.keysPresent + " entry key(s) still present."));
+  }
+  if (counters.hashesMatch === counters.keysPresent && counters.keysPresent > 0) {
+    findings.push(finding("ok", "drift", counters.hashesMatch + " entry(ies) match their installed content, no drift."));
+  }
+  if (counters.placeholdersClean === counters.hashesMatch && counters.hashesMatch > 0) {
+    findings.push(
+      finding("ok", "placeholder", counters.placeholdersClean + " entry(ies) have no unfilled placeholders.")
+    );
+  }
+}
+
+export async function runDoctor({ dir, homedir, platform }) {
+  const findings = [];
+
+  let manifest;
+  try {
+    manifest = await readManifest(dir);
+  } catch (err) {
+    if (err instanceof ManifestCorruptError) {
+      findings.push(finding("error", "manifest", err.message));
+      await checkLockfile(dir, findings);
+      return findings;
+    }
+    throw err;
+  }
+
+  if (manifest === null || manifest.entries.length === 0) {
+    findings.push(finding("ok", "manifest", "No manifest found — nothing installed by bi-agent-kit yet."));
+    await checkLockfile(dir, findings);
+    return findings;
+  }
+
+  findings.push(finding("ok", "manifest", "Manifest read successfully with " + manifest.entries.length + " entry(ies)."));
+
+  const groups = resolveTargets(dir, homedir, platform);
+  const counters = {
+    filesPresent: 0,
+    filesParsed: 0,
+    keysPresent: 0,
+    hashesMatch: 0,
+    placeholdersClean: 0,
+    healthy: 0,
+  };
+
+  for (const entry of manifest.entries) {
+    const group = resolveGroupForEntry(entry, groups);
+    await checkEntry(entry, group, findings, counters);
+  }
+
+  pushEntrySummaries(findings, counters, manifest.entries.length);
+
+  await checkRequiredBinaries(manifest, findings);
+  await checkLockfile(dir, findings);
+
+  return findings;
+}

package/lib/hash.js

@@ -0,0 +1,18 @@
+import crypto from "node:crypto";
+
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(canonicalize).join(",") + "]";
+  }
+  const keys = Object.keys(value).sort();
+  const parts = keys.map((key) => JSON.stringify(key) + ":" + canonicalize(value[key]));
+  return "{" + parts.join(",") + "}";
+}
+
+export function hashValue(value) {
+  const canonical = canonicalize(value);
+  return crypto.createHash("sha256").update(canonical, "utf8").digest("hex");
+}

package/lib/installers.js

@@ -0,0 +1,77 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Per-binary install commands, keyed by process.platform.
+ *
+ * pac (Power Platform CLI) and dab (Data API Builder CLI) both ship as
+ * .NET global tools, so the dotnet-tool install command is identical across
+ * platforms as long as the .NET SDK is present. uv/uvx has no dotnet
+ * equivalent and instead ships a platform-specific standalone installer
+ * script (astral.sh).
+ */
+export const INSTALLERS = {
+  pac: {
+    label: "Power Platform CLI (pac)",
+    docs: "https://learn.microsoft.com/en-us/power-platform/developer/cli/introduction",
+    commands: {
+      win32: { command: "dotnet", args: ["tool", "install", "--global", "Microsoft.PowerApps.CLI.Tool"] },
+      darwin: { command: "dotnet", args: ["tool", "install", "--global", "Microsoft.PowerApps.CLI.Tool"] },
+      linux: { command: "dotnet", args: ["tool", "install", "--global", "Microsoft.PowerApps.CLI.Tool"] },
+    },
+  },
+  dab: {
+    label: "Data API Builder CLI (dab)",
+    docs: "https://learn.microsoft.com/en-us/azure/data-api-builder/how-to-install-cli",
+    commands: {
+      win32: { command: "dotnet", args: ["tool", "install", "--global", "Microsoft.DataApiBuilder"] },
+      darwin: { command: "dotnet", args: ["tool", "install", "--global", "Microsoft.DataApiBuilder"] },
+      linux: { command: "dotnet", args: ["tool", "install", "--global", "Microsoft.DataApiBuilder"] },
+    },
+  },
+  uvx: {
+    label: "uv / uvx",
+    docs: "https://docs.astral.sh/uv/getting-started/installation/",
+    commands: {
+      win32: { command: "powershell", args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", "irm https://astral.sh/uv/install.ps1 | iex"] },
+      darwin: { command: "sh", args: ["-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"] },
+      linux: { command: "sh", args: ["-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"] },
+    },
+  },
+};
+
+async function defaultRunner(command, args) {
+  await execFileAsync(command, args);
+}
+
+/**
+ * Offers to install a missing prerequisite binary, running the platform
+ * appropriate command only after the caller-supplied confirm() resolves
+ * truthy. Accepts an injectable `runner(command, args)` so tests never
+ * actually shell out.
+ *
+ * Returns { attempted, installed, reason?, message? }.
+ */
+export async function offerInstall(binaryName, { confirm, runner, platform = process.platform } = {}) {
+  const installer = INSTALLERS[binaryName];
+  if (!installer) {
+    return { attempted: false, installed: false, reason: "no-installer" };
+  }
+  const commandSpec = installer.commands[platform];
+  if (!commandSpec) {
+    return { attempted: false, installed: false, reason: "unsupported-platform" };
+  }
+  const proceed = await confirm({ message: "Install " + installer.label + " now?" });
+  if (!proceed) {
+    return { attempted: false, installed: false, reason: "declined" };
+  }
+  const run = runner || defaultRunner;
+  try {
+    await run(commandSpec.command, commandSpec.args);
+    return { attempted: true, installed: true };
+  } catch (err) {
+    return { attempted: true, installed: false, reason: "error", message: err.message };
+  }
+}

package/lib/json-adapter.js

@@ -0,0 +1,45 @@
+import { parse, modify, applyEdits } from "jsonc-parser";
+
+const FORMATTING_OPTIONS = { tabSize: 2, insertSpaces: true, eol: "\n" };
+
+export class MalformedConfigError extends Error {
+  constructor(detail) {
+    super("Config file content is not valid JSON: " + detail);
+    this.name = "MalformedConfigError";
+  }
+}
+
+function parseStrict(fileText) {
+  if (fileText.charCodeAt(0) === 0xfeff) fileText = fileText.slice(1);
+  const errors = [];
+  const parsed = parse(fileText, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    throw new MalformedConfigError("parse error code " + errors[0].error + " at offset " + errors[0].offset);
+  }
+  return parsed;
+}
+
+export function readJsonServers(fileText, rootKey) {
+  if (!fileText || fileText.trim().length === 0) return {};
+  const parsed = parseStrict(fileText);
+  if (!parsed || typeof parsed !== "object") return {};
+  const servers = parsed[rootKey];
+  if (!servers || typeof servers !== "object") return {};
+  return servers;
+}
+
+export function setJsonServer(fileText, rootKey, serverKey, serverValue) {
+  const base = fileText && fileText.trim().length > 0 ? fileText : "{}\n";
+  const edits = modify(base, [rootKey, serverKey], serverValue, {
+    formattingOptions: FORMATTING_OPTIONS,
+  });
+  return applyEdits(base, edits);
+}
+
+export function removeJsonServer(fileText, rootKey, serverKey) {
+  if (!fileText) return fileText;
+  const edits = modify(fileText, [rootKey, serverKey], undefined, {
+    formattingOptions: FORMATTING_OPTIONS,
+  });
+  return applyEdits(fileText, edits);
+}

package/lib/lock.js

@@ -0,0 +1,55 @@
+import { promises as fs } from "node:fs";
+import { readFileIfExists } from "./atomic-fs.js";
+
+export class LockHeldError extends Error {
+  constructor(lockPath) {
+    super("Another bi-agent-kit run is already in progress, lock at " + lockPath);
+    this.name = "LockHeldError";
+    this.lockPath = lockPath;
+  }
+}
+
+async function tryExclusiveCreate(lockPath, payload) {
+  const handle = await fs.open(lockPath, "wx");
+  try {
+    await handle.writeFile(payload, "utf8");
+  } finally {
+    await handle.close();
+  }
+}
+
+export async function acquireLock(lockPath, options) {
+  const ttlMs = options && options.ttlMs ? options.ttlMs : 30000;
+  const payload = JSON.stringify({ pid: process.pid, timestamp: Date.now() });
+  try {
+    await tryExclusiveCreate(lockPath, payload);
+    return async function release() {
+      await releaseLock(lockPath);
+    };
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  const existing = await readFileIfExists(lockPath);
+  if (existing !== null) {
+    const parsed = JSON.parse(existing);
+    const age = Date.now() - parsed.timestamp;
+    if (age < ttlMs) {
+      throw new LockHeldError(lockPath);
+    }
+  }
+  // Reclaiming a stale lock is best effort, not fully atomic.
+  // Acceptable for a single user local CLI, not a distributed system.
+  await fs.unlink(lockPath).catch(() => {});
+  await tryExclusiveCreate(lockPath, payload);
+  return async function release() {
+    await releaseLock(lockPath);
+  };
+}
+
+export async function releaseLock(lockPath) {
+  try {
+    await fs.unlink(lockPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}

package/lib/manifest.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+import { atomicWriteFile, readFileIfExists } from "./atomic-fs.js";
+
+export const MANIFEST_FILENAME = ".kae-bi-kit.json";
+
+export class ManifestCorruptError extends Error {
+  constructor(manifestPath, cause) {
+    super("Manifest at " + manifestPath + " is corrupt. Re-run init to rebuild it.");
+    this.name = "ManifestCorruptError";
+    this.manifestPath = manifestPath;
+    this.cause = cause;
+  }
+}
+
+function manifestPathFor(dir) {
+  return path.join(dir, MANIFEST_FILENAME);
+}
+
+function emptyManifest() {
+  return { version: 1, entries: [] };
+}
+
+export async function readManifest(dir) {
+  const manifestPath = manifestPathFor(dir);
+  const text = await readFileIfExists(manifestPath);
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.entries)) {
+      throw new Error("missing entries array");
+    }
+    return parsed;
+  } catch (err) {
+    throw new ManifestCorruptError(manifestPath, err);
+  }
+}
+
+async function persist(dir, manifest) {
+  const manifestPath = manifestPathFor(dir);
+  const currentContent = await readFileIfExists(manifestPath);
+  if (currentContent !== null) {
+    await atomicWriteFile(manifestPath + ".bak", currentContent);
+  }
+  await atomicWriteFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+}
+
+export async function writeManifestEntry(dir, entry) {
+  let manifest = await readManifest(dir);
+  if (manifest === null) manifest = emptyManifest();
+  const index = manifest.entries.findIndex(
+    (e) => e.absPath === entry.absPath && e.serverKey === entry.serverKey
+  );
+  if (index === -1) {
+    manifest.entries.push(entry);
+  } else {
+    manifest.entries[index] = entry;
+  }
+  await persist(dir, manifest);
+  return manifest;
+}
+
+export async function removeManifestEntry(dir, absPath, serverKey) {
+  const manifest = await readManifest(dir);
+  if (manifest === null) return null;
+  manifest.entries = manifest.entries.filter(
+    (e) => !(e.absPath === absPath && e.serverKey === serverKey)
+  );
+  await persist(dir, manifest);
+  return manifest;
+}

package/lib/merge-config.js

@@ -0,0 +1,141 @@
+import { readJsonServers, setJsonServer, removeJsonServer } from "./json-adapter.js";
+import { readTomlServers, setTomlServer, removeTomlServer } from "./toml-adapter.js";
+import path from "node:path";
+import { readFileIfExists, atomicWriteFile, backupIfMissing, assertNoSymlinkedAncestors } from "./atomic-fs.js";
+import { readManifest, writeManifestEntry, removeManifestEntry } from "./manifest.js";
+import { hashValue } from "./hash.js";
+
+export class CollisionError extends Error {
+  constructor(absPath, serverKey) {
+    super(
+      "A key named " + serverKey + " already exists in " + absPath +
+        " and is not owned by bi-agent-kit. Rename the server or remove the conflicting entry by hand first."
+    );
+    this.name = "CollisionError";
+    this.absPath = absPath;
+    this.serverKey = serverKey;
+  }
+}
+
+function readServers(shape, fileText, rootKey) {
+  if (shape === "toml") return readTomlServers(fileText);
+  return readJsonServers(fileText, rootKey);
+}
+
+function writeServer(shape, fileText, rootKey, serverKey, serverValue) {
+  if (shape === "toml") return setTomlServer(fileText, serverKey, serverValue);
+  return setJsonServer(fileText, rootKey, serverKey, serverValue);
+}
+
+function deleteServer(shape, fileText, rootKey, serverKey) {
+  if (shape === "toml") return removeTomlServer(fileText, serverKey);
+  return removeJsonServer(fileText, rootKey, serverKey);
+}
+
+// Every path component below this ancestor is checked for symlinks before we read/write it.
+// For paths inside the project dir, that's the project dir itself. For paths outside it
+// (e.g. user-home-scoped targets), fall back to the file's own grandparent directory so we
+// still catch a symlinked immediate parent without following the entire host filesystem.
+function symlinkCheckStopDir(dir, absPath) {
+  const resolvedDir = path.resolve(dir);
+  const resolvedAbsPath = path.resolve(absPath);
+  const relative = path.relative(resolvedDir, resolvedAbsPath);
+  if (relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+    return resolvedDir;
+  }
+  return path.dirname(path.dirname(resolvedAbsPath));
+}
+
+export async function addServerToTarget({ dir, resolvedTarget, serverKey, serverValue, templateId }) {
+  const manifest = await readManifest(dir);
+  const entries = manifest ? manifest.entries : [];
+  const ownedByUs = entries.some(
+    (e) => e.absPath === resolvedTarget.absPath && e.serverKey === serverKey
+  );
+  const fileHasAnyOwnedEntry = entries.some((e) => e.absPath === resolvedTarget.absPath);
+
+  await assertNoSymlinkedAncestors(
+    resolvedTarget.absPath,
+    symlinkCheckStopDir(dir, resolvedTarget.absPath)
+  );
+
+  const fileText = await readFileIfExists(resolvedTarget.absPath);
+  const currentServers = readServers(resolvedTarget.shape, fileText, resolvedTarget.rootKey);
+
+  if (Object.prototype.hasOwnProperty.call(currentServers, serverKey) && !ownedByUs) {
+    throw new CollisionError(resolvedTarget.absPath, serverKey);
+  }
+
+  if (!fileHasAnyOwnedEntry && fileText !== null) {
+    await backupIfMissing(resolvedTarget.absPath);
+  }
+
+  const newFileText = writeServer(
+    resolvedTarget.shape,
+    fileText,
+    resolvedTarget.rootKey,
+    serverKey,
+    serverValue
+  );
+  await assertNoSymlinkedAncestors(
+    resolvedTarget.absPath,
+    symlinkCheckStopDir(dir, resolvedTarget.absPath)
+  );
+  await atomicWriteFile(resolvedTarget.absPath, newFileText);
+
+  await writeManifestEntry(dir, {
+    absPath: resolvedTarget.absPath,
+    serverKey,
+    templateId: templateId || serverKey,
+    targetIds: resolvedTarget.targetIds,
+    contentHash: hashValue(serverValue),
+    installedAt: Date.now(),
+  });
+
+  return { status: "written" };
+}
+
+export async function removeServerFromTarget({ dir, resolvedTarget, serverKey }) {
+  const manifest = await readManifest(dir);
+  const entry = manifest
+    ? manifest.entries.find((e) => e.absPath === resolvedTarget.absPath && e.serverKey === serverKey)
+    : undefined;
+  if (!entry) {
+    return { status: "not-installed" };
+  }
+
+  await assertNoSymlinkedAncestors(
+    resolvedTarget.absPath,
+    symlinkCheckStopDir(dir, resolvedTarget.absPath)
+  );
+
+  const fileText = await readFileIfExists(resolvedTarget.absPath);
+  const currentServers = readServers(resolvedTarget.shape, fileText, resolvedTarget.rootKey);
+  const currentValue = currentServers[serverKey];
+
+  if (currentValue === undefined) {
+    await removeManifestEntry(dir, resolvedTarget.absPath, serverKey);
+    return { status: "already-removed" };
+  }
+
+  const currentHash = hashValue(currentValue);
+  if (currentHash !== entry.contentHash) {
+    return { status: "skipped-drift" };
+  }
+
+  const newFileText = deleteServer(resolvedTarget.shape, fileText, resolvedTarget.rootKey, serverKey);
+  const remaining = readServers(resolvedTarget.shape, newFileText, resolvedTarget.rootKey);
+  if (Object.prototype.hasOwnProperty.call(remaining, serverKey)) {
+    // Removal did not actually take effect; do not write and do not update the
+    // manifest, so state stays truthful and the entry remains managed.
+    return { status: "remove-failed" };
+  }
+  await assertNoSymlinkedAncestors(
+    resolvedTarget.absPath,
+    symlinkCheckStopDir(dir, resolvedTarget.absPath)
+  );
+  await atomicWriteFile(resolvedTarget.absPath, newFileText);
+  await removeManifestEntry(dir, resolvedTarget.absPath, serverKey);
+
+  return { status: "removed" };
+}

package/lib/prereq-check.js

@@ -0,0 +1,14 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function isBinaryOnPath(binaryName) {
+  const finderCommand = process.platform === "win32" ? "where" : "which";
+  try {
+    await execFileAsync(finderCommand, [binaryName]);
+    return true;
+  } catch {
+    return false;
+  }
+}