@ratio-app/cli 0.1.1

package/dist/commands/dev/trigger.js

@@ -0,0 +1,729 @@
+// src/commands/dev/trigger.ts
+import { Args, Flags as Flags2 } from "@oclif/core";
+import { z as z2 } from "zod";
+
+// src/lib/auth/config.ts
+var DEFAULT_SERVER_URL = "https://gkx.ratio.win";
+function resolveServerUrl(opts) {
+  const env = opts?.env ?? process.env;
+  if (typeof env["RATIO_SERVER_URL"] === "string" && env["RATIO_SERVER_URL"].length > 0) {
+    return env["RATIO_SERVER_URL"];
+  }
+  if (typeof opts?.credentials?.server === "string" && opts.credentials.server.length > 0) {
+    return opts.credentials.server;
+  }
+  return DEFAULT_SERVER_URL;
+}
+
+// src/lib/credentials/clock.ts
+var SystemClock = class {
+  now() {
+    return Date.now();
+  }
+};
+
+// src/lib/credentials/path.ts
+import os from "os";
+import path from "path";
+function snapshotPathEnv() {
+  const snapshot = {};
+  const xdgConfigHome = process.env["XDG_CONFIG_HOME"];
+  if (xdgConfigHome !== void 0) {
+    snapshot.XDG_CONFIG_HOME = xdgConfigHome;
+  }
+  const appData = process.env["APPDATA"];
+  if (appData !== void 0) {
+    snapshot.APPDATA = appData;
+  }
+  return snapshot;
+}
+function defaultCredentialsPath(platform, homedir, env) {
+  const resolvedPlatform = platform ?? process.platform;
+  const resolvedHome = homedir ?? os.homedir();
+  const resolvedEnv = env ?? snapshotPathEnv();
+  if (resolvedPlatform === "win32") {
+    const appData = resolvedEnv.APPDATA;
+    const base2 = appData !== void 0 && appData !== "" ? appData : path.win32.join(resolvedHome, "AppData", "Roaming");
+    return path.win32.join(base2, "ratio", "credentials");
+  }
+  const xdgConfigHome = resolvedEnv.XDG_CONFIG_HOME;
+  const base = typeof xdgConfigHome === "string" && xdgConfigHome !== "" ? xdgConfigHome : path.posix.join(resolvedHome, ".config");
+  return path.posix.join(base, "ratio", "credentials");
+}
+
+// src/lib/errors.ts
+var RatioCLIError = class extends Error {
+  code;
+  exitCode;
+  hint;
+  docsUrl;
+  constructor(opts) {
+    super(opts.message);
+    this.name = new.target.name;
+    this.code = opts.code;
+    this.exitCode = opts.exitCode;
+    if (opts.hint !== void 0) this.hint = opts.hint;
+    if (opts.docsUrl !== void 0) this.docsUrl = opts.docsUrl;
+  }
+};
+var NotLoggedInError = class extends RatioCLIError {
+  constructor(message, hint = "Run 'ratio auth login' to sign in.") {
+    super({ code: "NOT_LOGGED_IN", exitCode: 3, message, hint });
+  }
+};
+var TokenExpiredError = class extends RatioCLIError {
+  constructor(message, hint = "Run 'ratio auth login' to refresh your session.") {
+    super({ code: "TOKEN_EXPIRED", exitCode: 3, message, hint });
+  }
+};
+var NetworkError = class extends RatioCLIError {
+  constructor(message, hint = "Check your network and retry.") {
+    super({ code: "NETWORK_ERROR", exitCode: 5, message, hint });
+  }
+};
+var ValidationError = class extends RatioCLIError {
+  constructor(message, hint) {
+    const opts = {
+      code: "VALIDATION_ERROR",
+      exitCode: 8,
+      message
+    };
+    if (hint !== void 0) opts.hint = hint;
+    super(opts);
+  }
+};
+function isRatioCLIError(err) {
+  return err instanceof RatioCLIError;
+}
+
+// src/lib/credentials/refresher.ts
+var NotImplementedRefresher = class {
+  async refresh(refreshToken) {
+    void refreshToken;
+    throw new NotLoggedInError(
+      "Token refresh is not available yet in this CLI version."
+    );
+  }
+};
+
+// src/lib/credentials/store.ts
+import crypto from "crypto";
+import fs from "fs";
+import { dirname } from "path";
+
+// src/lib/credentials/schema.ts
+import { z } from "zod";
+var identitySchema = z.object({
+  developerId: z.string(),
+  email: z.string(),
+  // Token-derived fields captured at login. Optional (additive) so files
+  // written before these fields existed still validate as version 1.
+  merchantId: z.string().optional(),
+  scopes: z.array(z.string()).optional()
+}).strict();
+var profileSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string(),
+  expiresAt: z.string().datetime({ offset: true }),
+  identity: identitySchema,
+  obtainedAt: z.string().datetime({ offset: true })
+}).strict();
+var developerSessionSchema = z.object({
+  jwt: z.string(),
+  developerId: z.string(),
+  email: z.string(),
+  expiresAt: z.string().datetime({ offset: true }),
+  obtainedAt: z.string().datetime({ offset: true })
+}).strict();
+var credentialsSchema = z.object({
+  version: z.literal(1),
+  server: z.string(),
+  clientId: z.string(),
+  profiles: z.record(z.string(), profileSchema),
+  // Optional cached developer session. Additive so files written before
+  // this field existed still validate as version 1.
+  developer: developerSessionSchema.optional()
+}).strict();
+function parseCredentials(input) {
+  if (typeof input === "object" && input !== null && "version" in input) {
+    const version = input.version;
+    if (version !== 1) {
+      const label = typeof version === "number" ? String(version) : "unknown";
+      throw new ValidationError(
+        `credentials file version ${label} is unsupported by this CLI \u2014 upgrade the CLI or sign in again`
+      );
+    }
+  }
+  const result = credentialsSchema.safeParse(input);
+  if (!result.success) {
+    throw new ValidationError(
+      "credentials file schema mismatch \u2014 expected v1 shape"
+    );
+  }
+  return result.data;
+}
+
+// src/lib/credentials/store.ts
+var REFRESH_WINDOW_MS = 3e5;
+var ENV_TOKEN_VAR = "RATIO_API_TOKEN";
+var ENV_DEVELOPER_TOKEN_VAR = "RATIO_DEVELOPER_TOKEN";
+function hasErrnoCode(err, code) {
+  return err instanceof Error && err.code === code;
+}
+var FileCredentialStore = class {
+  filePath;
+  clock;
+  refresher;
+  envReader;
+  platform;
+  constructor(opts) {
+    this.filePath = opts?.filePath ?? defaultCredentialsPath();
+    this.clock = opts?.clock ?? new SystemClock();
+    this.refresher = opts?.refresher ?? new NotImplementedRefresher();
+    this.envReader = opts?.envReader ?? (() => process.env);
+    this.platform = opts?.platform ?? process.platform;
+  }
+  async load() {
+    this.reapplyFileModeIfDrifted();
+    let raw;
+    try {
+      raw = fs.readFileSync(this.filePath, "utf8");
+    } catch (err) {
+      if (hasErrnoCode(err, "ENOENT")) {
+        throw new NotLoggedInError("You are not signed in.");
+      }
+      throw err;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new ValidationError(
+        'credentials file is not valid JSON \u2014 run "ratio auth login" to reset'
+      );
+    }
+    return parseCredentials(parsed);
+  }
+  async save(creds) {
+    const dir = dirname(this.filePath);
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+    if (this.platform !== "win32") {
+      fs.chmodSync(dir, 448);
+    }
+    const tmpPath = `${this.filePath}.${process.pid}.${crypto.randomBytes(8).toString("hex")}.tmp`;
+    try {
+      fs.writeFileSync(tmpPath, JSON.stringify(creds, null, 2), {
+        mode: 384
+      });
+      fs.renameSync(tmpPath, this.filePath);
+    } catch (err) {
+      try {
+        fs.unlinkSync(tmpPath);
+      } catch {
+      }
+      throw err;
+    }
+    if (this.platform !== "win32") {
+      fs.chmodSync(this.filePath, 384);
+    }
+  }
+  async clear() {
+    try {
+      fs.unlinkSync(this.filePath);
+    } catch (err) {
+      if (hasErrnoCode(err, "ENOENT")) {
+        return;
+      }
+      throw err;
+    }
+  }
+  async getValidAccessToken(profileName) {
+    const envToken = this.envReader()[ENV_TOKEN_VAR];
+    if (typeof envToken === "string" && envToken.length > 0) {
+      return envToken;
+    }
+    const creds = await this.load();
+    const name = profileName ?? "default";
+    const profile = creds.profiles[name];
+    if (profile === void 0) {
+      throw new NotLoggedInError("You are not signed in.");
+    }
+    const msUntilExpiry = new Date(profile.expiresAt).getTime() - this.clock.now();
+    if (msUntilExpiry < REFRESH_WINDOW_MS) {
+      return this.refreshAndPersist(creds, name, profile);
+    }
+    return profile.accessToken;
+  }
+  async getValidDeveloperToken() {
+    const envToken = this.envReader()[ENV_DEVELOPER_TOKEN_VAR];
+    if (typeof envToken === "string" && envToken.length > 0) {
+      return envToken;
+    }
+    let creds;
+    try {
+      creds = await this.load();
+    } catch (err) {
+      if (err instanceof NotLoggedInError) {
+        throw new NotLoggedInError("Developer signin required.");
+      }
+      throw err;
+    }
+    const session = creds.developer;
+    if (session === void 0) {
+      throw new NotLoggedInError("Developer signin required.");
+    }
+    const msUntilExpiry = new Date(session.expiresAt).getTime() - this.clock.now();
+    if (msUntilExpiry < REFRESH_WINDOW_MS) {
+      throw new NotLoggedInError("Developer signin required.");
+    }
+    return session.jwt;
+  }
+  async saveDeveloperSession(session) {
+    let creds;
+    try {
+      creds = await this.load();
+    } catch (err) {
+      if (err instanceof NotLoggedInError) {
+        creds = { version: 1, server: "", clientId: "", profiles: {} };
+      } else {
+        throw err;
+      }
+    }
+    const updated = {
+      ...creds,
+      developer: session
+    };
+    await this.save(updated);
+  }
+  /**
+   * Exchange the profile's refresh token for a fresh token set, merge it
+   * into the loaded credentials (preserving every other profile), persist
+   * atomically, and return the new access token. A refresher failure is
+   * wrapped in TokenExpiredError; the underlying message is deliberately
+   * discarded so a secret can never leak through the error surface.
+   */
+  async refreshAndPersist(creds, name, profile) {
+    let refreshed;
+    try {
+      refreshed = await this.refresher.refresh(profile.refreshToken);
+    } catch {
+      throw new TokenExpiredError(
+        "Your session has expired and could not be refreshed."
+      );
+    }
+    const updated = {
+      ...creds,
+      profiles: {
+        ...creds.profiles,
+        [name]: {
+          ...profile,
+          accessToken: refreshed.accessToken,
+          refreshToken: refreshed.refreshToken,
+          expiresAt: refreshed.expiresAt
+        }
+      }
+    };
+    await this.save(updated);
+    return refreshed.accessToken;
+  }
+  /**
+   * POSIX-only startup permission check: if the file exists with a mode
+   * other than 0600, re-apply 0600 and emit a warning to stderr. Never
+   * runs on Windows (stat modes there do not map to POSIX bits and chmod
+   * must not be called). Missing file is NOT an error here — load()
+   * reports it as NotLoggedInError.
+   */
+  reapplyFileModeIfDrifted() {
+    if (this.platform === "win32") {
+      return;
+    }
+    let stat;
+    try {
+      stat = fs.statSync(this.filePath);
+    } catch (err) {
+      if (hasErrnoCode(err, "ENOENT")) {
+        return;
+      }
+      throw err;
+    }
+    const mode = stat.mode & 511;
+    if (mode !== 384) {
+      fs.chmodSync(this.filePath, 384);
+      process.stderr.write(
+        `[warn] credentials file permissions were 0o${mode.toString(8)}; corrected to 0600.
+`
+      );
+    }
+  }
+};
+
+// src/lib/ratio-command.ts
+import { Command, Errors } from "@oclif/core";
+
+// src/lib/render-error.ts
+function isOclifParserError(err) {
+  return err instanceof Error && "parse" in err && err.parse !== null && err.parse !== void 0;
+}
+function buildErrorEnvelope(code, message, hint, docsUrl) {
+  const obj = { ok: false, code, message };
+  if (hint !== void 0) obj["hint"] = hint;
+  if (docsUrl !== void 0) obj["docsUrl"] = docsUrl;
+  return JSON.stringify(obj) + "\n";
+}
+function renderError(input) {
+  const { err, verbose, json } = input;
+  if (isRatioCLIError(err)) {
+    const ratioErr = err;
+    if (ratioErr.exitCode === 0) {
+      if (json) {
+        return {
+          stdout: JSON.stringify({ ok: true, data: null }) + "\n",
+          stderr: "",
+          exitCode: 0
+        };
+      }
+      return {
+        stdout: ratioErr.message + "\n",
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    let stderrLines = `${ratioErr.code}: ${ratioErr.message}
+`;
+    if (ratioErr.hint !== void 0) stderrLines += `${ratioErr.hint}
+`;
+    if (ratioErr.docsUrl !== void 0) stderrLines += `${ratioErr.docsUrl}
+`;
+    if (json) {
+      return {
+        stdout: buildErrorEnvelope(ratioErr.code, ratioErr.message, ratioErr.hint, ratioErr.docsUrl),
+        stderr: verbose && ratioErr.stack ? ratioErr.stack + "\n" : "",
+        exitCode: ratioErr.exitCode
+      };
+    }
+    if (verbose && ratioErr.stack) {
+      stderrLines += ratioErr.stack + "\n";
+    }
+    return { stdout: "", stderr: stderrLines, exitCode: ratioErr.exitCode };
+  }
+  if (isOclifParserError(err)) {
+    const parserErr = err;
+    const msg = parserErr.message || "Unknown parse error";
+    const coercedErr = new ValidationError(msg);
+    let stderrText2 = `${coercedErr.code}: ${msg}
+`;
+    if (json) {
+      return {
+        stdout: buildErrorEnvelope(coercedErr.code, msg),
+        stderr: verbose && parserErr.stack ? parserErr.stack + "\n" : "",
+        exitCode: 8
+      };
+    }
+    if (verbose && parserErr.stack) {
+      stderrText2 += parserErr.stack + "\n";
+    }
+    return { stdout: "", stderr: stderrText2, exitCode: 8 };
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  const stack = err instanceof Error ? err.stack : void 0;
+  const stderrPrefix = `INTERNAL: ${message}
+`;
+  if (json) {
+    return {
+      stdout: buildErrorEnvelope("INTERNAL", message),
+      stderr: verbose && stack ? stack + "\n" : "",
+      exitCode: 1
+    };
+  }
+  let stderrText = stderrPrefix;
+  if (verbose && stack) {
+    stderrText += stack + "\n";
+  }
+  return { stdout: "", stderr: stderrText, exitCode: 1 };
+}
+
+// src/lib/ratio-command.ts
+var RatioCommand = class extends Command {
+  _getRenderFlags() {
+    const argv = this.argv;
+    return {
+      verbose: argv.includes("--verbose"),
+      json: argv.includes("--json")
+    };
+  }
+  async catch(err) {
+    const { verbose, json } = this._getRenderFlags();
+    const output = renderError({ err, verbose, json });
+    if (output.stdout) process.stdout.write(output.stdout);
+    if (output.stderr) process.stderr.write(output.stderr);
+    if (output.exitCode === 0) {
+      throw new Errors.ExitError(0);
+    }
+    err.skipOclifErrorHandling = true;
+    err.oclif = { exit: output.exitCode };
+    throw err;
+  }
+};
+
+// src/lib/verbose-flag.ts
+import { Flags } from "@oclif/core";
+var verboseFlag = {
+  verbose: Flags.boolean({
+    description: "Show diagnostic detail: HTTP status/timing lines for auth requests (stderr) and stack traces for internal errors."
+  })
+};
+var jsonFlag = {
+  json: Flags.boolean({
+    description: "Emit machine-readable JSON on stdout."
+  })
+};
+
+// src/commands/dev/trigger.ts
+var REQUEST_TIMEOUT_MS = 1e4;
+var SCENARIO_OPTIONS = ["cod", "prepaid", "cancelled"];
+var triggerResponseSchema = z2.object({
+  "deliveryId": z2.string().min(1)
+});
+var scenarioEntrySchema = z2.object({
+  "topic": z2.string(),
+  "aliases": z2.array(z2.string()),
+  "scenarios": z2.array(z2.string()),
+  "sampleShape": z2.unknown()
+});
+var scenariosResponseSchema = z2.array(scenarioEntrySchema);
+function errorForStatus(status) {
+  if (status === 400) {
+    return new ValidationError(
+      "The server rejected the request.",
+      "Unknown topic; run --list to see options."
+    );
+  }
+  if (status === 401) {
+    return new NotLoggedInError("The server rejected your session token.");
+  }
+  if (status === 404) {
+    return new ValidationError(
+      "App not found.",
+      "App not found or not accessible with this identity; verify --app-id."
+    );
+  }
+  if (status === 429) {
+    return new NetworkError(
+      "Too many requests.",
+      "You are being rate-limited; wait a moment and retry."
+    );
+  }
+  return new NetworkError(
+    `The server had a problem processing your request (status: ${status}); try again.`
+  );
+}
+async function requestJson(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(url, { ...init, signal: controller.signal });
+  } catch {
+    throw new NetworkError("Could not reach the Ratio platform.");
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    await response.arrayBuffer().catch(() => void 0);
+    throw errorForStatus(response.status);
+  }
+  try {
+    return await response.json();
+  } catch {
+    throw new NetworkError("The server response was not the expected shape.");
+  }
+}
+async function postTrigger(serverUrl, token, body) {
+  const base = serverUrl.replace(/\/+$/, "");
+  const raw = await requestJson(`${base}/dev/trigger`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      "topic": body.topic,
+      "scenario": body.scenario,
+      "appId": body.appId
+    })
+  });
+  const parsed = triggerResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new NetworkError("The server response was not the expected shape.");
+  }
+  return parsed.data;
+}
+async function getScenarios(serverUrl, token) {
+  const base = serverUrl.replace(/\/+$/, "");
+  const raw = await requestJson(`${base}/dev/scenarios`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const parsed = scenariosResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new NetworkError("The server response was not the expected shape.");
+  }
+  return parsed.data;
+}
+function summarizeSampleShape(sample) {
+  if (typeof sample !== "object" || sample === null || Array.isArray(sample)) {
+    return "-";
+  }
+  const keys = Object.keys(sample);
+  return keys.length > 0 ? keys.join(", ") : "-";
+}
+function renderScenarioTable(entries) {
+  if (entries.length === 0) {
+    return "No scenarios are available yet.\n";
+  }
+  const header = "TOPIC";
+  const topicWidth = Math.max(
+    header.length,
+    ...entries.map((entry) => entry.topic.length)
+  );
+  const lines = [
+    `${header.padEnd(topicWidth)}  SCENARIOS                SAMPLE FIELDS`
+  ];
+  for (const entry of entries) {
+    const scenarioCol = entry.scenarios.join(", ").padEnd(23);
+    lines.push(
+      `${entry.topic.padEnd(topicWidth)}  ${scenarioCol}  ${summarizeSampleShape(entry.sampleShape)}`
+    );
+    if (entry.aliases.length > 0) {
+      lines.push(
+        `${"".padEnd(topicWidth)}  Also accepted: ${entry.aliases.join(", ")}`
+      );
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+var DevTrigger = class _DevTrigger extends RatioCommand {
+  static description = "Fire a synthetic Ratio webhook event for local testing.";
+  static examples = [
+    "<%= config.bin %> dev trigger --list",
+    "<%= config.bin %> dev trigger orders.created --scenario=cod --app-id=4f9d2c31-8a6b-4f2e-9c1d-3e5a7b9d0f12",
+    "<%= config.bin %> dev trigger --list --json"
+  ];
+  static args = {
+    topic: Args.string({
+      name: "topic",
+      required: false,
+      description: "Event topic, e.g. orders.created."
+    })
+  };
+  static flags = {
+    ...verboseFlag,
+    ...jsonFlag,
+    scenario: Flags2.string({
+      options: [...SCENARIO_OPTIONS],
+      description: "Payload scenario."
+    }),
+    list: Flags2.boolean({
+      description: "List available topics and scenarios."
+    }),
+    "app-id": Flags2.string({
+      description: "App id whose synthetic delivery to trigger (UUID). Required when a topic is given."
+    })
+  };
+  // ── Seams: overridable in tests; defaults hit the real process. ──────────
+  writeOut = (chunk) => {
+    process.stdout.write(chunk);
+  };
+  writeErr = (chunk) => {
+    process.stderr.write(chunk);
+  };
+  makeCredentialStore = () => new FileCredentialStore();
+  async run() {
+    const { args, flags } = await this.parse(_DevTrigger);
+    const jsonMode = flags.json === true;
+    const verbose = flags.verbose === true;
+    const trace = (message) => {
+      if (verbose) {
+        this.writeErr(`${message}
+`);
+      }
+    };
+    if (flags.list === true) {
+      await this.runList(jsonMode, trace);
+      return;
+    }
+    const topic = args.topic;
+    if (topic === void 0) {
+      throw new ValidationError(
+        "Pass a topic or use --list to see options.",
+        "Example: ratio dev trigger orders.created --scenario=cod --app-id=<uuid>"
+      );
+    }
+    const scenario = flags.scenario;
+    if (scenario === void 0) {
+      throw new ValidationError(
+        "A topic requires a --scenario.",
+        "Pass --scenario=cod|prepaid|cancelled or run --list to see options."
+      );
+    }
+    const appId = flags["app-id"];
+    if (appId === void 0 || appId === "") {
+      throw new ValidationError(
+        "A topic requires an --app-id.",
+        "Pass --app-id=<uuid>."
+      );
+    }
+    const store = this.makeCredentialStore();
+    const token = await store.getValidAccessToken();
+    const serverUrl = resolveServerUrl();
+    trace(`server: ${serverUrl}`);
+    trace(`trigger: topic=${topic} scenario=${scenario}`);
+    const started = Date.now();
+    const result = await postTrigger(serverUrl, token, {
+      topic,
+      scenario,
+      appId
+    });
+    trace(`trigger accepted in ${Date.now() - started}ms`);
+    if (jsonMode) {
+      this.writeOut(
+        `${JSON.stringify({ ok: true, data: { "deliveryId": result.deliveryId } })}
+`
+      );
+      return;
+    }
+    this.writeOut(
+      `Triggered ${topic} scenario=${scenario} deliveryId=${result.deliveryId}
+`
+    );
+  }
+  /** Handle `--list`: fetch the catalog and render table or JSON envelope. */
+  async runList(jsonMode, trace) {
+    const store = this.makeCredentialStore();
+    const token = await store.getValidAccessToken();
+    const serverUrl = resolveServerUrl();
+    trace(`server: ${serverUrl}`);
+    const started = Date.now();
+    const entries = await getScenarios(serverUrl, token);
+    trace(
+      `scenarios fetched in ${Date.now() - started}ms (${entries.length} topics)`
+    );
+    if (jsonMode) {
+      this.writeOut(`${JSON.stringify({ ok: true, data: entries })}
+`);
+      return;
+    }
+    this.writeOut(renderScenarioTable(entries));
+  }
+};
+export {
+  REQUEST_TIMEOUT_MS,
+  SCENARIO_OPTIONS,
+  DevTrigger as default,
+  getScenarios,
+  postTrigger,
+  renderScenarioTable,
+  summarizeSampleShape
+};
+//# sourceMappingURL=trigger.js.map