@ppcassist/amazon-ads-mcp 1.0.0 → 1.0.2

package/index.js

@@ -76,13 +76,35 @@ async function handleRequest(proxy, request) {
     const result = await proxy.forward(request);
 
     if (result.type === "stream") {
-      // SSE stream: pipe each event line directly to stdout
+      // SSE stream: buffer chunks, extract JSON from "data: ..." lines,
+      // and write as newline-delimited JSON-RPC for Claude Desktop
+      let sseBuf = "";
+      result.stream.setEncoding("utf8");
+
       result.stream.on("data", (chunk) => {
-        process.stdout.write(chunk);
+        sseBuf += chunk;
+        let lineEnd;
+        while ((lineEnd = sseBuf.indexOf("\n")) !== -1) {
+          const line = sseBuf.slice(0, lineEnd).trim();
+          sseBuf = sseBuf.slice(lineEnd + 1);
+          if (line.startsWith("data: ")) {
+            const json = line.slice(6);
+            if (json) {
+              process.stdout.write(json + "\n");
+            }
+          }
+        }
       });
 
       result.stream.on("end", () => {
-        // SSE streams end naturally; nothing extra needed
+        // Flush any remaining data in buffer
+        const remaining = sseBuf.trim();
+        if (remaining.startsWith("data: ")) {
+          const json = remaining.slice(6);
+          if (json) {
+            process.stdout.write(json + "\n");
+          }
+        }
       });
 
       result.stream.on("error", (err) => {

package/lib/auth.js

@@ -14,7 +14,11 @@ class TokenManager {
 
   async init() {
     await this.refresh();
-    this.timer = setInterval(() => this.refresh(), REFRESH_INTERVAL_MS);
+    this.timer = setInterval(() => {
+      this.refresh().catch((err) => {
+        process.stderr.write(`[auth] Token refresh failed: ${err.message}\n`);
+      });
+    }, REFRESH_INTERVAL_MS);
     this.timer.unref(); // don't keep process alive just for refresh
   }
 

package/lib/proxy.js

@@ -19,7 +19,20 @@ class McpProxy {
     this.endpoint = new URL(endpoint);
   }
 
-  async forward(jsonRpcRequest) {
+  async forward(jsonRpcRequest, _isRetry) {
+    const result = await this._doRequest(jsonRpcRequest);
+
+    // Retry once on 401 (token expired between refreshes)
+    if (!_isRetry && result.statusCode === 401) {
+      process.stderr.write("[proxy] Got 401, refreshing token and retrying\n");
+      await this.tokenManager.refresh();
+      return this.forward(jsonRpcRequest, true);
+    }
+
+    return result;
+  }
+
+  _doRequest(jsonRpcRequest) {
     const body = JSON.stringify(jsonRpcRequest);
     const token = this.tokenManager.getToken();
 
@@ -51,9 +64,8 @@ class McpProxy {
           res.on("end", () => {
             const raw = Buffer.concat(chunks).toString();
             try {
-              resolve({ type: "json", data: JSON.parse(raw) });
+              resolve({ type: "json", data: JSON.parse(raw), statusCode: res.statusCode });
             } catch {
-              // Return raw text if not valid JSON (error pages, etc.)
               resolve({ type: "raw", data: raw, statusCode: res.statusCode });
             }
           });

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@ppcassist/amazon-ads-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Local MCP proxy for Amazon Ads API - authenticates and forwards requests to Amazon's official MCP server",
   "main": "index.js",
   "bin": {
-    "amazon-ads-mcp": "./index.js"
+    "amazon-ads-mcp": "./index.js",
+    "amazon-ads-setup": "./setup.js"
   },
   "keywords": [
     "amazon-ads",
@@ -21,6 +22,7 @@
   },
   "files": [
     "index.js",
+    "setup.js",
     "lib/",
     "README.md"
   ]

package/setup.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+
+const http = require("http");
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { exec } = require("child_process");
+const readline = require("readline");
+
+// ─── PPC Assist OAuth credentials (placeholders) ───
+const PPCASSIST_CLIENT_ID = "amzn1.application-oa2-client.REPLACE_ME";
+const PPCASSIST_CLIENT_SECRET = "REPLACE_ME";
+const REDIRECT_URI_BASE = "http://localhost";
+const CALLBACK_PATH = "/callback";
+
+const OAUTH_AUTHORIZE_URL = "https://www.amazon.com/ap/oa";
+const OAUTH_TOKEN_URL = "https://api.amazon.com/auth/o2/token";
+const PROFILES_URL = "https://advertising-api-eu.amazon.com/v2/profiles";
+
+const TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes
+
+// ─── Helpers ───
+
+function print(msg) {
+  process.stdout.write(msg + "\n");
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd =
+    platform === "darwin" ? "open" :
+    platform === "win32" ? "start" :
+    "xdg-open";
+
+  exec(`${cmd} "${url}"`, (err) => {
+    if (err) {
+      print(`\n  Could not open browser automatically.`);
+      print(`  Open this URL manually:\n`);
+      print(`  ${url}\n`);
+    }
+  });
+}
+
+function httpPost(urlStr, body, headers) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlStr);
+    const options = {
+      hostname: url.hostname,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": Buffer.byteLength(body),
+        ...headers,
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      let chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString();
+        try {
+          resolve(JSON.parse(raw));
+        } catch {
+          reject(new Error(`Invalid JSON from ${urlStr}: ${raw.slice(0, 200)}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function httpGet(urlStr, headers) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlStr);
+    const options = {
+      hostname: url.hostname,
+      path: url.pathname + url.search,
+      method: "GET",
+      headers,
+    };
+
+    const req = https.request(options, (res) => {
+      let chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString();
+        try {
+          resolve(JSON.parse(raw));
+        } catch {
+          reject(new Error(`Invalid JSON from ${urlStr}: ${raw.slice(0, 200)}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function askQuestion(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function getConfigPath() {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  }
+  // Linux fallback
+  return path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+
+function detectRegion(profiles) {
+  // Use the first profile's country to guess region
+  // EU marketplaces
+  const euCountries = ["UK", "GB", "DE", "FR", "IT", "ES", "NL", "SE", "PL", "BE", "TR", "AE", "SA", "EG", "IN"];
+  const feCountries = ["JP", "AU", "SG"];
+
+  for (const p of profiles) {
+    const cc = (p.countryCode || "").toUpperCase();
+    if (euCountries.includes(cc)) return "EU";
+    if (feCountries.includes(cc)) return "FE";
+  }
+  return "NA";
+}
+
+// ─── Start local server and wait for callback ───
+
+function waitForCallback(port) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      if (!req.url.startsWith(CALLBACK_PATH)) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+
+      const params = new URL(req.url, `http://localhost:${port}`).searchParams;
+      const code = params.get("code");
+      const error = params.get("error");
+
+      if (error) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Authorization denied.</h2><p>You can close this tab.</p></body></html>");
+        server.close();
+        reject(new Error(`Amazon returned error: ${error}`));
+        return;
+      }
+
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h2>Missing authorization code.</h2></body></html>");
+        return;
+      }
+
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end("<html><body><h2>Authorization successful!</h2><p>You can close this tab and return to the terminal.</p></body></html>");
+      server.close();
+      resolve(code);
+    });
+
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Timed out waiting for authorization (2 minutes). Please try again."));
+    }, TIMEOUT_MS);
+
+    server.on("close", () => clearTimeout(timeout));
+
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve(null); // Signal to try next port
+      } else {
+        reject(err);
+      }
+    });
+
+    server.listen(port, () => {
+      resolve._server = server; // store for reference
+    });
+  });
+}
+
+// ─── Main ───
+
+async function main() {
+  print("");
+  print("\u{1F680} Amazon Ads MCP Setup");
+  print("\u2500".repeat(35));
+
+  // Find an available port
+  let port = 8080;
+  let code = null;
+
+  while (port <= 8082) {
+    const redirectUri = `${REDIRECT_URI_BASE}:${port}${CALLBACK_PATH}`;
+    const authUrl =
+      `${OAUTH_AUTHORIZE_URL}?client_id=${encodeURIComponent(PPCASSIST_CLIENT_ID)}` +
+      `&scope=advertising::campaign_management` +
+      `&response_type=code` +
+      `&redirect_uri=${encodeURIComponent(redirectUri)}`;
+
+    const promise = waitForCallback(port);
+
+    // Check if port was available (give server a moment to start)
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Try to get the code; null means port was in use
+    const result = await Promise.race([
+      promise,
+      new Promise((r) => setTimeout(() => r("pending"), 200)),
+    ]);
+
+    if (result === null) {
+      print(`  Port ${port} in use, trying ${port + 1}...`);
+      port++;
+      continue;
+    }
+
+    // Port is available — open browser and wait
+    print(`\u2192 Opening Amazon authorization in your browser...`);
+    openBrowser(authUrl);
+    print(`\u2192 Waiting for authorization... (press Ctrl+C to cancel)`);
+
+    if (result === "pending") {
+      code = await promise;
+    } else {
+      code = result;
+    }
+    break;
+  }
+
+  if (!code) {
+    print("\n\u274C Could not find an available port (tried 8080-8082). Please free one and try again.");
+    process.exit(1);
+  }
+
+  print("\u2705 Authorization received");
+
+  // Exchange code for tokens
+  const redirectUri = `${REDIRECT_URI_BASE}:${port}${CALLBACK_PATH}`;
+  const tokenBody = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: PPCASSIST_CLIENT_ID,
+    client_secret: PPCASSIST_CLIENT_SECRET,
+  }).toString();
+
+  let tokenData;
+  try {
+    tokenData = await httpPost(OAUTH_TOKEN_URL, tokenBody);
+  } catch (err) {
+    print(`\n\u274C Token exchange failed: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (tokenData.error) {
+    print(`\n\u274C Amazon OAuth error: ${tokenData.error} - ${tokenData.error_description || ""}`);
+    process.exit(1);
+  }
+
+  const { access_token, refresh_token } = tokenData;
+
+  // Fetch advertiser profiles
+  print("\u2192 Fetching your Amazon Ads profiles...");
+
+  let profiles;
+  try {
+    profiles = await httpGet(PROFILES_URL, {
+      Authorization: `Bearer ${access_token}`,
+      "Amazon-Advertising-API-ClientId": PPCASSIST_CLIENT_ID,
+    });
+  } catch (err) {
+    print(`\n\u274C Failed to fetch profiles: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!Array.isArray(profiles) || profiles.length === 0) {
+    print("\n\u274C No advertising profiles found on this account.");
+    process.exit(1);
+  }
+
+  // Select profile
+  let selectedProfile;
+
+  if (profiles.length === 1) {
+    selectedProfile = profiles[0];
+    print(`\u2192 Found 1 profile: ${selectedProfile.accountInfo?.name || "Account"} (${selectedProfile.profileId})`);
+  } else {
+    print(`\u2192 Found ${profiles.length} profiles:`);
+    profiles.forEach((p, i) => {
+      const name = p.accountInfo?.name || `Profile ${p.profileId}`;
+      const cc = p.countryCode || "";
+      print(`   ${i + 1}. ${name} ${cc ? `(${cc})` : ""} — profile_id: ${p.profileId}`);
+    });
+
+    const answer = await askQuestion(`\u2192 Select a profile [1-${profiles.length}]: `);
+    const idx = parseInt(answer, 10) - 1;
+
+    if (isNaN(idx) || idx < 0 || idx >= profiles.length) {
+      print("\n\u274C Invalid selection.");
+      process.exit(1);
+    }
+
+    selectedProfile = profiles[idx];
+  }
+
+  const profileName = selectedProfile.accountInfo?.name || "Amazon Ads";
+  const profileId = String(selectedProfile.profileId);
+  const region = detectRegion([selectedProfile]);
+
+  print(`\u2705 Profile selected: ${profileName} (${region})`);
+
+  // Write Claude Desktop config
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    } catch {
+      print(`  Warning: existing config was invalid JSON, creating fresh.`);
+    }
+  }
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+
+  config.mcpServers["amazon-ads"] = {
+    command: "npx",
+    args: ["-y", "@ppcassist/amazon-ads-mcp"],
+    env: {
+      CLIENT_ID: PPCASSIST_CLIENT_ID,
+      CLIENT_SECRET: PPCASSIST_CLIENT_SECRET,
+      REFRESH_TOKEN: refresh_token,
+      PROFILE_ID: profileId,
+      REGION: region,
+    },
+  };
+
+  // Ensure directory exists
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+
+  print(`\u2705 Claude Desktop config updated`);
+  print(`   ${configPath}`);
+  print("\u2500".repeat(35));
+  print(`\u2705 Setup complete! Restart Claude Desktop to activate.`);
+  print("");
+}
+
+main().catch((err) => {
+  print(`\n\u274C Fatal error: ${err.message}`);
+  process.exit(1);
+});