@myelixlabs/sample-mcp 0.1.6

package/bin/sample-mcp.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { install, resolvePaths } = require('../lib/install');
+const { offerMcpConfig } = require('../lib/mcp-config');
+const { printVersionInfo } = require('../lib/version');
+const pkg = require('../package.json');
+
+const { binPath: BIN_PATH } = resolvePaths();
+const PACKAGE_NAME = path.basename(process.argv[1] || '') === 'synapse-mcp' ? 'synapse-mcp' : pkg.name;
+
+async function run(args) {
+  await install({ quiet: true, packageName: PACKAGE_NAME });
+  const result = spawnSync(BIN_PATH, args, { stdio: 'inherit' });
+  process.exit(result.status ?? 1);
+}
+
+function usage() {
+  console.error('Usage: npx @myelixlabs/sample-mcp <command> [args]');
+  console.error('Commands:');
+  console.error('  install             Download or update the Sample MCP launcher');
+  console.error('  setup               Detect editors and offer to configure MCP servers');
+  console.error('  auth                Start device sign-in');
+  console.error('  serve               Run the MCP server');
+  console.error('  --version           Print version');
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (command === '--version' || command === '-V' || command === 'version') {
+    printVersionInfo({ json: args.includes('--json') });
+    return;
+  }
+
+  if (command === 'install') {
+    const quiet = args.includes('--quiet');
+    await install({ quiet, packageName: PACKAGE_NAME });
+    if (!args.includes('--no-config')) {
+      await offerMcpConfig({
+        quiet,
+        yes:
+          args.includes('--yes') ||
+          args.includes('-y') ||
+          process.env.SAMPLE_MCP_CONFIG_YES === '1' ||
+          process.env.SYNAPSE_MCP_CONFIG_YES === '1',
+        command: BIN_PATH,
+      });
+    }
+    return;
+  }
+
+  if (command === 'setup' || command === 'configure') {
+    await install({ quiet: args.includes('--quiet'), packageName: PACKAGE_NAME });
+    await offerMcpConfig({
+      quiet: args.includes('--quiet'),
+      yes:
+        args.includes('--yes') ||
+        args.includes('-y') ||
+        process.env.SAMPLE_MCP_CONFIG_YES === '1' ||
+        process.env.SYNAPSE_MCP_CONFIG_YES === '1',
+      command: BIN_PATH,
+    });
+    return;
+  }
+
+  if (!command || command === '--help' || command === '-h') {
+    usage();
+    process.exit(command ? 0 : 1);
+  }
+
+  await run(args);
+}
+
+main().catch((err) => {
+  console.error(`sample-mcp: ${err.message}`);
+  process.exit(1);
+});

package/bin/synapse-mcp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+console.error('synapse-mcp is deprecated; use sample-mcp instead.');
+require('./sample-mcp.js');

package/lib/install.js

@@ -0,0 +1,212 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const childProcess = require('child_process');
+
+const DEFAULT_BASE_URL = 'https://downloads.synapse-mcp.dev/sample-mcp';
+
+function env(name, fallbackName) {
+  return process.env[name] || (fallbackName ? process.env[fallbackName] : undefined);
+}
+
+function platformId() {
+  if (process.platform === 'linux' && process.arch === 'x64') return 'linux-x86_64';
+  if (process.platform === 'linux' && process.arch === 'arm64') return 'linux-aarch64';
+  if (process.platform === 'darwin' && process.arch === 'x64') return 'darwin-x86_64';
+  if (process.platform === 'darwin' && process.arch === 'arm64') return 'darwin-aarch64';
+  if (process.platform === 'win32' && process.arch === 'x64') return 'windows-x86_64.exe';
+  throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`);
+}
+
+function resolvePaths(options = {}) {
+  const baseUrl =
+    options.baseUrl || env('SAMPLE_MCP_BASE_URL', 'SYNAPSE_MCP_BASE_URL') || DEFAULT_BASE_URL;
+  const installDir =
+    options.installDir ||
+    env('SAMPLE_MCP_INSTALL_DIR', 'SYNAPSE_MCP_INSTALL_DIR') ||
+    path.join(process.env.HOME || process.env.USERPROFILE, '.sample-mcp');
+  const binName = process.platform === 'win32' ? 'sample-mcp.exe' : 'sample-mcp';
+  const platform = env('SAMPLE_MCP_PLATFORM', 'SYNAPSE_MCP_PLATFORM') || platformId();
+
+  return {
+    baseUrl,
+    installDir,
+    binPath: path.join(installDir, binName),
+    platform,
+    fallbackUrl: `${baseUrl}/latest/sample-mcp-${platform}`,
+  };
+}
+
+function sha256File(filePath) {
+  const hash = crypto.createHash('sha256');
+  hash.update(fs.readFileSync(filePath));
+  return hash.digest('hex');
+}
+
+function launcherVersion(binPath, spawnSync = childProcess.spawnSync) {
+  const result = spawnSync(binPath, ['--version'], { encoding: 'utf8' });
+  if (result.status !== 0) return null;
+  const match = `${result.stdout || ''}${result.stderr || ''}`.trim().match(/sample-mcp\s+(\S+)/);
+  return match ? match[1] : null;
+}
+
+async function fetchManifest(baseUrl, fetchImpl = globalThis.fetch) {
+  const url = `${baseUrl}/manifest.json`;
+  try {
+    const init = {};
+    if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {
+      init.signal = AbortSignal.timeout(15000);
+    }
+    const res = await fetchImpl(url, init);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+function downloadArtifact(url, binPath, quiet, spawnSync = childProcess.spawnSync) {
+  const tmp = `${binPath}.tmp`;
+  const result = spawnSync('curl', ['-fSL', url, '-o', tmp], { stdio: quiet ? 'pipe' : 'inherit' });
+
+  if (result.status !== 0) {
+    if (fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    throw new Error(`Failed to download Sample MCP from ${url}`);
+  }
+
+  if (process.platform !== 'win32') fs.chmodSync(tmp, 0o755);
+  fs.renameSync(tmp, binPath);
+}
+
+function versionLabel(releaseVersion, launcherVersionValue) {
+  if (releaseVersion) return releaseVersion;
+  if (launcherVersionValue) return launcherVersionValue;
+  return null;
+}
+
+function formatStatus(action, { releaseVersion, launcherVersion: launcherVersionValue, binPath }) {
+  const version = versionLabel(releaseVersion, launcherVersionValue);
+  const suffix = version ? ` (${version})` : '';
+
+  switch (action) {
+    case 'already_installed':
+      return `Sample MCP is already installed${suffix} at ${binPath}`;
+    case 'updated':
+      return `Sample MCP updated${suffix} at ${binPath}`;
+    case 'installed':
+      return `Sample MCP installed${suffix} to ${binPath}`;
+    default:
+      throw new Error(`Unknown install status: ${action}`);
+  }
+}
+
+function formatAuthNextStep(packageName = 'sample-mcp') {
+  const scopedPackage = packageName.startsWith('@') ? packageName : `@myelixlabs/${packageName}`;
+  return `Next: run \`npx ${scopedPackage} auth\` to sign in and activate your license.`;
+}
+
+/**
+ * Ensure the Sample MCP launcher is present and up to date.
+ */
+async function install(options = {}) {
+  const quiet = Boolean(options.quiet);
+  const spawnSync = options.spawnSync || childProcess.spawnSync;
+  const { baseUrl, installDir, binPath, platform, fallbackUrl } = resolvePaths(options);
+  const fetchImpl = options.fetch || globalThis.fetch;
+
+  fs.mkdirSync(installDir, { recursive: true });
+
+  const exists = fs.existsSync(binPath);
+  const installedLauncherVersion = exists ? launcherVersion(binPath, spawnSync) : null;
+  const manifest = await fetchManifest(baseUrl, fetchImpl);
+  const launcherArtifact = manifest?.artifacts?.[platform]?.launcher;
+  const releaseVersion = manifest?.latest ?? null;
+  const downloadUrl = launcherArtifact?.url || fallbackUrl;
+  const expectedSha = launcherArtifact?.sha256;
+  const updateCheckFailed = !manifest;
+
+  if (exists && expectedSha) {
+    const localSha = sha256File(binPath);
+    if (localSha === expectedSha) {
+      const message = formatStatus('already_installed', {
+        releaseVersion,
+        launcherVersion: installedLauncherVersion,
+        binPath,
+      });
+      if (!quiet) {
+        console.error(message);
+        console.error(formatAuthNextStep(options.packageName));
+      }
+      return {
+        status: 'already_installed',
+        binPath,
+        releaseVersion,
+        launcherVersion: installedLauncherVersion,
+        updateCheckFailed,
+      };
+    }
+  } else if (exists && updateCheckFailed) {
+    const message = formatStatus('already_installed', {
+      releaseVersion: null,
+      launcherVersion: installedLauncherVersion,
+      binPath,
+    });
+    if (!quiet) {
+      console.error(message);
+      console.error('Could not check for updates (release manifest unavailable).');
+      console.error(formatAuthNextStep(options.packageName));
+    }
+    return {
+      status: 'already_installed',
+      binPath,
+      releaseVersion: null,
+      launcherVersion: installedLauncherVersion,
+      updateCheckFailed: true,
+    };
+  }
+
+  if (!quiet) {
+    console.error(exists ? 'Downloading Sample MCP update...' : 'Downloading Sample MCP...');
+  }
+
+  downloadArtifact(downloadUrl, binPath, quiet, spawnSync);
+
+  if (expectedSha) {
+    const downloadedSha = sha256File(binPath);
+    if (downloadedSha !== expectedSha) {
+      fs.unlinkSync(binPath);
+      throw new Error('Downloaded Sample MCP launcher failed integrity check');
+    }
+  }
+
+  const status = exists ? 'updated' : 'installed';
+  const newLauncherVersion = launcherVersion(binPath, spawnSync);
+  const message = formatStatus(status, {
+    releaseVersion,
+    launcherVersion: newLauncherVersion,
+    binPath,
+  });
+  if (!quiet) {
+    console.error(message);
+    console.error(formatAuthNextStep(options.packageName));
+  }
+
+  return {
+    status,
+    binPath,
+    releaseVersion,
+    launcherVersion: newLauncherVersion,
+    updateCheckFailed,
+  };
+}
+
+module.exports = {
+  DEFAULT_BASE_URL,
+  formatAuthNextStep,
+  formatStatus,
+  install,
+  launcherVersion,
+  platformId,
+  resolvePaths,
+  sha256File,
+};

package/lib/mcp-config.js

@@ -0,0 +1,220 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+
+const SERVER_NAME = 'sample-mcp';
+
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+function appDataDir() {
+  if (process.platform === 'win32') return process.env.APPDATA || path.join(homeDir(), 'AppData', 'Roaming');
+  if (process.platform === 'darwin') return path.join(homeDir(), 'Library', 'Application Support');
+  return process.env.XDG_CONFIG_HOME || path.join(homeDir(), '.config');
+}
+
+function sampleServerConfig(command = 'sample-mcp') {
+  return { command, args: ['serve'] };
+}
+
+function jsonConfig(id, label, configPath, section = 'mcpServers') {
+  return { id, label, type: 'json', configPath, section };
+}
+
+function codexConfig(configPath) {
+  return { id: 'codex', label: 'Codex', type: 'toml', configPath };
+}
+
+function candidateConfigs(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const home = options.home || homeDir();
+  const appData = options.appData || appDataDir();
+
+  return [
+    jsonConfig('cursor', 'Cursor', path.join(home, '.cursor', 'mcp.json')),
+    jsonConfig('cursor', 'Cursor', path.join(appData, 'Cursor', 'User', 'mcp.json')),
+    jsonConfig('antigravity', 'Antigravity', path.join(home, '.antigravity', 'mcp.json')),
+    jsonConfig('antigravity', 'Antigravity', path.join(appData, 'Antigravity', 'User', 'mcp.json')),
+    jsonConfig('claude-code', 'Claude Code', path.join(home, '.claude.json')),
+    jsonConfig('claude-code', 'Claude Code', path.join(home, '.claude', 'mcp.json')),
+    jsonConfig('claude-code', 'Claude Code', path.join(cwd, '.mcp.json')),
+    codexConfig(path.join(home, '.codex', 'config.toml')),
+    codexConfig(path.join(appData, 'Codex', 'config.toml')),
+    jsonConfig('windsurf', 'Windsurf', path.join(home, '.codeium', 'windsurf', 'mcp_config.json')),
+    jsonConfig('vscode', 'VS Code', path.join(appData, 'Code', 'User', 'mcp.json')),
+  ];
+}
+
+function readJson(file) {
+  if (!fs.existsSync(file)) return null;
+  const text = fs.readFileSync(file, 'utf8').trim();
+  if (!text) return {};
+  return JSON.parse(text);
+}
+
+function hasSampleJson(data, section = 'mcpServers') {
+  if (!data || typeof data !== 'object') return false;
+  const servers = data[section];
+  if (servers && typeof servers === 'object') {
+    if (servers[SERVER_NAME]) return true;
+    return Object.entries(servers).some(([name, server]) => {
+      if (String(name).toLowerCase() === SERVER_NAME) return true;
+      if (String(name).toLowerCase() === 'synapse') return true;
+      return (
+        server &&
+        typeof server === 'object' &&
+        typeof server.command === 'string' &&
+        /(sample-mcp|synapse-mcp)/.test(server.command)
+      );
+    });
+  }
+
+  return Object.values(data).some((value) => {
+    if (!value || typeof value !== 'object') return false;
+    return hasSampleJson(value, section);
+  });
+}
+
+function hasSampleToml(text) {
+  return (
+    /\[\s*mcp_servers\.sample-mcp\s*\]/.test(text) ||
+    /\[\s*mcp_servers\.synapse\s*\]/.test(text) ||
+    /(sample-mcp|synapse-mcp)/.test(text)
+  );
+}
+
+function discoverHarnesses(options = {}) {
+  const seen = new Set();
+  const discovered = [];
+
+  for (const candidate of candidateConfigs(options)) {
+    const key = `${candidate.id}:${candidate.configPath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (!fs.existsSync(candidate.configPath)) continue;
+
+    let hasSample = false;
+    try {
+      if (candidate.type === 'json') {
+        hasSample = hasSampleJson(readJson(candidate.configPath), candidate.section);
+      } else if (candidate.type === 'toml') {
+        hasSample = hasSampleToml(fs.readFileSync(candidate.configPath, 'utf8'));
+      }
+    } catch (err) {
+      discovered.push({ ...candidate, installed: true, hasSample: false, parseError: err.message });
+      continue;
+    }
+
+    discovered.push({ ...candidate, installed: true, hasSample });
+  }
+
+  return discovered;
+}
+
+function writeJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function configureJsonHarness(harness, serverConfig) {
+  const current = readJson(harness.configPath) || {};
+  if (hasSampleJson(current, harness.section)) return false;
+  if (!current[harness.section] || typeof current[harness.section] !== 'object') {
+    current[harness.section] = {};
+  }
+  current[harness.section][SERVER_NAME] = serverConfig;
+  writeJson(harness.configPath, current);
+  return true;
+}
+
+function configureTomlHarness(harness, serverConfig) {
+  let current = fs.existsSync(harness.configPath) ? fs.readFileSync(harness.configPath, 'utf8') : '';
+  if (hasSampleToml(current)) return false;
+  if (current.length && !current.endsWith('\n')) current += '\n';
+  const args = JSON.stringify(serverConfig.args || ['serve']);
+  const block = [
+    '',
+    '[mcp_servers.sample-mcp]',
+    `command = ${JSON.stringify(serverConfig.command)}`,
+    `args = ${args}`,
+    '',
+  ].join('\n');
+  fs.mkdirSync(path.dirname(harness.configPath), { recursive: true });
+  fs.writeFileSync(harness.configPath, current + block);
+  return true;
+}
+
+function configureHarness(harness, options = {}) {
+  const serverConfig = sampleServerConfig(options.command || 'sample-mcp');
+  if (harness.type === 'json') return configureJsonHarness(harness, serverConfig);
+  if (harness.type === 'toml') return configureTomlHarness(harness, serverConfig);
+  throw new Error(`Unsupported harness config type: ${harness.type}`);
+}
+
+function ask(question, rl) {
+  return new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+}
+
+async function offerMcpConfig(options = {}) {
+  const quiet = Boolean(options.quiet);
+  if (quiet) return [];
+
+  const harnesses = discoverHarnesses(options);
+  if (harnesses.length === 0) {
+    console.error(
+      'No supported MCP editor configs found. Supported: Cursor, Antigravity, Claude Code, Codex, Windsurf, VS Code.'
+    );
+    return [];
+  }
+
+  const pending = harnesses.filter((h) => !h.hasSample && !h.parseError);
+  const alreadyConfigured = harnesses.filter((h) => h.hasSample);
+  for (const harness of alreadyConfigured) {
+    console.error(`Sample MCP is already configured for ${harness.label}: ${harness.configPath}`);
+  }
+  for (const harness of harnesses.filter((h) => h.parseError)) {
+    console.error(`Skipping ${harness.label}; could not parse ${harness.configPath}: ${harness.parseError}`);
+  }
+  if (pending.length === 0) return [];
+
+  const yes = Boolean(options.yes);
+  const rl = yes ? null : readline.createInterface({ input: process.stdin, output: process.stderr });
+  const configured = [];
+  try {
+    for (const harness of pending) {
+      let shouldConfigure = yes;
+      if (!yes) {
+        const answer = await ask(
+          `Add Sample MCP to ${harness.label} (${harness.configPath})? [Y/n] `,
+          rl
+        );
+        shouldConfigure = answer === '' || /^y(es)?$/i.test(answer);
+      }
+      if (!shouldConfigure) continue;
+      if (configureHarness(harness, { command: options.command || 'sample-mcp' })) {
+        configured.push(harness);
+        console.error(`Configured Sample MCP for ${harness.label}: ${harness.configPath}`);
+      }
+    }
+  } finally {
+    if (rl) rl.close();
+  }
+  return configured;
+}
+
+module.exports = {
+  SERVER_NAME,
+  candidateConfigs,
+  configureHarness,
+  discoverHarnesses,
+  hasSampleJson,
+  hasSampleToml,
+  offerMcpConfig,
+  sampleServerConfig,
+  // Backward-compatible aliases
+  hasSynapseJson: hasSampleJson,
+  hasSynapseToml: hasSampleToml,
+  synapseServerConfig: sampleServerConfig,
+};

package/lib/version.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const childProcess = require('child_process');
+const { launcherVersion, resolvePaths } = require('./install');
+
+const RUNTIME_NAME = 'sample_mcp';
+
+function runtimeCacheRoots() {
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  const roots = [path.join(home, '.local', 'share', 'sample-mcp', 'base')];
+
+  if (process.platform === 'darwin') {
+    roots.push(path.join(home, 'Library', 'Application Support', 'sample-mcp', 'base'));
+  }
+
+  if (process.env.LOCALAPPDATA) {
+    roots.push(path.join(process.env.LOCALAPPDATA, 'sample-mcp', 'base'));
+  }
+
+  // Legacy Synapse-branded cache locations
+  roots.push(path.join(home, '.local', 'share', 'synapse-mcp', 'base'));
+  if (process.platform === 'darwin') {
+    roots.push(path.join(home, 'Library', 'Application Support', 'synapse-mcp', 'base'));
+  }
+
+  return roots;
+}
+
+function detectDownloadedRuntime() {
+  const encNames =
+    process.platform === 'win32'
+      ? ['sample_mcp.exe.enc', 'synapse_mcp.exe.enc']
+      : ['sample_mcp.enc', 'synapse_mcp.enc'];
+
+  for (const baseDir of runtimeCacheRoots()) {
+    if (!fs.existsSync(baseDir)) continue;
+
+    const versions = fs.readdirSync(baseDir).filter((entry) => {
+      return encNames.some((name) => fs.existsSync(path.join(baseDir, entry, name)));
+    });
+
+    if (versions.length === 0) continue;
+
+    versions.sort((a, b) => b.localeCompare(a));
+    return versions[0];
+  }
+
+  return null;
+}
+
+function launcherVersionJson(binPath, spawnSync = childProcess.spawnSync) {
+  const result = spawnSync(binPath, ['version', '--json'], { encoding: 'utf8' });
+  if (result.status !== 0) return null;
+
+  try {
+    return JSON.parse(`${result.stdout || ''}`.trim());
+  } catch {
+    return null;
+  }
+}
+
+function collectVersionInfo(options = {}) {
+  const pkg = options.pkg || require('../package.json');
+  const spawnSync = options.spawnSync || childProcess.spawnSync;
+  const { binPath } = resolvePaths(options);
+
+  const info = {
+    shim: {
+      name: '@myelixlabs/sample-mcp',
+      version: pkg.version,
+    },
+    launcher: {
+      installed: false,
+      version: null,
+      path: binPath,
+    },
+    runtime: {
+      name: RUNTIME_NAME,
+      version: null,
+      downloaded: false,
+    },
+  };
+
+  if (!fs.existsSync(binPath)) {
+    return info;
+  }
+
+  info.launcher.installed = true;
+  info.launcher.version = launcherVersion(binPath, spawnSync);
+
+  const launcherJson = launcherVersionJson(binPath, spawnSync);
+  if (launcherJson) {
+    if (launcherJson.launcher_version) {
+      info.launcher.version = launcherJson.launcher_version;
+    }
+    if (launcherJson.runtime_downloaded && launcherJson.resolved_version) {
+      info.runtime.downloaded = true;
+      info.runtime.version = launcherJson.resolved_version;
+    }
+  }
+
+  if (!info.runtime.downloaded) {
+    const cachedVersion = detectDownloadedRuntime();
+    if (cachedVersion) {
+      info.runtime.downloaded = true;
+      info.runtime.version = cachedVersion;
+    }
+  }
+
+  return info;
+}
+
+function formatVersionInfo(info) {
+  const lines = [`sample-mcp npm shim: ${info.shim.version}`];
+
+  if (info.launcher.installed) {
+    lines.push(`sample-mcp launcher: ${info.launcher.version || 'unknown'} (${info.launcher.path})`);
+  } else {
+    lines.push('sample-mcp launcher: not installed');
+  }
+
+  if (info.runtime.downloaded) {
+    lines.push(`${info.runtime.name} runtime: ${info.runtime.version} (downloaded)`);
+  } else {
+    lines.push(`${info.runtime.name} runtime: not downloaded`);
+  }
+
+  return lines.join('\n');
+}
+
+function printVersionInfo(options = {}) {
+  const info = collectVersionInfo(options);
+  if (options.json) {
+    console.log(JSON.stringify(info, null, 2));
+    return info;
+  }
+
+  console.log(formatVersionInfo(info));
+  return info;
+}
+
+module.exports = {
+  RUNTIME_NAME,
+  collectVersionInfo,
+  detectDownloadedRuntime,
+  formatVersionInfo,
+  launcherVersionJson,
+  printVersionInfo,
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@myelixlabs/sample-mcp",
+  "version": "0.1.6",
+  "description": "POC installer/launcher for the Sample MCP precompiled binary.",
+  "bin": {
+    "sample-mcp": "bin/sample-mcp.js",
+    "synapse-mcp": "bin/synapse-mcp.js"
+  },
+  "scripts": {
+    "postinstall": "node bin/sample-mcp.js install --quiet",
+    "test": "node --test test/*.test.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=18"
+  }
+}