@fire-spark/cli 0.0.0-stage → 0.13.2

package/src/core/redact.ts

@@ -0,0 +1,71 @@
+export const REDACTED = "[redacted]";
+
+const SECRET_NAME =
+  /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|PRIVATE|CREDENTIAL|AUTH)/i;
+
+// Values shorter than this are too likely to collide with ordinary words.
+const MIN_SECRET_LENGTH = 6;
+
+const PATTERNS: RegExp[] = [
+  /\beyJ[\w-]{6,}\.[\w-]{6,}\.[\w-]{6,}\b/g,
+  /\b(Bearer|Basic)\s+[\w.~+/=-]{8,}/gi,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\b(sk|pk|rk)_(live|test)_[\w]{8,}\b/g,
+  /\bAIza[\w-]{30,}\b/g,
+  /\bgh[pousr]_[\w]{20,}\b/g,
+  /\bsb_(secret|publishable)_[\w-]{8,}\b/g,
+  /\bp\.ey[\w.-]{20,}\b/g
+];
+
+const URL_CREDENTIALS = /(\b[a-z][\w+.-]*:\/\/)([^\s/:@]+):([^\s/@]+)@/gi;
+const QUERY_SECRET =
+  /([?&](?:key|token|apikey|api_key|secret|password|sig|signature|access_token)=)[^&\s"']+/gi;
+
+export const isSecretName = (name: string) => SECRET_NAME.test(name);
+
+const escapeRegExp = (value: string) => {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+
+export interface Redactor {
+  add: (value: string | undefined) => void;
+  redact: (text: string) => string;
+  size: () => number;
+}
+
+export const createRedactor = (initial: Iterable<string> = []): Redactor => {
+  const secrets = new Set<string>();
+  const add = (value: string | undefined) => {
+    if (!value) return;
+    const trimmed = value.trim();
+    if (trimmed.length < MIN_SECRET_LENGTH) return;
+    secrets.add(trimmed);
+    const encoded = encodeURIComponent(trimmed);
+    if (encoded !== trimmed) secrets.add(encoded);
+  };
+  for (const value of initial) add(value);
+  const redact = (text: string) => {
+    let out = text;
+    const ordered = [...secrets].sort((a, b) => b.length - a.length);
+    for (const secret of ordered) {
+      out = out.replace(new RegExp(escapeRegExp(secret), "g"), REDACTED);
+    }
+    for (const pattern of PATTERNS) out = out.replace(pattern, REDACTED);
+    out = out.replace(URL_CREDENTIALS, `$1${REDACTED}@`);
+    return out.replace(QUERY_SECRET, `$1${REDACTED}`);
+  };
+  return { add, redact, size: () => secrets.size };
+};
+
+export const secretsFromEnv = (env: NodeJS.ProcessEnv) => {
+  const values: string[] = [];
+  for (const [name, value] of Object.entries(env)) {
+    if (value && isSecretName(name)) values.push(value);
+  }
+  return values;
+};
+
+export const redactError = (error: unknown, redactor: Redactor) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return redactor.redact(message);
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export { run } from "./main";
+export type { RunIo } from "./main";
+export { COMMANDS, findCommand } from "./commands";
+export { createRedactor } from "./core/redact";

package/src/main.ts

@@ -0,0 +1,113 @@
+import { COMMANDS, findCommand } from "./commands";
+import type { Command } from "./core/command.types";
+import { renderCommandHelp, renderRootHelp } from "./core/help";
+import { resolveLocale, translate } from "./core/i18n";
+import type { Locale } from "./core/i18n";
+import { GLOBAL_OPTIONS, UsageError, parseOptions } from "./core/options";
+import { resolveOptions, secretValues } from "./core/options";
+import { createOutput } from "./core/output";
+import type { Writer } from "./core/output";
+import { createRedactor, redactError, secretsFromEnv } from "./core/redact";
+import type { Redactor } from "./core/redact";
+
+export interface RunIo {
+  env: NodeJS.ProcessEnv;
+  cwd: string;
+  stdout: Writer;
+  stderr: Writer;
+  isTty: boolean;
+  ask?: (question: string) => Promise<string>;
+}
+
+const UNKNOWN_COMMAND = {
+  "es-EC": "Comando desconocido: {name}",
+  "en-US": "Unknown command: {name}",
+  "pt-BR": "Comando desconhecido: {name}"
+};
+
+const USAGE_ERROR = {
+  "es-EC": "Error de uso: {message}",
+  "en-US": "Usage error: {message}",
+  "pt-BR": "Erro de uso: {message}"
+};
+
+const UNEXPECTED = {
+  "es-EC": "Error inesperado: {message}",
+  "en-US": "Unexpected error: {message}",
+  "pt-BR": "Erro inesperado: {message}"
+};
+
+const defaultIo = (): RunIo => {
+  return {
+    env: process.env,
+    cwd: process.cwd(),
+    stdout: process.stdout,
+    stderr: process.stderr,
+    isTty: Boolean(process.stdout.isTTY)
+  };
+};
+
+const peekLocale = (argv: string[], env: NodeJS.ProcessEnv) => {
+  const index = argv.findIndex(arg => arg === "--locale");
+  const inline = argv.find(arg => arg.startsWith("--locale="));
+  const flag = inline ? inline.slice("--locale=".length) : argv[index + 1];
+  return resolveLocale(index >= 0 || inline ? flag : undefined, env);
+};
+
+interface CommandRun {
+  command: Command;
+  argv: string[];
+  io: RunIo;
+  locale: Locale;
+  redactor: Redactor;
+}
+
+const runCommand = async (input: CommandRun) => {
+  const { command, argv, io, locale, redactor } = input;
+  const specs = [...command.options, ...GLOBAL_OPTIONS];
+  const { values, positionals } = parseOptions(argv, specs);
+  const options = resolveOptions(specs, values, io.env);
+  for (const secret of secretValues(specs, options)) redactor.add(secret);
+  const colors = io.isTty && !options["no-color"];
+  const output = createOutput(io.stdout, io.stderr, redactor, colors);
+  if (options.help) {
+    output.line(renderCommandHelp(command, locale));
+    return 0;
+  }
+  const { env, cwd, ask, isTty } = io;
+  const context = { locale, options, positionals, env, cwd, output, redactor };
+  return command.run({ ...context, isTty, ask });
+};
+
+// `pnpm run doctor -- --live` forwards the separator itself.
+const dropSeparators = (argv: string[]) => argv.filter(arg => arg !== "--");
+
+export const run = async (input: string[], io: RunIo = defaultIo()) => {
+  const argv = dropSeparators(input);
+  const locale = peekLocale(argv, io.env);
+  const redactor = createRedactor(secretsFromEnv(io.env));
+  const output = createOutput(io.stdout, io.stderr, redactor, false);
+  const [name, ...rest] = argv;
+  if (!name || name === "--help" || name === "-h" || name === "help") {
+    output.line(renderRootHelp(COMMANDS, locale));
+    return 0;
+  }
+  const command = findCommand(name);
+  if (!command) {
+    output.error(translate(locale, UNKNOWN_COMMAND, { name }));
+    output.error(renderRootHelp(COMMANDS, locale));
+    return 2;
+  }
+  try {
+    const input = { command, argv: rest, io, locale, redactor };
+    return await runCommand(input);
+  } catch (error) {
+    const message = redactError(error, redactor);
+    if (error instanceof UsageError) {
+      output.error(translate(locale, USAGE_ERROR, { message }));
+      return 2;
+    }
+    output.error(translate(locale, UNEXPECTED, { message }));
+    return 1;
+  }
+};

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.