@nimrobo/mcporter-remote 0.1.0

package/src/cli/http-utils.ts

@@ -0,0 +1,89 @@
+const DOMAIN_WITH_PATH_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9.-]*)(?::\d+)?\//;
+
+export function normalizeHttpUrlCandidate(value?: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const hasScheme = /^https?:\/\//i.test(trimmed);
+  const candidate = hasScheme ? trimmed : DOMAIN_WITH_PATH_PATTERN.test(trimmed) ? `https://${trimmed}` : null;
+  if (!candidate) {
+    return undefined;
+  }
+  try {
+    const url = new URL(candidate);
+    return url.href;
+  } catch {
+    return undefined;
+  }
+}
+
+export function looksLikeHttpUrl(value?: string): boolean {
+  return Boolean(normalizeHttpUrlCandidate(value));
+}
+
+export function splitHttpToolSelector(input: string): { baseUrl: string; tool: string } | null {
+  const trimmed = input.trim();
+  const candidate = (() => {
+    const openParen = trimmed.indexOf('(');
+    if (openParen === -1) {
+      return trimmed;
+    }
+    return trimmed.slice(0, openParen);
+  })();
+  const normalized = normalizeHttpUrlCandidate(candidate);
+  if (!normalized) {
+    return null;
+  }
+  let url: URL;
+  try {
+    url = new URL(normalized);
+  } catch {
+    return null;
+  }
+  const pathname = url.pathname || '/';
+  const lastSlash = pathname.lastIndexOf('/');
+  const segment = pathname.slice(lastSlash + 1);
+  const dotIndex = segment.lastIndexOf('.');
+  if (dotIndex <= 0) {
+    return null;
+  }
+  const tool = segment.slice(dotIndex + 1);
+  if (!tool || !/^[A-Za-z0-9_-]+$/.test(tool)) {
+    return null;
+  }
+  const baseSegment = segment.slice(0, dotIndex);
+  if (!baseSegment) {
+    return null;
+  }
+  const basePath = `${pathname.slice(0, Math.max(0, lastSlash + 1))}${baseSegment}`;
+  const normalizedPath = basePath.startsWith('/') ? basePath : `/${basePath}`;
+  const baseUrl = `${url.origin}${normalizedPath}`;
+  return { baseUrl, tool };
+}
+
+export function normalizeHttpUrl(value: string | URL): string | undefined {
+  try {
+    const url = value instanceof URL ? new URL(value.href) : new URL(value);
+    url.protocol = url.protocol.toLowerCase();
+    url.hostname = url.hostname.replace(/^www\./i, '').toLowerCase();
+    if (!url.pathname) {
+      url.pathname = '/';
+    }
+    return url.href.replace(/\/$/, '/');
+  } catch {
+    return undefined;
+  }
+}
+
+export function extractHttpServerTarget(value: string): string | undefined {
+  const split = splitHttpToolSelector(value);
+  if (split) {
+    return split.baseUrl;
+  }
+  const normalized = normalizeHttpUrlCandidate(value);
+  return normalized ?? undefined;
+}

package/src/cli/identifier-helpers.ts

@@ -0,0 +1,107 @@
+const AUTO_THRESHOLD_RATIO = 0.3;
+const AUTO_THRESHOLD_MIN = 2;
+
+export type IdentifierResolution = { kind: 'auto'; value: string } | { kind: 'suggest'; value: string };
+
+export function chooseClosestIdentifier(input: string, candidates: string[]): IdentifierResolution | undefined {
+  if (candidates.length === 0) {
+    return undefined;
+  }
+  const normalizedInput = normalizeIdentifier(input);
+  let bestName: string | undefined;
+  let bestScore = Number.POSITIVE_INFINITY;
+
+  for (const candidate of candidates) {
+    if (candidate === input) {
+      return { kind: 'auto', value: candidate };
+    }
+    const normalizedCandidate = normalizeIdentifier(candidate);
+    if (normalizedCandidate === normalizedInput) {
+      return { kind: 'auto', value: candidate };
+    }
+    if (candidate.toLowerCase() === input.toLowerCase()) {
+      return { kind: 'auto', value: candidate };
+    }
+    const score = levenshtein(normalizedInput, normalizedCandidate);
+    if (score < bestScore) {
+      bestScore = score;
+      bestName = candidate;
+    }
+  }
+
+  if (!bestName) {
+    return undefined;
+  }
+
+  const normalizedBest = normalizeIdentifier(bestName);
+  const lengthBaseline = Math.max(normalizedInput.length, normalizedBest.length, 1);
+  const threshold = Math.max(AUTO_THRESHOLD_MIN, Math.floor(lengthBaseline * AUTO_THRESHOLD_RATIO));
+  if (bestScore <= threshold) {
+    return { kind: 'auto', value: bestName };
+  }
+  return { kind: 'suggest', value: bestName };
+}
+
+export function normalizeIdentifier(value: string): string {
+  return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
+}
+
+export interface IdentifierResolutionContext {
+  entity: 'server' | 'tool';
+  attempted: string;
+  resolution: IdentifierResolution;
+  scope?: string;
+}
+
+export function renderIdentifierResolutionMessages(context: IdentifierResolutionContext): {
+  auto?: string;
+  suggest?: string;
+} {
+  const resolvedDisplay =
+    context.entity === 'tool' && context.scope
+      ? `${context.scope}.${context.resolution.value}`
+      : context.resolution.value;
+  const attemptedDisplay =
+    context.entity === 'tool' && context.scope ? `${context.scope}.${context.attempted}` : context.attempted;
+  if (context.resolution.kind === 'auto') {
+    const noun = context.entity === 'tool' ? 'tool call' : 'server name';
+    return {
+      auto: `[mcporter] Auto-corrected ${noun} to ${resolvedDisplay} (input: ${attemptedDisplay}).`,
+    };
+  }
+  return {
+    suggest: `[mcporter] Did you mean ${resolvedDisplay}?`,
+  };
+}
+
+function levenshtein(a: string, b: string): number {
+  if (a === b) {
+    return 0;
+  }
+  if (a.length === 0) {
+    return b.length;
+  }
+  if (b.length === 0) {
+    return a.length;
+  }
+
+  const previous: number[] = Array.from({ length: b.length + 1 }, (_, index) => index);
+  const current: number[] = Array.from({ length: b.length + 1 }, () => 0);
+
+  for (let i = 1; i <= a.length; i += 1) {
+    current[0] = i;
+    const charA = a[i - 1];
+    for (let j = 1; j <= b.length; j += 1) {
+      const charB = b[j - 1];
+      const insertCost = (current[j - 1] ?? Number.POSITIVE_INFINITY) + 1;
+      const deleteCost = (previous[j] ?? Number.POSITIVE_INFINITY) + 1;
+      const replaceCost = (previous[j - 1] ?? Number.POSITIVE_INFINITY) + (charA === charB ? 0 : 1);
+      current[j] = Math.min(insertCost, deleteCost, replaceCost);
+    }
+    for (let j = 0; j <= b.length; j += 1) {
+      previous[j] = current[j] ?? Number.POSITIVE_INFINITY;
+    }
+  }
+
+  return previous[b.length] ?? Number.POSITIVE_INFINITY;
+}

package/src/cli/image-output.ts

@@ -0,0 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { CallResult } from '../result-utils.js';
+
+export function saveCallImagesIfRequested<T>(wrapped: CallResult<T>, outputDir: string | undefined): void {
+  if (!outputDir) {
+    return;
+  }
+  const images = wrapped.images();
+  if (!images || images.length === 0) {
+    return;
+  }
+
+  fs.mkdirSync(outputDir, { recursive: true });
+  const writtenPaths: string[] = [];
+  const timestamp = Date.now();
+  for (const [index, image] of images.entries()) {
+    const extension = extensionFromMimeType(image.mimeType);
+    const baseName = `mcp-image-${timestamp}-${index + 1}`;
+    const outputPath = resolveImageOutputPath(outputDir, baseName, extension);
+    fs.writeFileSync(outputPath, Buffer.from(image.data, 'base64'));
+    writtenPaths.push(outputPath);
+  }
+
+  for (const outputPath of writtenPaths) {
+    console.error(`[mcporter] Saved image: ${outputPath}`);
+  }
+}
+
+function extensionFromMimeType(mimeType: string | undefined): string {
+  if (!mimeType) {
+    return '.bin';
+  }
+  const normalized = mimeType.toLowerCase().split(';', 1)[0]?.trim() ?? '';
+  const mapping: Record<string, string> = {
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'image/jpg': '.jpg',
+    'image/webp': '.webp',
+    'image/gif': '.gif',
+    'image/svg+xml': '.svg',
+    'image/bmp': '.bmp',
+    'image/tiff': '.tiff',
+    'image/x-icon': '.ico',
+  };
+  return mapping[normalized] ?? '.bin';
+}
+
+function resolveImageOutputPath(outputDir: string, baseName: string, extension: string): string {
+  let candidate = path.join(outputDir, `${baseName}${extension}`);
+  if (!fs.existsSync(candidate)) {
+    return candidate;
+  }
+  let suffix = 2;
+  while (true) {
+    candidate = path.join(outputDir, `${baseName}-${suffix}${extension}`);
+    if (!fs.existsSync(candidate)) {
+      return candidate;
+    }
+    suffix += 1;
+  }
+}

package/src/cli/inspect-cli-command.ts

@@ -0,0 +1,89 @@
+import { readCliMetadata } from '../cli-metadata.js';
+import { expectValue } from './flag-utils.js';
+import { buildGenerateCliCommand, shellQuote } from './generate/template-data.js';
+import { formatSourceSuffix } from './list-format.js';
+import { consumeOutputFormat } from './output-format.js';
+import { formatPathForDisplay } from './path-utils.js';
+
+interface InspectFlags {
+  artifactPath: string;
+  format: 'text' | 'json';
+}
+
+export async function handleInspectCli(args: string[]): Promise<void> {
+  const parsed = parseInspectFlags(args);
+  const metadata = await readCliMetadata(parsed.artifactPath);
+  if (parsed.format === 'json') {
+    console.log(JSON.stringify(metadata, null, 2));
+    return;
+  }
+  console.log(`Artifact: ${formatPathForDisplay(metadata.artifact.path)} (${metadata.artifact.kind})`);
+  console.log(`Server: ${metadata.server.name}`);
+  if (metadata.server.source) {
+    const suffix = formatSourceSuffix(metadata.server.source, true);
+    if (suffix) {
+      console.log(`Source: ${suffix}`);
+    }
+  }
+  console.log(
+    `Generated: ${new Date(metadata.generatedAt).toISOString()} via ${metadata.generator.name}@${
+      metadata.generator.version
+    }`
+  );
+  if (metadata.invocation.runtime) {
+    console.log(`Runtime: ${metadata.invocation.runtime}`);
+  }
+  console.log('Invocation flags:');
+  for (const [key, value] of Object.entries(metadata.invocation)) {
+    if (value === undefined || value === null || key === 'runtime') {
+      continue;
+    }
+    console.log(`  ${key}: ${Array.isArray(value) ? JSON.stringify(value) : String(value)}`);
+  }
+  const dryRunCommand = buildGenerateCliCommand(metadata.invocation, metadata.server.definition);
+  console.log('Regenerate with:');
+  console.log(`  mcporter generate-cli --from ${shellQuote(parsed.artifactPath)}`);
+  if (dryRunCommand) {
+    console.log('Underlying generate-cli command:');
+    console.log(`  ${dryRunCommand}`);
+  }
+}
+
+function parseInspectFlags(args: string[]): InspectFlags {
+  let format = consumeOutputFormat(args, {
+    defaultFormat: 'text',
+    allowed: ['text', 'json'],
+    enableRawShortcut: false,
+    jsonShortcutFlag: '--json',
+  }) as InspectFlags['format'];
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === '--format') {
+      const value = expectValue(token, args[index + 1]);
+      if (value !== 'json' && value !== 'text') {
+        throw new Error("--format must be 'json' or 'text'.");
+      }
+      format = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token.startsWith('--')) {
+      throw new Error(`Unknown flag '${token}' for inspect-cli.`);
+    }
+    index += 1;
+  }
+  const artifactPath = args.shift();
+  if (!artifactPath) {
+    throw new Error('Usage: mcporter inspect-cli <artifact> [--json]');
+  }
+  return { artifactPath, format };
+}
+
+export const __test = {
+  parseInspectFlags,
+};

package/src/cli/json-output.ts

@@ -0,0 +1,60 @@
+import type { ConnectionIssue } from '../error-classifier.js';
+
+export interface ConnectionIssueEnvelope {
+  server: string;
+  tool?: string;
+  error: string;
+  issue?: SerializedConnectionIssue;
+}
+
+export interface SerializedConnectionIssue {
+  kind: ConnectionIssue['kind'];
+  statusCode?: number;
+  stdioExitCode?: number;
+  stdioSignal?: string;
+  rawMessage?: string;
+}
+
+export function buildConnectionIssueEnvelope(params: {
+  server: string;
+  tool?: string;
+  error: unknown;
+  issue?: ConnectionIssue;
+}): ConnectionIssueEnvelope {
+  return {
+    server: params.server,
+    tool: params.tool,
+    error: formatErrorMessage(params.error),
+    issue: serializeConnectionIssue(params.issue),
+  };
+}
+
+export function serializeConnectionIssue(issue?: ConnectionIssue): SerializedConnectionIssue | undefined {
+  if (!issue) {
+    return undefined;
+  }
+  return {
+    kind: issue.kind,
+    statusCode: issue.statusCode,
+    stdioExitCode: issue.stdioExitCode,
+    stdioSignal: issue.stdioSignal,
+    rawMessage: issue.rawMessage,
+  };
+}
+
+export function formatErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message ?? 'Unknown error';
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error === undefined || error === null) {
+    return 'Unknown error';
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return 'Unknown error';
+  }
+}