@atlascompiler/mcp 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,612 @@
+#!/usr/bin/env node
+import {
+  createAtlasMcpServer
+} from "./chunk-QNNAZCBS.js";
+
+// src/cli.ts
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+
+// src/auth/store.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var FileCredentialStore = class {
+  filePath;
+  constructor(customPath) {
+    if (customPath) {
+      this.filePath = customPath;
+    } else {
+      const home = os.homedir();
+      this.filePath = path.join(home, ".atlas", "credentials.json");
+    }
+  }
+  getPath() {
+    return this.filePath;
+  }
+  async getApiKey() {
+    try {
+      if (!fs.existsSync(this.filePath)) {
+        return null;
+      }
+      const raw = fs.readFileSync(this.filePath, "utf8");
+      if (!raw || !raw.trim()) {
+        return null;
+      }
+      const parsed = JSON.parse(raw);
+      if (typeof parsed?.apiKey === "string" && parsed.apiKey.trim().length > 0) {
+        return parsed.apiKey.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async saveApiKey(apiKey) {
+    const trimmed = apiKey.trim();
+    if (!trimmed) {
+      throw new Error("Cannot save an empty API key.");
+    }
+    const dir = path.dirname(this.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+    if (process.platform !== "win32") {
+      try {
+        fs.chmodSync(dir, 448);
+      } catch {
+      }
+    }
+    let createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      if (fs.existsSync(this.filePath)) {
+        const raw = fs.readFileSync(this.filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.createdAt) {
+          createdAt = parsed.createdAt;
+        }
+      }
+    } catch {
+    }
+    const payload = {
+      apiKey: trimmed,
+      createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tempFile = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tempFile, `${JSON.stringify(payload, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+    if (process.platform !== "win32") {
+      try {
+        fs.chmodSync(tempFile, 384);
+      } catch {
+      }
+    }
+    fs.renameSync(tempFile, this.filePath);
+  }
+  async deleteApiKey() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        fs.unlinkSync(this.filePath);
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+};
+
+// src/auth/resolve.ts
+async function resolveAtlasApiKey(options = {}) {
+  const result = await resolveAtlasApiKeyWithSource(options);
+  return result.apiKey;
+}
+async function resolveAtlasApiKeyWithSource(options = {}) {
+  const env = options.env ?? process.env;
+  const envKey = env.ATLAS_API_KEY?.trim();
+  if (envKey) {
+    return {
+      apiKey: envKey,
+      source: "env",
+      location: "process.env.ATLAS_API_KEY"
+    };
+  }
+  const store = options.store ?? new FileCredentialStore();
+  const storedKey = await store.getApiKey();
+  if (storedKey) {
+    return {
+      apiKey: storedKey,
+      source: "store",
+      location: store.getPath()
+    };
+  }
+  return {
+    apiKey: null,
+    source: "none"
+  };
+}
+
+// src/auth/wizard.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+import * as readline from "readline/promises";
+import { fileURLToPath } from "url";
+var API_KEY_REGEX = /^(atlas_[A-Za-z0-9_-]{43}|ak_(live|test)_[0-9A-Za-z]{32,64})$/;
+function validateApiKey(key) {
+  return API_KEY_REGEX.test(key.trim());
+}
+function maskApiKey(key) {
+  const trimmed = key.trim();
+  if (trimmed.length <= 10) {
+    return "***";
+  }
+  return `${trimmed.slice(0, 8)}...${trimmed.slice(-4)}`;
+}
+function getDetectedEditorConfigs(homeDir = os2.homedir(), projectDir = process.cwd()) {
+  const targets = [];
+  const platform = process.platform;
+  let claudeConfigPath;
+  if (platform === "darwin") {
+    claudeConfigPath = path2.join(
+      homeDir,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  } else if (platform === "win32") {
+    const appData = process.env.APPDATA || path2.join(homeDir, "AppData", "Roaming");
+    claudeConfigPath = path2.join(appData, "Claude", "claude_desktop_config.json");
+  } else {
+    claudeConfigPath = path2.join(homeDir, ".config", "Claude", "claude_desktop_config.json");
+  }
+  targets.push({
+    name: "Claude Desktop",
+    configPath: claudeConfigPath,
+    exists: fs2.existsSync(claudeConfigPath),
+    scope: "global",
+    format: "standard"
+  });
+  const cursorGlobalPath = path2.join(homeDir, ".cursor", "mcp.json");
+  targets.push({
+    name: "Cursor (Global)",
+    configPath: cursorGlobalPath,
+    exists: fs2.existsSync(cursorGlobalPath),
+    scope: "global",
+    format: "standard"
+  });
+  const windsurfGlobalPath = path2.join(homeDir, ".codeium", "windsurf", "mcp_config.json");
+  targets.push({
+    name: "Windsurf (Global)",
+    configPath: windsurfGlobalPath,
+    exists: fs2.existsSync(windsurfGlobalPath),
+    scope: "global",
+    format: "standard"
+  });
+  const cursorProjectPath = path2.join(projectDir, ".cursor", "mcp.json");
+  targets.push({
+    name: "Cursor (Project)",
+    configPath: cursorProjectPath,
+    exists: fs2.existsSync(cursorProjectPath),
+    scope: "project",
+    format: "standard"
+  });
+  const vscodeProjectPath = path2.join(projectDir, ".vscode", "mcp.json");
+  targets.push({
+    name: "VS Code (Project)",
+    configPath: vscodeProjectPath,
+    exists: fs2.existsSync(vscodeProjectPath),
+    scope: "project",
+    format: "vscode"
+  });
+  return targets;
+}
+function mergeMcpConfig(configPath, serverName = "atlas", format = "standard") {
+  let existingJson = {};
+  if (fs2.existsSync(configPath)) {
+    const raw = fs2.readFileSync(configPath, "utf8");
+    if (raw.trim()) {
+      try {
+        existingJson = JSON.parse(raw);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(
+          `Failed to parse existing config at ${configPath}: ${msg}. Manual inspection required to avoid overwriting invalid JSON.`
+        );
+      }
+    }
+  }
+  const rootKey = format === "vscode" ? "servers" : "mcpServers";
+  const existingServers = existingJson[rootKey] ?? {};
+  const previousServers = Object.keys(existingServers);
+  const updatedServers = {
+    ...existingServers,
+    [serverName]: {
+      command: "npx",
+      args: ["-y", "@atlascompiler/mcp"]
+    }
+  };
+  const updatedConfig = {
+    ...existingJson,
+    [rootKey]: updatedServers
+  };
+  const dir = path2.dirname(configPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+  fs2.writeFileSync(tempPath, `${JSON.stringify(updatedConfig, null, 2)}
+`, "utf8");
+  fs2.renameSync(tempPath, configPath);
+  return {
+    previousServers,
+    updatedServers: Object.keys(updatedServers)
+  };
+}
+function getBundledSkillContent() {
+  if (typeof import.meta.url !== "string" || !import.meta.url.startsWith("file:")) {
+    throw new Error(
+      "Unable to resolve package directory: import.meta.url is not a valid file URL."
+    );
+  }
+  const currentDir = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(currentDir, "../skills/atlas/SKILL.md"),
+    path2.resolve(currentDir, "../../skills/atlas/SKILL.md"),
+    path2.resolve(currentDir, "../../../skills/atlas/SKILL.md")
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) {
+      return fs2.readFileSync(candidate, "utf8");
+    }
+  }
+  throw new Error("Bundled Atlas SKILL.md could not be found.");
+}
+function installAtlasSkill(targetBaseDir = process.cwd(), isGlobal = false) {
+  const content = getBundledSkillContent();
+  const targetDir = isGlobal ? path2.join(os2.homedir(), ".agents", "skills", "atlas") : path2.join(targetBaseDir, ".agents", "skills", "atlas");
+  const targetFile = path2.join(targetDir, "SKILL.md");
+  const isNew = !fs2.existsSync(targetFile);
+  if (!fs2.existsSync(targetDir)) {
+    fs2.mkdirSync(targetDir, { recursive: true });
+  }
+  const tempFile = `${targetFile}.${process.pid}.${Date.now()}.tmp`;
+  fs2.writeFileSync(tempFile, content, "utf8");
+  fs2.renameSync(tempFile, targetFile);
+  return { targetPath: targetFile, isNew };
+}
+async function probeAtlasApiKey(apiKey, baseUrl = "https://api.atlas-compiler.com") {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`${baseUrl}/health`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "User-Agent": "Atlas-MCP-Init-Probe/1.0"
+      },
+      signal: controller.signal
+    }).finally(() => clearTimeout(timer));
+    if (res.ok) {
+      return { success: true, message: "Atlas API probe succeeded." };
+    }
+    if (res.status === 401 || res.status === 403) {
+      return {
+        success: false,
+        message: "Atlas API rejected key: Invalid or unauthorized credentials."
+      };
+    }
+    return {
+      success: true,
+      message: `Atlas API returned HTTP ${res.status}; key format is valid.`
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      success: true,
+      message: `Could not reach Atlas API (${msg}); proceeding with format validation.`
+    };
+  }
+}
+async function promptForApiKey(rl, store, initialKey) {
+  if (initialKey?.trim()) {
+    return initialKey.trim();
+  }
+  const existingKey = await store.getApiKey();
+  if (existingKey) {
+    console.log(`Found existing credentials at: ${store.getPath()}`);
+    console.log(`Active Key: ${maskApiKey(existingKey)}`);
+    const replaceAns = await rl.question(
+      "Do you want to overwrite this key with a new one? [y/N]: "
+    );
+    if (!replaceAns.trim().toLowerCase().startsWith("y")) {
+      return existingKey;
+    }
+  }
+  while (true) {
+    const input = await rl.question("Enter your Atlas API Key (atlas_... or ak_live_...): ");
+    const trimmed = input.trim();
+    if (!trimmed) {
+      console.log("API key cannot be empty. Please try again.");
+      continue;
+    }
+    if (!validateApiKey(trimmed)) {
+      console.log(
+        "Invalid API key format. Expected format: atlas_<43 chars> or ak_live_<32-64 chars>."
+      );
+      const retry = await rl.question("Try again? [Y/n]: ");
+      if (retry.trim().toLowerCase().startsWith("n")) {
+        return null;
+      }
+      continue;
+    }
+    return trimmed;
+  }
+}
+async function probeApiKeyWithConfirmation(rl, apiKey) {
+  process.stdout.write("Probing Atlas endpoint... ");
+  const probeResult = await probeAtlasApiKey(apiKey);
+  console.log(probeResult.success ? "OK" : "Warning");
+  if (!probeResult.success) {
+    console.warn(`[!] ${probeResult.message}`);
+    const cont = await rl.question("Save key anyway? [Y/n]: ");
+    if (cont.trim().toLowerCase().startsWith("n")) {
+      return false;
+    }
+  }
+  return true;
+}
+async function selectScope(rl, preselected) {
+  if (preselected) {
+    return preselected;
+  }
+  console.log("\n--- MCP Editor Configuration ---");
+  console.log("Where would you like to configure Atlas MCP?");
+  console.log("  1) Global / User-Level (Claude Desktop, ~/.cursor/mcp.json, Windsurf) [Default]");
+  console.log(
+    "  2) Project-Level (Configure for this repository: .cursor/mcp.json, .vscode/mcp.json)"
+  );
+  console.log("  3) Both Global & Project-Level");
+  console.log("  4) Skip editor configuration");
+  const answer = await rl.question("Select scope [1-4] (Default: 1): ");
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === "2" || trimmed.startsWith("p")) return "project";
+  if (trimmed === "3" || trimmed.startsWith("b")) return "both";
+  if (trimmed === "4" || trimmed.startsWith("s")) return "skip";
+  return "global";
+}
+async function configureSingleEditor(rl, editor) {
+  const scopeTag = editor.scope === "global" ? "[Global]" : "[Project]";
+  const promptText = editor.exists ? `Configure Atlas MCP in ${editor.name} ${scopeTag} (${editor.configPath})? [Y/n]: ` : `Initialize Atlas MCP in ${editor.name} ${scopeTag} (${editor.configPath})? [Y/n]: `;
+  const answer = await rl.question(promptText);
+  if (answer.trim() && !answer.trim().toLowerCase().startsWith("y")) {
+    console.log(`  Skipped ${editor.name}.`);
+    return;
+  }
+  try {
+    const res = mergeMcpConfig(editor.configPath, "atlas", editor.format);
+    console.log(
+      `  \u2713 Configured ${editor.name}. Active MCP servers: [${res.updatedServers.join(", ")}]`
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`  \u2717 Failed to configure ${editor.name}: ${msg}`);
+  }
+}
+async function configureEditors(rl, scope, projectDir) {
+  if (scope === "skip") {
+    console.log("Skipped editor configuration.");
+    return;
+  }
+  console.log("\n--- Editor & Agent Integration ---");
+  const allEditors = getDetectedEditorConfigs(os2.homedir(), projectDir);
+  const targets = allEditors.filter((editor) => {
+    if (scope === "both") return true;
+    return editor.scope === scope;
+  });
+  for (const editor of targets) {
+    await configureSingleEditor(rl, editor);
+  }
+}
+async function promptSkillInstallation(rl, projectDir = process.cwd()) {
+  console.log("\n--- Agent Skill Installation ---");
+  console.log("Install the canonical Atlas Agent Skill (.agents/skills/atlas/SKILL.md)?");
+  console.log("  1) In this project (.agents/skills/atlas/SKILL.md) [Default]");
+  console.log("  2) Globally for all projects (~/.agents/skills/atlas/SKILL.md)");
+  console.log("  3) Skip skill installation");
+  const ans = await rl.question("Select option [1-3] (Default: 1): ");
+  const trimmed = ans.trim();
+  if (trimmed === "2" || trimmed.toLowerCase().startsWith("g")) {
+    try {
+      const res = installAtlasSkill(projectDir, true);
+      console.log(`  \u2713 Installed Atlas Agent Skill globally to: ${res.targetPath}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`  \u2717 Failed to install global Agent Skill: ${msg}`);
+    }
+  } else if (trimmed === "3" || trimmed.toLowerCase().startsWith("s")) {
+    console.log("  Skipped Agent Skill installation.");
+  } else {
+    try {
+      const res = installAtlasSkill(projectDir, false);
+      console.log(`  \u2713 Installed Atlas Agent Skill to: ${res.targetPath}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`  \u2717 Failed to install Agent Skill: ${msg}`);
+    }
+  }
+}
+async function runSetupWizard(options = {}) {
+  const store = options.store ?? new FileCredentialStore();
+  const rl = options.rlInterface ?? readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const shouldCloseRl = !options.rlInterface;
+  const projectDir = options.projectDir ?? process.cwd();
+  try {
+    console.log("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+    console.log("\u2551       Atlas MCP - Zero-Friction Credential Setup          \u2551");
+    console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n");
+    const apiKey = await promptForApiKey(rl, store, options.apiKey);
+    if (!apiKey) {
+      console.log("Setup aborted.");
+      return;
+    }
+    if (!options.skipProbe) {
+      const confirmed = await probeApiKeyWithConfirmation(rl, apiKey);
+      if (!confirmed) {
+        console.log("Setup cancelled.");
+        return;
+      }
+    }
+    await store.saveApiKey(apiKey);
+    console.log(`
+\u2713 Securely saved credentials to: ${store.getPath()}`);
+    const scope = await selectScope(rl, options.scope);
+    await configureEditors(rl, scope, projectDir);
+    await promptSkillInstallation(rl, projectDir);
+    console.log("\n\u2728 Atlas MCP setup completed successfully!");
+    console.log("You can now run:");
+    console.log("  npx -y @atlascompiler/mcp");
+    console.log("or use Atlas tools directly in your AI assistant!\n");
+  } finally {
+    if (shouldCloseRl) {
+      rl.close();
+    }
+  }
+}
+
+// src/cli.ts
+try {
+  if (typeof process.loadEnvFile === "function") {
+    process.loadEnvFile();
+  }
+} catch {
+}
+var cliArgs = process.argv.slice(2);
+for (const arg of cliArgs) {
+  if (arg.startsWith("--api-key") || arg.startsWith("-k")) {
+    console.error(
+      "Security Error: Passing API keys via CLI flags (--api-key) is prohibited.\nPlease supply your credentials via ~/.atlas/credentials.json (run: atlas-mcp init) or the ATLAS_API_KEY environment variable."
+    );
+    process.exit(1);
+  }
+}
+var firstArg = cliArgs[0]?.toLowerCase();
+async function handleInit() {
+  let scope;
+  if (cliArgs.includes("--global") || cliArgs.includes("-g")) {
+    scope = "global";
+  } else if (cliArgs.includes("--project") || cliArgs.includes("-p")) {
+    scope = "project";
+  } else if (cliArgs.includes("--both")) {
+    scope = "both";
+  } else if (cliArgs.includes("--skip-editors")) {
+    scope = "skip";
+  }
+  const skipProbe = cliArgs.includes("--skip-probe");
+  await runSetupWizard({ scope, skipProbe });
+}
+async function handleWhoami() {
+  const result = await resolveAtlasApiKeyWithSource();
+  if (result.apiKey) {
+    console.log("Atlas Credentials:");
+    console.log(`  Source:   ${result.source} (${result.location})`);
+    console.log(`  API Key:  ${maskApiKey(result.apiKey)}`);
+  } else {
+    console.log("No Atlas credentials found.");
+    console.log(
+      "Run `atlas-mcp init` to configure credentials or set ATLAS_API_KEY in your environment."
+    );
+  }
+}
+async function handleLogout() {
+  const store = new FileCredentialStore();
+  await store.deleteApiKey();
+  console.log(`Cleared stored credentials from ${store.getPath()}.`);
+}
+function handleSkillInstall() {
+  const isGlobal = cliArgs.includes("--global") || cliArgs.includes("-g");
+  try {
+    const result = installAtlasSkill(process.cwd(), isGlobal);
+    console.log(`\u2713 Atlas Agent Skill installed to: ${result.targetPath}`);
+    console.log(
+      "AI agents (Claude Code, Cursor, Antigravity) in this environment will now discover and use Atlas tools."
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to install Agent Skill: ${msg}`);
+    process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+Atlas Model Context Protocol (MCP) CLI
+
+Usage:
+  atlas-mcp [command] [options]
+
+Commands:
+  (default)            Start the MCP stdio server for Claude, Cursor, and other MCP clients
+  init | login | setup Interactive credential setup wizard and editor configuration
+    --global, -g       Configure user-level editor settings (Claude, ~/.cursor, Windsurf)
+    --project, -p      Configure project-level editor settings (.cursor/mcp.json, .vscode/mcp.json)
+    --both             Configure both user-level and project-level editor settings
+    --skip-editors     Skip editor configuration during setup
+    --skip-probe       Skip network probe verification during setup
+  skill [--global, -g] Install the canonical Atlas Agent Skill into .agents/skills/atlas/SKILL.md
+  whoami               Check currently active credentials and source
+  logout               Clear stored credentials from ~/.atlas/credentials.json
+  help, -h, --help     Show this help message
+
+Environment Variables:
+  ATLAS_API_KEY        Overrides stored credentials for CI/CD or ephemeral environments
+  ATLAS_BASE_URL       Atlas API endpoint (default: https://api.atlas-compiler.com)
+`);
+}
+async function main() {
+  if (firstArg === "init" || firstArg === "login" || firstArg === "setup") {
+    await handleInit();
+    return;
+  }
+  if (firstArg === "skill" || firstArg === "install-skill") {
+    handleSkillInstall();
+    return;
+  }
+  if (firstArg === "whoami") {
+    await handleWhoami();
+    return;
+  }
+  if (firstArg === "logout") {
+    await handleLogout();
+    return;
+  }
+  if (firstArg === "help" || firstArg === "--help" || firstArg === "-h") {
+    printHelp();
+    return;
+  }
+  const apiKey = await resolveAtlasApiKey();
+  if (!apiKey) {
+    console.error(
+      "[atlas-mcp] Notice: No Atlas API key found in ATLAS_API_KEY or ~/.atlas/credentials.json.\n[atlas-mcp] Execution calls against Atlas API will require valid credentials. Run `atlas-mcp init` to set up."
+    );
+  }
+  const baseUrl = process.env.ATLAS_BASE_URL ?? "https://api.atlas-compiler.com";
+  const server = createAtlasMcpServer({
+    context: {
+      apiKey: apiKey ?? void 0,
+      baseUrl
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("Fatal error in Atlas MCP CLI:", err);
+  process.exit(1);
+});