requestshield 0.1.3 → 0.1.5

package/src/commands/apps-list.mjs

@@ -0,0 +1,90 @@
+// @ts-check
+
+import { CliError } from "../errors.mjs";
+import { objectString } from "../api-client.mjs";
+
+const HEADERS = ["APP KEY", "NAME", "STATUS"];
+
+/** @typedef {{ appKey: string, name: string, status: string, createdAt: string, updatedAt: string }} App */
+
+/**
+ * @param {{ json: boolean }} options
+ * @param {{ api: { listApps(accessToken: string): Promise<{body: unknown}> }, sessions: { loadToken(): Promise<string> }, log: (message: string) => void }} deps
+ */
+export async function listApps(options, deps) {
+  const accessToken =
+    await deps.sessions.loadToken();
+  
+  const result =
+    await deps.api.listApps(accessToken);
+  
+  const { data: apps, nextCursor } = parseApps(result.body);
+
+  if (options.json) {
+    deps.log(JSON.stringify({ data: apps, nextCursor }, null, 2));
+    return;
+  }
+
+  if (apps.length === 0) {
+    deps.log("No applications are available to this account.");
+    return;
+  }
+
+  for (const line of formatTable(apps)) deps.log(line);
+}
+
+/** @param {unknown} body @returns {{ data: App[], nextCursor: string | null }} */
+function parseApps(body) {
+  const data = body && typeof body === "object" ?
+    Reflect.get(body, "data") : undefined;
+
+  const nextCursor = body && typeof body === "object" ?
+    Reflect.get(body, "nextCursor") : undefined;
+
+  if (!Array.isArray(data)) {
+    throw new CliError("The applications response did not contain a data array", {
+      code: "INVALID_RESPONSE",
+    });
+  }
+
+  if (nextCursor !== null && (typeof nextCursor !== "string" || nextCursor.length === 0)) {
+    throw new CliError("The applications response contained an invalid nextCursor", {
+      code: "INVALID_RESPONSE",
+    });
+  }
+
+  // Rebuild every item from approved metadata so unexpected API fields never reach output.
+  const apps = data.map((entry, index) => {
+    const appKey = objectString(entry, "appKey");
+    const name = objectString(entry, "name");
+    const status = objectString(entry, "status");
+    const createdAt = objectString(entry, "createdAt");
+    const updatedAt = objectString(entry, "updatedAt");
+
+    if (!appKey || !name || !status || !createdAt || !updatedAt) {
+      throw new CliError(
+        `Application at position ${index + 1} is missing appKey, name, status, createdAt, or updatedAt`,
+        { code: "INVALID_RESPONSE" },
+      );
+    }
+
+    return { appKey, name, status, createdAt, updatedAt };
+  });
+
+  return { data: apps, nextCursor };
+}
+
+/** @param {App[]} apps @returns {string[]} */
+function formatTable(apps) {
+  const rows = [HEADERS, ...apps.map((app) =>
+    [app.appKey, app.name, app.status])];
+  
+  const widths = HEADERS.map((_, column) =>
+    Math.max(...rows.map((row) => row[column].length)));
+  
+  return rows.map((row) =>
+    row
+      .map((cell, column) => (column === HEADERS.length - 1 ? cell : cell.padEnd(widths[column])))
+      .join("  "),
+  );
+}

package/src/commands/billing-get.mjs

@@ -0,0 +1,110 @@
+// @ts-check
+
+import { CliError } from "../errors.mjs";
+import { objectString } from "../api-client.mjs";
+
+/**
+ * @param {{ appKey: string }} options
+ * @param {{ api: { getBilling(accessToken: string, appKey: string): Promise<{body: unknown}> }, sessions: { loadToken(): Promise<string> }, log: (message: string) => void }} deps
+ */
+export async function showBilling(options, deps) {
+  const accessToken =
+    await deps.sessions.loadToken();
+  
+  const result =
+    await deps.api.getBilling(accessToken, options.appKey);
+  
+  const billing = parseBilling(result.body);
+
+  deps.log(JSON.stringify({ ok: true, data: billing }, null, 2));
+}
+
+/** @param {unknown} body */
+function parseBilling(body) {
+  const ok = body && typeof body === "object" ?
+    Reflect.get(body, "ok") : undefined;
+  
+  const data = objectValue(body, "data");
+
+  const plan = objectValue(data, "plan");
+
+  const usage = objectValue(data, "usage");
+
+  if (ok !== true || !data || !plan || !usage) {
+    throw invalidResponse("The billing response did not contain ok=true, data.plan, and data.usage");
+  }
+
+  const tier = objectString(plan, "tier");
+  const currentCycle = Reflect.get(plan, "current_cycle");
+  const billing = Reflect.get(plan, "billing");
+  const nextCharge = objectString(plan, "next_charge");
+  const monthlyQuota = Reflect.get(usage, "monthly_quota");
+  const currentUsage = Reflect.get(usage, "current_usage");
+  const overageCharge = Reflect.get(usage, "overage_charge");
+
+  if (!tier) throw invalidResponse("The billing response did not contain plan.tier");
+  if (
+    !Array.isArray(currentCycle)
+    || currentCycle.length !== 2
+    || !currentCycle.every((value) =>
+      typeof value === "string" && isIsoDateTime(value))
+    || Date.parse(currentCycle[0]) > Date.parse(currentCycle[1])
+  ) {
+    throw invalidResponse("The billing response contained an invalid plan.current_cycle");
+  }
+  if (!nonNegativeNumber(billing)) {
+    throw invalidResponse("The billing response contained an invalid plan.billing");
+  }
+  if (!nextCharge || !isIsoDateTime(nextCharge)) {
+    throw invalidResponse("The billing response contained an invalid plan.next_charge");
+  }
+  if (!nonNegativeInteger(monthlyQuota) || !nonNegativeInteger(currentUsage)) {
+    throw invalidResponse("The billing response contained invalid quota or usage values");
+  }
+  if (!nonNegativeNumber(overageCharge)) {
+    throw invalidResponse("The billing response contained an invalid usage.overage_charge");
+  }
+
+  // Rebuild nested output so unexpected response fields cannot reach the terminal.
+  return {
+    plan: {
+      tier,
+      current_cycle: currentCycle,
+      billing,
+      next_charge: nextCharge,
+    },
+    usage: {
+      monthly_quota: monthlyQuota,
+      current_usage: currentUsage,
+      overage_charge: overageCharge,
+    },
+  };
+}
+
+/** @param {unknown} value @param {string} property */
+function objectValue(value, property) {
+  if (!value || typeof value !== "object") return undefined;
+  const found = Reflect.get(value, property);
+  return found && typeof found === "object" && !Array.isArray(found) ? found : undefined;
+}
+
+/** @param {unknown} value */
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+/** @param {unknown} value */
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+/** @param {string} value */
+function isIsoDateTime(value) {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})?$/.test(value)
+    && Number.isFinite(Date.parse(value));
+}
+
+/** @param {string} message */
+function invalidResponse(message) {
+  return new CliError(message, { code: "INVALID_RESPONSE" });
+}

package/src/commands/challenge-volume.mjs

@@ -0,0 +1,81 @@
+// @ts-check
+
+import { CliError } from "../errors.mjs";
+import { objectString } from "../api-client.mjs";
+
+/**
+ * @param {{ appKey: string, from?: string, to?: string, granularity?: string }} options
+ * @param {{ api: { challengeVolume(accessToken: string, appKey: string, options: {from?: string, to?: string, granularity?: string}): Promise<{body: unknown}> }, sessions: { loadToken(): Promise<string> }, log: (message: string) => void }} deps
+ */
+export async function showChallengeVolume(options, deps) {
+  const accessToken = await deps.sessions.loadToken();
+  const filters = {
+    ...(options.from ? { from: options.from } : {}),
+    ...(options.to ? { to: options.to } : {}),
+    ...(options.granularity ? { granularity: options.granularity } : {}),
+  };
+  const result = await deps.api.challengeVolume(accessToken, options.appKey, filters);
+  const volume = parseChallengeVolume(result.body, options);
+  deps.log(JSON.stringify({ ok: true, data: volume }, null, 2));
+}
+
+/**
+ * @param {unknown} body
+ * @param {{ appKey: string, from?: string, to?: string, granularity?: string }} requested
+ */
+function parseChallengeVolume(body, requested) {
+  const ok = body && typeof body === "object" ?
+    Reflect.get(body, "ok") : undefined;
+  
+  const data = body && typeof body === "object" ?
+    Reflect.get(body, "data") : undefined;
+  
+  if (ok !== true || !data || typeof data !== "object" || Array.isArray(data)) {
+    throw invalidResponse("The challenge volume response did not contain ok=true and data");
+  }
+
+  const appKey = objectString(data, "app_key");
+  const from = objectString(data, "from");
+  const to = objectString(data, "to");
+  const granularity = objectString(data, "granularity");
+  const challengeCount = Reflect.get(data, "challenge_count");
+  
+  if (appKey !== requested.appKey) {
+    throw invalidResponse("The challenge volume response did not match the requested App Key");
+  }
+  if (!from || !to || !isIsoTime(from) || !isIsoTime(to) || Date.parse(from) > Date.parse(to)) {
+    throw invalidResponse("The challenge volume response contained an invalid time range");
+  }
+  if (requested.from && Date.parse(from) !== Date.parse(requested.from)) {
+    throw invalidResponse("The challenge volume response did not match the requested start time");
+  }
+  if (requested.to && Date.parse(to) !== Date.parse(requested.to)) {
+    throw invalidResponse("The challenge volume response did not match the requested end time");
+  }
+  if (!granularity || (requested.granularity && granularity !== requested.granularity)) {
+    throw invalidResponse("The challenge volume response contained an unexpected granularity");
+  }
+  if (!Number.isSafeInteger(challengeCount) || /** @type {number} */ (challengeCount) < 0) {
+    throw invalidResponse("The challenge volume response contained an invalid challenge_count");
+  }
+
+  // Rebuild the response so unexpected API fields cannot reach command output.
+  return {
+    app_key: appKey,
+    from,
+    to,
+    granularity,
+    challenge_count: challengeCount,
+  };
+}
+
+/** @param {string} value */
+function isIsoTime(value) {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})$/.test(value)
+    && Number.isFinite(Date.parse(value));
+}
+
+/** @param {string} message */
+function invalidResponse(message) {
+  return new CliError(message, { code: "INVALID_RESPONSE" });
+}

package/src/commands/contract.mjs

@@ -0,0 +1,106 @@
+// @ts-check
+
+import { CliError } from "../errors.mjs";
+import { objectString } from "../api-client.mjs";
+
+const SENSITIVE_FIELDS = new Set([
+  "access_token",
+  "accesstoken",
+  "api_secret",
+  "apisecret",
+  "secret_key",
+  "secretkey",
+  "session_token",
+  "sessiontoken",
+]);
+
+/**
+ * @param {{ api: { integrationContract(accessToken: string): Promise<{body: unknown}> }, sessions: { loadToken(): Promise<string> }, log: (message: string) => void }} deps
+ */
+export async function showIntegrationContract(deps) {
+  const accessToken =
+    await deps.sessions.loadToken();
+  
+  const result =
+    await deps.api.integrationContract(accessToken);
+  
+  const data = parseIntegrationContract(result.body);
+
+  deps.log(JSON.stringify({ ok: true, data }, null, 2));
+}
+
+/** @param {unknown} body @returns {Record<string, unknown>} */
+function parseIntegrationContract(body) {
+  const ok = body && typeof body === "object" ?
+    Reflect.get(body, "ok") : undefined;
+  
+  const data = objectValue(body, "data");
+  if (ok !== true || !data) {
+    throw invalidResponse("The integration contract response did not contain ok=true and data");
+  }
+
+  const browser = objectValue(data, "browser");
+  const backend = objectValue(data, "backend");
+  const minJdk = backend ?
+    Reflect.get(backend, "min_jdk") : undefined;
+  
+  if (
+    !objectString(data, "contract_version")
+    || !browser
+    || !objectString(browser, "script_url")
+    || !objectString(browser, "token_header")
+    || !stringArray(browser, "available_modes")
+    || !backend
+    || !stringArray(backend, "supported_languages")
+    || !Number.isInteger(minJdk)
+    || /** @type {number} */ (minJdk) < 1
+    || !objectString(data, "release_state")
+  ) {
+    throw invalidResponse("The integration contract response is missing required fields");
+  }
+
+  // Preserve future contract fields, but never relay credential-shaped fields to output.
+  assertNoSensitiveFields(data);
+  return data;
+}
+
+/** @param {unknown} value @param {string} property */
+function objectValue(value, property) {
+  if (!value || typeof value !== "object")
+    return undefined;
+
+  const found = Reflect.get(value, property);
+
+  return found && typeof found === "object" && !Array.isArray(found) ? found : undefined;
+}
+
+/** @param {unknown} value @param {string} property */
+function stringArray(value, property) {
+  if (!value || typeof value !== "object")
+    return false;
+
+  const found = Reflect.get(value, property);
+
+  return Array.isArray(found) && found.every((item) => typeof item === "string" && item !== "");
+}
+
+/** @param {unknown} value */
+function assertNoSensitiveFields(value) {
+  if (Array.isArray(value)) {
+    for (const item of value) assertNoSensitiveFields(item);
+    return;
+  }
+  if (!value || typeof value !== "object")
+    return;
+  for (const [key, nestedValue] of Object.entries(value)) {
+    if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
+      throw invalidResponse("The integration contract response contained a sensitive field");
+    }
+    assertNoSensitiveFields(nestedValue);
+  }
+}
+
+/** @param {string} message */
+function invalidResponse(message) {
+  return new CliError(message, { code: "INVALID_RESPONSE" });
+}

package/src/commands/update-check.mjs

@@ -0,0 +1,139 @@
+// @ts-check
+
+import readline from "node:readline/promises";
+import { spawn } from "node:child_process";
+import { stdin, stdout } from "node:process";
+import { CliError } from "../errors.mjs";
+
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+
+/**
+ * @param {{ currentVersion: string, packageName: string, log: (message: string) => void, fetchImpl?: typeof fetch, confirm?: () => Promise<boolean>, install?: (packageName: string, version: string) => Promise<void> }} options
+ */
+export async function checkForUpdate(options) {
+  const latestVersion = await fetchLatestVersion(
+    options.packageName,
+    options.fetchImpl ?? fetch,
+  );
+
+  options.log(`Current version: ${options.currentVersion}`);
+  options.log(`Latest version: ${latestVersion}`);
+
+  if (compareVersions(latestVersion, options.currentVersion) <= 0) {
+    options.log("RequestShield is already up to date.");
+    return;
+  }
+
+  const accepted = await (options.confirm ?? confirmUpdate)(latestVersion);
+  if (!accepted) {
+    options.log("Update cancelled.");
+    return;
+  }
+
+  options.log(`Updating RequestShield to ${latestVersion}...`);
+  await (options.install ?? installWithNpm)(options.packageName, latestVersion);
+  options.log(`RequestShield ${latestVersion} was installed successfully.`);
+  options.log("Open a new terminal before running RequestShield again.");
+}
+
+/** @param {string} packageName @param {typeof fetch} fetchImpl */
+async function fetchLatestVersion(packageName, fetchImpl) {
+  const url = `${DEFAULT_REGISTRY}/${encodeURIComponent(packageName)}/latest`;
+  let response;
+  try {
+    response = await fetchImpl(url, { signal: AbortSignal.timeout(15_000) });
+  } catch (error) {
+    throw new CliError(`Could not check the latest RequestShield version: ${messageOf(error)}`, {
+      code: "UPDATE_CHECK_FAILED",
+      exitCode: 7,
+    });
+  }
+
+  if (!response.ok) {
+    throw new CliError(`Could not check the latest RequestShield version: HTTP ${response.status}`, {
+      code: "UPDATE_CHECK_FAILED",
+      exitCode: 7,
+    });
+  }
+
+  const body = await response.json();
+  const version = body && typeof body === "object" ? Reflect.get(body, "version") : undefined;
+  if (typeof version !== "string" || !parseVersion(version)) {
+    throw new CliError("The npm registry returned an invalid RequestShield version", {
+      code: "INVALID_UPDATE_RESPONSE",
+    });
+  }
+  return version;
+}
+
+/** @param {string} latestVersion */
+async function confirmUpdate(latestVersion) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new CliError(`RequestShield ${latestVersion} is available, but confirmation requires an interactive terminal`, {
+      code: "UPDATE_CONFIRMATION_REQUIRED",
+      exitCode: 2,
+    });
+  }
+  const prompt = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await prompt.question(`Update to RequestShield ${latestVersion}? (y/N): `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    prompt.close();
+  }
+}
+
+/** @param {string} packageName @param {string} version */
+async function installWithNpm(packageName, version) {
+  await new Promise((resolve, reject) => {
+    const child = spawn("npm", ["install", "--global", `${packageName}@${version}`], {
+      shell: process.platform === "win32",
+      stdio: "inherit",
+      windowsHide: true,
+    });
+    child.once("error", (error) => {
+      reject(new CliError(`Could not start npm: ${error.message}`, {
+        code: "UPDATE_FAILED",
+        exitCode: 1,
+      }));
+    });
+    child.once("exit", (code) => {
+      if (code === 0) resolve(undefined);
+      else reject(new CliError(`npm update failed with exit code ${code ?? "unknown"}`, {
+        code: "UPDATE_FAILED",
+        exitCode: 1,
+      }));
+    });
+  });
+}
+
+/** @param {string} left @param {string} right */
+function compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) throw new CliError("RequestShield has an invalid semantic version");
+  for (let index = 0; index < 3; index++) {
+    if (a.numbers[index] !== b.numbers[index]) return a.numbers[index] - b.numbers[index];
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (a.prerelease === undefined) return 1;
+  if (b.prerelease === undefined) return -1;
+  return a.prerelease.localeCompare(b.prerelease, "en", { numeric: true });
+}
+
+/** @param {string} value */
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value);
+  if (!match) return undefined;
+  return {
+    numbers: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4],
+  };
+}
+
+/** @param {unknown} error */
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export { compareVersions };

package/src/config.mjs

@@ -0,0 +1,8 @@
+export const DEFAULT_MANAGEMENT_API_URL =
+    "https://api.intellifend.ai";
+
+export const DEFAULT_MAVEN_REPOSITORY =
+    "https://sdk.intellifend.com/packages/maven";
+
+export const DEFAULT_BROWSER_SCRIPT_URL =
+    "https://intellifend.ai/intellifend.js";