@rk0429/morphe-cli 0.1.0-dev.0

package/dist/index.js

@@ -0,0 +1,1725 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import {
+  AuthError,
+  AssetError,
+  FontValidationError,
+  GoogleSlidesApiError,
+  LayoutIntegrityError,
+  MORPHE_CORE_VERSION,
+  MarkdownAuthoringError,
+  ReauthRequiredError,
+  MORPHE_MCP_PATH,
+  PptxExtractionError,
+  ThemeResolutionError,
+  createAuthService,
+  createAssetRepository,
+  createComposePresentationFn,
+  createMermaidCliRenderer,
+  createNodeHttpRemoteFetcher,
+  createRenderPptxFn,
+  createResvgAssetBinaryProcessor,
+  createShikiCodeHighlighter,
+  extractGslides as extractGslidesFromCore,
+  extractPptx as extractPptxFromCore,
+  formatStyleYamlDiagnostic,
+  formatWorkspaceBaseline,
+  generateGslides as generateGslidesFromCore,
+  generatePptx as generatePptxFromCore,
+  listThemes,
+  packPptxEntries,
+  serveMcpOverStdio,
+  startMcpHttpServer,
+  validateYaml as validateYamlFromCore
+} from "@rk0429/morphe-core";
+import { lstat, mkdir, opendir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var CLI_VERSION = MORPHE_CORE_VERSION;
+var CLI_EXIT_CODES = {
+  success: 0,
+  input: 1,
+  layout: 2,
+  auth: 3,
+  api: 4,
+  internal: 70
+};
+var MARKDOWN_INPUT_MAX_BYTES = 10 * 1024 * 1024;
+var STYLE_YAML_INPUT_MAX_BYTES = 2 * 1024 * 1024;
+var CliUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+};
+var CliParseDiagnosticError = class extends CliUsageError {
+  diagnostic;
+  constructor(diagnostic) {
+    super(diagnostic.actual ?? "Input parse error.");
+    this.name = "CliParseDiagnosticError";
+    this.diagnostic = diagnostic;
+  }
+};
+function renderCliOutput() {
+  return formatWorkspaceBaseline();
+}
+var SERVICE_ACCOUNT_AUTH_GUIDANCE = "Use --service-account <path> or set GOOGLE_APPLICATION_CREDENTIALS to a service account JSON key, then retry. If OAuth was completed ahead of time, pass --token-path <path> or set MORPHE_TOKEN_PATH to the prepared token cache.";
+function writeLine(io, line) {
+  io.write(`${line}
+`);
+}
+function parseGlobalFlags(argv) {
+  const remaining = [];
+  const flags = {
+    verbose: false,
+    quiet: false,
+    nonInteractive: false
+  };
+  for (const arg of argv) {
+    if (arg === "--verbose") {
+      flags.verbose = true;
+      continue;
+    }
+    if (arg === "--quiet") {
+      flags.quiet = true;
+      continue;
+    }
+    if (arg === "--non-interactive") {
+      flags.nonInteractive = true;
+      continue;
+    }
+    remaining.push(arg);
+  }
+  if (flags.verbose && flags.quiet) {
+    throw new CliUsageError("`--verbose` and `--quiet` cannot be used together.");
+  }
+  return {
+    argv: remaining,
+    flags
+  };
+}
+function resolveNonInteractiveMode(dependencies, globalFlags) {
+  return globalFlags.nonInteractive || !isTtyInput(dependencies.stdin);
+}
+function isTtyInput(stdin) {
+  return stdin.isTTY === true;
+}
+function hasServiceAccountCredential(flags, env) {
+  return Boolean(flags.serviceAccountPath || env.GOOGLE_APPLICATION_CREDENTIALS);
+}
+function createNonInteractiveAuthError(action) {
+  return new AuthError(
+    `${action} cannot start the OAuth browser flow in non-interactive mode. ${SERVICE_ACCOUNT_AUTH_GUIDANCE}`,
+    "non_interactive_auth_required"
+  );
+}
+function formatNonInteractiveAuthFailure(error) {
+  return `${toErrorMessage(error)}
+${SERVICE_ACCOUNT_AUTH_GUIDANCE}`;
+}
+function parseLogFormat(value, source) {
+  if (value === "text" || value === "json") {
+    return value;
+  }
+  throw new CliUsageError(`${source} must be \`text\` or \`json\`.`);
+}
+var CONFIG_FILE_NAMES = [".morpherc", "morphe.config.yaml"];
+var FONT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".otf", ".ttf", ".woff", ".woff2"]);
+var RASTERIZATION_FONT_DIR_LIMITS = Object.freeze({
+  maxDirectories: 64,
+  maxFonts: 256,
+  maxSingleFontBytes: 32 * 1024 * 1024,
+  maxTotalFontBytes: 128 * 1024 * 1024
+});
+async function loadCliConfig(baseDir = process.cwd()) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const configPath = resolve(baseDir, fileName);
+    try {
+      const content = await readFile(configPath, "utf8");
+      return parseCliConfig(content, configPath);
+    } catch (error) {
+      if (isErrnoError(error) && error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return {
+    path: null,
+    fontDirs: []
+  };
+}
+function parseCliConfig(content, configPath) {
+  const rawConfig = parseConfigDocument(content, configPath);
+  const theme = optionalConfigString(rawConfig, ["theme"], configPath);
+  const rawLogFormat = optionalConfigString(rawConfig, ["logFormat", "log_format"], configPath) ?? void 0;
+  const rawFontDirs = rawConfig.fontDirs ?? rawConfig.font_dirs;
+  const fontDirs = normalizeConfigStringArray(rawFontDirs, "fontDirs", configPath).map(
+    (fontDir) => resolve(dirname(configPath), fontDir)
+  );
+  return {
+    path: configPath,
+    ...theme ? { theme } : {},
+    ...rawLogFormat ? { logFormat: parseLogFormat(rawLogFormat, `${configPath} logFormat`) } : {},
+    fontDirs
+  };
+}
+function parseConfigDocument(content, configPath) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) {
+    return {};
+  }
+  if (trimmed.startsWith("{")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      throw new CliUsageError(`${configPath} is not valid JSON: ${toErrorMessage(error)}`);
+    }
+    if (!isRecord(parsed)) {
+      throw new CliUsageError(`${configPath} must contain a JSON object.`);
+    }
+    return parsed;
+  }
+  return parseSimpleYamlConfig(content, configPath);
+}
+function parseSimpleYamlConfig(content, configPath) {
+  const result = {};
+  let listKey = null;
+  for (const [index, rawLine] of content.split(/\r?\n/u).entries()) {
+    const line = rawLine.replace(/\s+#.*$/u, "");
+    if (line.trim().length === 0) {
+      continue;
+    }
+    if (/^\s/u.test(line)) {
+      const item = line.trim().match(/^-\s+(.+)$/u);
+      if (!listKey || !item?.[1]) {
+        throw new CliUsageError(`${configPath}:L${index + 1} uses unsupported config YAML syntax.`);
+      }
+      const current = result[listKey];
+      if (!Array.isArray(current)) {
+        throw new CliUsageError(`${configPath}:L${index + 1} appends to a non-list config key.`);
+      }
+      current.push(parseYamlScalar(item[1]));
+      continue;
+    }
+    listKey = null;
+    const entry = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):(?:\s*(.*))?$/u);
+    if (!entry?.[1]) {
+      throw new CliUsageError(`${configPath}:L${index + 1} uses unsupported config YAML syntax.`);
+    }
+    const key = entry[1];
+    const value = entry[2] ?? "";
+    if (value.length === 0) {
+      result[key] = [];
+      listKey = key;
+      continue;
+    }
+    result[key] = value.trim().startsWith("[") ? parseInlineYamlList(value, configPath, index + 1) : parseYamlScalar(value);
+  }
+  return result;
+}
+function parseInlineYamlList(value, configPath, line) {
+  if (!value.endsWith("]")) {
+    throw new CliUsageError(`${configPath}:L${line} has an unterminated inline list.`);
+  }
+  const body = value.slice(1, -1).trim();
+  if (body.length === 0) {
+    return [];
+  }
+  return body.split(",").map((item) => parseYamlScalar(item));
+}
+function parseYamlScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function optionalConfigString(config, keys, configPath) {
+  for (const key of keys) {
+    const value = config[key];
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value !== "string") {
+      throw new CliUsageError(`${configPath} ${key} must be a string.`);
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  }
+  return void 0;
+}
+function normalizeConfigStringArray(value, key, configPath) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? [trimmed] : [];
+  }
+  if (!Array.isArray(value)) {
+    throw new CliUsageError(`${configPath} ${key} must be a string or string list.`);
+  }
+  return value.map((item) => {
+    if (typeof item !== "string") {
+      throw new CliUsageError(`${configPath} ${key} entries must be strings.`);
+    }
+    return item.trim();
+  }).filter((item) => item.length > 0);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveLogOptions(dependencies, globalFlags, flagLogFormat, config = { path: null, fontDirs: [] }) {
+  const envLogFormat = dependencies.env.MORPHE_LOG_FORMAT?.trim();
+  const format = flagLogFormat ?? (envLogFormat ? parseLogFormat(envLogFormat, "MORPHE_LOG_FORMAT") : config.logFormat ?? "text");
+  return {
+    format,
+    minimumLevel: globalFlags.quiet ? "error" : globalFlags.verbose ? "debug" : "info"
+  };
+}
+function shouldWriteLog(options, level) {
+  const levels = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40
+  };
+  return levels[level] >= levels[options.minimumLevel];
+}
+function writeLog(io, options, level, eventType, payload, text) {
+  if (!shouldWriteLog(options, level)) {
+    return;
+  }
+  if (options.format === "json") {
+    writeLine(
+      io,
+      JSON.stringify({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        event_type: eventType,
+        payload
+      })
+    );
+    return;
+  }
+  writeLine(io, text);
+}
+function resolveLogOptionsForError(dependencies, globalFlags, logOptions, args) {
+  if (logOptions) {
+    return logOptions;
+  }
+  return resolveLogOptions(dependencies, globalFlags, findRawLogFormat(args));
+}
+function findRawLogFormat(args) {
+  const logFormatIndex = args.indexOf("--log-format");
+  if (logFormatIndex === -1) {
+    return void 0;
+  }
+  const value = args[logFormatIndex + 1];
+  return value === "text" || value === "json" ? value : void 0;
+}
+function writeErrorDiagnostic(io, options, diagnostic, text) {
+  writeLog(io, options, "error", "diagnostic", diagnostic, text);
+}
+function createCliErrorDiagnostic(error, message, suggestion) {
+  if (isAuthError(error)) {
+    return {
+      error_type: "auth_error",
+      actual: message,
+      suggestion: SERVICE_ACCOUNT_AUTH_GUIDANCE
+    };
+  }
+  const pptxExtractionError = findFirstErrorInChain(error, PptxExtractionError);
+  if (pptxExtractionError) {
+    return {
+      error_type: pptxExtractionError.errorType,
+      actual: message,
+      suggestion
+    };
+  }
+  return {
+    error_type: isInputError(error) ? "parse_error" : "internal_error",
+    actual: message,
+    suggestion
+  };
+}
+function parseOptionalEnvBoolean(value, source) {
+  if (value === void 0 || value.trim().length === 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  throw new CliUsageError(`${source} must be a boolean value.`);
+}
+function resolveRemoteFetchPolicy(flags, env) {
+  const policy = {};
+  const envAllowRemote = parseOptionalEnvBoolean(
+    env.MORPHE_ALLOW_REMOTE_IMAGES,
+    "MORPHE_ALLOW_REMOTE_IMAGES"
+  );
+  if (flags.allowRemoteImages) {
+    policy.allowRemote = true;
+  } else if (envAllowRemote !== void 0) {
+    policy.allowRemote = envAllowRemote;
+  }
+  if (flags.allowPrivateIp) {
+    policy.allowPrivateIp = true;
+  }
+  return Object.keys(policy).length > 0 ? policy : void 0;
+}
+async function resolveRasterizationFontSources(flags, config) {
+  const collectionState = {
+    directoryCount: 0,
+    fontCount: 0,
+    seenDirectories: /* @__PURE__ */ new Set(),
+    totalBytes: 0
+  };
+  return [
+    ...await collectRasterizationFontSources(
+      flags.fontDirs,
+      "CliSpecifiedFont",
+      process.cwd(),
+      collectionState
+    ),
+    ...await collectRasterizationFontSources(
+      config.fontDirs,
+      "ProjectLocalFont",
+      process.cwd(),
+      collectionState
+    )
+  ];
+}
+async function collectRasterizationFontSources(directories, source, baseDir, collectionState) {
+  const sources = [];
+  for (const directory of directories) {
+    const absoluteDirectory = resolve(baseDir, directory);
+    if (collectionState.seenDirectories.has(absoluteDirectory)) {
+      continue;
+    }
+    collectionState.seenDirectories.add(absoluteDirectory);
+    enforceFontDirectoryCountLimit(absoluteDirectory, collectionState);
+    await validateFontDirectory(absoluteDirectory);
+    let directoryHandle;
+    try {
+      directoryHandle = await opendir(absoluteDirectory);
+    } catch (error) {
+      if (isErrnoError(error) && ["ENOENT", "ENOTDIR"].includes(error.code ?? "")) {
+        throw new CliUsageError(`Font directory does not exist: ${absoluteDirectory}`);
+      }
+      throw error;
+    }
+    for await (const entry of directoryHandle) {
+      const extension = extname(entry.name).toLowerCase();
+      if (!FONT_FILE_EXTENSIONS.has(extension)) {
+        continue;
+      }
+      const fontPath = resolve(absoluteDirectory, entry.name);
+      const stats = await validateFontDirectoryEntry(fontPath, entry);
+      enforceFontDirectoryLimits(fontPath, stats.size, collectionState);
+      sources.push({
+        family: basename(entry.name, extension).replaceAll(/[_-]+/gu, " ").trim(),
+        source,
+        resolvedPath: fontPath,
+        fallbackFor: null
+      });
+    }
+  }
+  return sources.filter((fontSource) => fontSource.family.length > 0);
+}
+function enforceFontDirectoryCountLimit(directory, collectionState) {
+  const nextDirectoryCount = collectionState.directoryCount + 1;
+  if (nextDirectoryCount > RASTERIZATION_FONT_DIR_LIMITS.maxDirectories) {
+    throw createFontDirsParseError(
+      `fontDirs contain more than ${RASTERIZATION_FONT_DIR_LIMITS.maxDirectories} directories: ${directory}.`
+    );
+  }
+  collectionState.directoryCount = nextDirectoryCount;
+}
+async function validateFontDirectory(directory) {
+  let stats;
+  try {
+    stats = await lstat(directory);
+  } catch (error) {
+    if (isErrnoError(error) && ["ENOENT", "ENOTDIR"].includes(error.code ?? "")) {
+      throw new CliUsageError(`Font directory does not exist: ${directory}`);
+    }
+    throw error;
+  }
+  if (stats.isSymbolicLink() || !stats.isDirectory()) {
+    throw createFontDirsParseError(`Font directory is not a regular directory: ${directory}`);
+  }
+}
+async function validateFontDirectoryEntry(fontPath, entry) {
+  let stats;
+  try {
+    stats = await lstat(fontPath);
+  } catch (error) {
+    throw createFontDirsParseError(
+      `Font file could not be inspected before rasterization: ${fontPath}`,
+      toErrorMessage(error)
+    );
+  }
+  if (!entry.isFile() || stats.isSymbolicLink() || !stats.isFile()) {
+    throw createFontDirsParseError(`Font path is not a regular file: ${fontPath}`);
+  }
+  return {
+    size: stats.size
+  };
+}
+function enforceFontDirectoryLimits(fontPath, size, collectionState) {
+  if (size > RASTERIZATION_FONT_DIR_LIMITS.maxSingleFontBytes) {
+    throw createFontDirsParseError(
+      `Font file exceeds the ${formatByteCount(RASTERIZATION_FONT_DIR_LIMITS.maxSingleFontBytes)} per-file limit: ${fontPath} (${formatByteCount(size)}).`
+    );
+  }
+  const nextFontCount = collectionState.fontCount + 1;
+  if (nextFontCount > RASTERIZATION_FONT_DIR_LIMITS.maxFonts) {
+    throw createFontDirsParseError(
+      `fontDirs contain more than ${RASTERIZATION_FONT_DIR_LIMITS.maxFonts} font files.`
+    );
+  }
+  const nextTotalBytes = collectionState.totalBytes + size;
+  if (nextTotalBytes > RASTERIZATION_FONT_DIR_LIMITS.maxTotalFontBytes) {
+    throw createFontDirsParseError(
+      `fontDirs exceed the ${formatByteCount(RASTERIZATION_FONT_DIR_LIMITS.maxTotalFontBytes)} total font size limit (${formatByteCount(nextTotalBytes)}).`
+    );
+  }
+  collectionState.fontCount = nextFontCount;
+  collectionState.totalBytes = nextTotalBytes;
+}
+function createFontDirsParseError(actual, suggestion) {
+  return new CliParseDiagnosticError({
+    error_type: "parse_error",
+    actual,
+    suggestion: suggestion ?? "Reduce --font-dir inputs or remove oversized font files."
+  });
+}
+async function readTextFileWithLimit(filePath, fieldName, maxBytes) {
+  const stats = await lstat(filePath);
+  if (stats.size > maxBytes) {
+    throw new CliParseDiagnosticError({
+      error_type: "parse_error",
+      actual: `${fieldName} file exceeds the ${formatByteCount(maxBytes)} size limit: ${filePath} (${formatByteCount(stats.size)}).`,
+      expected: `${fieldName} file must be at most ${formatByteCount(maxBytes)}.`,
+      suggestion: `Reduce ${fieldName} to ${formatByteCount(maxBytes)} or less before running the command.`
+    });
+  }
+  return await readFile(filePath, "utf8");
+}
+function formatByteCount(bytes) {
+  const mib = bytes / (1024 * 1024);
+  return Number.isInteger(mib) ? `${mib} MiB` : `${bytes} bytes`;
+}
+function basenameWithoutExtension(path) {
+  const extension = extname(path);
+  return basename(path, extension);
+}
+function deriveOutputPath(outputDir, sourcePath, extension) {
+  return join(outputDir, `${basenameWithoutExtension(sourcePath)}${extension}`);
+}
+async function ensureDirectoryForOutputDir(outputDir) {
+  if (!outputDir) {
+    return;
+  }
+  await mkdir(outputDir, { recursive: true });
+}
+function deriveExtractOutputPath(flags) {
+  if (!flags.outputDir) {
+    return void 0;
+  }
+  if (flags.inputPath) {
+    return deriveOutputPath(flags.outputDir, flags.inputPath, ".yaml");
+  }
+  if (flags.presentationId) {
+    return join(flags.outputDir, `${flags.presentationId}.yaml`);
+  }
+  const presentationId = flags.presentationUrl?.match(/\/presentation\/d\/(?<id>[^/]+)/u)?.groups?.id;
+  return join(flags.outputDir, `${presentationId ?? "style"}.yaml`);
+}
+function resolveGenerateTheme(flags, env, config) {
+  const theme = flags.theme ?? (env.MORPHE_THEME && env.MORPHE_THEME.trim().length > 0 ? env.MORPHE_THEME : config.theme);
+  if (theme === void 0) {
+    return void 0;
+  }
+  const builtinThemeNames = new Set(listThemes().map((summary) => summary.name));
+  return builtinThemeNames.has(theme) ? `builtin:${theme}` : theme;
+}
+function resolveMcpPublicBaseUrl(value, bindHost) {
+  if (value === void 0) {
+    if (!isLoopbackHost(bindHost)) {
+      throw new CliUsageError(
+        "Non-loopback HTTP MCP bindings require an explicit HTTPS publicBaseUrl."
+      );
+    }
+    return void 0;
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CliUsageError("publicBaseUrl must be a valid absolute HTTP(S) URL.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new CliUsageError("publicBaseUrl must be a valid absolute HTTP(S) URL.");
+  }
+  if ((!isLoopbackHost(bindHost) || !isLoopbackHost(url.hostname)) && url.protocol !== "https:") {
+    throw new CliUsageError(
+      "Non-loopback HTTP MCP bindings require an explicit HTTPS publicBaseUrl."
+    );
+  }
+  return serializeBaseUrl(url);
+}
+function isLoopbackHost(host) {
+  const normalized = normalizeHostForComparison(host);
+  return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1";
+}
+function normalizeHostForComparison(host) {
+  const normalized = host.trim().toLowerCase();
+  return normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
+}
+function serializeBaseUrl(url) {
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/+$/u, "") || "/";
+  return url.pathname === "/" ? url.origin : `${url.origin}${url.pathname}`;
+}
+function detectCliExitCode(error) {
+  if (isInputError(error)) {
+    return CLI_EXIT_CODES.input;
+  }
+  if (isLayoutError(error)) {
+    return CLI_EXIT_CODES.layout;
+  }
+  if (isAuthError(error)) {
+    return CLI_EXIT_CODES.auth;
+  }
+  if (isApiError(error)) {
+    return CLI_EXIT_CODES.api;
+  }
+  return CLI_EXIT_CODES.internal;
+}
+function isInputError(error) {
+  if (error instanceof CliUsageError) {
+    return true;
+  }
+  if (errorChainContains(
+    error,
+    (candidate) => candidate instanceof AssetError && (candidate.diagnostic.errorType === "parse_error" || candidate.diagnostic.errorType === "schema_error")
+  )) {
+    return true;
+  }
+  if (error instanceof PptxExtractionError) {
+    return error.errorType === "parse_error";
+  }
+  if (error instanceof MarkdownAuthoringError) {
+    return error.errorType === "parse_error";
+  }
+  if (error instanceof ThemeResolutionError) {
+    return error.errorType === "parse_error" || error.errorType === "schema_error";
+  }
+  if (errorChainContains(error, (candidate) => candidate instanceof FontValidationError)) {
+    return true;
+  }
+  if (isErrnoError(error) && ["ENOENT", "EISDIR", "ENOTDIR"].includes(error.code ?? "")) {
+    return true;
+  }
+  return false;
+}
+function isLayoutError(error) {
+  if (errorChainContains(error, (candidate) => candidate instanceof LayoutIntegrityError)) {
+    return true;
+  }
+  const layoutIntegrityError = [...iterateErrorChain(error)].some(
+    (candidate) => /layout_integrity_error|strict extraction failed/iu.test(candidate.message)
+  );
+  if (layoutIntegrityError) {
+    return true;
+  }
+  return errorChainContains(
+    error,
+    (candidate) => candidate instanceof AssetError && candidate.diagnostic.errorType === "rasterization_warning" && candidate.diagnostic.fatal
+  );
+}
+function isAuthError(error) {
+  return errorChainContains(
+    error,
+    (candidate) => candidate instanceof ReauthRequiredError || candidate instanceof AuthError
+  );
+}
+function isApiError(error) {
+  return errorChainContains(
+    error,
+    (candidate) => candidate instanceof GoogleSlidesApiError || candidate instanceof AssetError && candidate.diagnostic.errorType === "api_error"
+  );
+}
+function errorChainContains(error, predicate) {
+  for (const candidate of iterateErrorChain(error)) {
+    if (predicate(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+function* iterateErrorChain(error) {
+  let current = error;
+  const seen = /* @__PURE__ */ new Set();
+  while (current instanceof Error && !seen.has(current)) {
+    seen.add(current);
+    yield current;
+    current = current.cause;
+  }
+}
+function findFirstErrorInChain(error, constructor) {
+  for (const candidate of iterateErrorChain(error)) {
+    if (candidate instanceof constructor) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isErrnoError(error) {
+  return error instanceof Error;
+}
+function parseAuthFlags(args) {
+  const flags = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--token-path") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --token-path");
+      }
+      flags.tokenPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--service-account") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --service-account");
+      }
+      flags.serviceAccountPath = value;
+      index += 1;
+      continue;
+    }
+    throw new CliUsageError(`Unknown auth flag: ${arg}`);
+  }
+  return flags;
+}
+function parseExtractFlags(args) {
+  const flags = {
+    strict: false
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--input") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --input");
+      }
+      flags.inputPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--output") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --output");
+      }
+      flags.outputPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--output-dir") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --output-dir");
+      }
+      flags.outputDir = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--log-format") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --log-format");
+      }
+      flags.logFormat = parseLogFormat(value, "`--log-format`");
+      index += 1;
+      continue;
+    }
+    if (arg === "--presentation-id") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --presentation-id");
+      }
+      flags.presentationId = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--presentation-url") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --presentation-url");
+      }
+      flags.presentationUrl = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--token-path") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --token-path");
+      }
+      flags.tokenPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--service-account") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --service-account");
+      }
+      flags.serviceAccountPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--strict") {
+      flags.strict = true;
+      continue;
+    }
+    throw new CliUsageError(`Unknown extract flag: ${arg}`);
+  }
+  if (!flags.inputPath && !flags.presentationId && !flags.presentationUrl) {
+    throw new CliUsageError("Either `--input`, `--presentation-id`, or `--presentation-url` is required.");
+  }
+  return flags;
+}
+function parseGenerateFlags(args) {
+  const flags = {
+    mode: "new",
+    fontDirs: [],
+    strictRasterization: false,
+    allowRemoteImages: false,
+    allowPrivateIp: false
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--input") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --input");
+      }
+      flags.inputPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--style") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --style");
+      }
+      flags.stylePath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--output") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --output");
+      }
+      flags.outputPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--output-dir") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --output-dir");
+      }
+      flags.outputDir = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--format") {
+      const value = args[index + 1];
+      if (value !== "pptx" && value !== "gslides") {
+        throw new CliUsageError("`--format` must be one of `pptx` or `gslides`.");
+      }
+      flags.format = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--log-format") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --log-format");
+      }
+      flags.logFormat = parseLogFormat(value, "`--log-format`");
+      index += 1;
+      continue;
+    }
+    if (arg === "--strict-rasterization") {
+      flags.strictRasterization = true;
+      continue;
+    }
+    if (arg === "--allow-remote-images") {
+      flags.allowRemoteImages = true;
+      continue;
+    }
+    if (arg === "--allow-private-ip") {
+      flags.allowPrivateIp = true;
+      continue;
+    }
+    if (arg === "--mode") {
+      const value = args[index + 1];
+      if (value !== "new" && value !== "overwrite" && value !== "diff") {
+        throw new CliUsageError("`--mode` must be one of `new`, `overwrite`, or `diff`.");
+      }
+      flags.mode = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--presentation-id") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --presentation-id");
+      }
+      flags.presentationId = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--drive-folder") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --drive-folder");
+      }
+      flags.driveFolder = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--theme") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --theme");
+      }
+      flags.theme = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--font-dir") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --font-dir");
+      }
+      flags.fontDirs.push(value);
+      index += 1;
+      continue;
+    }
+    if (arg === "--token-path") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --token-path");
+      }
+      flags.tokenPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--service-account") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --service-account");
+      }
+      flags.serviceAccountPath = value;
+      index += 1;
+      continue;
+    }
+    throw new CliUsageError(`Unknown generate flag: ${arg}`);
+  }
+  if (!flags.inputPath) {
+    throw new CliUsageError("`--input` is required.");
+  }
+  if (!flags.outputPath && flags.outputDir && flags.format !== "gslides") {
+    flags.outputPath = deriveOutputPath(flags.outputDir, flags.inputPath, ".pptx");
+  }
+  if (!flags.format) {
+    if (flags.outputPath?.toLowerCase().endsWith(".pptx")) {
+      flags.format = "pptx";
+    } else {
+      throw new CliUsageError("`--format` is required unless `--output` ends with `.pptx`.");
+    }
+  }
+  if (flags.format === "pptx" && !flags.outputPath) {
+    throw new CliUsageError("`--output` is required when `--format pptx` is used.");
+  }
+  if (flags.format === "gslides" && (flags.mode === "overwrite" || flags.mode === "diff") && !flags.presentationId) {
+    throw new CliUsageError("`--presentation-id` is required when `--mode overwrite` or `--mode diff` is used.");
+  }
+  return flags;
+}
+function parseValidateFlags(args) {
+  const flags = {};
+  const positionals = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--input") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --input");
+      }
+      flags.inputPath = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--log-format") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --log-format");
+      }
+      flags.logFormat = parseLogFormat(value, "`--log-format`");
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      throw new CliUsageError(`Unknown validate flag: ${arg}`);
+    }
+    positionals.push(arg);
+  }
+  if (!flags.inputPath) {
+    flags.inputPath = positionals[0];
+  }
+  if (!flags.inputPath) {
+    throw new CliUsageError("A YAML file path is required.");
+  }
+  return flags;
+}
+function parseMcpServeFlags(args) {
+  const flags = {
+    transport: "stdio",
+    host: "127.0.0.1",
+    port: 8080
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--transport") {
+      const value = args[index + 1];
+      if (value !== "stdio" && value !== "http") {
+        throw new CliUsageError("`--transport` must be `stdio` or `http`.");
+      }
+      flags.transport = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--host") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --host");
+      }
+      flags.host = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--port") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError("Missing value for --port");
+      }
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+        throw new CliUsageError("`--port` must be an integer between 0 and 65535.");
+      }
+      flags.port = parsed;
+      index += 1;
+      continue;
+    }
+    if (arg === "--public-base-url" || arg === "--publicBaseUrl") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new CliUsageError(`Missing value for ${arg}`);
+      }
+      flags.publicBaseUrl = value;
+      index += 1;
+      continue;
+    }
+    throw new CliUsageError(`Unknown mcp flag: ${arg}`);
+  }
+  if (flags.transport === "http") {
+    flags.publicBaseUrl = resolveMcpPublicBaseUrl(flags.publicBaseUrl, flags.host);
+  }
+  return flags;
+}
+function formatDiagnosticForCli(diagnostic, label = "warning") {
+  const details = [
+    diagnostic.location ? formatCliSourceLocation(diagnostic.location) : void 0,
+    diagnostic.actual,
+    diagnostic.expected ? `expected ${diagnostic.expected}` : void 0,
+    diagnostic.suggestion
+  ].filter((value) => Boolean(value && value.length > 0)).join(" | ");
+  return details.length > 0 ? `${label} [${diagnostic.error_type}] ${details}` : `${label} [${diagnostic.error_type}]`;
+}
+function formatCliSourceLocation(location) {
+  return `${location.file}:L${location.start.line}:C${location.start.column}`;
+}
+function formatAssetErrorDiagnosticForCli(error) {
+  return {
+    error_type: error.diagnostic.errorType,
+    actual: error.diagnostic.message,
+    location: error.diagnostic.location,
+    suggestion: error.diagnostic.suggestion
+  };
+}
+function formatFontValidationDiagnosticsForCli(error) {
+  return error.diagnostics.map((diagnostic) => ({
+    error_type: diagnostic.errorType,
+    actual: diagnostic.message,
+    location: diagnostic.location,
+    suggestion: diagnostic.suggestion
+  }));
+}
+function formatLayoutIntegrityDiagnosticsForCli(error) {
+  return error.diagnostics.map((diagnostic) => ({
+    error_type: error.errorType,
+    actual: diagnostic.message,
+    suggestion: `${diagnostic.yamlSuggestion} ${diagnostic.markdownSuggestion}`
+  }));
+}
+function renderGeneralHelp() {
+  return [
+    "Usage: morphe <command> [options]",
+    "",
+    "Commands:",
+    "  generate          Generate a PPTX or Google Slides presentation",
+    "  extract           Extract Morphe style YAML from PPTX or Google Slides",
+    "  validate          Validate Morphe style YAML",
+    "  themes list       List bundled theme presets",
+    "  auth login        Authenticate with Google APIs",
+    "  auth logout       Remove cached OAuth tokens",
+    "  mcp serve         Start the Morphe MCP server",
+    "",
+    "Global options:",
+    "  --help            Show help",
+    "  --version         Print the Morphe CLI version",
+    "  --verbose         Emit DEBUG and above logs",
+    "  --quiet           Emit ERROR logs only",
+    "  --non-interactive Disable OAuth/browser prompts (also enabled when stdin is not a TTY)"
+  ].join("\n");
+}
+function renderAuthHelp() {
+  return "Usage: morphe auth <login|logout> [--token-path <path>] [--service-account <path>] [--non-interactive]";
+}
+function renderExtractHelp() {
+  return [
+    "Usage:",
+    "  morphe extract --input <existing.pptx> [--output <style.yaml>] [--output-dir <dir>] [--log-format <text|json>]",
+    "  morphe extract (--presentation-id <id> | --presentation-url <url>) [--output <style.yaml>] [--output-dir <dir>] [--log-format <text|json>] [--token-path <path>] [--service-account <path>] [--non-interactive] [--strict]"
+  ].join("\n");
+}
+function renderGenerateHelp() {
+  return [
+    "Usage:",
+    "  morphe generate --input <slides.md> --format pptx (--output <out.pptx> | --output-dir <dir>) [--style <theme.yaml>] [--theme <theme>] [--font-dir <dir>]... [--log-format <text|json>] [--strict-rasterization] [--allow-remote-images] [--allow-private-ip]",
+    "  morphe generate --input <slides.md> --format gslides [--style <theme.yaml>] [--mode <new|overwrite|diff>] [--presentation-id <id>] [--drive-folder <id>] [--theme <theme>] [--font-dir <dir>]... [--log-format <text|json>] [--strict-rasterization] [--allow-remote-images] [--allow-private-ip] [--token-path <path>] [--service-account <path>] [--non-interactive]",
+    "",
+    "Config files: .morpherc or morphe.config.yaml may set theme, logFormat, and fontDirs."
+  ].join("\n");
+}
+function renderValidateHelp() {
+  return "Usage: morphe validate <style.yaml> [--log-format <text|json>]";
+}
+function renderThemesHelp() {
+  return "Usage: morphe themes list";
+}
+function renderMcpHelp() {
+  return "Usage: morphe mcp serve [--transport <stdio|http>] [--host <host>] [--port <port>] [--public-base-url <url>]";
+}
+async function handleAuthCommand(args, dependencies, nonInteractive) {
+  const [subcommand, ...flagArgs] = args;
+  if (!subcommand || subcommand === "--help") {
+    writeLine(dependencies.stdout, renderAuthHelp());
+    return subcommand ? 0 : 1;
+  }
+  try {
+    if ((subcommand === "login" || subcommand === "logout") && flagArgs.includes("--help")) {
+      writeLine(dependencies.stdout, renderAuthHelp());
+      return CLI_EXIT_CODES.success;
+    }
+    const flags = parseAuthFlags(flagArgs);
+    if (subcommand === "login") {
+      if (nonInteractive && !hasServiceAccountCredential(flags, dependencies.env)) {
+        throw createNonInteractiveAuthError("morphe auth login");
+      }
+      const result = await dependencies.authService.login({
+        env: dependencies.env,
+        tokenPath: flags.tokenPath,
+        serviceAccountPath: flags.serviceAccountPath,
+        allowInteractive: !nonInteractive
+      });
+      if (result.session.source === "service-account") {
+        const jsonKeyPath = result.session.principal.kind === "service-account" ? result.session.principal.jsonKeyPath : "unknown";
+        writeLine(dependencies.stdout, `Loaded service account credentials from ${jsonKeyPath}.`);
+        return 0;
+      }
+      const authUrlSuffix = result.authorizationUrl ? ` ${result.authorizationUrl}` : "";
+      writeLine(dependencies.stdout, `Started OAuth login flow.${authUrlSuffix}`.trimEnd());
+      return 0;
+    }
+    if (subcommand === "logout") {
+      if (flags.serviceAccountPath) {
+        throw new CliUsageError("`--service-account` is only supported with `morphe auth login`.");
+      }
+      await dependencies.authService.logout({
+        env: dependencies.env,
+        tokenPath: flags.tokenPath
+      });
+      writeLine(dependencies.stdout, "Removed cached Morphe OAuth tokens.");
+      return 0;
+    }
+    writeLine(dependencies.stderr, renderAuthHelp());
+    return 1;
+  } catch (error) {
+    writeLine(dependencies.stderr, toErrorMessage(error));
+    return detectCliExitCode(error);
+  }
+}
+function handleThemesCommand(args, dependencies) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand || subcommand === "--help") {
+    writeLine(dependencies.stdout, renderThemesHelp());
+    return subcommand ? 0 : 1;
+  }
+  if (subcommand !== "list") {
+    writeLine(dependencies.stderr, `Unknown themes command: ${subcommand}`);
+    return CLI_EXIT_CODES.input;
+  }
+  if (rest.includes("--help")) {
+    writeLine(dependencies.stdout, renderThemesHelp());
+    return CLI_EXIT_CODES.success;
+  }
+  if (rest.length > 0) {
+    writeLine(dependencies.stderr, `Unknown themes flag: ${rest[0]}`);
+    return CLI_EXIT_CODES.input;
+  }
+  for (const theme of listThemes()) {
+    writeLine(dependencies.stdout, `${theme.name}	${theme.display_name}	${theme.description}`);
+  }
+  return CLI_EXIT_CODES.success;
+}
+async function handleExtractCommand(args, dependencies, globalFlags, nonInteractive) {
+  if (args.includes("--help")) {
+    writeLine(dependencies.stdout, renderExtractHelp());
+    return 0;
+  }
+  let logOptions = null;
+  try {
+    const flags = parseExtractFlags(args);
+    const config = await loadCliConfig();
+    logOptions = resolveLogOptions(dependencies, globalFlags, flags.logFormat, config);
+    const outputPath = flags.outputPath ?? deriveExtractOutputPath(flags);
+    await ensureDirectoryForOutputDir(flags.outputDir);
+    if (flags.inputPath) {
+      const response2 = await dependencies.extractPptx(
+        {
+          input: {
+            kind: "path",
+            path: flags.inputPath
+          }
+        },
+        {}
+      );
+      const yaml2 = response2.style_yaml.content;
+      if (outputPath) {
+        await writeFile(outputPath, yaml2, "utf8");
+      } else {
+        writeLine(dependencies.stdout, yaml2.trimEnd());
+      }
+      if (response2.report.headerComment.length > 0) {
+        writeLog(
+          dependencies.stderr,
+          logOptions,
+          "warn",
+          "extraction_warning_report",
+          {
+            header_comment: response2.report.headerComment,
+            items: response2.report.items
+          },
+          response2.report.headerComment
+        );
+      }
+      return 0;
+    }
+    const response = await dependencies.extractGslides(
+      {
+        env: dependencies.env,
+        presentationId: flags.presentationId,
+        presentationUrl: flags.presentationUrl,
+        serviceAccountPath: flags.serviceAccountPath,
+        allowInteractive: !nonInteractive,
+        strict: flags.strict,
+        tokenPath: flags.tokenPath
+      },
+      {
+        authService: dependencies.authService
+      }
+    );
+    const yaml = response.style_yaml;
+    if (outputPath) {
+      await writeFile(outputPath, yaml, "utf8");
+    } else {
+      writeLine(dependencies.stdout, yaml.trimEnd());
+    }
+    if (response.report.headerComment.length > 0) {
+      writeLog(
+        dependencies.stderr,
+        logOptions,
+        "warn",
+        "extraction_warning_report",
+        {
+          header_comment: response.report.headerComment,
+          items: response.report.items
+        },
+        response.report.headerComment
+      );
+    }
+    return 0;
+  } catch (error) {
+    const message = nonInteractive && isAuthError(error) ? formatNonInteractiveAuthFailure(error) : toErrorMessage(error);
+    const errorLogOptions = resolveLogOptionsForError(dependencies, globalFlags, logOptions, args);
+    if (errorLogOptions.format === "json") {
+      const diagnostic = createCliErrorDiagnostic(error, message, renderExtractHelp());
+      writeErrorDiagnostic(
+        dependencies.stderr,
+        errorLogOptions,
+        diagnostic,
+        formatDiagnosticForCli(diagnostic, "error")
+      );
+      return detectCliExitCode(error);
+    }
+    writeLine(dependencies.stderr, `${message}
+${renderExtractHelp()}`);
+    return detectCliExitCode(error);
+  }
+}
+async function handleGenerateCommand(args, dependencies, globalFlags, nonInteractive) {
+  if (args.includes("--help")) {
+    writeLine(dependencies.stdout, renderGenerateHelp());
+    return 0;
+  }
+  let logOptions = null;
+  try {
+    const flags = parseGenerateFlags(args);
+    const config = await loadCliConfig();
+    logOptions = resolveLogOptions(dependencies, globalFlags, flags.logFormat, config);
+    const theme = resolveGenerateTheme(flags, dependencies.env, config);
+    const rasterizationFontSources = await resolveRasterizationFontSources(flags, config);
+    const markdown = await readTextFileWithLimit(
+      flags.inputPath,
+      "markdown",
+      MARKDOWN_INPUT_MAX_BYTES
+    );
+    const styleYaml = flags.stylePath ? await readTextFileWithLimit(flags.stylePath, "style_yaml", STYLE_YAML_INPUT_MAX_BYTES) : void 0;
+    if (flags.format === "pptx") {
+      await ensureDirectoryForOutputDir(flags.outputDir);
+      const remoteFetchPolicy2 = resolveRemoteFetchPolicy(flags, dependencies.env);
+      const request2 = {
+        markdown,
+        markdownPath: flags.inputPath,
+        styleYaml,
+        stylePath: flags.stylePath,
+        theme,
+        ...rasterizationFontSources.length > 0 ? { rasterizationFontSources } : {},
+        outputPath: flags.outputPath,
+        ...flags.strictRasterization ? { strictRasterization: true } : {},
+        ...remoteFetchPolicy2 ? { remoteFetchPolicy: remoteFetchPolicy2 } : {}
+      };
+      const result = await dependencies.generatePptx(
+        request2,
+        {
+          assetRepository: createAssetRepository({
+            binaryProcessor: createResvgAssetBinaryProcessor(),
+            codeBlockHighlighter: createShikiCodeHighlighter(),
+            mermaidRenderer: createMermaidCliRenderer(),
+            remoteAssetFetcher: createNodeHttpRemoteFetcher()
+          }),
+          compose: createComposePresentationFn(),
+          render: createRenderPptxFn(),
+          packZip: {
+            pack: packPptxEntries
+          }
+        }
+      );
+      writeLine(dependencies.stdout, flags.outputPath);
+      for (const warning of result.warnings) {
+        writeLog(
+          dependencies.stderr,
+          logOptions,
+          "warn",
+          "diagnostic",
+          warning,
+          formatDiagnosticForCli(warning)
+        );
+      }
+      return 0;
+    }
+    const remoteFetchPolicy = resolveRemoteFetchPolicy(flags, dependencies.env);
+    const request = {
+      env: dependencies.env,
+      markdown,
+      markdownPath: flags.inputPath,
+      styleYaml,
+      stylePath: flags.stylePath,
+      mode: flags.mode,
+      presentationId: flags.presentationId,
+      driveFolder: flags.driveFolder,
+      serviceAccountPath: flags.serviceAccountPath,
+      allowInteractive: !nonInteractive,
+      tokenPath: flags.tokenPath,
+      theme,
+      ...rasterizationFontSources.length > 0 ? { rasterizationFontSources } : {},
+      ...flags.strictRasterization ? { strictRasterization: true } : {},
+      ...remoteFetchPolicy ? { remoteFetchPolicy } : {}
+    };
+    const response = await dependencies.generateGslides(
+      request,
+      {
+        authService: dependencies.authService,
+        assetRepository: createAssetRepository({
+          binaryProcessor: createResvgAssetBinaryProcessor(),
+          codeBlockHighlighter: createShikiCodeHighlighter(),
+          mermaidRenderer: createMermaidCliRenderer(),
+          remoteAssetFetcher: createNodeHttpRemoteFetcher()
+        })
+      }
+    );
+    writeLine(dependencies.stdout, response.presentation_url);
+    writeLine(dependencies.stdout, response.presentation_id);
+    const hasStrictRasterizationWarning = flags.strictRasterization && response.warnings.some((warning) => warning.error_type === "rasterization_warning");
+    for (const warning of response.warnings) {
+      const level = hasStrictRasterizationWarning && warning.error_type === "rasterization_warning" ? "error" : "warn";
+      writeLog(
+        dependencies.stderr,
+        logOptions,
+        level,
+        "diagnostic",
+        warning,
+        formatDiagnosticForCli(warning, level === "error" ? "error" : "warning")
+      );
+    }
+    return hasStrictRasterizationWarning ? CLI_EXIT_CODES.layout : 0;
+  } catch (error) {
+    const cliParseDiagnosticError = findFirstErrorInChain(error, CliParseDiagnosticError);
+    if (cliParseDiagnosticError) {
+      writeErrorDiagnostic(
+        dependencies.stderr,
+        resolveLogOptionsForError(dependencies, globalFlags, logOptions, args),
+        cliParseDiagnosticError.diagnostic,
+        formatDiagnosticForCli(cliParseDiagnosticError.diagnostic, "error")
+      );
+      return detectCliExitCode(error);
+    }
+    const assetError = findFirstErrorInChain(error, AssetError);
+    if (assetError) {
+      const diagnostic = formatAssetErrorDiagnosticForCli(assetError);
+      writeErrorDiagnostic(
+        dependencies.stderr,
+        resolveLogOptionsForError(dependencies, globalFlags, logOptions, args),
+        diagnostic,
+        formatDiagnosticForCli(diagnostic, "error")
+      );
+      return detectCliExitCode(error);
+    }
+    const fontValidationError = findFirstErrorInChain(error, FontValidationError);
+    if (fontValidationError) {
+      for (const diagnostic of formatFontValidationDiagnosticsForCli(fontValidationError)) {
+        writeErrorDiagnostic(
+          dependencies.stderr,
+          resolveLogOptionsForError(dependencies, globalFlags, logOptions, args),
+          diagnostic,
+          formatDiagnosticForCli(diagnostic, "error")
+        );
+      }
+      return detectCliExitCode(error);
+    }
+    const layoutIntegrityError = findFirstErrorInChain(error, LayoutIntegrityError);
+    if (layoutIntegrityError) {
+      for (const diagnostic of formatLayoutIntegrityDiagnosticsForCli(layoutIntegrityError)) {
+        writeErrorDiagnostic(
+          dependencies.stderr,
+          resolveLogOptionsForError(dependencies, globalFlags, logOptions, args),
+          diagnostic,
+          formatDiagnosticForCli(diagnostic, "error")
+        );
+      }
+      return detectCliExitCode(error);
+    }
+    const message = nonInteractive && isAuthError(error) ? formatNonInteractiveAuthFailure(error) : toErrorMessage(error);
+    const errorLogOptions = resolveLogOptionsForError(dependencies, globalFlags, logOptions, args);
+    if (errorLogOptions.format === "json") {
+      const diagnostic = createCliErrorDiagnostic(error, message, renderGenerateHelp());
+      writeErrorDiagnostic(
+        dependencies.stderr,
+        errorLogOptions,
+        diagnostic,
+        formatDiagnosticForCli(diagnostic, "error")
+      );
+      return detectCliExitCode(error);
+    }
+    writeLine(dependencies.stderr, `${message}
+${renderGenerateHelp()}`);
+    return detectCliExitCode(error);
+  }
+}
+async function handleValidateCommand(args, dependencies, globalFlags) {
+  if (args.includes("--help")) {
+    writeLine(dependencies.stdout, renderValidateHelp());
+    return 0;
+  }
+  try {
+    const flags = parseValidateFlags(args);
+    const config = await loadCliConfig();
+    const logOptions = resolveLogOptions(dependencies, globalFlags, flags.logFormat, config);
+    const styleYaml = await readTextFileWithLimit(
+      flags.inputPath,
+      "style_yaml",
+      STYLE_YAML_INPUT_MAX_BYTES
+    );
+    const result = dependencies.validateYaml({
+      styleYaml,
+      filePath: flags.inputPath
+    });
+    if (logOptions.format === "json") {
+      const jsonPayload = !result.valid ? {
+        valid: false,
+        diagnostics: result.diagnostics.map(formatValidationResultDiagnostic)
+      } : result.diagnostics && result.diagnostics.length > 0 ? {
+        valid: true,
+        diagnostics: result.diagnostics.map(formatValidationResultDiagnostic)
+      } : {
+        valid: true
+      };
+      writeLine(dependencies.stdout, JSON.stringify(jsonPayload));
+      return result.valid ? 0 : 1;
+    }
+    if (!result.valid) {
+      writeLine(dependencies.stdout, `invalid: ${result.diagnostics.length} violation(s)`);
+      for (const diagnostic of result.diagnostics) {
+        writeLine(dependencies.stdout, formatStyleYamlDiagnostic(diagnostic));
+      }
+      return 1;
+    }
+    if (!result.diagnostics || result.diagnostics.length === 0) {
+      writeLine(dependencies.stdout, "valid");
+      return 0;
+    }
+    writeLine(dependencies.stdout, `valid (${result.diagnostics.length} warning(s))`);
+    for (const diagnostic of result.diagnostics) {
+      writeLine(dependencies.stdout, formatStyleYamlDiagnostic(diagnostic));
+    }
+    return 0;
+  } catch (error) {
+    const cliParseDiagnosticError = findFirstErrorInChain(error, CliParseDiagnosticError);
+    if (cliParseDiagnosticError) {
+      writeLog(
+        dependencies.stderr,
+        resolveLogOptionsForError(dependencies, globalFlags, null, args),
+        "error",
+        "diagnostic",
+        cliParseDiagnosticError.diagnostic,
+        formatDiagnosticForCli(cliParseDiagnosticError.diagnostic, "error")
+      );
+      return detectCliExitCode(error);
+    }
+    const errorLogOptions = resolveLogOptionsForError(dependencies, globalFlags, null, args);
+    if (errorLogOptions.format === "json") {
+      const message = toErrorMessage(error);
+      const diagnostic = createCliErrorDiagnostic(error, message, renderValidateHelp());
+      writeErrorDiagnostic(
+        dependencies.stderr,
+        errorLogOptions,
+        diagnostic,
+        formatDiagnosticForCli(diagnostic, "error")
+      );
+      return detectCliExitCode(error);
+    }
+    writeLine(dependencies.stderr, `${toErrorMessage(error)}
+${renderValidateHelp()}`);
+    return detectCliExitCode(error);
+  }
+}
+async function handleMcpCommand(args, dependencies, globalFlags) {
+  const [subcommand, ...flagArgs] = args;
+  if (!subcommand || subcommand === "--help") {
+    writeLine(dependencies.stdout, renderMcpHelp());
+    return subcommand ? 0 : 1;
+  }
+  if (subcommand !== "serve") {
+    writeLine(dependencies.stderr, renderMcpHelp());
+    return 1;
+  }
+  if (flagArgs.includes("--help")) {
+    writeLine(dependencies.stdout, renderMcpHelp());
+    return 0;
+  }
+  try {
+    const flags = parseMcpServeFlags(flagArgs);
+    if (flags.transport === "stdio") {
+      await dependencies.serveMcpOverStdio({
+        authService: dependencies.authService
+      });
+      return 0;
+    }
+    const token = dependencies.env.MORPHE_MCP_TOKEN;
+    if (!token) {
+      throw new CliUsageError("`MORPHE_MCP_TOKEN` is required for `morphe mcp serve --transport http`.");
+    }
+    const handle = await dependencies.startMcpHttpServer({
+      host: flags.host,
+      port: flags.port,
+      publicBaseUrl: flags.publicBaseUrl,
+      token,
+      authService: dependencies.authService
+    });
+    const logOptions = resolveLogOptions(dependencies, globalFlags);
+    writeLog(
+      dependencies.stderr,
+      logOptions,
+      "info",
+      "mcp_http_listening",
+      {
+        url: `${handle.baseUrl}${MORPHE_MCP_PATH}`
+      },
+      `MCP HTTP server listening on ${handle.baseUrl}${MORPHE_MCP_PATH}`
+    );
+    await dependencies.waitForTermination(handle);
+    return 0;
+  } catch (error) {
+    writeLine(dependencies.stderr, `${toErrorMessage(error)}
+${renderMcpHelp()}`);
+    return detectCliExitCode(error);
+  }
+}
+async function waitForTermination(handle) {
+  await new Promise((resolve2, reject) => {
+    let shuttingDown = false;
+    const shutdown = () => {
+      if (shuttingDown) {
+        return;
+      }
+      shuttingDown = true;
+      void handle.close().then(resolve2).catch(reject).finally(() => {
+        process.off("SIGINT", shutdown);
+        process.off("SIGTERM", shutdown);
+      });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+function formatValidationResultDiagnostic(diagnostic) {
+  return {
+    error_type: diagnostic.errorType,
+    location: {
+      file: diagnostic.location.filePath,
+      start: {
+        line: diagnostic.location.line,
+        column: diagnostic.location.column,
+        offset: null
+      },
+      end: {
+        line: diagnostic.location.line,
+        column: diagnostic.location.column,
+        offset: null
+      }
+    },
+    actual: diagnostic.message
+  };
+}
+function toErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function runCli(argv = process.argv.slice(2), dependencies = {}) {
+  const resolvedDependencies = {
+    authService: dependencies.authService ?? createAuthService({ env: dependencies.env ?? process.env }),
+    extractGslides: dependencies.extractGslides ?? extractGslidesFromCore,
+    extractPptx: dependencies.extractPptx ?? extractPptxFromCore,
+    generateGslides: dependencies.generateGslides ?? generateGslidesFromCore,
+    generatePptx: dependencies.generatePptx ?? generatePptxFromCore,
+    validateYaml: dependencies.validateYaml ?? validateYamlFromCore,
+    serveMcpOverStdio: dependencies.serveMcpOverStdio ?? serveMcpOverStdio,
+    startMcpHttpServer: dependencies.startMcpHttpServer ?? startMcpHttpServer,
+    waitForTermination: dependencies.waitForTermination ?? waitForTermination,
+    env: dependencies.env ?? process.env,
+    stdin: dependencies.stdin ?? process.stdin,
+    stdout: dependencies.stdout ?? process.stdout,
+    stderr: dependencies.stderr ?? process.stderr
+  };
+  if (argv.length === 0) {
+    writeLine(resolvedDependencies.stdout, renderCliOutput());
+    return 0;
+  }
+  let parsedGlobal;
+  try {
+    parsedGlobal = parseGlobalFlags(argv);
+  } catch (error) {
+    writeLine(resolvedDependencies.stderr, toErrorMessage(error));
+    return detectCliExitCode(error);
+  }
+  const parsedArgv = parsedGlobal.argv;
+  const globalFlags = parsedGlobal.flags;
+  const nonInteractive = resolveNonInteractiveMode(resolvedDependencies, globalFlags);
+  if (parsedArgv.length === 0) {
+    writeLine(resolvedDependencies.stdout, renderCliOutput());
+    return 0;
+  }
+  if (parsedArgv.length === 1 && parsedArgv[0] === "--version") {
+    writeLine(resolvedDependencies.stdout, `morphe ${CLI_VERSION}`);
+    return 0;
+  }
+  if (parsedArgv.length === 1 && parsedArgv[0] === "--help") {
+    writeLine(resolvedDependencies.stdout, renderGeneralHelp());
+    return 0;
+  }
+  const [command, ...args] = parsedArgv;
+  if (command === "auth") {
+    return handleAuthCommand(args, resolvedDependencies, nonInteractive);
+  }
+  if (command === "extract") {
+    return handleExtractCommand(args, resolvedDependencies, globalFlags, nonInteractive);
+  }
+  if (command === "generate") {
+    return handleGenerateCommand(args, resolvedDependencies, globalFlags, nonInteractive);
+  }
+  if (command === "validate") {
+    return handleValidateCommand(args, resolvedDependencies, globalFlags);
+  }
+  if (command === "themes") {
+    return handleThemesCommand(args, resolvedDependencies);
+  }
+  if (command === "mcp") {
+    return handleMcpCommand(args, resolvedDependencies, globalFlags);
+  }
+  writeLine(resolvedDependencies.stderr, `Unknown command: ${command}`);
+  return 1;
+}
+async function run() {
+  process.exitCode = await runCli();
+}
+var entryUrl = process.argv[1] ? pathToFileURL(process.argv[1]).href : void 0;
+if (entryUrl === import.meta.url) {
+  void run();
+}
+export {
+  renderCliOutput,
+  run,
+  runCli
+};