html2pptx-local-mcp 1.1.17

package/lib/local-slide-editor-launcher.js

@@ -0,0 +1,353 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { access, readFile, realpath, stat } from 'node:fs/promises';
+import { dirname, extname, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ALLOWED_EXTENSIONS = new Set(['.html', '.htm']);
+const EDITOR_SERVER_STATE_FILE = '.html2pptx/edit-slide/editor-server.json';
+const LEGACY_EDITOR_SERVER_STATE_FILE = '.open-slide/editor-server.json';
+const DEFAULT_LAUNCH_TIMEOUT_MS = 10000;
+
+export function createLocalSlideEditorManager(options = {}) {
+  const sessions = new Map();
+  const rootCwd = options.cwd
+    ? resolve(options.cwd)
+    : resolve(process.env.CLAUDE_PROJECT_DIR || process.cwd());
+  const launchTimeoutMs = Number.isFinite(options.launchTimeoutMs)
+    ? Math.max(1000, Math.floor(options.launchTimeoutMs))
+    : DEFAULT_LAUNCH_TIMEOUT_MS;
+
+  async function open(input = {}) {
+    const file = await resolveEditableFile(input.filePath, rootCwd);
+    const baseUrl = normalizeEditorBaseUrl(
+      input.baseUrl || process.env.HTML2PPTX_EDITOR_BASE_URL || await readRegisteredEditorBaseUrl(file.root),
+    );
+    const port = normalizePort(input.port, 0);
+    const openBrowser = input.openBrowser !== false;
+    const invocation = resolveCliInvocation(options);
+    const childArgs = [
+      ...invocation.baseArgs,
+      'edit',
+      file.relativePath,
+      '--json',
+      '--base-url',
+      baseUrl,
+      '--port',
+      String(port),
+    ];
+    if (!openBrowser) childArgs.push('--no-open');
+
+    const child = spawn(invocation.command, childArgs, {
+      cwd: file.root,
+      env: {
+        ...process.env,
+        NO_COLOR: '1',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const session = {
+      id: randomUUID(),
+      child,
+      command: invocation.command,
+      args: childArgs,
+      filePath: file.absolutePath,
+      relativePath: file.relativePath,
+      root: file.root,
+      startedAt: new Date().toISOString(),
+      stdout: '',
+      stderr: '',
+      details: null,
+    };
+    sessions.set(session.id, session);
+
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+
+    child.stdout.on('data', (chunk) => {
+      session.stdout += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+      session.stderr += chunk;
+    });
+    child.once('exit', () => {
+      sessions.delete(session.id);
+    });
+
+    const details = await waitForBridgeDetails(session, launchTimeoutMs);
+    session.details = details;
+    return redactSessionForResponse(session);
+  }
+
+  async function stop(sessionId) {
+    if (typeof sessionId !== 'string' || sessionId.trim() === '') {
+      throw new Error('sessionId must be a non-empty string.');
+    }
+    const session = sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Local slide editor session not found: ${sessionId}`);
+    }
+    session.child.kill('SIGTERM');
+    sessions.delete(sessionId);
+    return {
+      sessionId,
+      stopped: true,
+      file: session.relativePath,
+    };
+  }
+
+  function list() {
+    return Array.from(sessions.values(), redactSessionForResponse);
+  }
+
+  function stopAll() {
+    for (const session of sessions.values()) {
+      session.child.kill('SIGTERM');
+    }
+    sessions.clear();
+  }
+
+  return {
+    open,
+    stop,
+    list,
+    stopAll,
+  };
+}
+
+export const localSlideEditorManager = createLocalSlideEditorManager();
+
+export async function resolveEditableFile(filePath, cwd = process.cwd()) {
+  if (typeof filePath !== 'string' || filePath.trim() === '') {
+    throw new Error('filePath must be a non-empty .html or .htm path.');
+  }
+
+  const root = await resolveRealpath(cwd);
+  const absolutePath = resolve(root, filePath);
+  if (absolutePath !== root && !absolutePath.startsWith(root + sep)) {
+    throw new Error('filePath must be inside the MCP server working directory.');
+  }
+
+  const extension = extname(absolutePath).toLowerCase();
+  if (!ALLOWED_EXTENSIONS.has(extension)) {
+    throw new Error('Only .html and .htm files can be opened in the local slide editor.');
+  }
+
+  const info = await stat(absolutePath).catch(() => null);
+  if (!info || !info.isFile()) {
+    throw new Error(`HTML file not found: ${filePath}`);
+  }
+
+  const realFile = await resolveRealpath(absolutePath);
+  if (realFile !== root && !realFile.startsWith(root + sep)) {
+    throw new Error('filePath must not escape the working directory through a symlink.');
+  }
+
+  return {
+    root,
+    absolutePath: realFile,
+    relativePath: toPosixPath(relative(root, realFile)),
+  };
+}
+
+export function resolveCliInvocation(options = {}) {
+  if (options.command) {
+    return {
+      command: options.command,
+      baseArgs: Array.isArray(options.baseArgs) ? options.baseArgs : [],
+    };
+  }
+
+  const envCommand = process.env.HTML2PPTX_CLI_BIN;
+  if (envCommand) {
+    return {
+      command: envCommand,
+      baseArgs: [],
+    };
+  }
+
+  const bundledCli = fileURLToPath(new URL('../cli/dist/index.js', import.meta.url));
+  if (existsSync(bundledCli)) {
+    return {
+      command: process.execPath,
+      baseArgs: [bundledCli],
+    };
+  }
+
+  return {
+    command: 'html2pptx',
+    baseArgs: [],
+  };
+}
+
+export function parseBridgeDetails(stdout) {
+  const lines = String(stdout || '').split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed?.success && parsed?.editorUrl && parsed?.bridgeUrl) {
+        return parsed;
+      }
+    } catch {
+      // Ignore non-JSON log lines.
+    }
+  }
+  return null;
+}
+
+function waitForBridgeDetails(session, timeoutMs) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let done = false;
+
+    const cleanup = () => {
+      session.child.stdout.off('data', onStdout);
+      session.child.off('exit', onExit);
+      clearTimeout(timer);
+    };
+
+    const finish = (fn, value) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      fn(value);
+    };
+
+    const onStdout = () => {
+      const details = parseBridgeDetails(session.stdout);
+      if (details) finish(resolvePromise, details);
+    };
+
+    const onExit = (code, signal) => {
+      finish(
+        rejectPromise,
+        new Error(
+          [
+            `html2pptx edit exited before the local bridge was ready (code ${code ?? 'null'}, signal ${signal ?? 'none'}).`,
+            session.stderr.trim() || session.stdout.trim(),
+          ].filter(Boolean).join(' '),
+        ),
+      );
+    };
+
+    const timer = setTimeout(() => {
+      session.child.kill('SIGTERM');
+      finish(
+        rejectPromise,
+        new Error(`Timed out after ${timeoutMs}ms while starting the local slide editor bridge.`),
+      );
+    }, timeoutMs);
+
+    session.child.stdout.on('data', onStdout);
+    session.child.once('exit', onExit);
+    onStdout();
+  });
+}
+
+function redactSessionForResponse(session) {
+  const details = session.details || {};
+  return {
+    sessionId: session.id,
+    pid: session.child.pid,
+    editorUrl: details.editorUrl,
+    bridgeUrl: details.bridgeUrl,
+    sessionTokenRequired: details.sessionTokenRequired !== false,
+    file: details.file || session.relativePath,
+    root: details.root || session.root,
+    startedAt: session.startedAt,
+  };
+}
+
+async function resolveRealpath(path) {
+  try {
+    await access(path);
+    return await realpath(path);
+  } catch (error) {
+    if (path === dirname(path)) throw error;
+    const parent = await resolveRealpath(dirname(path));
+    return resolve(parent, relative(dirname(path), path));
+  }
+}
+
+export function normalizeEditorBaseUrl(raw) {
+  try {
+    if (!raw) {
+      throw new Error(
+        'Local editor UI is not registered. Start it with `node scripts/dev-studio.mjs`, then retry, or pass baseUrl as a loopback editor URL.',
+      );
+    }
+    const url = new URL(raw);
+    url.search = '';
+    url.hash = '';
+    if (!isAllowedEditorBaseUrl(url)) {
+      throw new Error(
+        'baseUrl for local file editing must be a loopback http(s) origin such as http://localhost:<port>. Hosted editor URLs are not allowed.',
+      );
+    }
+    return url.toString().replace(/\/$/, '');
+  } catch (error) {
+    if (error?.message?.startsWith('baseUrl must be ')) throw error;
+    if (error?.message?.startsWith('baseUrl for local file editing')) throw error;
+    if (error?.message?.startsWith('Local editor UI is not registered')) throw error;
+    throw new Error('baseUrl must be a valid http(s) URL.');
+  }
+}
+
+function isAllowedEditorBaseUrl(url) {
+  if (!['http:', 'https:'].includes(url.protocol)) return false;
+  return isLoopbackHostname(url.hostname);
+}
+
+export async function readRegisteredEditorBaseUrl(root = process.cwd()) {
+  for (const stateFile of [EDITOR_SERVER_STATE_FILE, LEGACY_EDITOR_SERVER_STATE_FILE]) {
+    try {
+      const raw = await readFile(join(root, stateFile), 'utf8');
+      const state = JSON.parse(raw);
+      if (typeof state?.baseUrl === 'string') return state.baseUrl;
+    } catch {
+      // Try the next known state location.
+    }
+  }
+  return null;
+}
+
+function isLoopbackHostname(hostname) {
+  const host = String(hostname || '').replace(/^\[|\]$/g, '').toLowerCase();
+  return (
+    host === 'localhost' ||
+    host === '::1' ||
+    host === '0:0:0:0:0:0:0:1' ||
+    /^127(?:\.\d{1,3}){3}$/.test(host)
+  );
+}
+
+function normalizePort(value, fallback) {
+  if (value == null || value === '') return fallback;
+  const port = Number.parseInt(String(value), 10);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error('port must be an integer from 0 to 65535.');
+  }
+  return port;
+}
+
+function toPosixPath(filePath) {
+  return filePath.split(sep).join('/');
+}
+
+function installExitHandlers() {
+  const stop = () => localSlideEditorManager.stopAll();
+  process.once('exit', stop);
+  process.once('SIGINT', () => {
+    stop();
+    process.exit(130);
+  });
+  process.once('SIGTERM', () => {
+    stop();
+    process.exit(143);
+  });
+}
+
+installExitHandlers();