@nimrobo/mcporter-remote 0.1.0

package/src/cli/generate/flags.ts

@@ -0,0 +1,248 @@
+import { splitCommandLine } from '../adhoc-server.js';
+import { expectValue } from '../flag-utils.js';
+import {
+  extractHttpServerTarget,
+  looksLikeHttpUrl,
+  normalizeHttpUrlCandidate,
+  splitHttpToolSelector,
+} from '../http-utils.js';
+import { extractGeneratorFlags } from './flag-parser.js';
+import type { CommandInput } from './types.js';
+
+export interface GenerateFlags {
+  server?: string;
+  name?: string;
+  command?: CommandInput;
+  description?: string;
+  output?: string;
+  bundler?: 'rolldown' | 'bun';
+  bundle?: boolean | string;
+  compile?: boolean | string;
+  runtime?: 'node' | 'bun';
+  timeout: number;
+  minify?: boolean;
+  from?: string;
+  dryRun: boolean;
+  includeTools?: string[];
+  excludeTools?: string[];
+}
+
+export function parseGenerateFlags(args: string[]): GenerateFlags {
+  const common = extractGeneratorFlags(args);
+  let server: string | undefined;
+  let name: string | undefined;
+  let command: CommandInput | undefined;
+  let description: string | undefined;
+  let output: string | undefined;
+  let bundler: 'rolldown' | 'bun' | undefined;
+  let bundle: boolean | string | undefined;
+  let compile: boolean | string | undefined;
+  const runtime: 'node' | 'bun' | undefined = common.runtime;
+  const timeout = common.timeout ?? 30_000;
+  let minify: boolean | undefined;
+  let from: string | undefined;
+  let dryRun = false;
+  let includeTools: string[] | undefined;
+  let excludeTools: string[] | undefined;
+
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === '--from') {
+      from = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--dry-run') {
+      dryRun = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === '--include-tools') {
+      const value = expectValue(token, args[index + 1]);
+      includeTools = mergeCsvList(includeTools, value);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--exclude-tools') {
+      const value = expectValue(token, args[index + 1]);
+      excludeTools = mergeCsvList(excludeTools, value);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--server') {
+      server = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--name') {
+      name = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--command') {
+      const value = expectValue(token, args[index + 1]);
+      command = normalizeCommandInput(value);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--description') {
+      description = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--output') {
+      output = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--bundle') {
+      const next = args[index + 1];
+      if (!next || next.startsWith('--')) {
+        bundle = true;
+        args.splice(index, 1);
+      } else {
+        bundle = next;
+        args.splice(index, 2);
+      }
+      continue;
+    }
+    if (token === '--bundler') {
+      const value = expectValue(token, args[index + 1]);
+      if (value !== 'rolldown' && value !== 'bun') {
+        throw new Error("--bundler must be 'rolldown' or 'bun'.");
+      }
+      bundler = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === '--compile') {
+      const next = args[index + 1];
+      if (!next || next.startsWith('--')) {
+        compile = true;
+        args.splice(index, 1);
+      } else {
+        compile = next;
+        args.splice(index, 2);
+      }
+      continue;
+    }
+    if (token === '--minify') {
+      minify = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === '--no-minify') {
+      minify = false;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token.startsWith('--')) {
+      throw new Error(`Unknown flag '${token}' for generate-cli.`);
+    }
+    index += 1;
+  }
+
+  const positional = !server && !command && !from ? args.find((token) => token && !token.startsWith('--')) : undefined;
+  if (positional) {
+    const position = args.indexOf(positional);
+    if (position !== -1) {
+      args.splice(position, 1);
+    }
+    if (looksLikeInlineCommand(positional)) {
+      command = normalizeCommandInput(positional);
+    } else if (looksLikeHttpUrl(positional) || positional.includes('://')) {
+      command = positional;
+    } else {
+      server = positional;
+    }
+  }
+
+  // translate shorthand env:/URL into normalized http url
+  if (!server && !command && common.runtime === 'node' && common.timeout && !from && args[0]) {
+    const target = extractHttpServerTarget(args[0]);
+    if (target) {
+      server = target;
+    }
+  }
+
+  return {
+    server,
+    name,
+    command,
+    description,
+    output,
+    bundler,
+    bundle,
+    compile,
+    runtime,
+    timeout,
+    minify,
+    from,
+    dryRun,
+    includeTools,
+    excludeTools,
+  };
+}
+
+function mergeCsvList(existing: string[] | undefined, value: string): string[] {
+  const parts = value
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+
+  const base = existing ?? [];
+  const merged = [...base, ...parts];
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const name of merged) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push(name);
+    }
+  }
+  return result;
+}
+
+function normalizeCommandInput(value: string): CommandInput {
+  const httpCandidate = normalizeHttpUrlCandidate(value);
+  if (httpCandidate) {
+    const selector = splitHttpToolSelector(httpCandidate);
+    if (selector) {
+      return selector.baseUrl;
+    }
+    return httpCandidate;
+  }
+  if (looksLikeInlineCommand(value)) {
+    return parseInlineCommand(value);
+  }
+  return { command: value };
+}
+
+function looksLikeInlineCommand(value: string): boolean {
+  if (!value) {
+    return false;
+  }
+  if (!/\s/.test(value)) {
+    return false;
+  }
+  try {
+    const parts = splitCommandLine(value.trim());
+    return parts.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function parseInlineCommand(value: string): CommandInput {
+  const parts = splitCommandLine(value.trim());
+  if (parts.length === 0) {
+    throw new Error('--command requires a non-empty value.');
+  }
+  const [command, ...rest] = parts as [string, ...string[]];
+  return { command, args: rest };
+}

package/src/cli/generate/fs-helpers.ts

@@ -0,0 +1,34 @@
+import fs from 'node:fs/promises';
+
+// Windows/WSL DrvFs mounts frequently reject chmod/copyfile when targeting NTFS-backed paths.
+// Keep these helpers best-effort so CLI generation still works on those hosts.
+export async function markExecutable(filePath: string): Promise<void> {
+  try {
+    await fs.chmod(filePath, 0o755);
+  } catch (error) {
+    if (!shouldIgnorePosixPermissionError(error)) {
+      throw error;
+    }
+  }
+}
+
+export async function safeCopyFile(sourcePath: string, targetPath: string): Promise<void> {
+  try {
+    await fs.copyFile(sourcePath, targetPath);
+    return;
+  } catch (error) {
+    if (!shouldIgnorePosixPermissionError(error)) {
+      throw error;
+    }
+  }
+  const data = await fs.readFile(sourcePath);
+  await fs.writeFile(targetPath, data);
+}
+
+function shouldIgnorePosixPermissionError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+  const code = (error as NodeJS.ErrnoException).code;
+  return code === 'EPERM' || code === 'EINVAL' || code === 'ENOSYS' || code === 'EACCES';
+}

package/src/cli/generate/name-utils.ts

@@ -0,0 +1,176 @@
+import { splitCommandLine } from '../adhoc-server.js';
+import { normalizeHttpUrlCandidate } from '../http-utils.js';
+import type { CommandInput } from './types.js';
+
+export function inferNameFromCommand(command: CommandInput): string | undefined {
+  if (typeof command === 'string') {
+    const normalizedHttp = normalizeHttpUrlCandidate(command);
+    if (normalizedHttp) {
+      try {
+        const url = new URL(normalizedHttp);
+        const segments = url.hostname.split('.').filter(Boolean);
+        for (const segment of segments) {
+          const lowered = segment.toLowerCase();
+          if (lowered === 'www' || lowered === 'api' || lowered === 'mcp') {
+            continue;
+          }
+          const slug = slugify(segment);
+          if (slug) {
+            return slug;
+          }
+        }
+        const fallback = slugify(segments[0] ?? url.hostname);
+        if (fallback) {
+          return fallback;
+        }
+        const derived = deriveNameFromUrl(url);
+        const derivedSlug = derived ? slugify(derived) : undefined;
+        if (derivedSlug) {
+          return derivedSlug;
+        }
+      } catch {
+        // ignore invalid URL; fall through to token logic
+      }
+    }
+    const trimmed = command.trim();
+    if (looksLikeInlineCommand(trimmed)) {
+      try {
+        const parsed = parseInlineCommand(trimmed);
+        const derived = inferNameFromCommand(parsed);
+        if (derived) {
+          return derived;
+        }
+      } catch {
+        // unable to parse; fall through to token heuristic
+      }
+    }
+    const firstToken = trimmed.split(/\s+/)[0] ?? trimmed;
+    const candidateToken = firstToken.split(/[\\/]/).pop() ?? firstToken;
+    return slugify(candidateToken.replace(/\.[a-z0-9]+$/i, ''));
+  }
+  const parts = [command.command, ...(command.args ?? [])];
+  if (parts.length === 0) {
+    return undefined;
+  }
+  const script = parts.find((part) => /\.[cm]?(ts|js)x?$/i.test(part));
+  if (script) {
+    return slugify(stripExtension(basename(script)));
+  }
+  const packageArg = parts.find((_part, index) => index > 0 && /[@/]/.test(_part));
+  if (packageArg) {
+    return slugify(packageArg.replace(/^@/, '').split('@')[0] ?? packageArg);
+  }
+  const bareArg = findLastPositionalArg(parts);
+  if (bareArg) {
+    return slugify(bareArg);
+  }
+  return slugify(basename(parts[0] ?? 'command'));
+}
+
+export function normalizeCommandInput(value: string): CommandInput {
+  const httpCandidate = normalizeHttpUrlCandidate(value);
+  if (httpCandidate) {
+    return httpCandidate;
+  }
+  if (looksLikeInlineCommand(value)) {
+    return parseInlineCommand(value);
+  }
+  return { command: value };
+}
+
+export function looksLikeInlineCommand(value: string): boolean {
+  if (!value) {
+    return false;
+  }
+  if (!/\s/.test(value)) {
+    return false;
+  }
+  try {
+    const parts = splitCommandLine(value.trim());
+    return parts.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function parseInlineCommand(value: string): CommandInput {
+  const parts = splitCommandLine(value.trim());
+  if (parts.length === 0) {
+    throw new Error('--command requires a non-empty value.');
+  }
+  const [command, ...rest] = parts as [string, ...string[]];
+  return { command, args: rest };
+}
+
+function slugify(value: string): string | undefined {
+  const normalized = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || undefined;
+}
+
+function basename(value: string): string {
+  const segments = value.split(/[\\/]/);
+  return segments[segments.length - 1] ?? value;
+}
+
+function stripExtension(value: string): string {
+  const index = value.lastIndexOf('.');
+  if (index === -1) {
+    return value;
+  }
+  return value.slice(0, index);
+}
+
+function findLastPositionalArg(parts: string[]): string | undefined {
+  for (let index = parts.length - 1; index >= 1; index -= 1) {
+    const part = parts[index];
+    if (!part) {
+      continue;
+    }
+    if (part.startsWith('-')) {
+      continue;
+    }
+    if (/^[A-Za-z0-9_]+=/.test(part)) {
+      continue;
+    }
+    if (part.includes('://')) {
+      continue;
+    }
+    return part;
+  }
+  return undefined;
+}
+
+function deriveNameFromUrl(url: URL): string | undefined {
+  const genericHosts = new Set(['www', 'api', 'mcp', 'service', 'services', 'app', 'localhost']);
+  const knownTlds = new Set(['com', 'net', 'org', 'io', 'ai', 'app', 'dev', 'co', 'cloud']);
+  const parts = url.hostname.split('.').filter(Boolean);
+  const filtered = parts.filter((part) => {
+    const lower = part.toLowerCase();
+    if (genericHosts.has(lower)) {
+      return false;
+    }
+    if (knownTlds.has(lower)) {
+      return false;
+    }
+    if (/^\d+$/.test(part)) {
+      return false;
+    }
+    return true;
+  });
+  if (filtered.length > 0) {
+    const last = filtered[filtered.length - 1];
+    if (last) {
+      return last;
+    }
+  }
+  const segments = url.pathname.split('/').filter(Boolean);
+  const firstSegment = segments[0];
+  if (firstSegment) {
+    return firstSegment.replace(/[^a-zA-Z0-9-_]/g, '-');
+  }
+  return undefined;
+}

package/src/cli/generate/output.ts

@@ -0,0 +1,27 @@
+import type { CliArtifactMetadata } from '../../cli-metadata.js';
+import { type GenerateCliOptions, generateCli } from '../../generate-cli.js';
+
+export async function performGenerateFromArtifact(
+  metadata: CliArtifactMetadata,
+  request: GenerateCliOptions
+): Promise<void> {
+  const { outputPath, bundlePath, compilePath } = await generateCli(request);
+  if (metadata.artifact.kind === 'binary' && compilePath) {
+    console.log(`Regenerated compiled CLI at ${compilePath}`);
+  } else if (metadata.artifact.kind === 'bundle' && bundlePath) {
+    console.log(`Regenerated bundled CLI at ${bundlePath}`);
+  } else {
+    console.log(`Regenerated template at ${outputPath}`);
+  }
+}
+
+export async function performGenerateFromRequest(request: GenerateCliOptions): Promise<void> {
+  const { outputPath, bundlePath, compilePath } = await generateCli(request);
+  console.log(`Generated CLI at ${outputPath}`);
+  if (bundlePath) {
+    console.log(`Bundled executable created at ${bundlePath}`);
+  }
+  if (compilePath) {
+    console.log(`Compiled executable created at ${compilePath}`);
+  }
+}

package/src/cli/generate/runtime.ts

@@ -0,0 +1,38 @@
+import { execFile } from 'node:child_process';
+
+export async function resolveRuntimeKind(
+  runtimeOption: 'node' | 'bun' | undefined,
+  compileOption: boolean | string | undefined
+): Promise<'node' | 'bun'> {
+  if (runtimeOption) {
+    return runtimeOption;
+  }
+  const bunAvailable = await isBunAvailable();
+  if (compileOption && !bunAvailable) {
+    throw new Error('--compile requires Bun. Install Bun or set BUN_BIN to the bun executable.');
+  }
+  return bunAvailable ? 'bun' : 'node';
+}
+
+export async function verifyBunAvailable(): Promise<string> {
+  const bunBin = process.env.BUN_BIN ?? 'bun';
+  await new Promise<void>((resolve, reject) => {
+    execFile(bunBin, ['--version'], { cwd: process.cwd(), env: process.env }, (error) => {
+      if (error) {
+        reject(new Error('Unable to locate Bun runtime. Install Bun or set BUN_BIN to the bun executable.'));
+        return;
+      }
+      resolve();
+    });
+  });
+  return bunBin;
+}
+
+async function isBunAvailable(): Promise<boolean> {
+  try {
+    await verifyBunAvailable();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/cli/generate/server-utils.ts

@@ -0,0 +1,38 @@
+import { looksLikeHttpUrl, normalizeHttpUrlCandidate } from '../http-utils.js';
+import type { CommandInput } from './types.js';
+
+export function buildInlineServerDefinition(
+  name: string,
+  command: CommandInput,
+  description?: string
+): Record<string, unknown> {
+  if (typeof command === 'string') {
+    const url = normalizeHttpUrlCandidate(command) ?? command;
+    if (looksLikeHttpUrl(command)) {
+      return {
+        name,
+        description,
+        command: url,
+      };
+    }
+    return {
+      name,
+      description,
+      command: {
+        kind: 'http',
+        url: new URL(url),
+      },
+      source: { kind: 'local', path: '<adhoc>' },
+    };
+  }
+  return {
+    name,
+    description,
+    command: {
+      kind: 'stdio',
+      command: command.command,
+      args: command.args ?? [],
+    },
+    source: { kind: 'local', path: '<adhoc>' },
+  };
+}

package/src/cli/generate/template-data.ts

@@ -0,0 +1,126 @@
+import type { CliArtifactMetadata, SerializedServerDefinition } from '../../cli-metadata.js';
+import type { GenerateCliOptions } from '../../generate-cli.js';
+
+export type InspectableInvocation = CliArtifactMetadata['invocation'] & {
+  serverRef?: string;
+};
+
+export interface GenerateCliContext {
+  invocation: InspectableInvocation;
+  definition: SerializedServerDefinition;
+}
+
+export function buildGenerateCliCommand(
+  invocation: InspectableInvocation,
+  definition: SerializedServerDefinition,
+  globalFlags: Record<string, string | undefined> = {}
+): string {
+  const tokens: string[] = ['mcporter'];
+  const configPath = invocation.configPath ?? globalFlags['--config'];
+  const rootDir = invocation.rootDir ?? globalFlags['--root'];
+  if (configPath) {
+    tokens.push('--config', configPath);
+  }
+  if (rootDir) {
+    tokens.push('--root', rootDir);
+  }
+  tokens.push('generate-cli');
+
+  const serverRef = invocation.serverRef ?? definition.name ?? JSON.stringify(definition);
+  tokens.push('--server', serverRef);
+
+  if (invocation.outputPath) {
+    tokens.push('--output', invocation.outputPath);
+  }
+  if (invocation.bundler && invocation.bundler !== 'rolldown') {
+    tokens.push('--bundler', invocation.bundler);
+  }
+  if (typeof invocation.bundle === 'string') {
+    tokens.push('--bundle', invocation.bundle);
+  } else if (invocation.bundle) {
+    tokens.push('--bundle');
+  }
+  if (typeof invocation.compile === 'string') {
+    tokens.push('--compile', invocation.compile);
+  } else if (invocation.compile) {
+    tokens.push('--compile');
+  }
+  if (invocation.runtime) {
+    tokens.push('--runtime', invocation.runtime);
+  }
+  if (invocation.timeoutMs && invocation.timeoutMs !== 30_000) {
+    tokens.push('--timeout', String(invocation.timeoutMs));
+  }
+  if (invocation.minify) {
+    tokens.push('--minify');
+  }
+  if (invocation.includeTools && invocation.includeTools.length > 0) {
+    tokens.push('--include-tools', invocation.includeTools.join(','));
+  }
+  if (invocation.excludeTools && invocation.excludeTools.length > 0) {
+    tokens.push('--exclude-tools', invocation.excludeTools.join(','));
+  }
+  return tokens.map(shellQuote).join(' ');
+}
+
+export function resolveGenerateRequestFromArtifact(
+  parsed: {
+    from?: string;
+    server?: string;
+    output?: string;
+    runtime?: GenerateCliOptions['runtime'];
+    bundler?: GenerateCliOptions['bundler'];
+    bundle?: GenerateCliOptions['bundle'];
+    timeout: number;
+    compile?: GenerateCliOptions['compile'];
+    minify?: boolean;
+    includeTools?: string[];
+    excludeTools?: string[];
+  },
+  metadata: CliArtifactMetadata,
+  globalFlags: Record<string, string | undefined>
+): GenerateCliOptions {
+  if (!parsed.from) {
+    throw new Error('Missing --from artifact path.');
+  }
+  const invocation = { ...metadata.invocation };
+  const serverRef =
+    parsed.server ?? invocation.serverRef ?? metadata.server.name ?? JSON.stringify(metadata.server.definition);
+  if (!serverRef) {
+    throw new Error('Unable to determine server definition from artifact; pass --server with a target name.');
+  }
+
+  const includeTools = parsed.includeTools ?? invocation.includeTools;
+  const excludeTools = parsed.excludeTools ?? invocation.excludeTools;
+  if (includeTools && excludeTools) {
+    throw new Error('Cannot combine --include-tools and --exclude-tools.');
+  }
+  if (includeTools && includeTools.length === 0) {
+    throw new Error('--include-tools requires at least one tool name.');
+  }
+  if (excludeTools && excludeTools.length === 0) {
+    throw new Error('--exclude-tools requires at least one tool name.');
+  }
+
+  return {
+    serverRef,
+    configPath: globalFlags['--config'] ?? invocation.configPath,
+    rootDir: globalFlags['--root'] ?? invocation.rootDir,
+    outputPath: parsed.output ?? invocation.outputPath,
+    runtime: parsed.runtime ?? invocation.runtime,
+    bundler: parsed.bundler ?? invocation.bundler,
+    bundle: parsed.bundle ?? invocation.bundle,
+    timeoutMs: parsed.timeout ?? invocation.timeoutMs,
+    compile: parsed.compile ?? invocation.compile,
+    minify: parsed.minify ?? invocation.minify ?? false,
+    includeTools,
+    excludeTools,
+  };
+}
+
+export function shellQuote(value: string): string {
+  if (/^[A-Za-z0-9_./@%-]+$/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}