@nado-language/mcp 0.1.0

package/dist/nado-mcp-cli.mjs

@@ -0,0 +1,521 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const sourceRoot = path.resolve(scriptDir, '..');
+const packageDistDir = scriptDir;
+const serverName = 'nado-language';
+const opencodeSchema = 'https://opencode.ai/config.json';
+
+const serverPath = firstExisting([
+  path.join(packageDistDir, 'nado-language-server.mjs'),
+  path.join(sourceRoot, 'mcp', 'nado-language-server.mjs'),
+]);
+const authPath = firstExisting([
+  path.join(packageDistDir, 'nado-mcp-auth.mjs'),
+  path.join(sourceRoot, 'scripts', 'nado-mcp-auth.mjs'),
+]);
+const probePath = firstExisting([
+  path.join(packageDistDir, 'probe-nado-mcp.mjs'),
+  path.join(sourceRoot, 'scripts', 'probe-nado-mcp.mjs'),
+]);
+
+const command = process.argv[2] || 'help';
+const args = process.argv.slice(3);
+
+try {
+  if (command === 'help' || command === '--help' || command === '-h') {
+    printHelp();
+  } else if (command === 'server') {
+    await runNode(serverPath, args, { stdio: 'inherit' });
+  } else if (command === 'login') {
+    await runAuth(['login', ...args]);
+  } else if (command === 'status') {
+    await runAuth(['status', ...args]);
+  } else if (command === 'logout') {
+    await runAuth(['logout', ...args]);
+  } else if (command === 'auth') {
+    await runAuth(args.length > 0 ? args : ['login']);
+  } else if (command === 'probe') {
+    await runNode(probePath, args, { stdio: 'inherit' });
+  } else if (command === 'setup') {
+    const parsed = splitClientAndSetupOptions(args);
+    await setup(parsed.client, parsed.setupOptions);
+  } else if (command === 'connect' || command === 'install') {
+    const parsed = splitClientAndSetupOptions(args);
+    await setup(parsed.client, parsed.setupOptions, { loginAfter: true });
+    await runAuth(['login', ...parsed.rest]);
+  } else if (command === 'config') {
+    printConfig(args[0] || 'all');
+  } else if (command === 'doctor') {
+    doctor();
+  } else {
+    throw new Error(`Unknown command: ${command}`);
+  }
+} catch (error) {
+  console.error(`nado-mcp failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+}
+
+async function runAuth(authArgs) {
+  const nextArgs = [...authArgs];
+  if (!hasOption(nextArgs, '--auth-file') && !process.env.NADO_MCP_AUTH_ENV_FILE) {
+    nextArgs.push('--auth-file', defaultUserAuthEnvFile());
+  }
+  await runNode(authPath, nextArgs, { stdio: 'inherit' });
+}
+
+async function setup(client, options = {}, flow = {}) {
+  const normalized = String(client || '').toLowerCase();
+  if (normalized === 'codex') {
+    setupCodex(flow);
+    return true;
+  }
+  if (normalized === 'claude' || normalized === 'claude-desktop') {
+    setupClaudeDesktop(options, flow);
+    return true;
+  }
+  if (normalized === 'opencode' || normalized === 'open-code') {
+    setupOpenCode(options, flow);
+    return true;
+  }
+  if (normalized === 'mcp-json' || normalized === 'json-file') {
+    if (options.configFile) {
+      setupMcpServersJson(options.configFile, flow);
+      return true;
+    }
+    printMcpServersSetup('mcp-json');
+    return false;
+  }
+  if (normalized === 'generic' || normalized === 'manual' || normalized === 'stdio' || normalized === 'json' || normalized === 'mcp') {
+    if (options.configFile) {
+      setupMcpServersJson(options.configFile, flow);
+      return true;
+    }
+    printGenericSetup();
+    return false;
+  }
+
+  if (options.configFile) {
+    console.log(`No built-in config writer for "${client}". Using generic mcpServers JSON at ${options.configFile}.`);
+    setupMcpServersJson(options.configFile, flow);
+    return true;
+  }
+
+  printUnknownClientSetup(client);
+  return false;
+}
+
+function setupCodex(flow = {}) {
+  const check = spawnSync('codex', ['--version'], { stdio: 'ignore' });
+  if (check.error || check.status !== 0) {
+    throw new Error('Codex CLI was not found on PATH. Install/open Codex first, then run `nado-mcp setup codex` again.');
+  }
+
+  const spec = stdioServerSpec();
+  const result = spawnSync('codex', ['mcp', 'add', serverName, '--', spec.command, ...spec.args], {
+    stdio: 'inherit',
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`codex mcp add exited with code ${result.status}`);
+
+  console.log('Registered Nado Language MCP with Codex.');
+  printLoginNext(flow);
+}
+
+function setupClaudeDesktop(options = {}, flow = {}) {
+  const configPath = options.configFile || claudeDesktopConfigPath();
+  mkdirSync(path.dirname(configPath), { recursive: true });
+
+  const config = readJsonConfig(configPath);
+
+  config.mcpServers = {
+    ...(config.mcpServers || {}),
+    [serverName]: stdioServerSpec(),
+  };
+
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  console.log(`Registered Nado Language MCP with Claude Desktop: ${configPath}`);
+  if (flow.loginAfter) console.log('Browser login will open next. Restart Claude Desktop after login completes.');
+  else console.log('Restart Claude Desktop, then run `nado-mcp login`.');
+}
+
+function setupOpenCode(options = {}, flow = {}) {
+  const configPath = options.configFile || opencodeConfigPath();
+  mkdirSync(path.dirname(configPath), { recursive: true });
+
+  const config = readJsonConfig(configPath);
+  if (!config.$schema) config.$schema = opencodeSchema;
+  config.mcp = {
+    ...(config.mcp || {}),
+    [serverName]: opencodeServerSpec(),
+  };
+
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  console.log(`Registered Nado Language MCP with OpenCode: ${configPath}`);
+  printLoginNext(flow);
+}
+
+function setupMcpServersJson(configPath, flow = {}) {
+  const resolvedPath = expandHome(configPath);
+  mkdirSync(path.dirname(resolvedPath), { recursive: true });
+
+  const config = readJsonConfig(resolvedPath);
+  config.mcpServers = {
+    ...(config.mcpServers || {}),
+    [serverName]: stdioServerSpec(),
+  };
+
+  writeFileSync(resolvedPath, `${JSON.stringify(config, null, 2)}\n`);
+  console.log(`Registered Nado Language MCP in MCP JSON config: ${resolvedPath}`);
+  printLoginNext(flow);
+}
+
+function doctor() {
+  console.log('Nado MCP doctor');
+  console.log(`Node: ${process.version}`);
+  console.log(`Server: ${serverPath}${existsSync(serverPath) ? '' : ' (missing)'}`);
+  console.log(`Auth CLI: ${authPath}${existsSync(authPath) ? '' : ' (missing)'}`);
+  console.log(`Auth file: ${defaultUserAuthEnvFile()}${existsSync(defaultUserAuthEnvFile()) ? ' (present)' : ' (missing)'}`);
+  console.log(`Claude Desktop config: ${claudeDesktopConfigPath()}`);
+  console.log(`OpenCode config: ${opencodeConfigPath()}`);
+}
+
+function firstExisting(candidates) {
+  return candidates.find((candidate) => existsSync(candidate)) || candidates[0];
+}
+
+function splitClientAndSetupOptions(values) {
+  const hasClient = values[0] && !values[0].startsWith('-');
+  const rawClient = hasClient ? values[0] : '';
+  const optionValues = hasClient ? values.slice(1) : values;
+  const parsed = takeSetupOptions(optionValues);
+  const client = rawClient || (parsed.setupOptions.configFile ? 'mcp-json' : 'generic');
+  return { client, setupOptions: parsed.setupOptions, rest: parsed.rest };
+}
+
+function takeSetupOptions(values) {
+  const setupOptions = {};
+  const rest = [];
+
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (value === '--config-file' || value === '--file') {
+      const nextValue = values[index + 1];
+      if (!nextValue) throw new Error(`${value} requires a path`);
+      setupOptions.configFile = expandHome(nextValue);
+      index += 1;
+      continue;
+    }
+    if (value.startsWith('--config-file=')) {
+      setupOptions.configFile = expandHome(value.slice('--config-file='.length));
+      continue;
+    }
+    if (value.startsWith('--file=')) {
+      setupOptions.configFile = expandHome(value.slice('--file='.length));
+      continue;
+    }
+    rest.push(value);
+  }
+
+  return { setupOptions, rest };
+}
+
+function hasOption(values, option) {
+  return values.some((value) => value === option || value.startsWith(`${option}=`));
+}
+
+function runNode(scriptPath, scriptArgs, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [scriptPath, ...scriptArgs], options);
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${path.basename(scriptPath)} exited with code ${code}`));
+    });
+  });
+}
+
+function stdioServerSpec() {
+  return {
+    command: process.execPath,
+    args: [serverPath],
+  };
+}
+
+function mcpServersConfig() {
+  return {
+    mcpServers: {
+      [serverName]: stdioServerSpec(),
+    },
+  };
+}
+
+function opencodeServerSpec() {
+  const spec = stdioServerSpec();
+  return {
+    type: 'local',
+    command: [spec.command, ...spec.args],
+    enabled: true,
+  };
+}
+
+function opencodeConfig() {
+  return {
+    $schema: opencodeSchema,
+    mcp: {
+      [serverName]: opencodeServerSpec(),
+    },
+  };
+}
+
+function printConfig(format) {
+  const normalized = String(format || 'all').toLowerCase();
+  if (normalized === 'command' || normalized === 'stdio') {
+    const spec = stdioServerSpec();
+    console.log(`${spec.command} ${spec.args.map(shellQuote).join(' ')}`);
+    return;
+  }
+  if (normalized === 'mcp-json' || normalized === 'claude' || normalized === 'mcpservers') {
+    console.log(JSON.stringify(mcpServersConfig(), null, 2));
+    return;
+  }
+  if (normalized === 'opencode' || normalized === 'open-code') {
+    console.log(JSON.stringify(opencodeConfig(), null, 2));
+    return;
+  }
+  if (normalized !== 'all' && normalized !== 'generic' && normalized !== 'json') {
+    throw new Error('config supports all, command, mcp-json, or opencode');
+  }
+
+  console.log('Stdio command:');
+  printIndented(`${stdioServerSpec().command} ${stdioServerSpec().args.map(shellQuote).join(' ')}`);
+  console.log('');
+  console.log('Generic MCP JSON:');
+  printIndented(JSON.stringify(mcpServersConfig(), null, 2));
+  console.log('');
+  console.log('OpenCode JSON:');
+  printIndented(JSON.stringify(opencodeConfig(), null, 2));
+}
+
+function printGenericSetup() {
+  console.log('Nado Language MCP is a standard stdio MCP server.');
+  console.log('Use this config in any MCP-compatible AI client:');
+  console.log('');
+  printIndented(JSON.stringify(mcpServersConfig(), null, 2));
+  console.log('');
+  console.log('For OpenCode, use:');
+  console.log('');
+  printIndented(JSON.stringify(opencodeConfig(), null, 2));
+  console.log('');
+  console.log('Then run `nado-mcp login`.');
+}
+
+function printMcpServersSetup(client) {
+  console.log(`No config file path was provided for ${client}.`);
+  console.log('Pass `--config-file /path/to/mcp.json`, or paste this into the client MCP config:');
+  console.log('');
+  printIndented(JSON.stringify(mcpServersConfig(), null, 2));
+}
+
+function printUnknownClientSetup(client) {
+  console.log(`No built-in config writer for "${client}".`);
+  printGenericSetup();
+}
+
+function printLoginNext(flow = {}) {
+  if (flow.loginAfter) console.log('Browser login will open next.');
+  else console.log('Next: run `nado-mcp login`.');
+}
+
+function printIndented(text) {
+  for (const line of String(text).split('\n')) {
+    console.log(`  ${line}`);
+  }
+}
+
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value;
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function readJsonConfig(filePath) {
+  if (!existsSync(filePath)) return {};
+  const text = readFileSync(filePath, 'utf8').trim();
+  if (!text) return {};
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    try {
+      return JSON.parse(removeTrailingJsonCommas(stripJsonComments(text)));
+    } catch (error) {
+      throw new Error(`Could not parse ${filePath} as JSON/JSONC: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+function stripJsonComments(text) {
+  let output = '';
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+
+    if (inLineComment) {
+      if (char === '\n' || char === '\r') {
+        inLineComment = false;
+        output += char;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (char === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      } else if (char === '\n' || char === '\r') {
+        output += char;
+      }
+      continue;
+    }
+
+    if (!inString && char === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (!inString && char === '/' && next === '*') {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+
+    output += char;
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+    } else if (char === '"') {
+      inString = true;
+    }
+  }
+
+  return output;
+}
+
+function removeTrailingJsonCommas(text) {
+  let output = '';
+  let inString = false;
+  let escaped = false;
+
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+
+    if (inString) {
+      output += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (char === '"') {
+      inString = true;
+      output += char;
+      continue;
+    }
+
+    if (char === ',') {
+      let lookahead = index + 1;
+      while (/\s/.test(text[lookahead] || '')) lookahead += 1;
+      if (text[lookahead] === '}' || text[lookahead] === ']') continue;
+    }
+
+    output += char;
+  }
+
+  return output;
+}
+
+function defaultUserAuthEnvFile() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Nado', 'MCP', 'auth.env');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'Nado', 'MCP', 'auth.env');
+  }
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'nado', 'mcp', 'auth.env');
+}
+
+function claudeDesktopConfigPath() {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'Claude', 'claude_desktop_config.json');
+}
+
+function opencodeConfigPath() {
+  if (process.env.OPENCODE_CONFIG) return expandHome(process.env.OPENCODE_CONFIG);
+  return path.join(os.homedir(), '.config', 'opencode', 'opencode.json');
+}
+
+function expandHome(value) {
+  const text = String(value || '');
+  if (text === '~') return os.homedir();
+  if (text.startsWith('~/') || text.startsWith('~\\')) return path.join(os.homedir(), text.slice(2));
+  return text;
+}
+
+function printHelp() {
+  console.log(`Nado Language MCP
+
+Usage:
+  nado-mcp connect codex              Register in Codex, then log in
+  nado-mcp connect claude             Register in Claude Desktop, then log in
+  nado-mcp connect opencode           Register in OpenCode, then log in
+  nado-mcp setup <client>             Register without login
+  nado-mcp setup mcp-json --file PATH Merge into a generic mcpServers JSON file
+  nado-mcp config                     Print generic MCP config snippets
+  nado-mcp login                      Open browser login and save local auth
+  nado-mcp status                     Show local auth status
+  nado-mcp logout                     Remove local auth tokens
+  nado-mcp server                     Start the stdio MCP server
+  nado-mcp probe list                 List exposed MCP tools
+  nado-mcp doctor                     Print local paths and auth status
+
+Supported automatic setup clients:
+  codex, claude, opencode
+
+Universal fallback:
+  Any MCP-compatible AI client can run the stdio server command printed by:
+  nado-mcp config
+
+AI-agent friendly flow:
+  1. Install the package
+  2. Run: nado-mcp connect <client>
+  3. If the client is unknown, paste the JSON from nado-mcp config
+`);
+}