@weppy/roblox-mcp 2.2.1 → 2.3.0

package/install.sh

@@ -117,11 +117,479 @@ try {
 ' >/dev/null 2>&1
 }
 
+# Antigravity 설정에 canonical mcpServers 래퍼로 MCP 서버를 추가하고 legacy flat key를 정리
+add_antigravity_mcp_config() {
+  local config_path="$1"
+  local parent_dir
+  parent_dir=$(dirname "$config_path")
+  mkdir -p "$parent_dir"
+  MCP_CONFIG_PATH="$config_path" node -e '
+const fs = require("fs");
+const configPath = process.env.MCP_CONFIG_PATH;
+let config = {};
+try { config = JSON.parse(fs.readFileSync(configPath, "utf8")); } catch {}
+if (!config || typeof config !== "object" || Array.isArray(config)) {
+  config = {};
+}
+const mcpServers = config.mcpServers;
+if (mcpServers !== undefined && (typeof mcpServers !== "object" || mcpServers === null || Array.isArray(mcpServers))) {
+  throw new Error("Antigravity mcpServers must be an object");
+}
+const next = { ...config };
+delete next["weppy-roblox-mcp"];
+next.mcpServers = {
+  ...(mcpServers || {}),
+  "weppy-roblox-mcp": { command: "npx", args: ["-y", "@weppy/roblox-mcp"] }
+};
+config = next;
+fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+'
+}
+
+is_antigravity_mcp_configured() {
+  local config_path="$1"
+
+  [ -f "$config_path" ] || return 1
+
+  MCP_CONFIG_PATH="$config_path" node -e '
+const fs = require("fs");
+const configPath = process.env.MCP_CONFIG_PATH;
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExpectedCommandShape(value) {
+  return (
+    isJsonObject(value) &&
+    value.command === "npx" &&
+    Array.isArray(value.args) &&
+    value.args.length === 2 &&
+    value.args[0] === "-y" &&
+    value.args[1] === "@weppy/roblox-mcp"
+  );
+}
+try {
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  const canonical = config?.mcpServers?.["weppy-roblox-mcp"];
+  const hasLegacyFlatKey = Object.prototype.hasOwnProperty.call(config, "weppy-roblox-mcp");
+  process.exit(hasExpectedCommandShape(canonical) && !hasLegacyFlatKey ? 0 : 1);
+} catch {
+  process.exit(1);
+}
+' >/dev/null 2>&1
+}
+
 is_codex_config_configured() {
   local config_path="$1"
 
   [ -f "$config_path" ] || return 1
-  grep -Eq '^[[:space:]]*\[mcp_servers\.weppy-roblox-mcp\][[:space:]]*$' "$config_path"
+  MCP_CODEX_CONFIG_PATH="$config_path" node <<'NODE' >/dev/null 2>&1
+const fs = require("fs");
+
+const configPath = process.env.MCP_CODEX_CONFIG_PATH;
+const serverName = "weppy-roblox-mcp";
+const expectedCommand = "npx";
+const expectedArgs = ["-y", "@weppy/roblox-mcp"];
+const headerPattern = new RegExp(
+  "^\\s*\\[\\s*mcp_servers\\." + serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\s*\\]\\s*(?:#.*)?$",
+);
+
+function stripCommentOutsideStrings(line) {
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+
+    if (char === '"' && !inSingle && !escaped) {
+      inDouble = !inDouble;
+    } else if (char === "'" && !inDouble && !escaped) {
+      inSingle = !inSingle;
+    } else if (char === "#" && !inSingle && !inDouble) {
+      return line.slice(0, index).trimEnd();
+    }
+
+    escaped = char === "\\" && !escaped;
+    if (char !== "\\") {
+      escaped = false;
+    }
+  }
+
+  return line.trimEnd();
+}
+
+function countTripleQuoteToggles(line, quote) {
+  let count = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index] ?? "";
+    const nextThree = line.slice(index, index + 3);
+    const isOutsideStrings = !inSingle && !inDouble;
+
+    if (isOutsideStrings && nextThree === quote.repeat(3)) {
+      count += 1;
+      index += 2;
+      escaped = false;
+      continue;
+    }
+
+    if (char === '"' && !inSingle && !escaped) {
+      inDouble = !inDouble;
+    } else if (char === "'" && !inDouble && !escaped) {
+      inSingle = !inSingle;
+    } else if (char === "#" && !inSingle && !inDouble) {
+      break;
+    }
+
+    escaped = char === "\\" && !escaped;
+    if (char !== "\\") {
+      escaped = false;
+    }
+  }
+
+  return count;
+}
+
+function advanceTripleQuoteState(line, state) {
+  const next = { ...state };
+  const tripleDoubleCount = countTripleQuoteToggles(line, '"');
+  const tripleSingleCount = countTripleQuoteToggles(line, "'");
+
+  if (!next.inTripleSingle && tripleDoubleCount % 2 === 1) {
+    next.inTripleDouble = !next.inTripleDouble;
+  }
+
+  if (!next.inTripleDouble && tripleSingleCount % 2 === 1) {
+    next.inTripleSingle = !next.inTripleSingle;
+  }
+
+  return next;
+}
+
+function isTomlTableHeaderLine(line) {
+  const normalized = stripCommentOutsideStrings(line).trim();
+
+  if (normalized.length === 0) {
+    return false;
+  }
+
+  return /^\[\[.*\]\]$/.test(normalized) || /^\[.*\]$/.test(normalized);
+}
+
+function findAllCodexBlocks(source) {
+  const lines = source.split("\n");
+  const blocks = [];
+  let activeLines = null;
+  let state = {
+    inTripleDouble: false,
+    inTripleSingle: false,
+  };
+
+  for (const line of lines) {
+    const isHeaderCandidate = !state.inTripleDouble && !state.inTripleSingle && isTomlTableHeaderLine(line);
+    const isCodexHeader = isHeaderCandidate && headerPattern.test(line);
+
+    if (isCodexHeader) {
+      if (activeLines !== null) {
+        blocks.push(activeLines.join("\n").trim());
+      }
+      activeLines = [line];
+    } else if (activeLines !== null && isHeaderCandidate) {
+      blocks.push(activeLines.join("\n").trim());
+      activeLines = null;
+    } else if (activeLines !== null) {
+      activeLines.push(line);
+    }
+
+    state = advanceTripleQuoteState(line, state);
+  }
+
+  if (activeLines !== null) {
+    blocks.push(activeLines.join("\n").trim());
+  }
+
+  return blocks;
+}
+
+function parseStringAssignment(value, key) {
+  const match = new RegExp("^\\s*" + key + "\\s*=\\s*([\"'])([^\"']+)\\1\\s*$").exec(value);
+  return match ? match[2] : null;
+}
+
+function parseTomlStringArray(value) {
+  const match = /^\s*args\s*=\s*\[(.*)\]\s*$/ms.exec(value.trim());
+
+  if (match === null) {
+    return null;
+  }
+
+  const body = match[1] ?? "";
+  const values = [];
+  let cursor = 0;
+  let expectValue = true;
+
+  while (cursor < body.length) {
+    while (cursor < body.length && /\s/.test(body[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    if (cursor >= body.length) {
+      break;
+    }
+
+    if (!expectValue) {
+      if (body[cursor] !== ",") {
+        return null;
+      }
+      cursor += 1;
+      expectValue = true;
+      continue;
+    }
+
+    const quote = body[cursor];
+    if (quote !== '"' && quote !== "'") {
+      return null;
+    }
+
+    cursor += 1;
+    let token = "";
+    let escaped = false;
+
+    while (cursor < body.length) {
+      const char = body[cursor] ?? "";
+
+      if (char === quote && !escaped) {
+        cursor += 1;
+        values.push(token);
+        break;
+      }
+
+      token += char;
+      escaped = char === "\\" && !escaped;
+      if (char !== "\\") {
+        escaped = false;
+      }
+      cursor += 1;
+    }
+
+    if (cursor > body.length) {
+      return null;
+    }
+
+    expectValue = false;
+  }
+
+  const leftover = body.slice(cursor).trim();
+  if (leftover === ",") {
+    return values;
+  }
+
+  return leftover.length === 0 ? values : null;
+}
+
+function collectArrayLines(lines, startIndex) {
+  const collected = [stripCommentOutsideStrings(lines[startIndex] ?? "")];
+  let bracketDepth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+
+  for (let lineIndex = startIndex; lineIndex < lines.length; lineIndex += 1) {
+    const sanitized = stripCommentOutsideStrings(lines[lineIndex] ?? "");
+    if (lineIndex !== startIndex) {
+      collected.push(sanitized);
+    }
+
+    for (let index = 0; index < sanitized.length; index += 1) {
+      const char = sanitized[index] ?? "";
+
+      if (char === '"' && !inSingle && !escaped) {
+        inDouble = !inDouble;
+      } else if (char === "'" && !inDouble && !escaped) {
+        inSingle = !inSingle;
+      } else if (!inSingle && !inDouble) {
+        if (char === "[") {
+          bracketDepth += 1;
+        } else if (char === "]") {
+          bracketDepth -= 1;
+        }
+      }
+
+      escaped = char === "\\" && !escaped;
+      if (char !== "\\") {
+        escaped = false;
+      }
+    }
+
+    if (bracketDepth <= 0) {
+      return {
+        nextIndex: lineIndex,
+        text: collected.join("\n"),
+      };
+    }
+  }
+
+  return null;
+}
+
+function parseCodexBlock(blockContent) {
+  const lines = blockContent.split("\n");
+  let command = null;
+  let args = null;
+  let hasConflict = false;
+  let inTripleDouble = false;
+  let inTripleSingle = false;
+
+  for (let index = 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const sanitized = stripCommentOutsideStrings(line);
+    const trimmed = sanitized.trim();
+
+    if (inTripleDouble) {
+      if (countTripleQuoteToggles(sanitized, '"') % 2 === 1) {
+        inTripleDouble = false;
+      }
+      continue;
+    }
+
+    if (inTripleSingle) {
+      if (countTripleQuoteToggles(sanitized, "'") % 2 === 1) {
+        inTripleSingle = false;
+      }
+      continue;
+    }
+
+    if (countTripleQuoteToggles(sanitized, '"') % 2 === 1) {
+      inTripleDouble = true;
+      continue;
+    }
+
+    if (countTripleQuoteToggles(sanitized, "'") % 2 === 1) {
+      inTripleSingle = true;
+      continue;
+    }
+
+    if (trimmed.length === 0) {
+      continue;
+    }
+
+    if (/^command\s*=/.test(trimmed)) {
+      const parsedCommand = parseStringAssignment(trimmed, "command");
+      if (command !== null || parsedCommand === null) {
+        hasConflict = true;
+      } else {
+        command = parsedCommand;
+      }
+      continue;
+    }
+
+    if (/^args\s*=/.test(trimmed)) {
+      const collected = collectArrayLines(lines, index);
+      const parsedArgs = collected === null ? null : parseTomlStringArray(collected.text);
+
+      if (args !== null || parsedArgs === null || collected === null) {
+        hasConflict = true;
+      } else {
+        args = parsedArgs;
+        index = collected.nextIndex;
+      }
+    }
+  }
+
+  return {
+    args,
+    command,
+    hasConflict,
+  };
+}
+
+function isStructurallySafe(source) {
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  let tripleState = {
+    inTripleDouble: false,
+    inTripleSingle: false,
+  };
+
+  for (const line of source.split("\n")) {
+    tripleState = advanceTripleQuoteState(line, tripleState);
+
+    for (let index = 0; index < line.length; index += 1) {
+      const char = line[index] ?? "";
+
+      if (!inSingle && !inDouble && char === "#") {
+        break;
+      }
+
+      if (char === '"' && !inSingle && !escaped) {
+        inDouble = !inDouble;
+      } else if (char === "'" && !inDouble && !escaped) {
+        inSingle = !inSingle;
+      } else if (!inSingle && !inDouble) {
+        if (char === "[") {
+          bracketDepth += 1;
+        } else if (char === "]") {
+          bracketDepth -= 1;
+          if (bracketDepth < 0) {
+            return false;
+          }
+        } else if (char === "{") {
+          braceDepth += 1;
+        } else if (char === "}") {
+          braceDepth -= 1;
+          if (braceDepth < 0) {
+            return false;
+          }
+        }
+      }
+
+      escaped = char === "\\" && !escaped;
+      if (char !== "\\") {
+        escaped = false;
+      }
+    }
+  }
+
+  return (
+    !tripleState.inTripleDouble &&
+    !tripleState.inTripleSingle &&
+    bracketDepth === 0 &&
+    braceDepth === 0 &&
+    !inSingle &&
+    !inDouble
+  );
+}
+
+try {
+  const source = fs.readFileSync(configPath, "utf8");
+  if (!isStructurallySafe(source)) {
+    process.exit(1);
+  }
+
+  const blocks = findAllCodexBlocks(source);
+  if (blocks.length !== 1) {
+    process.exit(1);
+  }
+
+  const parsed = parseCodexBlock(blocks[0]);
+  const isConfigured =
+    !parsed.hasConflict &&
+    parsed.command === expectedCommand &&
+    Array.isArray(parsed.args) &&
+    parsed.args.length === expectedArgs.length &&
+    parsed.args.every((entry, index) => entry === expectedArgs[index]);
+
+  process.exit(isConfigured ? 0 : 1);
+} catch {
+  process.exit(1);
+}
+NODE
 }
 
 resolve_optional_cli_command() {
@@ -236,8 +704,7 @@ fi
 # [3/3] Register MCP with AI apps
 # ═══════════════════════════════════
 step "3/3" "Register MCP with AI apps"
-printf "  Automatic registration: Claude Code, Claude Desktop, Cursor, Codex CLI, Gemini CLI\n"
-printf "  Manual setup required: Codex App, Antigravity\n"
+printf "  Automatic registration: Claude Code, Claude Desktop, Cursor, Codex CLI/App, Gemini CLI, Antigravity\n"
 
 MCP_COMMAND='npx -y @weppy/roblox-mcp'
 
@@ -279,17 +746,17 @@ else
   NOT_DETECTED+=("Cursor (not found)")
 fi
 
-# Codex CLI
+# Codex CLI / Codex App (share the same ~/.codex/config.toml)
 CODEX_CONFIG="$HOME/.codex/config.toml"
 CODEX_CLI_COMMAND="$(resolve_optional_cli_command codex 2>/dev/null || true)"
 if is_codex_config_configured "$CODEX_CONFIG"; then
-  DETECTED_NAMES+=("Codex CLI (configured)")
+  DETECTED_NAMES+=("Codex CLI/App (configured)")
   DETECTED_TYPES+=("codex-cli")
 elif [ -n "$CODEX_CLI_COMMAND" ]; then
-  DETECTED_NAMES+=("Codex CLI")
+  DETECTED_NAMES+=("Codex CLI/App")
   DETECTED_TYPES+=("codex-cli")
 else
-  NOT_DETECTED+=("Codex CLI (not found)")
+  NOT_DETECTED+=("Codex CLI/App (not found)")
 fi
 
 # Gemini CLI
@@ -306,6 +773,21 @@ else
   NOT_DETECTED+=("Gemini CLI (not found)")
 fi
 
+# Antigravity (unofficial path, auto-register if found)
+ANTIGRAVITY_CONFIG="$HOME/.gemini/antigravity/mcp_config.json"
+if is_antigravity_mcp_configured "$ANTIGRAVITY_CONFIG"; then
+  DETECTED_NAMES+=("Antigravity (configured)")
+  DETECTED_TYPES+=("antigravity")
+elif [ -f "$ANTIGRAVITY_CONFIG" ]; then
+  DETECTED_NAMES+=("Antigravity")
+  DETECTED_TYPES+=("antigravity")
+elif [ -d "$HOME/.gemini/antigravity" ]; then
+  DETECTED_NAMES+=("Antigravity")
+  DETECTED_TYPES+=("antigravity")
+else
+  NOT_DETECTED+=("Antigravity (not found)")
+fi
+
 if [ ${#DETECTED_NAMES[@]} -eq 0 ]; then
   warn "No AI apps detected"
   info "Register MCP server manually: $MCP_COMMAND"
@@ -411,6 +893,15 @@ else
           fail "Failed: $app_name"
         fi
         ;;
+      antigravity)
+        if is_antigravity_mcp_configured "$ANTIGRAVITY_CONFIG"; then
+          success "Already configured: $app_name"
+        elif add_antigravity_mcp_config "$ANTIGRAVITY_CONFIG"; then
+          success "Registered: $app_name"
+        else
+          fail "Failed: $app_name"
+        fi
+        ;;
     esac
   done
 fi
@@ -428,7 +919,6 @@ printf "  1. Restart Roblox Studio\n"
 # shellcheck disable=SC2059
 printf "  2. Look for the ${BOLD}WROX${NC} button in the Plugins tab\n"
 printf "  3. Click Connect and start building with AI!\n\n"
-printf "  Auto registration: Claude Code, Claude Desktop, Cursor, Codex CLI, Gemini CLI\n"
-printf "  Manual setup required: Codex App, Antigravity\n\n"
+printf "  Auto registration: Claude Code, Claude Desktop, Cursor, Codex CLI/App, Gemini CLI, Antigravity\n\n"
 # shellcheck disable=SC2059
 printf "  ${DIM}Docs: https://github.com/hope1026/weppy-roblox-mcp${NC}\n\n"

package/llms-full.txt

@@ -21,9 +21,21 @@ Roblox Studio Plugin ← Executes commands inside Studio
 
 When an AI app says "Create a blue part", the MCP server converts this request, and the Roblox Studio plugin actually creates the part.
 
-## One-Line Install (Recommended)
+## Web Installer (Recommended)
 
-Installs the MCP server, Roblox Studio plugin, and registers with your AI apps in one step:
+Open the installer page in Chrome, Edge, or Arc for one-click setup:
+
+https://hope1026.github.io/weppy-roblox-mcp/installer/
+
+It writes the supported AI app config for `npx -y @weppy/roblox-mcp` first.
+
+After you reopen the AI app, the first MCP run fetches the package through `npx` and auto-installs the Roblox Studio plugin.
+
+For Safari or Firefox, use the installer page as a guide or continue with the manual install below.
+
+## One-Line Install (Fallback)
+
+Advanced users can install everything in one command:
 
 ```bash
 # macOS / Linux

package/llms.txt

@@ -21,7 +21,11 @@ terrain, and more — inside a live Studio session.
 
 ## Installation
 
-**One-line install** (installs MCP server, Roblox Studio plugin, and registers with AI apps):
+**Web installer** (recommended one-click setup for Chrome, Edge, and Arc):
+
+https://hope1026.github.io/weppy-roblox-mcp/installer/
+
+**One-line install** (advanced fallback):
 
 ```bash
 # macOS / Linux
@@ -31,8 +35,10 @@ curl -fsSL https://raw.githubusercontent.com/hope1026/weppy-roblox-mcp/main/inst
 irm https://raw.githubusercontent.com/hope1026/weppy-roblox-mcp/main/install.ps1 | iex
 ```
 
-Or manually:
-1. Install Roblox Studio plugin (bridge between Studio and AI)
+Safari / Firefox users should follow the installer page guide or open the installation docs.
+
+Manual alternative:
+1. Install Roblox Studio plugin via the installation guide
 2. Register MCP server: `npx -y @weppy/roblox-mcp`
 
 ## Tiers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weppy/roblox-mcp",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "MCP (Model Context Protocol) server for Roblox Studio integration - enables AI coding agents to interact with Roblox Studio in real-time",
   "main": "plugins/weppy-roblox-mcp/dist/index.js",
   "type": "module",

package/plugins/weppy-roblox-mcp/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "weppy-roblox-mcp",
   "description": "MCP server for Roblox Studio integration - AI-powered game development with specialized agents and skills",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "author": {
     "name": "hope1026"
   },