@nado-language/mcp 0.1.0 → 0.1.2

package/README.md

@@ -14,6 +14,18 @@ The default MCP path is designed to avoid double charging for AI. ChatGPT, Claud
 
 ## Authentication
 
+Install from npm:
+
+```bash
+npm install --global @nado-language/mcp
+```
+
+Install on macOS with Homebrew:
+
+```bash
+brew install jintonyc/tap/nado-mcp
+```
+
 Installed package browser login:
 
 ```bash
@@ -103,12 +115,33 @@ export NADO_MCP_AUTH_RELAY_URL='https://language.nado.ai.kr/auth/mcp-callback'
 
 Installed package, one-command setup plus browser login:
 
+```bash
+nado-mcp connect
+```
+
+To force every supported local config writer:
+
+```bash
+nado-mcp connect all
+```
+
+Client-specific setup remains available:
+
 ```bash
 nado-mcp connect codex
 nado-mcp connect claude
 nado-mcp connect opencode
 ```
 
+For Codex, the command uses the Codex CLI when it is on `PATH`. If the user only has Codex Desktop, it writes Codex Desktop's TOML config directly:
+
+- macOS/Linux: `~/.codex/config.toml`
+- Windows: `%USERPROFILE%\.codex\config.toml`
+
+Restart Codex Desktop after login completes.
+
+ChatGPT is different: it uses hosted/remote MCP apps configured from ChatGPT Apps settings, not local stdio config files. The local package can prepare local clients such as Codex, Claude Desktop, OpenCode, and generic JSON-based MCP clients.
+
 Setup without login:
 
 ```bash

package/dist/nado-mcp-cli.mjs

@@ -48,8 +48,8 @@ try {
     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]);
+    const didRegister = await setup(parsed.client, parsed.setupOptions, { loginAfter: true });
+    if (didRegister) await runAuth(['login', ...parsed.rest]);
   } else if (command === 'config') {
     printConfig(args[0] || 'all');
   } else if (command === 'doctor') {
@@ -72,6 +72,16 @@ async function runAuth(authArgs) {
 
 async function setup(client, options = {}, flow = {}) {
   const normalized = String(client || '').toLowerCase();
+  if (normalized === 'auto') {
+    return setupAutoLocalClients(options, flow);
+  }
+  if (normalized === 'all') {
+    return setupAllLocalClients(options, flow);
+  }
+  if (normalized === 'chatgpt' || normalized === 'openai' || normalized === 'chatgpt-app') {
+    printChatGptSetup();
+    return false;
+  }
   if (normalized === 'codex') {
     setupCodex(flow);
     return true;
@@ -111,10 +121,38 @@ async function setup(client, options = {}, flow = {}) {
   return false;
 }
 
+function setupAutoLocalClients(options = {}, flow = {}) {
+  const targets = [];
+  if (isCodexAvailable()) targets.push(['codex', () => setupCodex(flow)]);
+  if (isClaudeDesktopAvailable(options)) targets.push(['claude', () => setupClaudeDesktop(options, flow)]);
+  if (isOpenCodeAvailable(options)) targets.push(['opencode', () => setupOpenCode(options, flow)]);
+
+  if (targets.length === 0) {
+    console.log('No supported local MCP client was detected.');
+    printGenericSetup();
+    return false;
+  }
+
+  console.log(`Detected local MCP client${targets.length === 1 ? '' : 's'}: ${targets.map(([name]) => name).join(', ')}`);
+  for (const [, register] of targets) register();
+  printChatGptLocalLimit();
+  return true;
+}
+
+function setupAllLocalClients(options = {}, flow = {}) {
+  console.log('Registering Nado Language MCP with every supported local config writer.');
+  setupCodexDesktopConfig(flow);
+  setupClaudeDesktop(options, flow);
+  setupOpenCode(options, flow);
+  printChatGptLocalLimit();
+  return true;
+}
+
 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.');
+    setupCodexDesktopConfig(flow, 'Codex CLI was not found on PATH.');
+    return;
   }
 
   const spec = stdioServerSpec();
@@ -128,6 +166,20 @@ function setupCodex(flow = {}) {
   printLoginNext(flow);
 }
 
+function setupCodexDesktopConfig(flow = {}, reason = '') {
+  const configPath = codexDesktopConfigPath();
+  mkdirSync(path.dirname(configPath), { recursive: true });
+
+  const currentConfig = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+  const nextConfig = upsertTomlSection(currentConfig, `mcp_servers.${serverName}`, codexDesktopTomlSection());
+  writeFileSync(configPath, nextConfig);
+
+  if (reason) console.log(`${reason} Falling back to Codex Desktop config.`);
+  console.log(`Registered Nado Language MCP with Codex Desktop: ${configPath}`);
+  if (flow.loginAfter) console.log('Browser login will open next. Restart Codex Desktop after login completes.');
+  else console.log('Restart Codex Desktop, then run `nado-mcp login`.');
+}
+
 function setupClaudeDesktop(options = {}, flow = {}) {
   const configPath = options.configFile || claudeDesktopConfigPath();
   mkdirSync(path.dirname(configPath), { recursive: true });
@@ -182,6 +234,7 @@ function doctor() {
   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(`Codex Desktop config: ${codexDesktopConfigPath()}`);
   console.log(`Claude Desktop config: ${claudeDesktopConfigPath()}`);
   console.log(`OpenCode config: ${opencodeConfigPath()}`);
 }
@@ -195,7 +248,7 @@ function splitClientAndSetupOptions(values) {
   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');
+  const client = rawClient || (parsed.setupOptions.configFile ? 'mcp-json' : 'auto');
   return { client, setupOptions: parsed.setupOptions, rest: parsed.rest };
 }
 
@@ -274,6 +327,67 @@ function opencodeConfig() {
   };
 }
 
+function isCodexAvailable() {
+  if (process.env.NADO_MCP_CODEX_CONFIG_FILE) return true;
+  if (commandExists('codex')) return true;
+  return existsSync(path.dirname(codexDesktopConfigPath()));
+}
+
+function isClaudeDesktopAvailable(options = {}) {
+  if (options.configFile) return true;
+  if (existsSync(claudeDesktopConfigPath())) return true;
+  if (process.platform === 'darwin') {
+    return existsSync('/Applications/Claude.app') || existsSync(path.join(os.homedir(), 'Applications', 'Claude.app'));
+  }
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    return existsSync(path.join(localAppData, 'Programs', 'Claude', 'Claude.exe'));
+  }
+  return commandExists('claude');
+}
+
+function isOpenCodeAvailable(options = {}) {
+  if (options.configFile || process.env.OPENCODE_CONFIG) return true;
+  if (existsSync(opencodeConfigPath())) return true;
+  return commandExists('opencode');
+}
+
+function commandExists(commandName) {
+  const result = spawnSync(commandName, ['--version'], { stdio: 'ignore' });
+  return !result.error && result.status === 0;
+}
+
+function codexDesktopTomlSection() {
+  const spec = stdioServerSpec();
+  return [
+    `[mcp_servers.${serverName}]`,
+    `command = ${tomlString(spec.command)}`,
+    `args = ${tomlString(spec.args)}`,
+  ].join('\n');
+}
+
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+
+function upsertTomlSection(text, sectionName, sectionText) {
+  const output = [];
+  let removing = false;
+
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const header = line.match(/^\s*\[([^\]]+)]\s*$/);
+    if (header) {
+      const name = header[1];
+      removing = name === sectionName || name.startsWith(`${sectionName}.`);
+    }
+
+    if (!removing) output.push(line);
+  }
+
+  const base = output.join('\n').trimEnd();
+  return `${base}${base ? '\n\n' : ''}${sectionText.trimEnd()}\n`;
+}
+
 function printConfig(format) {
   const normalized = String(format || 'all').toLowerCase();
   if (normalized === 'command' || normalized === 'stdio') {
@@ -316,6 +430,16 @@ function printGenericSetup() {
   console.log('Then run `nado-mcp login`.');
 }
 
+function printChatGptSetup() {
+  console.log('ChatGPT does not use local stdio MCP config files.');
+  console.log('Use a hosted/remote MCP endpoint in ChatGPT Apps settings, then scan tools in ChatGPT.');
+  console.log('Nado local package setup can configure Codex, Claude Desktop, OpenCode, and generic local MCP JSON clients.');
+}
+
+function printChatGptLocalLimit() {
+  console.log('Note: ChatGPT requires a hosted/remote MCP app registration in ChatGPT settings; local package setup cannot install into ChatGPT directly.');
+}
+
 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:');
@@ -467,6 +591,11 @@ function defaultUserAuthEnvFile() {
   return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'nado', 'mcp', 'auth.env');
 }
 
+function codexDesktopConfigPath() {
+  if (process.env.NADO_MCP_CODEX_CONFIG_FILE) return expandHome(process.env.NADO_MCP_CODEX_CONFIG_FILE);
+  return path.join(os.homedir(), '.codex', 'config.toml');
+}
+
 function claudeDesktopConfigPath() {
   if (process.platform === 'win32') {
     return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
@@ -493,7 +622,9 @@ function printHelp() {
   console.log(`Nado Language MCP
 
 Usage:
-  nado-mcp connect codex              Register in Codex, then log in
+  nado-mcp connect                    Auto-register detected local MCP clients, then log in
+  nado-mcp connect all                Register all supported local config writers, then log in
+  nado-mcp connect codex              Register in Codex CLI/Desktop, 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
@@ -515,7 +646,7 @@ Universal fallback:
 
 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
+  2. Run: nado-mcp connect
+  3. If the client is unknown or remote-only, paste the JSON from nado-mcp config
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nado-language/mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Nado Language MCP server for saving AI-generated English flashcards and practicing saved materials.",
   "type": "module",
   "private": false,