@witchpot/gmc 0.1.0

package/src/args.js

@@ -0,0 +1,99 @@
+import { EXIT_USAGE } from "./constants.js";
+import { writeJsonError } from "./output.js";
+
+export const BOOLEAN_OPTIONS = new Set(["json", "help", "version", "no-open"]);
+
+export function parseArgs(args) {
+  const command = [];
+  const positional = [];
+  const options = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith("--")) {
+      const raw = arg.slice(2);
+      const separatorIndex = raw.indexOf("=");
+      const key = separatorIndex >= 0 ? raw.slice(0, separatorIndex) : raw;
+      const inlineValue = separatorIndex >= 0 ? raw.slice(separatorIndex + 1) : undefined;
+      if (BOOLEAN_OPTIONS.has(key)) {
+        options[key] = true;
+        continue;
+      }
+
+      const value = inlineValue ?? args[index + 1];
+      if (value == null || value === "" || value.startsWith("--")) {
+        writeJsonError({
+          code: "CLI_USAGE_ERROR",
+          message: `Missing value for --${key}`
+        });
+        process.exit(EXIT_USAGE);
+      }
+
+      if (inlineValue == null) index += 1;
+      options[key] = value;
+      continue;
+    }
+
+    if (command.length < 2 && isCommandToken(command, arg)) {
+      command.push(arg);
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { command, options, positional };
+}
+
+function isCommandToken(command, token) {
+  if (command.length === 0) {
+    return [
+      "status",
+      "schema",
+      "games",
+      "reviews",
+      "campaigns",
+      "marketing",
+      "creators",
+      "cohort",
+      "showcases",
+      "auth",
+      "login",
+      "logout",
+      "config",
+      "update",
+      "version"
+    ].includes(token);
+  }
+  if (command[0] === "auth") {
+    return token === "status";
+  }
+  if (command[0] === "config") {
+    return ["get", "set"].includes(token);
+  }
+  if (command[0] === "games") {
+    return ["search", "resolve", "benchmark", "detail", "analysis", "compare", "topics"].includes(token);
+  }
+  if (command[0] === "reviews") {
+    return token === "patterns";
+  }
+  if (command[0] === "campaigns") {
+    return token === "signals";
+  }
+  if (command[0] === "marketing") {
+    return ["patterns", "timing"].includes(token);
+  }
+  if (command[0] === "creators") {
+    return token === "patterns";
+  }
+  if (command[0] === "cohort") {
+    return ["trends", "pricing", "brief", "compare"].includes(token);
+  }
+  if (command[0] === "showcases") {
+    return ["search", "fit", "patterns"].includes(token);
+  }
+  return false;
+}
+
+export function matches(actual, expected) {
+  return actual.length === expected.length && expected.every((part, index) => actual[index] === part);
+}

package/src/browser-login.js

@@ -0,0 +1,255 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { platform } from "node:os";
+import { spawn } from "node:child_process";
+import { EXIT_API, EXIT_CONFIG } from "./constants.js";
+import { writeJsonError } from "./output.js";
+
+const DEFAULT_LOGIN_TIMEOUT_MS = 120000;
+
+export async function runBrowserLogin({
+  apiBaseUrl,
+  label = "GMC CLI",
+  noOpen = false,
+  timeoutMs = DEFAULT_LOGIN_TIMEOUT_MS,
+  openBrowser = openSystemBrowser,
+  fetchImpl = fetch
+}) {
+  const state = randomToken();
+  const codeVerifier = randomToken();
+  const codeChallenge = createHash("sha256").update(codeVerifier).digest("base64url");
+  const callback = await createLoopbackCallback({ state, timeoutMs });
+
+  try {
+    const loginUrl = buildLoginUrl({
+      apiBaseUrl,
+      redirectUri: callback.redirectUri,
+      state,
+      codeChallenge,
+      label
+    });
+
+    process.stderr.write(`Open this URL to sign in to GMC:\n${loginUrl.toString()}\n`);
+    if (!noOpen) openBrowser(loginUrl.toString());
+
+    const authorization = await callback.wait();
+    const credential = await exchangeAuthorizationCode({
+      apiBaseUrl,
+      code: authorization.code,
+      codeVerifier,
+      redirectUri: callback.redirectUri,
+      fetchImpl
+    });
+
+    return {
+      credential,
+      loginUrl: loginUrl.toString()
+    };
+  } finally {
+    await callback.close();
+  }
+}
+
+export function buildLoginUrl({ apiBaseUrl, redirectUri, state, codeChallenge, label }) {
+  const url = new URL("/cli/login", apiBaseUrl);
+  url.searchParams.set("redirect_uri", redirectUri);
+  url.searchParams.set("state", state);
+  url.searchParams.set("code_challenge", codeChallenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  if (label) url.searchParams.set("label", label);
+  return url;
+}
+
+export async function exchangeAuthorizationCode({
+  apiBaseUrl,
+  code,
+  codeVerifier,
+  redirectUri,
+  fetchImpl = fetch
+}) {
+  const response = await fetchImpl(new URL("/api/v1/cli/oauth/token", apiBaseUrl), {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      code,
+      codeVerifier,
+      redirectUri
+    })
+  }).catch((error) => {
+    writeJsonError({
+      code: "CLI_API_ERROR",
+      message: `Failed to exchange GMC CLI authorization code at ${new URL(apiBaseUrl).origin}`,
+      cause: error instanceof Error ? error.message : "Unknown network failure"
+    });
+    process.exit(EXIT_API);
+  });
+
+  const contentType = response.headers.get("content-type") ?? "";
+  const payload = contentType.includes("application/json")
+    ? await response.json().catch(() => null)
+    : null;
+  if (!contentType.includes("application/json")) {
+    writeJsonError({
+      code: "CLI_API_ERROR",
+      message: "GMC CLI authorization exchange returned a non-JSON response. If production is behind Cloudflare Access, allow CLI/API routes or use a Cloudflare service-token path for the CLI.",
+      response: summarizeTokenExchangeResponse(response)
+    });
+    process.exit(EXIT_API);
+  }
+  if (!response.ok || payload?.error) {
+    process.stdout.write(`${JSON.stringify(payload ?? {
+      error: {
+        code: "CLI_API_ERROR",
+        message: `GMC CLI authorization exchange failed with HTTP ${response.status}`
+      }
+    }, null, 2)}\n`);
+    process.exit(EXIT_API);
+  }
+  const credential = extractCredentialFromTokenPayload(payload);
+  if (!credential?.secret) {
+    writeJsonError({
+      code: "CLI_API_ERROR",
+      message: "GMC CLI authorization exchange did not return a credential",
+      response: summarizeTokenPayloadShape(payload, response)
+    });
+    process.exit(EXIT_API);
+  }
+  return credential;
+}
+
+export function extractCredentialFromTokenPayload(payload) {
+  const candidates = [
+    payload?.data,
+    payload?.data?.credential,
+    payload?.data?.cliCredential
+  ];
+
+  return candidates.find((candidate) => candidate && typeof candidate.secret === "string") ?? null;
+}
+
+function summarizeTokenPayloadShape(payload, response) {
+  return {
+    status: response.status,
+    contentType: response.headers.get("content-type") ?? undefined,
+    path: "/api/v1/cli/oauth/token",
+    requestId: payload?.meta?.requestId ?? payload?.error?.requestId,
+    topLevelKeys: getObjectKeys(payload),
+    dataKeys: getObjectKeys(payload?.data),
+    credentialKeys: getObjectKeys(payload?.data?.credential),
+    cliCredentialKeys: getObjectKeys(payload?.data?.cliCredential)
+  };
+}
+
+function summarizeTokenExchangeResponse(response) {
+  return {
+    status: response.status,
+    contentType: response.headers.get("content-type") ?? undefined,
+    path: "/api/v1/cli/oauth/token"
+  };
+}
+
+function getObjectKeys(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return Object.keys(value).filter((key) => key !== "secret");
+}
+
+function createLoopbackCallback({ state, timeoutMs }) {
+  let server;
+  let settled = false;
+  let timeout;
+
+  const waitPromise = new Promise((resolve, reject) => {
+    server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/callback") {
+        response.writeHead(404, { "content-type": "text/plain" });
+        response.end("Not found");
+        return;
+      }
+
+      const receivedState = url.searchParams.get("state");
+      const code = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+
+      if (receivedState !== state) {
+        response.writeHead(400, { "content-type": "text/plain" });
+        response.end("Invalid state. You can close this tab.");
+        if (!settled) reject(new Error("Invalid login state returned by browser"));
+        settled = true;
+        return;
+      }
+
+      if (error || !code) {
+        response.writeHead(400, { "content-type": "text/plain" });
+        response.end("GMC CLI login failed. You can close this tab.");
+        if (!settled) reject(new Error(error || "Missing authorization code"));
+        settled = true;
+        return;
+      }
+
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      response.end("<!doctype html><title>GMC CLI login complete</title><p>GMC CLI login complete. You can close this tab.</p>");
+      if (!settled) resolve({ code });
+      settled = true;
+    });
+
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      timeout = setTimeout(() => {
+        if (!settled) reject(new Error("Timed out waiting for browser login"));
+        settled = true;
+      }, timeoutMs);
+    });
+  });
+
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.on("listening", () => {
+      const address = server.address();
+      if (!address || typeof address !== "object") {
+        reject(new Error("Unable to allocate localhost callback port"));
+        return;
+      }
+      resolve({
+        redirectUri: `http://127.0.0.1:${address.port}/callback`,
+        wait: () => waitPromise,
+        close: () => new Promise((closeResolve) => {
+          if (timeout) clearTimeout(timeout);
+          server.close(() => closeResolve());
+        })
+      });
+    });
+  });
+}
+
+function openSystemBrowser(url) {
+  const currentPlatform = platform();
+  const command = currentPlatform === "darwin"
+    ? "open"
+    : currentPlatform === "win32"
+      ? "cmd"
+      : "xdg-open";
+  const args = currentPlatform === "win32"
+    ? ["/c", "start", "", url]
+    : [url];
+
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.on("error", () => {
+    writeJsonError({
+      code: "CLI_CONFIG_ERROR",
+      message: "Unable to open the browser. Re-run with --no-open and open the URL manually."
+    });
+    process.exit(EXIT_CONFIG);
+  });
+  child.unref();
+}
+
+function randomToken() {
+  return randomBytes(32).toString("base64url");
+}

package/src/config.js

@@ -0,0 +1,320 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import {
+  CLI_BETA_PACKAGE_NAME,
+  CLI_PACKAGE_NAME,
+  CLI_VERSION,
+  DEFAULT_API_BASE_URL,
+  DEFAULT_CONFIG_PATH,
+  EXIT_CONFIG,
+  EXIT_USAGE
+} from "./constants.js";
+import { matches } from "./args.js";
+import { writeJsonError } from "./output.js";
+import { runBrowserLogin } from "./browser-login.js";
+
+export function loadConfig() {
+  const configPath = resolveConfigPath(process.env.GMC_CONFIG_PATH);
+  const fileConfig = readConfigFile(configPath);
+  const authMode = resolveAuthMode({
+    envApiKey: process.env.GMC_API_KEY,
+    envCliCredential: process.env.GMC_CLI_CREDENTIAL,
+    fileConfig
+  });
+  return {
+    apiBaseUrl: process.env.GMC_API_BASE_URL || fileConfig.apiBaseUrl || DEFAULT_API_BASE_URL,
+    apiKey: process.env.GMC_API_KEY || process.env.GMC_CLI_CREDENTIAL || fileConfig.apiKey,
+    authMode,
+    configPath,
+    sources: {
+      apiBaseUrl: process.env.GMC_API_BASE_URL ? "env" : fileConfig.apiBaseUrl ? "config" : "default",
+      apiKey: process.env.GMC_API_KEY ? "env" : process.env.GMC_CLI_CREDENTIAL ? "env" : fileConfig.apiKey ? "config" : "none"
+    },
+    fileConfig
+  };
+}
+
+function readConfigFile(configPath) {
+  if (!configPath) return {};
+
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : undefined,
+      apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : undefined,
+      authMode: parsed.authMode === "cli_credential" || parsed.authMode === "api_key"
+        ? parsed.authMode
+        : undefined
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    writeJsonError({
+      code: "CLI_CONFIG_ERROR",
+      message: `Failed to read GMC CLI config at ${configPath}`
+    });
+    process.exit(EXIT_CONFIG);
+  }
+}
+
+function writeConfig(configPath, config) {
+  try {
+    mkdirSync(path.dirname(configPath), { recursive: true, mode: 0o700 });
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+  } catch {
+    writeJsonError({
+      code: "CLI_CONFIG_ERROR",
+      message: `Failed to write GMC CLI config at ${configPath}`
+    });
+    process.exit(EXIT_CONFIG);
+  }
+}
+
+function resolveConfigPath(configPath) {
+  return path.resolve((configPath || DEFAULT_CONFIG_PATH).replace(/^~(?=$|\/)/, homedir()));
+}
+
+function resolveAuthMode({ envApiKey, envCliCredential, fileConfig }) {
+  if (envApiKey) return "api_key";
+  if (envCliCredential) return "cli_credential";
+  if (fileConfig.authMode === "api_key" || fileConfig.authMode === "cli_credential") {
+    return fileConfig.authMode;
+  }
+  if (fileConfig.apiKey && String(fileConfig.apiKey).startsWith("gmcc_")) return "cli_credential";
+  if (fileConfig.apiKey) return "api_key";
+  return "anonymous";
+}
+
+export async function handleLocalCommand(command, options, positional, config) {
+  if (matches(command, ["login"])) {
+    const apiKey = options["api-key"];
+    const apiBaseUrl = options["api-base-url"] || options["base-url"] || config.apiBaseUrl;
+    parseBaseUrl(apiBaseUrl);
+
+    if (!apiKey) {
+      const { credential } = await runBrowserLogin({
+        apiBaseUrl,
+        label: options.label ? String(options.label) : "GMC CLI",
+        noOpen: Boolean(options["no-open"]),
+        ...(options.timeout ? { timeoutMs: Number(options.timeout) * 1000 } : {})
+      });
+      const nextConfig = {
+        ...config.fileConfig,
+        apiBaseUrl,
+        apiKey: credential.secret,
+        authMode: "cli_credential"
+      };
+      writeConfig(config.configPath, nextConfig);
+      return {
+        data: {
+          ok: true,
+          authMode: "cli_credential",
+          configPath: config.configPath,
+          apiBaseUrl,
+          cliCredential: {
+            id: credential.id,
+            label: credential.label,
+            prefix: credential.prefix,
+            expiresAt: credential.expiresAt
+          }
+        }
+      };
+    }
+
+    const nextConfig = {
+      ...config.fileConfig,
+      apiBaseUrl,
+      apiKey,
+      authMode: "api_key"
+    };
+    writeConfig(config.configPath, nextConfig);
+    return {
+      data: {
+        ok: true,
+        authMode: "api_key",
+        configPath: config.configPath,
+        apiBaseUrl,
+        apiKey: {
+          prefix: getApiKeyPrefix(apiKey)
+        }
+      }
+    };
+  }
+
+  if (matches(command, ["logout"])) {
+    const remoteRevoke = await revokeCurrentCliCredentialIfNeeded(config);
+    const nextConfig = {
+      ...config.fileConfig
+    };
+    delete nextConfig.apiKey;
+    delete nextConfig.authMode;
+    writeConfig(config.configPath, nextConfig);
+    return {
+      data: {
+        ok: true,
+        configPath: config.configPath,
+        ...(remoteRevoke ? { remoteRevoke } : {}),
+        apiKey: {
+          configured: false
+        }
+      },
+      ...(remoteRevoke?.warning ? { warnings: [remoteRevoke.warning] } : {})
+    };
+  }
+
+  if (matches(command, ["update"])) {
+    return {
+      data: {
+        currentVersion: CLI_VERSION,
+        packageName: CLI_PACKAGE_NAME,
+        betaPackageName: CLI_BETA_PACKAGE_NAME,
+        status: "manual_update_required",
+        updateCheck: {
+          available: null,
+          reason: "The CLI does not query the npm registry yet. Use the install command for the closed-beta package once it is published."
+        },
+        commands: {
+          npmGlobal: `npm install -g ${CLI_BETA_PACKAGE_NAME}@beta`,
+          npmExec: `npx ${CLI_BETA_PACKAGE_NAME}@beta --version`
+        },
+        notes: [
+          "This command is intentionally non-mutating in the closed-beta contract.",
+          "A future gmc update --apply command can run the package-manager update after the npm distribution channel is finalized."
+        ]
+      }
+    };
+  }
+
+  if (matches(command, ["config", "get"])) {
+    return {
+      data: redactConfig(config)
+    };
+  }
+
+  if (matches(command, ["config", "set"])) {
+    const key = positional[0];
+    const value = positional[1];
+    if (key !== "apiBaseUrl") {
+      writeJsonError({
+        code: "CLI_USAGE_ERROR",
+        message: "Usage: gmc config set apiBaseUrl <url>"
+      });
+      process.exit(EXIT_USAGE);
+    }
+    if (!value) {
+      writeJsonError({
+        code: "CLI_USAGE_ERROR",
+        message: "Missing value. Usage: gmc config set apiBaseUrl <url>"
+      });
+      process.exit(EXIT_USAGE);
+    }
+
+    parseBaseUrl(value);
+    const nextConfig = {
+      ...config.fileConfig,
+      apiBaseUrl: value
+    };
+    writeConfig(config.configPath, nextConfig);
+    return {
+      data: {
+        ok: true,
+        configPath: config.configPath,
+        apiBaseUrl: value
+      }
+    };
+  }
+
+  return null;
+}
+
+function redactConfig(config) {
+  return {
+    configPath: config.configPath,
+    apiBaseUrl: config.apiBaseUrl,
+    authMode: config.authMode,
+    apiKey: config.apiKey
+      ? {
+          configured: true,
+          prefix: getApiKeyPrefix(config.apiKey)
+        }
+      : {
+          configured: false
+        },
+    sources: config.sources
+  };
+}
+
+function getApiKeyPrefix(apiKey) {
+  return String(apiKey).slice(0, 12);
+}
+
+async function revokeCurrentCliCredentialIfNeeded(config) {
+  if (!config.apiKey || config.authMode !== "cli_credential") return null;
+
+  try {
+    const baseUrl = parseBaseUrl(config.apiBaseUrl);
+    const url = new URL("/api/v1/cli/credentials/current", baseUrl);
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${config.apiKey}`
+      }
+    });
+    const payload = await readJsonResponse(response);
+    if (!response.ok) {
+      return {
+        status: "failed",
+        warning: {
+          code: "CLI_REMOTE_LOGOUT_FAILED",
+          message: payload?.error?.message || `Remote CLI credential revoke failed with HTTP ${response.status}`
+        }
+      };
+    }
+
+    return {
+      status: "revoked",
+      credential: payload?.data
+        ? {
+            id: payload.data.id,
+            prefix: payload.data.prefix,
+            revokedAt: payload.data.revokedAt
+          }
+        : undefined
+    };
+  } catch (error) {
+    return {
+      status: "failed",
+      warning: {
+        code: "CLI_REMOTE_LOGOUT_FAILED",
+        message: error instanceof Error ? error.message : "Remote CLI credential revoke failed"
+      }
+    };
+  }
+}
+
+async function readJsonResponse(response) {
+  const text = await response.text();
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+export function parseBaseUrl(value) {
+  try {
+    const normalized = value.endsWith("/") ? value : `${value}/`;
+    return new URL(normalized);
+  } catch {
+    writeJsonError({
+      code: "CLI_CONFIG_ERROR",
+      message: "GMC_API_BASE_URL must be a valid URL"
+    });
+    process.exit(EXIT_CONFIG);
+  }
+}