maybethisone 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # maybethisone
 
-A CLI tool to check name availability across multiple platforms - GitHub, npm, Twitter/X, LinkedIn, and domains.
+A CLI tool and MCP server to check name availability across multiple platforms - GitHub, npm, Twitter/X, LinkedIn, and domains.
 
 ## Installation
 
@@ -73,11 +73,64 @@ Results for: myproject
 | `~ No DNS`    | No DNS record found (domain may still be registered - verify manually) |
 | `? Error`     | Check failed                                                           |
 
+## MCP Server (for AI Agents)
+
+maybethisone includes an MCP (Model Context Protocol) server that allows AI agents like Claude to check name availability.
+
+### Tools Available
+
+| Tool                         | Description                                                    |
+| ---------------------------- | -------------------------------------------------------------- |
+| `check_name_availability`    | Full check - all platforms including social media (uses browser) |
+| `check_name_availability_quick` | Quick check - GitHub, npm package, and .com domain only (no browser) |
+
+### Claude Desktop Configuration
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "maybethisone": {
+      "command": "npx",
+      "args": ["maybethisone-mcp"]
+    }
+  }
+}
+```
+
+Or if installed locally:
+
+```json
+{
+  "mcpServers": {
+    "maybethisone": {
+      "command": "node",
+      "args": ["/path/to/maybethisone/dist/mcp.js"]
+    }
+  }
+}
+```
+
+### Example Response
+
+```json
+{
+  "name": "myproject",
+  "results": [
+    { "resource": "github.com/orgs/myproject", "status": "available" },
+    { "resource": "npm package: myproject", "status": "taken" },
+    { "resource": "myproject.com", "status": "taken" }
+  ]
+}
+```
+
 ## Project Structure
 
 ```
 src/
-├── index.ts              # Main entry point
+├── index.ts              # CLI entry point
+├── mcp.ts                # MCP server entry point
 ├── types.ts              # TypeScript type definitions
 ├── checkers/
 │   ├── index.ts          # Re-exports all checkers

package/dist/index.js

@@ -33,6 +33,13 @@ async function getBrowserContext() {
   }
   return browserContext;
 }
+async function closeBrowser() {
+  if (browser) {
+    await browser.close();
+    browser = null;
+    browserContext = null;
+  }
+}
 
 // src/checkers/npm.ts
 async function checkNpmPackage(name) {
@@ -145,7 +152,7 @@ async function checkDomain(name, extension) {
 import { chromium as chromium2 } from "playwright";
 var browser2 = null;
 var browserContext2 = null;
-async function closeBrowser() {
+async function closeBrowser2() {
   if (browser2) {
     await browser2.close();
     browser2 = null;
@@ -190,30 +197,34 @@ function formatStatus(result) {
   return chalk2.red("\u2717 Taken");
 }
 async function checkAllForName(name) {
-  const results = [];
-  logProgress("Checking GitHub organization...");
-  const githubResult = await checkGitHubOrg(name);
-  results.push({ resource: `github.com/orgs/${name}`, ...githubResult });
-  logProgress("Checking npm package...");
-  const npmPkgResult = await checkNpmPackage(name);
-  results.push({ resource: `npm package: ${name}`, ...npmPkgResult });
-  logProgress("Checking npm org (loading browser)...");
-  const npmOrgResult = await checkNpmOrg(name);
-  results.push({ resource: `npm org: @${name}`, ...npmOrgResult });
-  logProgress("Checking Twitter/X...");
-  const twitterResult = await checkTwitter(name);
-  results.push({ resource: `x.com/${name}`, ...twitterResult });
-  logProgress("Checking LinkedIn...");
-  const linkedinResult = await checkLinkedIn(name);
-  results.push({ resource: `linkedin.com/company/${name}`, ...linkedinResult });
-  logProgress("Checking domains...");
-  const domainResults = await Promise.all(DOMAIN_EXTENSIONS.map(async (ext) => {
-    const result = await checkDomain(name, ext);
-    return { resource: `${name}${ext}`, ...result };
-  }));
-  results.push(...domainResults);
+  logProgress("Checking all platforms...");
+  const [
+    githubResult,
+    npmPkgResult,
+    npmOrgResult,
+    twitterResult,
+    linkedinResult,
+    ...domainResults
+  ] = await Promise.all([
+    checkGitHubOrg(name),
+    checkNpmPackage(name),
+    checkNpmOrg(name),
+    checkTwitter(name),
+    checkLinkedIn(name),
+    ...DOMAIN_EXTENSIONS.map((ext) => checkDomain(name, ext))
+  ]);
   clearProgress();
-  return results;
+  return [
+    { resource: `github.com/orgs/${name}`, ...githubResult },
+    { resource: `npm package: ${name}`, ...npmPkgResult },
+    { resource: `npm org: @${name}`, ...npmOrgResult },
+    { resource: `x.com/${name}`, ...twitterResult },
+    { resource: `linkedin.com/company/${name}`, ...linkedinResult },
+    ...DOMAIN_EXTENSIONS.map((ext, i) => ({
+      resource: `${name}${ext}`,
+      ...domainResults[i]
+    }))
+  ];
 }
 function displayResults(name, results) {
   console.log(chalk2.bold(`
@@ -247,6 +258,12 @@ function showUsage() {
   console.log("  \u2022 Twitter/X username");
   console.log("  \u2022 LinkedIn company page");
   console.log(`  \u2022 Domains (${DOMAIN_EXTENSIONS.join(", ")})
+`);
+  console.log(chalk2.bold("MCP Server (for AI agents):"));
+  console.log(`  maybethisone-mcp
+`);
+  console.log("  Add to Claude Desktop config:");
+  console.log(`  { "mcpServers": { "maybethisone": { "command": "npx", "args": ["maybethisone-mcp"] } } }
 `);
 }
 function isValidName(name) {
@@ -275,10 +292,10 @@ async function main() {
       await Bun.sleep(500);
     }
   }
-  await closeBrowser();
+  await closeBrowser2();
 }
 main().catch(async (err) => {
   console.error(err);
-  await closeBrowser();
+  await closeBrowser2();
   process.exit(1);
 });

package/dist/mcp.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/checkers/github.ts
+async function checkGitHubOrg(name) {
+  try {
+    const response = await fetch(`https://github.com/orgs/${name}`, {
+      method: "HEAD",
+      redirect: "manual"
+    });
+    return { available: response.status === 404 };
+  } catch (error) {
+    return { available: null, error: error.message };
+  }
+}
+// src/utils/browser.ts
+import { chromium } from "playwright";
+var browser = null;
+var browserContext = null;
+async function getBrowserContext() {
+  if (!browser) {
+    browser = await chromium.launch({
+      headless: true,
+      args: ["--disable-blink-features=AutomationControlled"]
+    });
+    browserContext = await browser.newContext({
+      userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    });
+  }
+  return browserContext;
+}
+async function closeBrowser() {
+  if (browser) {
+    await browser.close();
+    browser = null;
+    browserContext = null;
+  }
+}
+
+// src/checkers/npm.ts
+async function checkNpmPackage(name) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${name}`, {
+      method: "HEAD"
+    });
+    const isAvailable = response.status === 404;
+    return { available: isAvailable, maybeAvailable: isAvailable };
+  } catch (error) {
+    return { available: null, error: error.message };
+  }
+}
+async function checkNpmOrg(name) {
+  try {
+    const context = await getBrowserContext();
+    const page = await context.newPage();
+    await page.addInitScript(() => {
+      Object.defineProperty(navigator, "webdriver", { get: () => false });
+    });
+    await page.goto(`https://www.npmjs.com/org/${name}`, {
+      waitUntil: "load",
+      timeout: 30000
+    });
+    try {
+      await page.waitForFunction(() => !document.title.includes("moment"), { timeout: 15000 });
+    } catch {}
+    await page.waitForTimeout(1000);
+    const bodyText = await page.evaluate(() => document.body.innerText);
+    await page.close();
+    const notFoundPatterns = [
+      /scope not found/i,
+      /NotFoundError/i,
+      /couldn't find.*org/i
+    ];
+    const isNotFound = notFoundPatterns.some((pattern) => pattern.test(bodyText));
+    return { available: isNotFound };
+  } catch (error) {
+    return { available: null, error: error.message };
+  }
+}
+// src/checkers/twitter.ts
+async function checkTwitter(name) {
+  try {
+    const context = await getBrowserContext();
+    const page = await context.newPage();
+    await page.addInitScript(() => {
+      Object.defineProperty(navigator, "webdriver", { get: () => false });
+    });
+    await page.goto(`https://x.com/${name}`, {
+      waitUntil: "domcontentloaded",
+      timeout: 45000
+    });
+    await page.waitForTimeout(3000);
+    const bodyText = await page.evaluate(() => document.body.innerText);
+    await page.close();
+    const notFoundPatterns = [
+      /this account doesn.t exist/i,
+      /account suspended/i,
+      /doesn.t exist/i,
+      /hmm.*this page doesn.t exist/i
+    ];
+    const isNotFound = notFoundPatterns.some((pattern) => pattern.test(bodyText));
+    return { available: isNotFound };
+  } catch (error) {
+    return { available: null, error: error.message };
+  }
+}
+// src/checkers/linkedin.ts
+async function checkLinkedIn(name) {
+  try {
+    const context = await getBrowserContext();
+    const page = await context.newPage();
+    await page.addInitScript(() => {
+      Object.defineProperty(navigator, "webdriver", { get: () => false });
+    });
+    await page.goto(`https://www.linkedin.com/company/${name}`, {
+      waitUntil: "load",
+      timeout: 30000
+    });
+    await page.waitForTimeout(2000);
+    const bodyText = await page.evaluate(() => document.body.innerText);
+    const url = page.url();
+    await page.close();
+    const notFoundPatterns = [
+      /page not found/i,
+      /this page doesn.t exist/i,
+      /couldn.t find/i
+    ];
+    const isNotFound = notFoundPatterns.some((pattern) => pattern.test(bodyText)) || url.includes("/404") || url.includes("pagenotfound");
+    return { available: isNotFound };
+  } catch (error) {
+    return { available: null, error: error.message };
+  }
+}
+// src/checkers/domain.ts
+import { resolve } from "dns/promises";
+async function checkDomain(name, extension) {
+  try {
+    await resolve(`${name}${extension}`);
+    return { available: false };
+  } catch (error) {
+    if (error.code === "ENOTFOUND" || error.code === "ENODATA") {
+      return { available: true, dnsOnly: true };
+    }
+    return { available: null, error: error.message };
+  }
+}
+// src/types.ts
+var DOMAIN_EXTENSIONS = [".com", ".dev", ".io", ".org", ".net", ".co", ".app"];
+
+// src/mcp.ts
+var server = new McpServer({
+  name: "maybethisone",
+  version: "0.1.0"
+});
+function formatResult(result) {
+  if (result.error) {
+    return "error";
+  }
+  if (result.available) {
+    if (result.dnsOnly) {
+      return "no_dns";
+    }
+    if (result.maybeAvailable) {
+      return "maybe";
+    }
+    return "available";
+  }
+  return "taken";
+}
+async function checkAllForName(name) {
+  const [
+    githubResult,
+    npmPkgResult,
+    npmOrgResult,
+    twitterResult,
+    linkedinResult,
+    ...domainResults
+  ] = await Promise.all([
+    checkGitHubOrg(name),
+    checkNpmPackage(name),
+    checkNpmOrg(name),
+    checkTwitter(name),
+    checkLinkedIn(name),
+    ...DOMAIN_EXTENSIONS.map((ext) => checkDomain(name, ext))
+  ]);
+  return [
+    { resource: `github.com/orgs/${name}`, ...githubResult },
+    { resource: `npm package: ${name}`, ...npmPkgResult },
+    { resource: `npm org: @${name}`, ...npmOrgResult },
+    { resource: `x.com/${name}`, ...twitterResult },
+    { resource: `linkedin.com/company/${name}`, ...linkedinResult },
+    ...DOMAIN_EXTENSIONS.map((ext, i) => ({
+      resource: `${name}${ext}`,
+      ...domainResults[i]
+    }))
+  ];
+}
+server.tool("check_name_availability", "Check if a name is available across GitHub orgs, npm packages/orgs, Twitter/X, LinkedIn, and domains (.com, .dev, .io, .org, .net, .co, .app)", {
+  name: z.string().describe('The name to check availability for (e.g., "myproject")')
+}, async ({ name }) => {
+  const validNamePattern = /^[a-zA-Z0-9][-a-zA-Z0-9]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$/;
+  if (!validNamePattern.test(name)) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: "Invalid name format. Name must start and end with alphanumeric characters and can contain hyphens.",
+          name
+        }, null, 2)
+      }]
+    };
+  }
+  try {
+    const results = await checkAllForName(name.toLowerCase());
+    await closeBrowser();
+    const formattedResults = results.map((r) => ({
+      resource: r.resource,
+      status: formatResult(r),
+      error: r.error || undefined
+    }));
+    const summary = {
+      name,
+      results: formattedResults,
+      legend: {
+        available: "Confirmed available",
+        taken: "Confirmed taken",
+        maybe: "npm package - may conflict with normalized names or private packages",
+        no_dns: "No DNS record found (domain may still be registered)",
+        error: "Check failed"
+      }
+    };
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(summary, null, 2)
+      }]
+    };
+  } catch (error) {
+    await closeBrowser();
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: `Failed to check availability: ${error.message}`,
+          name
+        }, null, 2)
+      }],
+      isError: true
+    };
+  }
+});
+server.tool("check_name_availability_quick", "Quick check for name availability - only checks GitHub org, npm package, and .com domain (faster, no browser needed)", {
+  name: z.string().describe("The name to check availability for")
+}, async ({ name }) => {
+  const validNamePattern = /^[a-zA-Z0-9][-a-zA-Z0-9]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$/;
+  if (!validNamePattern.test(name)) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: "Invalid name format",
+          name
+        }, null, 2)
+      }]
+    };
+  }
+  try {
+    const results = [];
+    const lowerName = name.toLowerCase();
+    const githubResult = await checkGitHubOrg(lowerName);
+    results.push({ resource: `github.com/orgs/${lowerName}`, ...githubResult });
+    const npmPkgResult = await checkNpmPackage(lowerName);
+    results.push({ resource: `npm package: ${lowerName}`, ...npmPkgResult });
+    const domainResult = await checkDomain(lowerName, ".com");
+    results.push({ resource: `${lowerName}.com`, ...domainResult });
+    const formattedResults = results.map((r) => ({
+      resource: r.resource,
+      status: formatResult(r),
+      error: r.error || undefined
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          name,
+          results: formattedResults
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          error: `Failed to check: ${error.message}`,
+          name
+        }, null, 2)
+      }],
+      isError: true
+    };
+  }
+});
+function logStartup() {
+  const msg = (text) => console.error(text);
+  const cwd = process.cwd();
+  msg("");
+  msg("✓ maybethisone MCP server running");
+  msg("");
+  msg("Available tools:");
+  msg("  • check_name_availability       - Full check (all platforms, uses browser)");
+  msg("  • check_name_availability_quick - Quick check (GitHub, npm, .com only)");
+  msg("");
+  msg("Claude Desktop config (~/.config/claude/claude_desktop_config.json):");
+  msg("");
+  msg("  // If installed via npm");
+  msg("  {");
+  msg('    "mcpServers": {');
+  msg('      "maybethisone": {');
+  msg('        "command": "npx",');
+  msg('        "args": ["maybethisone-mcp"]');
+  msg("      }");
+  msg("    }");
+  msg("  }");
+  msg("");
+  msg("  // For local development");
+  msg("  {");
+  msg('    "mcpServers": {');
+  msg('      "maybethisone": {');
+  msg('        "command": "bun",');
+  msg('        "args": ["run", "src/mcp.ts"],');
+  msg(`        "cwd": "${cwd}"`);
+  msg("      }");
+  msg("    }");
+  msg("  }");
+  msg("");
+  msg("Note: You don't need to run this manually.");
+  msg("Claude Desktop will start it automatically when configured.");
+  msg("");
+}
+async function main() {
+  logStartup();
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("MCP server error:", error);
+  process.exit(1);
+});

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "maybethisone",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Check availability of GitHub orgs, npm packages, social media handles, and domains",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "maybethisone": "dist/index.js"
+    "maybethisone": "dist/index.js",
+    "maybethisone-mcp": "dist/mcp.js"
   },
   "files": [
     "dist"
@@ -13,7 +14,8 @@
   "scripts": {
     "search": "bun run src/index.ts",
     "dev": "bun --watch src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --external playwright --external chalk --external cli-table3",
+    "mcp": "bun run src/mcp.ts",
+    "build": "bun build src/index.ts src/mcp.ts --outdir dist --target node --format esm --external playwright --external chalk --external cli-table3 --external @modelcontextprotocol/sdk --external zod",
     "clean": "rm -rf dist",
     "prebuild": "bun run clean",
     "prepublishOnly": "bun run build",
@@ -37,14 +39,18 @@
     "twitter",
     "linkedin",
     "cli",
+    "mcp",
+    "model-context-protocol",
     "maybethisone"
   ],
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
-    "playwright": "^1.57.0"
+    "playwright": "^1.57.0",
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/bun": "latest",