html2pptx-local-mcp 1.1.17

package/scripts/install-mcp.mjs

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import packageJson from '../package.json' with { type: 'json' };
+
+const VERSION = packageJson.version;
+const PACKAGE_SPEC = 'html2pptx-local-mcp@latest';
+const VERSIONED_PACKAGE_SPEC = `html2pptx-local-mcp@${VERSION}`;
+const PACKAGE_URL = 'https://html2pptx.app/downloads/html2pptx-local-mcp-latest.tgz';
+const VERSIONED_PACKAGE_URL = `https://html2pptx.app/downloads/html2pptx-local-mcp-${VERSION}.tgz`;
+const MANIFEST_URL = 'https://html2pptx.app/downloads/latest.json';
+const REMOTE_MCP_URL = 'https://html2pptx.app/mcp';
+const LOCAL_SERVER_NAME = 'html2pptx-local';
+const REMOTE_SERVER_NAME = 'html2pptx';
+const LAUNCHER_PATH = join(homedir(), '.html2pptx', 'bin', 'html2pptx-local-mcp-launcher.mjs');
+const INSTALL_ROOT = join(homedir(), '.html2pptx', 'local-mcp', VERSION);
+const LOCAL_PACKAGE_ROOT = join(INSTALL_ROOT, 'node_modules', 'html2pptx-local-mcp');
+const LOCAL_SERVER_ENTRY = join(LOCAL_PACKAGE_ROOT, 'mcp', 'pptx-studio-mcp-server.mjs');
+
+if (isMain()) {
+  main();
+}
+
+function main() {
+  const target = process.argv[2] || 'claude';
+
+  if (!['claude'].includes(target)) {
+    fail(`Unsupported target "${target}". Usage: html2pptx-install-mcp claude`);
+  }
+
+  console.log(`Installing html2pptx MCP for ${target}.`);
+  console.log(`Remote server: ${REMOTE_SERVER_NAME} -> ${REMOTE_MCP_URL}`);
+  console.log(`Local server:  ${LOCAL_SERVER_NAME} -> ${PACKAGE_SPEC}`);
+  console.log(`Local launcher: ${LAUNCHER_PATH}`);
+  console.log('');
+
+  installClaude();
+
+  console.log('');
+  console.log('html2pptx MCP setup finished.');
+  console.log('Restart Claude Code if it was already running.');
+}
+
+function isMain() {
+  return import.meta.url === new URL(process.argv[1], 'file:').href;
+}
+
+function installClaude() {
+  runClaudeRemoteAdd();
+  installLocalPackage();
+  writeLocalLauncher();
+  writeClaudeLocalConfig();
+}
+
+function runClaudeRemoteAdd() {
+  const args = [
+    'mcp',
+    'add',
+    '--scope',
+    'user',
+    '--transport',
+    'http',
+    REMOTE_SERVER_NAME,
+    REMOTE_MCP_URL,
+  ];
+  console.log(`> claude ${args.join(' ')}`);
+  const result = spawnSync(commandForPlatform('claude'), args, { encoding: 'utf8' });
+
+  if (result.status === 0) {
+    printOutput(result);
+    return;
+  }
+
+  const combined = `${result.stdout || ''}\n${result.stderr || ''}`;
+  if (/already exists|already registered|duplicate/i.test(combined)) {
+    console.log('claude reported that this MCP server is already registered; continuing.');
+    printOutput(result);
+    return;
+  }
+
+  printOutput(result);
+  fail('Failed to register the remote html2pptx MCP server with Claude Code.');
+}
+
+function installLocalPackage() {
+  mkdirSync(INSTALL_ROOT, { recursive: true });
+  const args = ['install', '--silent', '--prefix', INSTALL_ROOT, VERSIONED_PACKAGE_SPEC];
+  console.log(`> npm ${args.join(' ')}`);
+  const result = spawnSync(commandForPlatform('npm'), args, { stdio: 'inherit' });
+  if (result.status !== 0) {
+    fail(`Failed to install ${PACKAGE_URL}.`);
+  }
+  if (!existsSync(LOCAL_SERVER_ENTRY)) {
+    fail(`Installed package is missing ${LOCAL_SERVER_ENTRY}.`);
+  }
+}
+
+function writeClaudeLocalConfig() {
+  const configPath = join(homedir(), '.claude.json');
+  const config = readJsonObject(configPath);
+  config.mcpServers = isPlainObject(config.mcpServers) ? config.mcpServers : {};
+  config.mcpServers[LOCAL_SERVER_NAME] = {
+    type: 'stdio',
+    command: process.execPath,
+    args: [LAUNCHER_PATH],
+    env: {},
+  };
+
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  console.log(`Updated ${configPath}`);
+}
+
+function writeLocalLauncher() {
+  mkdirSync(dirname(LAUNCHER_PATH), { recursive: true });
+  writeFileSync(LAUNCHER_PATH, launcherSource(), 'utf8');
+  chmodSync(LAUNCHER_PATH, 0o755);
+  console.log(`Updated ${LAUNCHER_PATH}`);
+}
+
+function readJsonObject(path) {
+  if (!existsSync(path)) return {};
+  const raw = readFileSync(path, 'utf8').trim();
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return isPlainObject(parsed) ? parsed : {};
+  } catch (error) {
+    fail(`Could not parse ${path}: ${error.message}`);
+  }
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function printOutput(result) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+}
+
+function fail(message) {
+  console.error(`error: ${message}`);
+  process.exit(1);
+}
+
+function commandForPlatform(command) {
+  return process.platform === 'win32' ? `${command}.cmd` : command;
+}
+
+function launcherSource() {
+  return `#!/usr/bin/env node
+
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
+
+const FALLBACK_VERSION = ${JSON.stringify(VERSION)};
+const FALLBACK_PACKAGE_SPEC = ${JSON.stringify(VERSIONED_PACKAGE_SPEC)};
+const FALLBACK_PACKAGE_URL = ${JSON.stringify(VERSIONED_PACKAGE_URL)};
+const FALLBACK_LATEST_PACKAGE_URL = ${JSON.stringify(PACKAGE_URL)};
+const MANIFEST_URL = process.env.HTML2PPTX_LOCAL_MCP_MANIFEST_URL || ${JSON.stringify(MANIFEST_URL)};
+const INSTALL_BASE = join(homedir(), '.html2pptx', 'local-mcp');
+const PACKAGE_NAME = 'html2pptx-local-mcp';
+
+main().catch((error) => {
+  log('launcher failed: ' + (error?.message || String(error)));
+  process.exit(1);
+});
+
+async function main() {
+  const manifest = await fetchManifest();
+  const desired = normalizeManifest(manifest) || {
+    version: FALLBACK_VERSION,
+    packageSpec: FALLBACK_PACKAGE_SPEC || FALLBACK_PACKAGE_URL || FALLBACK_LATEST_PACKAGE_URL,
+  };
+
+  let entry = serverEntryForVersion(desired.version);
+  if (!existsSync(entry)) {
+    const installed = installVersion(desired.version, desired.packageSpec);
+    if (installed) {
+      entry = serverEntryForVersion(desired.version);
+    }
+  }
+
+  if (!existsSync(entry)) {
+    entry = findNewestInstalledServer();
+  }
+
+  if (!entry) {
+    throw new Error('No installed html2pptx local MCP server found.');
+  }
+
+  const child = spawn(process.execPath, [entry, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+async function fetchManifest() {
+  try {
+    const response = await fetch('https://registry.npmjs.org/' + PACKAGE_NAME + '/latest', {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(2500),
+    });
+    if (response.ok) {
+      const payload = await response.json();
+      if (payload && typeof payload.version === 'string' && payload.version.trim()) {
+        return {
+          version: payload.version.trim(),
+          packageSpec: PACKAGE_NAME + '@' + payload.version.trim(),
+        };
+      }
+    }
+  } catch {
+    // Fall back to html2pptx.app manifest.
+  }
+
+  try {
+    const response = await fetch(MANIFEST_URL, {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(2500),
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+function normalizeManifest(value) {
+  if (!value || typeof value !== 'object') return null;
+  const version = typeof value.version === 'string' ? value.version.trim() : '';
+  const packageSpec =
+    typeof value.packageSpec === 'string' ? value.packageSpec.trim()
+    : typeof value.packageUrl === 'string' ? value.packageUrl.trim()
+    : typeof value.latestPackageUrl === 'string' ? value.latestPackageUrl.trim()
+    : '';
+  if (!version || !packageSpec) return null;
+  if (
+    !packageSpec.startsWith(PACKAGE_NAME + '@') &&
+    !/^https:\\/\\/html2pptx\\.app\\/downloads\\//.test(packageSpec)
+  ) return null;
+  return { version, packageSpec };
+}
+
+function installVersion(version, packageSpec) {
+  mkdirSync(join(INSTALL_BASE, version), { recursive: true });
+  log('installing html2pptx local MCP ' + version);
+  const result = spawnSync(commandForPlatform('npm'), [
+    'install',
+    '--silent',
+    '--prefix',
+    join(INSTALL_BASE, version),
+    packageSpec,
+  ], {
+    encoding: 'utf8',
+  });
+  if (result.stdout) process.stderr.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return result.status === 0 && existsSync(serverEntryForVersion(version));
+}
+
+function serverEntryForVersion(version) {
+  return join(INSTALL_BASE, version, 'node_modules', PACKAGE_NAME, 'mcp', 'pptx-studio-mcp-server.mjs');
+}
+
+function findNewestInstalledServer() {
+  let versions = [];
+  try {
+    versions = readdirSync(INSTALL_BASE, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((version) => existsSync(serverEntryForVersion(version)));
+  } catch {
+    return '';
+  }
+  versions.sort(compareVersions).reverse();
+  return versions.length ? serverEntryForVersion(versions[0]) : '';
+}
+
+function compareVersions(a, b) {
+  const aa = String(a).split('.').map((part) => Number.parseInt(part, 10) || 0);
+  const bb = String(b).split('.').map((part) => Number.parseInt(part, 10) || 0);
+  for (let i = 0; i < Math.max(aa.length, bb.length); i += 1) {
+    const diff = (aa[i] || 0) - (bb[i] || 0);
+    if (diff) return diff;
+  }
+  return String(a).localeCompare(String(b));
+}
+
+function commandForPlatform(command) {
+  return process.platform === 'win32' ? command + '.cmd' : command;
+}
+
+function log(message) {
+  process.stderr.write('[html2pptx-local-mcp] ' + message + '\\n');
+}
+`;
+}