@nimrobo/mcporter-remote 0.1.0

package/src/cli/list-signature.ts

@@ -0,0 +1,217 @@
+import type { GeneratedOption } from './generate/tools.js';
+import { buildFallbackLiteral, pickExampleLiteral } from './generate/tools.js';
+import { cyanText, dimText, extraDimText } from './terminal.js';
+
+export interface SignatureFormatOptions {
+  colorize?: boolean;
+  defaultReturnType?: string;
+}
+
+export interface FlagUsageExtra {
+  text: string;
+  required?: boolean;
+}
+
+export function formatFunctionSignature(
+  name: string,
+  options: GeneratedOption[],
+  outputSchema: unknown,
+  formatOptions?: SignatureFormatOptions
+): string {
+  const colorize = formatOptions?.colorize !== false;
+  const keyword = colorize ? extraDimText('function') : 'function';
+  const formattedName = colorize ? cyanText(name) : name;
+  const paramsText = options.map((option) => formatInlineParameter(option, colorize)).join(', ');
+  const returnType = inferReturnTypeName(outputSchema) ?? formatOptions?.defaultReturnType;
+  const signature = `${keyword} ${formattedName}(${paramsText})`;
+  return returnType ? `${signature}: ${returnType};` : `${signature};`;
+}
+
+export function formatOptionalSummary(hiddenOptions: GeneratedOption[], options?: { colorize?: boolean }): string {
+  const colorize = options?.colorize !== false;
+  const maxNames = 5;
+  const names = hiddenOptions.map((option) => option.property);
+  if (names.length === 0) {
+    return '';
+  }
+  const preview = names.slice(0, maxNames).join(', ');
+  const suffix = names.length > maxNames ? ', ...' : '';
+  const tint = colorize ? extraDimText : (value: string): string => value;
+  return tint(`// optional (${names.length}): ${preview}${suffix}`);
+}
+
+export function formatFlagUsage(
+  options: GeneratedOption[],
+  extras?: FlagUsageExtra[],
+  opts?: { colorize?: boolean }
+): string {
+  const colorize = opts?.colorize !== false;
+  const entries: Array<{ text: string; required: boolean }> = options.map((option) => ({
+    text: formatFlagLabel(option),
+    required: option.required,
+  }));
+  if (extras) {
+    entries.push(
+      ...extras
+        .map((extra) => ({
+          text: extra.text.trim(),
+          required: Boolean(extra.required),
+        }))
+        .filter((entry) => entry.text.length > 0)
+    );
+  }
+  const parts = entries
+    .filter((entry) => entry.text.length > 0)
+    .map((entry) => (entry.required ? entry.text : `[${entry.text}]`));
+  if (parts.length === 0) {
+    return '';
+  }
+  const rendered = parts.join(' ');
+  return colorize ? extraDimText(rendered) : rendered;
+}
+
+export function formatFlagLabel(option: GeneratedOption): string {
+  return `--${option.cliName} ${option.placeholder}`.trim();
+}
+
+export function formatCallExpressionExample(
+  serverName: string,
+  toolName: string,
+  options: GeneratedOption[],
+  extra?: { callSelector?: string; wrapExpression?: boolean }
+): string | undefined {
+  const assignments = options
+    .map((option) => ({ option, literal: pickExampleLiteral(option) }))
+    .filter(({ option, literal }) => option.required || literal !== undefined)
+    .map(({ option, literal }) => {
+      const value = literal ?? buildFallbackLiteral(option);
+      return `${option.property}: ${value}`;
+    });
+
+  const args = assignments.join(', ');
+  const callSuffix = assignments.length > 0 ? `(${args})` : '()';
+  const selector = extra?.callSelector ?? serverName;
+  const expression = `${selector}.${toolName}${callSuffix}`;
+  const rendered = extra?.wrapExpression ? quoteShellExpression(expression) : expression;
+  return `mcporter call ${rendered}`;
+}
+
+export function formatExampleBlock(
+  examples: string[],
+  options?: { maxExamples?: number; maxLength?: number }
+): string[] {
+  const maxExamples = options?.maxExamples ?? 1;
+  const maxLength = options?.maxLength ?? 80;
+  return Array.from(new Set(examples))
+    .filter(Boolean)
+    .slice(0, maxExamples)
+    .map((example) => truncateExample(example, maxLength));
+}
+
+function truncateExample(example: string, maxLength: number): string {
+  if (example.length <= maxLength) {
+    return example;
+  }
+  const openIndex = example.indexOf('(');
+  const closeIndex = example.lastIndexOf(')');
+  if (openIndex === -1 || closeIndex === -1 || closeIndex <= openIndex) {
+    return `${example.slice(0, Math.max(0, maxLength - 1))}…`;
+  }
+  const prefix = example.slice(0, openIndex + 1);
+  const suffix = example.slice(closeIndex);
+  const available = maxLength - prefix.length - suffix.length - 5;
+  if (available <= 0) {
+    return `${prefix}...${suffix}`;
+  }
+  const args = example.slice(openIndex + 1, closeIndex).trim();
+  const shortened = args
+    .slice(0, available)
+    .trimEnd()
+    .replace(/[\s,]+$/, '');
+  const ellipsis = shortened.length > 0 ? `${shortened}, ...` : '...';
+  return `${prefix}${ellipsis}${suffix}`;
+}
+
+function formatInlineParameter(option: GeneratedOption, colorize: boolean): string {
+  const typeAnnotation = formatTypeAnnotation(option, colorize);
+  const optionalSuffix = option.required ? '' : '?';
+  return `${option.property}${optionalSuffix}: ${typeAnnotation}`;
+}
+
+function quoteShellExpression(expression: string): string {
+  if (!expression.includes("'")) {
+    return `'${expression}'`;
+  }
+  const escaped = expression.replace(/(["\\$`])/g, '\\$1');
+  return `"${escaped}"`;
+}
+
+function inferReturnTypeName(schema: unknown): string | undefined {
+  if (!schema || typeof schema !== 'object') {
+    return undefined;
+  }
+  return inferSchemaDisplayType(schema as Record<string, unknown>);
+}
+
+function inferSchemaDisplayType(descriptor: Record<string, unknown>): string {
+  const title = typeof descriptor.title === 'string' ? descriptor.title.trim() : undefined;
+  if (title) {
+    return title;
+  }
+  const type = typeof descriptor.type === 'string' ? (descriptor.type as string) : undefined;
+  if (!type && typeof descriptor.properties === 'object') {
+    return 'object';
+  }
+  if (!type && descriptor.items && typeof descriptor.items === 'object') {
+    return `${inferSchemaDisplayType(descriptor.items as Record<string, unknown>)}[]`;
+  }
+  if (type === 'array' && descriptor.items && typeof descriptor.items === 'object') {
+    return `${inferSchemaDisplayType(descriptor.items as Record<string, unknown>)}[]`;
+  }
+  if (!type && Array.isArray(descriptor.enum)) {
+    const values = (descriptor.enum as unknown[]).filter((entry): entry is string => typeof entry === 'string');
+    if (values.length > 0) {
+      return values.map((entry) => JSON.stringify(entry)).join(' | ');
+    }
+  }
+  return type ?? 'unknown';
+}
+
+function formatTypeAnnotation(option: GeneratedOption, colorize: boolean): string {
+  let baseType: string;
+  if (option.enumValues && option.enumValues.length > 0) {
+    baseType = option.enumValues.map((value) => JSON.stringify(value)).join(' | ');
+  } else {
+    switch (option.type) {
+      case 'number':
+        baseType = 'number';
+        break;
+      case 'boolean':
+        baseType = 'boolean';
+        break;
+      case 'array':
+        baseType = 'string[]';
+        break;
+      case 'string':
+        baseType = 'string';
+        break;
+      default:
+        baseType = 'unknown';
+        break;
+    }
+  }
+  const tint = colorize ? dimText : (value: string): string => value;
+  const base = tint(baseType);
+  if (option.formatHint && option.type === 'string' && (!option.enumValues || option.enumValues.length === 0)) {
+    const descriptionText = option.description?.toLowerCase() ?? '';
+    const hintLower = option.formatHint.toLowerCase();
+    const normalizedDescription = descriptionText.replace(/[\s_-]+/g, '');
+    const normalizedHint = hintLower.replace(/[\s_-]+/g, '');
+    const hasHintInDescription = descriptionText.includes(hintLower) || normalizedDescription.includes(normalizedHint);
+    if (hasHintInDescription) {
+      return base;
+    }
+    return `${base} ${tint(`/* ${option.formatHint} */`)}`;
+  }
+  return base;
+}

package/src/cli/logger-context.ts

@@ -0,0 +1,36 @@
+import { createPrefixedConsoleLogger, type Logger, type LogLevel, resolveLogLevelFromEnv } from '../logging.js';
+
+let activeLogLevel: LogLevel = resolveLogLevelFromEnv();
+let activeLogger: Logger = createPrefixedConsoleLogger('mcporter', activeLogLevel);
+
+export function getActiveLogLevel(): LogLevel {
+  return activeLogLevel;
+}
+
+export function getActiveLogger(): Logger {
+  return activeLogger;
+}
+
+export function setLogLevel(level: LogLevel): void {
+  activeLogLevel = level;
+  activeLogger = createPrefixedConsoleLogger('mcporter', activeLogLevel);
+}
+
+export function setLogger(logger: Logger, level?: LogLevel): void {
+  activeLogger = logger;
+  if (level) {
+    activeLogLevel = level;
+  }
+}
+
+export function logInfo(message: string): void {
+  activeLogger.info(message);
+}
+
+export function logWarn(message: string): void {
+  activeLogger.warn(message);
+}
+
+export function logError(message: string, error?: unknown): void {
+  activeLogger.error(message, error);
+}

package/src/cli/output-format.ts

@@ -0,0 +1,63 @@
+import type { OutputFormat } from './output-utils.js';
+
+interface ConsumeOutputOptions {
+  defaultFormat?: OutputFormat;
+  allowed?: OutputFormat[];
+  enableRawShortcut?: boolean;
+  jsonShortcutFlag?: string;
+}
+
+export function consumeOutputFormat(args: string[], options: ConsumeOutputOptions = {}): OutputFormat {
+  const allowed = options.allowed ?? ['auto', 'text', 'markdown', 'json', 'raw'];
+  const defaultFormat = options.defaultFormat ?? 'auto';
+  const enableRawShortcut = options.enableRawShortcut !== false;
+  let format: OutputFormat = defaultFormat;
+
+  const isAllowed = (value: OutputFormat): boolean => allowed.includes(value);
+
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === '--output') {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--output' requires a value.");
+      }
+      if (!isCliOutputFormat(value)) {
+        throw new Error('--output format must be one of: auto, text, markdown, json, raw.');
+      }
+      if (!isAllowed(value)) {
+        throw new Error(`--output format '${value}' is not supported for this command.`);
+      }
+      format = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (enableRawShortcut && token === '--raw') {
+      if (!isAllowed('raw')) {
+        throw new Error('--raw is not supported for this command.');
+      }
+      format = 'raw';
+      args.splice(index, 1);
+      continue;
+    }
+    if (options.jsonShortcutFlag && token === options.jsonShortcutFlag) {
+      if (!isAllowed('json')) {
+        throw new Error(`${options.jsonShortcutFlag} is not supported for this command.`);
+      }
+      format = 'json';
+      args.splice(index, 1);
+      continue;
+    }
+    index += 1;
+  }
+
+  if (!isAllowed(format)) {
+    throw new Error(`Format '${format}' is not supported for this command.`);
+  }
+  return format;
+}
+
+export function isCliOutputFormat(value: string): value is OutputFormat {
+  return value === 'auto' || value === 'text' || value === 'markdown' || value === 'json' || value === 'raw';
+}

package/src/cli/output-utils.ts

@@ -0,0 +1,161 @@
+import fs from 'node:fs';
+import { inspect } from 'node:util';
+import type { CallResult } from '../result-utils.js';
+import { logWarn } from './logger-context.js';
+
+export type OutputFormat = 'auto' | 'text' | 'markdown' | 'json' | 'raw';
+const RAW_INSPECT_DEPTH = 8;
+
+type RenderableKind = 'json' | 'markdown' | 'text' | 'raw';
+
+interface RenderableOutput {
+  kind: RenderableKind;
+  value: unknown;
+}
+
+const PREFERRED_OUTPUT_BY_FORMAT: Record<OutputFormat, RenderableKind[]> = {
+  auto: ['json', 'markdown', 'text', 'raw'],
+  text: ['text', 'markdown', 'json', 'raw'],
+  markdown: ['markdown', 'text', 'json', 'raw'],
+  json: ['json', 'raw'],
+  raw: ['raw'],
+};
+
+export function printCallOutput<T>(wrapped: CallResult<T>, raw: T, format: OutputFormat): void {
+  const preferredKinds = PREFERRED_OUTPUT_BY_FORMAT[format];
+  const renderable = resolveRenderableOutput(wrapped, raw, preferredKinds);
+  emitRenderableOutput(renderable);
+}
+
+export function tailLogIfRequested(result: unknown, enabled: boolean): void {
+  // Some transports still encode log paths inside tool results; tail when explicitly asked.
+  if (!enabled) {
+    return;
+  }
+  const candidates: string[] = [];
+  if (typeof result === 'string') {
+    const idx = result.indexOf(':');
+    if (idx !== -1) {
+      const candidate = result.slice(idx + 1).trim();
+      if (candidate) {
+        candidates.push(candidate);
+      }
+    }
+  }
+  if (result && typeof result === 'object') {
+    const possibleKeys = ['logPath', 'logFile', 'logfile', 'path'];
+    for (const key of possibleKeys) {
+      const value = (result as Record<string, unknown>)[key];
+      if (typeof value === 'string') {
+        candidates.push(value);
+      }
+    }
+  }
+
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) {
+      logWarn(`Log path not found: ${candidate}`);
+      continue;
+    }
+    try {
+      const content = fs.readFileSync(candidate, 'utf8');
+      const lines = content.trimEnd().split(/\r?\n/);
+      const tail = lines.slice(-20);
+      console.log(`--- tail ${candidate} ---`);
+      for (const line of tail) {
+        console.log(line);
+      }
+    } catch (error) {
+      logWarn(`Failed to read log file ${candidate}: ${(error as Error).message}`);
+    }
+  }
+}
+
+function resolveRenderableOutput<T>(
+  wrapped: CallResult<T>,
+  raw: T,
+  preferredKinds: RenderableKind[]
+): RenderableOutput {
+  for (const kind of preferredKinds) {
+    if (kind === 'json') {
+      const jsonValue = wrapped.json();
+      if (jsonValue !== null) {
+        return { kind, value: jsonValue };
+      }
+      continue;
+    }
+    if (kind === 'markdown') {
+      const markdown = wrapped.markdown();
+      if (typeof markdown === 'string') {
+        return { kind, value: markdown };
+      }
+      continue;
+    }
+    if (kind === 'text') {
+      const text = wrapped.text();
+      if (typeof text === 'string') {
+        return { kind, value: text };
+      }
+      continue;
+    }
+    if (kind === 'raw') {
+      return { kind, value: raw };
+    }
+  }
+  return { kind: 'raw', value: raw };
+}
+
+function emitRenderableOutput(renderable: RenderableOutput): void {
+  if (renderable.kind === 'json') {
+    if (!attemptPrintJson(renderable.value)) {
+      printRaw(renderable.value);
+    }
+    return;
+  }
+  if (renderable.kind === 'markdown' || renderable.kind === 'text') {
+    console.log(String(renderable.value));
+    return;
+  }
+  printRaw(renderable.value);
+}
+
+function attemptPrintJson(value: unknown): boolean {
+  if (value === undefined) {
+    return false;
+  }
+  try {
+    if (value === null) {
+      console.log('null');
+    } else {
+      console.log(JSON.stringify(value, null, 2));
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function printRaw(raw: unknown): void {
+  if (typeof raw === 'string') {
+    console.log(raw);
+    return;
+  }
+  if (raw === null) {
+    console.log('null');
+    return;
+  }
+  if (raw === undefined) {
+    console.log('undefined');
+    return;
+  }
+  if (typeof raw === 'bigint') {
+    console.log(raw.toString());
+    return;
+  }
+  if (typeof raw === 'symbol' || typeof raw === 'function') {
+    console.log(raw.toString());
+    return;
+  }
+  // Keep nested payloads readable without unbounded inspect walks on huge objects.
+  console.log(inspect(raw, { depth: RAW_INSPECT_DEPTH, maxStringLength: null, breakLength: 80 }));
+}

package/src/cli/path-utils.ts

@@ -0,0 +1,13 @@
+import os from 'node:os';
+import path from 'node:path';
+
+// formatPathForDisplay rewrites absolute paths into user-friendly display strings.
+export function formatPathForDisplay(filePath: string): string {
+  const cwd = process.cwd();
+  const relative = path.relative(cwd, filePath);
+  const displayPath =
+    relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+      ? relative
+      : filePath.replace(os.homedir(), '~');
+  return displayPath;
+}

package/src/cli/runtime-debug.ts

@@ -0,0 +1,141 @@
+import type { ChildProcess } from 'node:child_process';
+import { logInfo, logWarn } from './logger-context.js';
+
+export const DEBUG_HANG = process.env.MCPORTER_DEBUG_HANG === '1';
+
+type ProcessWithHandles = NodeJS.Process & {
+  _getActiveHandles?: () => unknown[];
+  _getActiveRequests?: () => unknown[];
+};
+
+function describeHandle(handle: unknown): string {
+  if (!handle || (typeof handle !== 'object' && typeof handle !== 'function')) {
+    return String(handle);
+  }
+  const ctor = (handle as { constructor?: { name?: string } }).constructor?.name ?? typeof handle;
+  if (ctor === 'Socket') {
+    try {
+      const socket = handle as {
+        localAddress?: string;
+        localPort?: number;
+        remoteAddress?: string;
+        remotePort?: number;
+      };
+      const parts: string[] = ['Socket'];
+      if (socket.localAddress) {
+        parts.push(`local=${socket.localAddress}:${socket.localPort ?? '?'}`);
+      }
+      if (socket.remoteAddress) {
+        parts.push(`remote=${socket.remoteAddress}:${socket.remotePort ?? '?'}`);
+      }
+      if (typeof (socket as { address?: () => { address: string; port: number } | null }).address === 'function') {
+        const addr = (socket as { address?: () => { address: string; port: number } | null }).address?.();
+        if (addr) {
+          parts.push(`addr=${addr.address}:${addr.port}`);
+        }
+      }
+      const host = (handle as { _host?: string })._host;
+      if (host) {
+        parts.push(`host=${host}`);
+      }
+      const pipeName = (handle as { path?: string }).path;
+      if (pipeName) {
+        parts.push(`path=${pipeName}`);
+      }
+      const extraKeys = Reflect.ownKeys(handle as Record<string | symbol, unknown>)
+        .filter((key) => typeof key === 'string' && key.startsWith('_') && !['_events', '_eventsCount'].includes(key))
+        .slice(0, 4) as string[];
+      if (extraKeys.length > 0) {
+        parts.push(`keys=${extraKeys.join(',')}`);
+      }
+      return parts.join(' ');
+    } catch {
+      return ctor;
+    }
+  }
+  if (typeof handle === 'object') {
+    const pid = (handle as { pid?: number }).pid;
+    if (typeof pid === 'number') {
+      return `${ctor} (pid=${pid})`;
+    }
+    const fd = (handle as { fd?: number }).fd;
+    if (typeof fd === 'number') {
+      return `${ctor} (fd=${fd})`;
+    }
+  }
+  return ctor;
+}
+
+export function dumpActiveHandles(label: string): void {
+  if (!DEBUG_HANG) {
+    return;
+  }
+  const proc = process as ProcessWithHandles;
+  const activeHandles = proc._getActiveHandles?.() ?? [];
+  const activeRequests = proc._getActiveRequests?.() ?? [];
+  logInfo(`[debug] ${label}: ${activeHandles.length} active handle(s), ${activeRequests.length} request(s)`);
+  for (const handle of activeHandles) {
+    logInfo(`[debug] handle => ${describeHandle(handle)}`);
+  }
+  for (const request of activeRequests) {
+    logInfo(`[debug] request => ${describeHandle(request)}`);
+  }
+}
+
+export function terminateChildProcesses(label: string): void {
+  const proc = process as ProcessWithHandles;
+  const handles = proc._getActiveHandles?.() ?? [];
+  for (const handle of handles) {
+    if (!handle || typeof handle !== 'object') {
+      continue;
+    }
+    const candidate = handle as ChildProcess;
+    const ctor = (handle as { constructor?: { name?: string } }).constructor?.name ?? '';
+    if (ctor === 'Socket' && typeof (handle as { destroy?: () => void }).destroy === 'function') {
+      try {
+        (handle as { destroy?: () => void }).destroy?.();
+        if (typeof (handle as { unref?: () => void }).unref === 'function') {
+          (handle as { unref?: () => void }).unref?.();
+        }
+      } catch {
+        // ignore
+      }
+    }
+    if (typeof (candidate.stdout as { destroy?: () => void } | undefined)?.destroy === 'function') {
+      try {
+        (candidate.stdout as { destroy?: () => void }).destroy?.();
+      } catch {
+        // ignore
+      }
+    }
+    if (typeof (candidate.stderr as { destroy?: () => void } | undefined)?.destroy === 'function') {
+      try {
+        (candidate.stderr as { destroy?: () => void }).destroy?.();
+      } catch {
+        // ignore
+      }
+    }
+    if (typeof (candidate.stdin as { end?: () => void } | undefined)?.end === 'function') {
+      try {
+        (candidate.stdin as { end?: () => void }).end?.();
+      } catch {
+        // ignore
+      }
+    }
+    // When DEBUG_HANG is enabled we leave extra breadcrumbs so developers can see
+    // which transports required forceful teardown before Node would exit.
+    if (DEBUG_HANG) {
+      const killed = candidate.kill?.('SIGKILL') ?? false;
+      if (candidate.pid) {
+        const outcome = killed ? 'killed' : 'kill-failed';
+        logWarn(`[debug] forcibly ${outcome} child pid=${candidate.pid} (${label})`);
+      }
+    } else if (typeof candidate.kill === 'function' && typeof candidate.pid === 'number' && !candidate.killed) {
+      try {
+        candidate.kill('SIGKILL');
+      } catch {
+        // ignore
+      }
+    }
+  }
+}

package/src/cli/server-lookup.ts

@@ -0,0 +1,22 @@
+import type { ServerDefinition } from '../config.js';
+import { normalizeHttpUrl } from './http-utils.js';
+
+export function findServerByHttpUrl(definitions: readonly ServerDefinition[], urlString: string): string | undefined {
+  const normalizedTarget = normalizeHttpUrl(urlString);
+  if (!normalizedTarget) {
+    return undefined;
+  }
+  for (const definition of definitions) {
+    if (definition.command.kind !== 'http') {
+      continue;
+    }
+    const normalizedDefinitionUrl = normalizeHttpUrl(definition.command.url);
+    if (!normalizedDefinitionUrl) {
+      continue;
+    }
+    if (normalizedDefinitionUrl === normalizedTarget) {
+      return definition.name;
+    }
+  }
+  return undefined;
+}

package/src/cli/terminal.ts

@@ -0,0 +1,41 @@
+const forceColorRaw = process.env.FORCE_COLOR?.toLowerCase();
+const forceDisableColor = forceColorRaw === '0' || forceColorRaw === 'false';
+const forceEnableColor =
+  forceColorRaw === '1' || forceColorRaw === 'true' || forceColorRaw === '2' || forceColorRaw === '3';
+const hasNoColor = process.env.NO_COLOR !== undefined;
+const stdoutStream = process.stdout as NodeJS.WriteStream | undefined;
+
+export const supportsAnsiColor =
+  !hasNoColor && (forceEnableColor || (!forceDisableColor && Boolean(stdoutStream?.isTTY)));
+
+// colorize wraps a string in ANSI color codes when output supports them.
+export function colorize(code: number, text: string): string {
+  if (!supportsAnsiColor) {
+    return text;
+  }
+  return `\u001B[${code}m${text}\u001B[0m`;
+}
+
+export const dimText = (text: string): string => colorize(90, text);
+export const yellowText = (text: string): string => colorize(33, text);
+export const redText = (text: string): string => colorize(31, text);
+export const extraDimText = (text: string): string => {
+  if (!supportsAnsiColor) {
+    return text;
+  }
+  return `\u001B[38;5;244m${text}\u001B[0m`;
+};
+
+export const cyanText = (text: string): string => colorize(36, text);
+
+export const boldText = (text: string): string => {
+  if (!supportsAnsiColor) {
+    return text;
+  }
+  return `\u001B[1m${text}\u001B[0m`;
+};
+
+const isCI = Boolean(process.env.CI && process.env.CI !== '0' && process.env.CI.toLowerCase() !== 'false');
+const spinnerDisabled = process.env.MCPORTER_NO_SPINNER === '1';
+
+export const supportsSpinner = Boolean(stdoutStream?.isTTY && !isCI && !spinnerDisabled);