premanmcp 0.4.0 → 0.7.0

package/bin/cli.js

@@ -11,20 +11,34 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { existsSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 
+import { ENDPOINTS_HELP, TEST_HELP, endpointsCommand, testCommand } from "./api_tools.js";
+import { CONNECT_HELP, connectCommand, writeCursorConfig } from "./connect.js";
+import {
+  INTEGRATIONS_HELP,
+  awsCommand,
+  githubCommand,
+  onboardCommand,
+  slackCommand,
+} from "./integrations.js";
 import { HOSTED_HELP, linkCommand, runCommand, toolsCommand } from "./hosted.js";
+import {
+  CREDENTIALS_FILE,
+  DEFAULT_BACKEND,
+  DEFAULT_FRONTEND,
+  authenticateTerminal,
+  buildServerConfig,
+  hasKeyAvailable,
+  makeArgs,
+  readStoredCredentials,
+} from "./shared.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.join(__dirname, "..");
-const DEFAULT_BACKEND = "https://api.preman.live";
-const DEFAULT_FRONTEND = "https://app.preman.live";
-const CREDENTIALS_DIR = path.join(os.homedir(), ".preman");
-const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
 
 const args = process.argv.slice(2);
 const command = args[0] === "--help" || args[0] === "-h"
@@ -33,31 +47,35 @@ const command = args[0] === "--help" || args[0] === "-h"
     ? args[0]
     : "start";
 const commandArgs = command === "start" ? args : args.slice(1);
+const cliArgs = makeArgs(commandArgs);
 
 function argValue(name, fallback = "") {
-  const index = commandArgs.indexOf(name);
-  if (index === -1) return fallback;
-  return commandArgs[index + 1] || fallback;
+  return cliArgs.value(name, fallback);
 }
 
 function hasFlag(name) {
-  return commandArgs.includes(name);
+  return cliArgs.has(name);
 }
 
 function printHelp() {
   process.stdout.write(`PreMan MCP
 
 Usage:
+  preman onboard                                     Sign in, then connect agent, GitHub, AWS, Slack
+  preman connect [options]                           Pick a coding agent and connect it
+  preman aws | github | slack                        Connect one integration on its own
   npm exec -y premanmcp@latest -- login              Create/login to PreMan from the terminal
   npm exec -y premanmcp@latest -- install [options]  Install PreMan into Cursor MCP config
   npm exec -y premanmcp@latest --                    Start the PreMan MCP server
   preman link|tools|run ...                          Drive a published hosted MCP
-
+  preman endpoints list|discover|setup ...           Discover, list, and set up API endpoints
+  preman test <id> [--scenario ...] [--stress]       Generate + run tests for an endpoint
+${INTEGRATIONS_HELP}${CONNECT_HELP}${ENDPOINTS_HELP}${TEST_HELP}
 Login options:
   --email <email>       Pre-fill the email prompt
   --backend <url>       PreMan backend URL. Defaults to ${DEFAULT_BACKEND}
 
-Install options:
+Install options (Cursor only — prefer 'preman connect'):
   --api-key <key>       PreMan API key. If omitted, stored CLI credentials are used
   --backend <url>       PreMan backend URL. Defaults to ${DEFAULT_BACKEND}
   --frontend <url>      PreMan frontend URL. Defaults to ${DEFAULT_FRONTEND}
@@ -68,296 +86,15 @@ Install options:
   --print               Print the config instead of writing it
 
 Examples:
+  npm exec -y premanmcp@latest -- connect
+  preman connect --agent claude-code
   npm exec -y premanmcp@latest -- login
-  npm exec -y premanmcp@latest -- install
-  npm exec -y premanmcp@latest -- install --api-key pm_live_xxx
   npm exec -y premanmcp@latest -- install --project --backend http://127.0.0.1:8000
 ${HOSTED_HELP}`);
 }
 
-function readJsonFile(filePath) {
-  if (!existsSync(filePath)) return {};
-  const raw = readFileSync(filePath, "utf8").trim();
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`Could not parse ${filePath}: ${error.message}`);
-  }
-}
-
-function readStoredCredentials() {
-  try {
-    const raw = readFileSync(CREDENTIALS_FILE, "utf8").trim();
-    if (!raw) return null;
-    const creds = JSON.parse(raw);
-    if (creds && typeof creds.api_key === "string" && creds.api_key.startsWith("pm_live_")) {
-      return creds;
-    }
-  } catch {
-    // No stored credentials yet.
-  }
-  return null;
-}
-
-function saveStoredCredentials(creds) {
-  mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 0o700 });
-  writeFileSync(CREDENTIALS_FILE, `${JSON.stringify(creds, null, 2)}\n`, { mode: 0o600 });
-}
-
-function backendUrl() {
-  return argValue("--backend", process.env.PREMAN_BACKEND || DEFAULT_BACKEND).replace(/\/+$/, "");
-}
-
-async function promptText(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return (await rl.question(question)).trim();
-  } finally {
-    rl.close();
-  }
-}
-
-async function promptSecret(question) {
-  if (!process.stdin.isTTY || !process.stdin.setRawMode) {
-    return promptText(question);
-  }
-
-  return new Promise((resolve) => {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-    const wasRaw = stdin.isRaw;
-    let value = "";
-
-    function cleanup() {
-      stdin.off("data", onData);
-      stdin.setRawMode(Boolean(wasRaw));
-      stdin.pause();
-    }
-
-    function onData(chunk) {
-      const text = String(chunk);
-      if (text === "\u0003") {
-        stdout.write("\n");
-        cleanup();
-        process.exit(130);
-      }
-      if (text === "\r" || text === "\n" || text === "\u0004") {
-        stdout.write("\n");
-        cleanup();
-        resolve(value);
-        return;
-      }
-      if (text === "\u007f" || text === "\b") {
-        if (value.length) {
-          value = value.slice(0, -1);
-          stdout.write("\b \b");
-        }
-        return;
-      }
-      value += text;
-      stdout.write("*");
-    }
-
-    stdout.write(question);
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding("utf8");
-    stdin.on("data", onData);
-  });
-}
-
-async function promptPasswordTwice() {
-  const password = await promptSecret("Create password: ");
-  if (!password || password.length < 6) {
-    throw new Error("Password must be at least 6 characters.");
-  }
-  const confirm = await promptSecret("Confirm password: ");
-  if (password !== confirm) {
-    throw new Error("Passwords do not match.");
-  }
-  return password;
-}
-
-async function callBackendJson(method, routePath, { json, token, query } = {}) {
-  const url = new URL(routePath.replace(/^\/+/, ""), `${backendUrl()}/`);
-  if (query) {
-    for (const [key, value] of Object.entries(query)) {
-      if (value != null && value !== "") url.searchParams.set(key, String(value));
-    }
-  }
-
-  const headers = { Accept: "application/json" };
-  const hasBody = json !== undefined && json !== null;
-  if (hasBody) headers["Content-Type"] = "application/json";
-  if (token) headers.Authorization = `Bearer ${token}`;
-
-  const resp = await fetch(url, {
-    method,
-    headers,
-    body: hasBody ? JSON.stringify(json) : undefined,
-  });
-  const text = await resp.text();
-  let body = {};
-  try {
-    body = text ? JSON.parse(text) : {};
-  } catch {
-    body = { raw: text };
-  }
-  return {
-    status_code: resp.status,
-    ok: resp.ok,
-    ...body,
-  };
-}
-
-function assertOk(result, action) {
-  if (result.ok) return;
-  const detail = result.detail || result.message || result.raw || `${action} failed`;
-  throw new Error(`${action} failed: ${result.status_code} ${detail}`);
-}
-
-async function verifyUnconfirmedAccount(email) {
-  process.stdout.write("This email exists but is not verified. Sending a new OTP.\n");
-  const resend = await callBackendJson("POST", "/auth/resend-otp", { json: { email } });
-  assertOk(resend, "resend OTP");
-  const otp = await promptText("Verification code: ");
-  const verified = await callBackendJson("POST", "/auth/verify-otp", { json: { email, otp } });
-  assertOk(verified, "verify OTP");
-  return verified.access_token;
-}
-
-async function createAccountFromTerminal(email) {
-  const signup = await callBackendJson("POST", "/auth/start-signup", {
-    json: { email },
-  });
-
-  if (signup.ok) {
-    process.stdout.write("Verification code sent. Check your email.\n");
-    const otp = await promptText("Verification code: ");
-    const password = await promptPasswordTwice();
-    const setPassword = await callBackendJson("POST", "/auth/set-password", {
-      json: { email, otp, new_password: password },
-    });
-    assertOk(setPassword, "set password");
-    return String(setPassword.access_token || "");
-  }
-
-  if (signup.status_code !== 404) {
-    assertOk(signup, "start signup");
-  }
-
-  process.stdout.write(
-    "This PreMan backend uses the password-first signup flow. Create your password now, then enter the email code.\n"
-  );
-  const password = await promptPasswordTwice();
-  const legacySignup = await callBackendJson("POST", "/auth/signup", {
-    json: { email, password },
-  });
-  assertOk(legacySignup, "signup");
-  process.stdout.write("Verification code sent. Check your email.\n");
-  const otp = await promptText("Verification code: ");
-  const verified = await callBackendJson("POST", "/auth/verify-otp", {
-    json: { email, otp },
-  });
-  assertOk(verified, "verify OTP");
-  return String(verified.access_token || "");
-}
-
-async function authenticateTerminal() {
-  const explicitKey = argValue("--api-key", process.env.PREMAN_API_KEY || "");
-  if (explicitKey && explicitKey.startsWith("pm_live_")) {
-    const creds = {
-      api_key: explicitKey,
-      backend_url: backendUrl(),
-      user_email: argValue("--email", ""),
-      device_name: os.hostname(),
-      created_at: new Date().toISOString(),
-    };
-    saveStoredCredentials(creds);
-    return creds;
-  }
-
-  const email = (argValue("--email", "") || await promptText("Email: ")).trim().toLowerCase();
-  if (!email) throw new Error("Email is required.");
-
-  process.stdout.write(`Checking PreMan account for ${email}...\n`);
-  const account = await callBackendJson("GET", "/auth/needs-password", { query: { email } });
-  assertOk(account, "check account");
-
-  let accessToken = "";
-
-  if (!account.exists) {
-    process.stdout.write("No PreMan account found. Creating one now.\n");
-    accessToken = await createAccountFromTerminal(email);
-  } else if (account.needs_password) {
-    process.stdout.write("This account needs a password. Sending an OTP first.\n");
-    const resend = await callBackendJson("POST", "/auth/resend-otp", { json: { email } });
-    assertOk(resend, "resend OTP");
-    const otp = await promptText("Verification code: ");
-    const password = await promptPasswordTwice();
-    const setPassword = await callBackendJson("POST", "/auth/set-password", {
-      json: { email, otp, new_password: password },
-    });
-    assertOk(setPassword, "set password");
-    accessToken = String(setPassword.access_token || "");
-  } else {
-    const password = await promptSecret("Password: ");
-    const login = await callBackendJson("POST", "/auth/login", {
-      json: { email, password },
-    });
-    if (!login.ok && login.status_code === 403 && String(login.detail || "").toLowerCase().includes("not verified")) {
-      accessToken = await verifyUnconfirmedAccount(email);
-    } else {
-      assertOk(login, "login");
-      accessToken = String(login.access_token || "");
-    }
-  }
-
-  if (!accessToken) throw new Error("PreMan did not return an access token.");
-
-  const keyName = `PreMan MCP CLI (${os.hostname()})`;
-  const key = await callBackendJson("POST", "/api-keys", {
-    token: accessToken,
-    json: { name: keyName },
-  });
-  assertOk(key, "create API key");
-  if (!key.key || !String(key.key).startsWith("pm_live_")) {
-    throw new Error("PreMan did not return a valid API key.");
-  }
-
-  const creds = {
-    api_key: String(key.key),
-    backend_url: backendUrl(),
-    user_email: email,
-    device_name: os.hostname(),
-    created_at: new Date().toISOString(),
-  };
-  saveStoredCredentials(creds);
-  return creds;
-}
-
-function buildServerConfig() {
-  const apiKey = argValue("--api-key", process.env.PREMAN_API_KEY || "");
-  const backend = argValue("--backend", process.env.PREMAN_BACKEND || DEFAULT_BACKEND);
-  const frontend = argValue("--frontend", process.env.PREMAN_FRONTEND || DEFAULT_FRONTEND);
-  const env = {
-    PREMAN_BACKEND: backend,
-    PREMAN_FRONTEND: frontend,
-  };
-  if (apiKey) {
-    env.PREMAN_API_KEY = apiKey;
-  }
-
-  return {
-    command: "npm",
-    args: ["exec", "-y", "--package", "premanmcp@latest", "--", "premanmcp"],
-    env,
-  };
-}
-
 async function loginCommand() {
-  const creds = await authenticateTerminal();
+  const creds = await authenticateTerminal(cliArgs);
   process.stdout.write(`PreMan account ready.
 
 Email: ${creds.user_email || "unknown"}
@@ -366,61 +103,47 @@ API key: ${creds.api_key}
 Saved to: ${CREDENTIALS_FILE}
 
 You can now run:
-  npm exec -y premanmcp@latest -- install
+  preman connect
 `);
 }
 
+/**
+ * Cursor-only installer, kept for the documented `install` flow. `connect` is
+ * the same write plus agent choice, pairing, and dispatch setup.
+ */
 async function installCursorMcp() {
   const serverName = argValue("--name", "preman");
   const projectInstall = hasFlag("--project");
 
-  if (
-    !hasFlag("--print") &&
-    !hasFlag("--skip-login") &&
-    !argValue("--api-key", "") &&
-    !process.env.PREMAN_API_KEY &&
-    !readStoredCredentials()
-  ) {
+  if (!hasFlag("--print") && !hasFlag("--skip-login") && !hasKeyAvailable(cliArgs)) {
     process.stdout.write("First, let's create or connect your PreMan account.\n");
-    await authenticateTerminal();
+    await authenticateTerminal(cliArgs);
     process.stdout.write("\n");
   }
 
-  const serverConfig = buildServerConfig();
+  const serverConfig = buildServerConfig(cliArgs);
 
   if (hasFlag("--print")) {
     process.stdout.write(`${JSON.stringify({ mcpServers: { [serverName]: serverConfig } }, null, 2)}\n`);
     return;
   }
 
-  const configPath = projectInstall
-    ? path.join(process.cwd(), ".cursor", "mcp.json")
-    : path.join(os.homedir(), ".cursor", "mcp.json");
-
-  const config = {
-    ...readJsonFile(configPath),
-  };
-  config.mcpServers = {
-    ...(config.mcpServers || {}),
-    [serverName]: serverConfig,
-  };
+  const written = writeCursorConfig({ serverName, serverConfig, projectInstall });
 
-  const rendered = `${JSON.stringify(config, null, 2)}\n`;
-  mkdirSync(path.dirname(configPath), { recursive: true });
-  writeFileSync(configPath, rendered, { mode: 0o600 });
-
-  const hasInlineKey = Boolean(config.mcpServers[serverName].env.PREMAN_API_KEY);
+  const hasInlineKey = Boolean(serverConfig.env.PREMAN_API_KEY);
   const hasStoredKey = Boolean(readStoredCredentials());
-  process.stdout.write(`PreMan MCP installed in ${configPath}
+  process.stdout.write(`PreMan MCP installed in ${written.path}
 
 Server name: ${serverName}
-Backend: ${config.mcpServers[serverName].env.PREMAN_BACKEND}
+Backend: ${serverConfig.env.PREMAN_BACKEND}
 
 Next steps:
 1. ${hasInlineKey ? "Your PreMan API key was written to the MCP config." : hasStoredKey ? `Your PreMan API key is saved in ${CREDENTIALS_FILE}; the MCP server will load it automatically.` : "Run npm exec -y premanmcp@latest -- login to create/connect your account and generate an API key."}
 2. Restart Cursor or toggle the PreMan MCP server off/on.
 3. In your API repo, ask your coding agent:
    "Use PreMan to convert the endpoints I choose into a hosted MCP server, then give me the Cursor/Claude install snippet."
+
+Tip: 'preman connect' also supports Claude Code and Codex, and links the agent to your account.
 `);
 }
 
@@ -454,6 +177,18 @@ function startServer() {
 async function main() {
   if (command === "login") {
     await loginCommand();
+  } else if (command === "connect") {
+    await connectCommand(commandArgs);
+  } else if (command === "onboard" || command === "setup") {
+    // makeArgs/authenticateTerminal/connectCommand are injected rather than
+    // imported there, so integrations.js stays free of a cycle back into the CLI.
+    await onboardCommand(commandArgs, { makeArgs, authenticateTerminal, connectCommand });
+  } else if (command === "aws") {
+    await awsCommand(makeArgs(commandArgs));
+  } else if (command === "github") {
+    await githubCommand(makeArgs(commandArgs));
+  } else if (command === "slack") {
+    await slackCommand(makeArgs(commandArgs));
   } else if (command === "install") {
     await installCursorMcp();
   } else if (command === "link") {
@@ -462,6 +197,10 @@ async function main() {
     await toolsCommand(commandArgs);
   } else if (command === "run") {
     await runCommand(commandArgs);
+  } else if (command === "endpoints") {
+    await endpointsCommand(commandArgs);
+  } else if (command === "test") {
+    await testCommand(commandArgs);
   } else if (command === "help" || command === "--help" || command === "-h") {
     printHelp();
   } else if (command === "start") {