@phidiassj/aiyoperps-mcp-installer 0.5.2

package/README.md

@@ -0,0 +1,27 @@
+# AiyoPerps MCP Installer
+
+Interactive installer for registering the AiyoPerps MCP bridge with supported AI agent hosts.
+
+## Usage
+
+```bash
+npx -y @phidiassj/aiyoperps-mcp-installer
+```
+
+Optional MCP endpoint override:
+
+```bash
+npx -y @phidiassj/aiyoperps-mcp-installer --url http://127.0.0.1:5078/mcp
+```
+
+## Current host strategy
+
+- `Codex`: patch `~/.codex/config.toml` by updating only the `mcp_servers.aiyoperps` block
+- `Claude Code CLI`: use `claude mcp add-json` / `claude mcp remove`
+- `Claude Desktop`: merge into the desktop JSON config
+- `OpenClaw`: use `openclaw config set` / `openclaw config unset`
+
+## Notes
+
+- The installer creates `*.bak` backups before editing local config files.
+- If a host is detected but not considered safe to modify, the installer reports it and skips automatic changes.

package/bin/aiyoperps-mcp-installer.js

@@ -0,0 +1,736 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin, stdout, stderr, argv, env, exit, cwd } from 'node:process';
+import { spawnSync } from 'node:child_process';
+import { parse as parseToml } from 'smol-toml';
+
+const SERVER_NAME = 'aiyoperps';
+const DEFAULT_URL = 'http://127.0.0.1:5078/mcp';
+
+const cli = parseCliArgs(argv.slice(2));
+const targetUrl = cli.url;
+const interactive = stdin.isTTY && stdout.isTTY && !cli.nonInteractive;
+
+const hosts = await detectHosts(targetUrl);
+
+if (!interactive) {
+  await runNonInteractive(cli, hosts, targetUrl);
+  exit(0);
+}
+
+if (cli.statusOnly) {
+  printStatus(hosts, targetUrl);
+  exit(0);
+}
+
+const rl = readline.createInterface({ input: stdin, output: stdout });
+
+try {
+  printBanner(hosts, targetUrl);
+
+  while (true) {
+    stdout.write('\n1. install all\n2. install any of\n3. status\n4. uninstall\n5. exit\n');
+    const choice = (await rl.question('Select an action: ')).trim();
+
+    if (choice === '1') {
+      await installAll(hosts, targetUrl);
+      continue;
+    }
+
+    if (choice === '2') {
+      await installAnyOf(rl, hosts, targetUrl);
+      continue;
+    }
+
+    if (choice === '3') {
+      printStatus(hosts, targetUrl);
+      continue;
+    }
+
+    if (choice === '4') {
+      await uninstallAnyOf(rl, hosts);
+      continue;
+    }
+
+    if (choice === '5' || choice === '') {
+      break;
+    }
+
+    stdout.write('Invalid selection.\n');
+  }
+} finally {
+  rl.close();
+}
+
+async function detectHosts(url) {
+  return [
+    await detectCodex(url),
+    await detectClaudeCode(url),
+    await detectClaudeDesktop(url),
+    await detectOpenClaw(url)
+  ];
+}
+
+async function detectCodex(url) {
+  const configPath = resolveCodexConfigPath();
+  const exists = fs.existsSync(configPath);
+  const parentExists = fs.existsSync(path.dirname(configPath));
+  const detected = exists || parentExists;
+
+  let safelyWritable = parentExists;
+  let installed = false;
+  let reason = detected ? 'ready for TOML block patch' : 'config directory not found';
+
+  if (exists) {
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      parseToml(content);
+      installed = hasCodexBlock(content);
+      reason = installed ? 'installed' : 'config parsed successfully';
+    } catch (error) {
+      safelyWritable = false;
+      reason = `config parse failed: ${error.message}`;
+    }
+  }
+
+  return {
+    id: 'codex',
+    name: 'Codex',
+    kind: 'file',
+    detected,
+    supported: safelyWritable,
+    installed,
+    reason,
+    path: configPath,
+    install: () => installCodex(configPath, url),
+    uninstall: () => uninstallCodex(configPath)
+  };
+}
+
+async function detectClaudeCode(url) {
+  const version = runCommand('claude', ['--version']);
+  const detected = version.ok;
+  const mcpList = detected ? runCommand('claude', ['mcp', 'list']) : { ok: false, stdout: '' };
+  const installed = detected && mcpList.ok && mcpList.stdout.toLowerCase().includes(SERVER_NAME);
+  const reason = detected
+    ? 'official CLI integration available via claude mcp'
+    : 'claude command not found in PATH';
+
+  return {
+    id: 'claude-code',
+    name: 'Claude Code CLI',
+    kind: 'cli',
+    detected,
+    supported: detected,
+    installed,
+    reason,
+    path: detected ? 'claude mcp (CLI-managed)' : '',
+    install: () => installClaudeCode(url),
+    uninstall: () => uninstallClaudeCode()
+  };
+}
+
+async function detectClaudeDesktop(url) {
+  const candidates = getClaudeDesktopCandidates();
+  const configPath = candidates.find(fileExists) ?? candidates[0];
+  const exists = fileExists(configPath);
+  const parentExists = fs.existsSync(path.dirname(configPath));
+  const detected = exists || parentExists;
+  let supported = parentExists;
+  let installed = false;
+  let reason = detected ? 'ready for JSON config merge' : 'config directory not found';
+
+  if (exists) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      installed = Boolean(parsed?.mcpServers?.[SERVER_NAME]);
+      reason = installed ? 'installed' : 'config parsed successfully';
+    } catch (error) {
+      supported = false;
+      reason = `config parse failed: ${error.message}`;
+    }
+  }
+
+  return {
+    id: 'claude-desktop',
+    name: 'Claude Desktop',
+    kind: 'file',
+    detected,
+    supported,
+    installed,
+    reason,
+    path: configPath,
+    install: () => installClaudeDesktop(configPath, url),
+    uninstall: () => uninstallClaudeDesktop(configPath)
+  };
+}
+
+async function detectOpenClaw(url) {
+  const cli = runCommand('openclaw', ['--version']);
+  const configPath = resolveOpenClawConfigPath();
+  const detected = cli.ok || fileExists(configPath);
+
+  let installed = false;
+  let reason = cli.ok
+    ? 'official CLI config helpers available'
+    : fileExists(configPath)
+      ? 'config file found but CLI not detected'
+      : 'openclaw not detected';
+
+  if (cli.ok) {
+    const getResult = runCommand('openclaw', ['config', 'get', `mcp.servers.${SERVER_NAME}`]);
+    installed = getResult.ok && Boolean(getResult.stdout.trim());
+    if (installed) {
+      reason = 'installed';
+    }
+  }
+
+  return {
+    id: 'openclaw',
+    name: 'OpenClaw',
+    kind: 'cli',
+    detected,
+    supported: cli.ok,
+    installed,
+    reason,
+    path: cli.ok ? '~/.openclaw/openclaw.json (CLI-managed)' : configPath,
+    install: () => installOpenClaw(url),
+    uninstall: () => uninstallOpenClaw()
+  };
+}
+
+function printBanner(hosts, url) {
+  stdout.write(`AiyoPerps MCP installer\nTarget MCP URL: ${url}\n`);
+  printStatus(hosts, url);
+}
+
+function printStatus(hosts, url) {
+  stdout.write(`\nDetected hosts for ${url}:\n`);
+  hosts.forEach((host, index) => {
+    const flags = [
+      host.detected ? 'detected' : 'not detected',
+      host.supported ? 'supported' : 'not safely writable',
+      host.installed ? 'installed' : 'not installed'
+    ].join(', ');
+
+    stdout.write(
+      `${index + 1}. ${host.name}: ${flags}\n   reason: ${host.reason}\n` +
+      `${host.path ? `   path: ${host.path}\n` : ''}`);
+  });
+}
+
+async function installAll(hosts, url) {
+  const selected = hosts.filter(host => host.detected && host.supported);
+  if (selected.length === 0) {
+    stdout.write('No detected hosts are safe to modify.\n');
+    return;
+  }
+
+  await runForHosts(selected, 'install');
+}
+
+async function installAnyOf(rl, hosts, url) {
+  const eligible = hosts.filter(host => host.detected && host.supported);
+  if (eligible.length === 0) {
+    stdout.write('No detected hosts are safe to modify.\n');
+    return;
+  }
+
+  stdout.write('\nSelectable hosts:\n');
+  eligible.forEach((host, index) => {
+    stdout.write(`${index + 1}. ${host.name}\n`);
+  });
+
+  const raw = (await rl.question('Enter host numbers (comma separated): ')).trim();
+  const selected = parseSelections(raw, eligible);
+  if (selected.length === 0) {
+    stdout.write('Nothing selected.\n');
+    return;
+  }
+
+  await runForHosts(selected, 'install');
+}
+
+async function uninstallAnyOf(rl, hosts) {
+  const eligible = hosts.filter(host => host.detected && host.supported && host.installed);
+  if (eligible.length === 0) {
+    stdout.write('No installed hosts found for uninstall.\n');
+    return;
+  }
+
+  stdout.write('\nInstalled hosts:\n');
+  eligible.forEach((host, index) => {
+    stdout.write(`${index + 1}. ${host.name}\n`);
+  });
+
+  const raw = (await rl.question('Enter host numbers to uninstall (comma separated, or "all"): ')).trim();
+  const selected = raw.toLowerCase() === 'all'
+    ? eligible
+    : parseSelections(raw, eligible);
+
+  if (selected.length === 0) {
+    stdout.write('Nothing selected.\n');
+    return;
+  }
+
+  await runForHosts(selected, 'uninstall');
+}
+
+async function runForHosts(hosts, action) {
+  for (const host of hosts) {
+    stdout.write(`\n${action} -> ${host.name}\n`);
+    try {
+      await host[action]();
+      host.installed = action === 'install';
+      host.reason = action === 'install' ? 'installed' : 'removed';
+      stdout.write('  success\n');
+    } catch (error) {
+      stdout.write(`  failed: ${error.message}\n`);
+    }
+  }
+}
+
+async function runNonInteractive(cliArgs, hosts, url) {
+  if (cliArgs.uninstall.length > 0) {
+    const selected = selectHostsByIds(hosts, cliArgs.uninstall, {
+      requireDetected: true,
+      requireSupported: true,
+      requireInstalled: false
+    });
+    await runForHosts(selected, 'uninstall');
+    return;
+  }
+
+  if (cliArgs.installAll) {
+    await installAll(hosts, url);
+    return;
+  }
+
+  if (cliArgs.install.length > 0) {
+    const selected = selectHostsByIds(hosts, cliArgs.install, {
+      requireDetected: true,
+      requireSupported: true,
+      requireInstalled: false
+    });
+    await runForHosts(selected, 'install');
+    return;
+  }
+
+  printStatus(hosts, url);
+}
+
+function parseSelections(raw, hosts) {
+  const indexes = new Set(
+    raw
+      .split(',')
+      .map(value => Number.parseInt(value.trim(), 10))
+      .filter(Number.isInteger)
+      .filter(value => value >= 1 && value <= hosts.length));
+
+  return [...indexes].map(index => hosts[index - 1]);
+}
+
+function selectHostsByIds(hosts, ids, requirements) {
+  const wantAll = ids.includes('all');
+  const selected = wantAll
+    ? hosts
+    : hosts.filter(host => ids.includes(host.id));
+
+  return selected.filter(host => {
+    if (requirements.requireDetected && !host.detected) {
+      return false;
+    }
+
+    if (requirements.requireSupported && !host.supported) {
+      return false;
+    }
+
+    if (requirements.requireInstalled && !host.installed) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+function installCodex(configPath, url) {
+  ensureParentDir(configPath);
+
+  const original = fileExists(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+  if (original) {
+    parseToml(original);
+  }
+
+  const block = buildCodexBlock(url);
+  let next = original;
+
+  if (hasCodexBlock(original)) {
+    next = replaceCodexBlock(original, block);
+  } else if (original.trim().length === 0) {
+    next = `${block}\n`;
+  } else {
+    next = `${original.replace(/\s*$/, '')}\n\n${block}\n`;
+  }
+
+  parseToml(next);
+  backupIfExists(configPath);
+  fs.writeFileSync(configPath, next, 'utf8');
+}
+
+function uninstallCodex(configPath) {
+  if (!fileExists(configPath)) {
+    return;
+  }
+
+  const original = fs.readFileSync(configPath, 'utf8');
+  if (!hasCodexBlock(original)) {
+    return;
+  }
+
+  const next = removeCodexBlock(original);
+  if (next.trim()) {
+    parseToml(next);
+  }
+
+  backupIfExists(configPath);
+  fs.writeFileSync(configPath, next.trim() ? `${next.replace(/\s*$/, '')}\n` : '', 'utf8');
+}
+
+function installClaudeDesktop(configPath, url) {
+  ensureParentDir(configPath);
+
+  const payload = fileExists(configPath)
+    ? JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    : {};
+
+  payload.mcpServers ??= {};
+  payload.mcpServers[SERVER_NAME] = buildJsonServerConfig(url);
+
+  backupIfExists(configPath);
+  fs.writeFileSync(configPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+function uninstallClaudeDesktop(configPath) {
+  if (!fileExists(configPath)) {
+    return;
+  }
+
+  const payload = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (!payload?.mcpServers?.[SERVER_NAME]) {
+    return;
+  }
+
+  delete payload.mcpServers[SERVER_NAME];
+  if (Object.keys(payload.mcpServers).length === 0) {
+    delete payload.mcpServers;
+  }
+
+  backupIfExists(configPath);
+  fs.writeFileSync(configPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+function installClaudeCode(url) {
+  const commandLine = resolveCommandLineSpec(process.platform, url);
+  const spec = JSON.stringify({
+    type: 'stdio',
+    command: commandLine.command,
+    args: commandLine.args
+  });
+
+  const command = ['mcp', 'add-json', SERVER_NAME, spec, '--scope', 'user'];
+  const first = runCommand('claude', command);
+  if (first.ok) {
+    return;
+  }
+
+  const fallback = runCommand('claude', ['mcp', 'add-json', '--scope', 'user', SERVER_NAME, spec]);
+  if (!fallback.ok) {
+    throw new Error(first.stderr || fallback.stderr || 'claude mcp add-json failed');
+  }
+}
+
+function uninstallClaudeCode() {
+  const first = runCommand('claude', ['mcp', 'remove', SERVER_NAME, '--scope', 'user']);
+  if (first.ok) {
+    return;
+  }
+
+  const fallback = runCommand('claude', ['mcp', 'remove', '--scope', 'user', SERVER_NAME]);
+  if (!fallback.ok) {
+    throw new Error(first.stderr || fallback.stderr || 'claude mcp remove failed');
+  }
+}
+
+function installOpenClaw(url) {
+  const value = JSON.stringify(buildJsonServerConfig(url));
+  const result = runCommand('openclaw', ['config', 'set', `mcp.servers.${SERVER_NAME}`, value, '--json']);
+  if (!result.ok) {
+    throw new Error(result.stderr || 'openclaw config set failed');
+  }
+}
+
+function uninstallOpenClaw() {
+  const result = runCommand('openclaw', ['config', 'unset', `mcp.servers.${SERVER_NAME}`]);
+  if (!result.ok) {
+    throw new Error(result.stderr || 'openclaw config unset failed');
+  }
+}
+
+function buildCodexBlock(url) {
+  const commandLine = resolveCommandLineSpec(process.platform, url);
+  const args = JSON.stringify(commandLine.args, null, 0);
+  return [
+    `[mcp_servers.${SERVER_NAME}]`,
+    `command = ${JSON.stringify(commandLine.command)}`,
+    `args = ${args}`
+  ].join('\n');
+}
+
+function buildJsonServerConfig(url) {
+  const commandLine = resolveCommandLineSpec(process.platform, url);
+  return {
+    command: commandLine.command,
+    args: commandLine.args
+  };
+}
+
+function hasCodexBlock(content) {
+  return new RegExp(`^\\[mcp_servers\\.${SERVER_NAME}\\]\\s*$`, 'm').test(content);
+}
+
+function replaceCodexBlock(content, block) {
+  const range = findCodexBlockRange(content);
+  if (!range) {
+    throw new Error('Existing Codex MCP block could not be safely replaced.');
+  }
+
+  const prefix = content.slice(0, range.start).replace(/\s*$/, '');
+  const suffix = content.slice(range.end).replace(/^\s*/, '');
+  return [prefix, block, suffix].filter(Boolean).join('\n\n');
+}
+
+function removeCodexBlock(content) {
+  const range = findCodexBlockRange(content);
+  if (!range) {
+    return content;
+  }
+
+  const prefix = content.slice(0, range.start).replace(/\s*$/, '');
+  const suffix = content.slice(range.end).replace(/^\s*/, '');
+  return [prefix, suffix].filter(Boolean).join('\n\n');
+}
+
+function findCodexBlockRange(content) {
+  const headerRegex = new RegExp(`^\\[mcp_servers\\.${SERVER_NAME}\\]\\s*$`, 'm');
+  const match = headerRegex.exec(content);
+  if (!match) {
+    return null;
+  }
+
+  const start = match.index;
+  const afterHeader = start + match[0].length;
+  const rest = content.slice(afterHeader);
+  const nextHeaderMatch = /^\\[[^\\]]+\\]\\s*$/m.exec(rest);
+  const end = nextHeaderMatch ? afterHeader + nextHeaderMatch.index : content.length;
+  return { start, end };
+}
+
+function resolveTargetUrl(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith('--url=')) {
+      return arg.slice('--url='.length);
+    }
+
+    if (arg === '--url' && index + 1 < args.length) {
+      return args[index + 1];
+    }
+  }
+
+  return env.AIYOPERPS_MCP_URL || DEFAULT_URL;
+}
+
+function parseCliArgs(args) {
+  const install = [];
+  const uninstall = [];
+  let installAll = false;
+  let statusOnly = false;
+  let nonInteractive = false;
+  let url = env.AIYOPERPS_MCP_URL || DEFAULT_URL;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--yes') {
+      installAll = true;
+      nonInteractive = true;
+      continue;
+    }
+
+    if (arg === '--status') {
+      statusOnly = true;
+      nonInteractive = true;
+      continue;
+    }
+
+    if (arg === '--install-all') {
+      installAll = true;
+      nonInteractive = true;
+      continue;
+    }
+
+    if (arg.startsWith('--install=')) {
+      install.push(...splitCsvArg(arg.slice('--install='.length)));
+      nonInteractive = true;
+      continue;
+    }
+
+    if (arg === '--install' && index + 1 < args.length) {
+      install.push(...splitCsvArg(args[index + 1]));
+      nonInteractive = true;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--uninstall=')) {
+      uninstall.push(...splitCsvArg(arg.slice('--uninstall='.length)));
+      nonInteractive = true;
+      continue;
+    }
+
+    if (arg === '--uninstall' && index + 1 < args.length) {
+      uninstall.push(...splitCsvArg(args[index + 1]));
+      nonInteractive = true;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--url=')) {
+      url = arg.slice('--url='.length);
+      continue;
+    }
+
+    if (arg === '--url' && index + 1 < args.length) {
+      url = args[index + 1];
+      index += 1;
+      continue;
+    }
+  }
+
+  return {
+    install,
+    uninstall,
+    installAll,
+    statusOnly,
+    nonInteractive,
+    url
+  };
+}
+
+function splitCsvArg(value) {
+  return value
+    .split(',')
+    .map(item => item.trim())
+    .filter(Boolean);
+}
+
+function resolveCommandLineSpec(platform, url) {
+  const packageArgs = ['-y', '@phidiassj/aiyoperps-mcp-bridge', '--url', url];
+  if (platform === 'win32') {
+    return {
+      command: 'cmd',
+      args: ['/c', 'npx', ...packageArgs]
+    };
+  }
+
+  return {
+    command: 'npx',
+    args: packageArgs
+  };
+}
+
+function resolveCodexConfigPath() {
+  if (env.CODEX_CONFIG_PATH) {
+    return env.CODEX_CONFIG_PATH;
+  }
+
+  if (process.platform === 'win32') {
+    const home = env.USERPROFILE || os.homedir();
+    return path.join(home, '.codex', 'config.toml');
+  }
+
+  return path.join(os.homedir(), '.codex', 'config.toml');
+}
+
+function getClaudeDesktopCandidates() {
+  if (env.CLAUDE_DESKTOP_CONFIG_PATH) {
+    return [env.CLAUDE_DESKTOP_CONFIG_PATH];
+  }
+
+  if (process.platform === 'win32') {
+    const appData = env.APPDATA || path.join(env.USERPROFILE || os.homedir(), 'AppData', 'Roaming');
+    return [
+      path.join(appData, 'Claude', 'claude_desktop_config.json'),
+      path.join(appData, 'Claude', 'config.json')
+    ];
+  }
+
+  if (process.platform === 'darwin') {
+    return [
+      path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+      path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'config.json')
+    ];
+  }
+
+  return [
+    path.join(os.homedir(), '.config', 'Claude', 'claude_desktop_config.json'),
+    path.join(os.homedir(), '.config', 'Claude', 'config.json')
+  ];
+}
+
+function resolveOpenClawConfigPath() {
+  const explicit = env.OPENCLAW_CONFIG_PATH;
+  if (explicit) {
+    return explicit;
+  }
+
+  const stateDir = env.OPENCLAW_STATE_DIR || path.join(os.homedir(), '.openclaw');
+  return path.join(stateDir, 'openclaw.json');
+}
+
+function runCommand(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    cwd: cwd()
+  });
+
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+    error: result.error
+  };
+}
+
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function backupIfExists(filePath) {
+  if (!fileExists(filePath)) {
+    return;
+  }
+
+  fs.copyFileSync(filePath, `${filePath}.bak`);
+}
+
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@phidiassj/aiyoperps-mcp-installer",
+  "version": "0.5.2",
+  "description": "Interactive installer for registering AiyoPerps MCP with supported AI agent hosts.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "aiyoperps-mcp-installer": "./bin/aiyoperps-mcp-installer.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin"
+  ],
+  "dependencies": {
+    "smol-toml": "^1.4.2"
+  },
+  "keywords": [
+    "mcp",
+    "aiyoperps",
+    "installer",
+    "codex",
+    "claude",
+    "openclaw"
+  ]
+}