@jpkme/diff-review 0.1.10 → 0.1.13

package/lib/acp-policy.test.mjs

@@ -0,0 +1,136 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  decidePermission,
+  humanizePolicyReason,
+  permissionOutcome,
+  toolCallCommand,
+  toolCallLabel,
+} from "./acp-policy.mjs";
+
+const repo = process.platform === "win32" ? "C:\\repos\\app" : "/repos/app";
+const out = "diff-rev_75eca0c739_52eb729c8f.json";
+const ctx = (mode = "review") => ({ repo, outputFilename: out, mode });
+const outPath = join(repo, ".diff-review", out);
+
+// Formas reales que manda claude-agent-acp.
+const bash = (command) => ({ kind: "execute", title: command, rawInput: { command, description: "x" } });
+const read = (file_path) => ({ kind: "read", title: "Read", rawInput: { file_path }, locations: [{ path: file_path, line: 1 }] });
+const edit = (file_path) => ({ kind: "edit", title: "Write", rawInput: { file_path, content: "{}" }, locations: [{ path: file_path }] });
+
+test("decidePermission: lecturas solo dentro del repo", () => {
+  assert.equal(decidePermission(read(join(repo, "lib", "a.mjs")), ctx()).allow, true);
+  assert.equal(decidePermission(read("lib/a.mjs"), ctx()).allow, true);
+  const home = process.platform === "win32" ? "C:\\Users\\me\\.ssh\\id_rsa" : "/home/me/.ssh/id_rsa";
+  assert.equal(decidePermission(read(home), ctx()).allow, false);
+  assert.equal(decidePermission(read(join(repo, "..", "otro", "x")), ctx()).allow, false);
+  assert.equal(decidePermission({ kind: "read", title: "Read", rawInput: {} }, ctx()).allow, false);
+  assert.equal(decidePermission({ kind: "search", title: "Grep", rawInput: { pattern: "x" } }, ctx()).allow, false);
+  assert.equal(decidePermission({ kind: "search", title: "Grep", rawInput: { pattern: "x", path: "lib" } }, ctx()).allow, true);
+});
+
+test("decidePermission: symlink dentro del repo que apunta afuera no pasa", () => {
+  const root = mkdtempSync(join(tmpdir(), "dr-policy-"));
+  const outside = mkdtempSync(join(tmpdir(), "dr-policy-out-"));
+  writeFileSync(join(outside, "secret.txt"), "secret");
+  mkdirSync(join(root, "lib"), { recursive: true });
+  writeFileSync(join(root, "lib", "ok.mjs"), "ok");
+  const link = join(root, "escape");
+  try {
+    // junction en Windows no pide admin; 'dir' en posix.
+    symlinkSync(outside, link, process.platform === "win32" ? "junction" : "dir");
+  } catch (err) {
+    rmSync(root, { recursive: true, force: true });
+    rmSync(outside, { recursive: true, force: true });
+    // Entornos sin permiso de symlink: no fallar el suite.
+    if (err && (err.code === "EPERM" || err.code === "EACCES")) return;
+    throw err;
+  }
+  const local = (mode = "review") => ({ repo: root, outputFilename: out, mode });
+  try {
+    assert.equal(decidePermission(read(join(root, "lib", "ok.mjs")), local()).allow, true);
+    assert.equal(decidePermission(read(join(link, "secret.txt")), local()).allow, false);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+    rmSync(outside, { recursive: true, force: true });
+  }
+});
+
+test("decidePermission: escritura solo del JSON objetivo, nunca en modo pregunta ni fuera", () => {
+  assert.equal(decidePermission(edit(outPath), ctx("review")).allow, true);
+  assert.equal(decidePermission(edit(`.diff-review/${out}`), ctx("edit")).allow, true);
+  assert.equal(decidePermission(edit(join(repo, ".diff-review", "scratch.tmp")), ctx("review")).allow, false);
+  assert.equal(decidePermission(edit(join(repo, ".diff-review", out.replace(/\.json$/i, ".diff"))), ctx("review")).allow, false);
+  assert.equal(decidePermission(edit(outPath), ctx("ask")).allow, false);
+  // Fuera de .diff-review/: no.
+  assert.equal(decidePermission(edit(join(repo, out)), ctx("review")).allow, false);
+  assert.equal(decidePermission(edit(join(repo, "lib", "a.mjs")), ctx("edit")).allow, false);
+  assert.equal(decidePermission({ kind: "edit", title: "Edit", rawInput: {} }, ctx("edit")).allow, false);
+  // Claude manda el Write con el path solo en el diff de `content`.
+  const write = (path) => ({ kind: "edit", title: "Write", rawInput: {}, locations: [], content: [{ type: "diff", path, oldText: null, newText: "{}" }] });
+  assert.equal(decidePermission(write(outPath), ctx("review")).allow, true);
+  assert.equal(decidePermission(write(join(repo, "x.json")), ctx("review")).allow, false);
+  assert.equal(
+    decidePermission({ kind: "delete", title: "Delete", rawInput: { path: outPath }, locations: [{ path: outPath }] }, ctx("review"))
+      .allow,
+    true
+  );
+  assert.equal(
+    decidePermission(
+      { kind: "delete", title: "Delete", rawInput: { path: join(repo, "lib", "a.mjs") }, locations: [{ path: join(repo, "lib", "a.mjs") }] },
+      ctx("review")
+    ).allow,
+    false
+  );
+});
+
+test("decidePermission: comandos según isAllowedShell y el resto rechazado", () => {
+  assert.equal(decidePermission(bash("git diff a...b"), ctx("ask")).allow, true);
+  assert.equal(decidePermission(bash("rm -rf ."), ctx()).allow, false);
+  // Cursor: sin rawInput, el comando entre backticks en el título.
+  const cursor = (cmd) => ({ kind: "execute", title: `\`${cmd}\`` });
+  assert.equal(decidePermission(cursor("git log --oneline -3"), ctx()).allow, true);
+  assert.equal(decidePermission(cursor("echo hola > hola.txt"), ctx()).allow, false);
+  // El motivo del rechazo dice qué falló (lo ve el usuario en la web).
+  assert.match(decidePermission(bash("git diff > x.patch"), ctx()).reason, /redirección/);
+  assert.equal(decidePermission({ kind: "fetch", title: "WebFetch", rawInput: { url: "https://x" } }, ctx()).allow, false);
+  assert.equal(decidePermission({ kind: "delete", title: "rm", rawInput: {} }, ctx("edit")).allow, false);
+});
+
+test("toolCallCommand / toolCallLabel y humanizePolicyReason para la UI de permisos", () => {
+  assert.equal(toolCallCommand({ kind: "execute", rawInput: { command: "git status" } }), "git status");
+  assert.equal(toolCallCommand({ kind: "execute", title: "`ls -la`" }), "ls -la");
+  assert.equal(
+    toolCallCommand({ kind: "execute", title: "@\nnode -e 'x'\n@" }),
+    "node -e 'x'"
+  );
+  assert.equal(toolCallLabel({ title: "Probe symlink" }, "node -e 'x'"), "Probe symlink");
+  assert.equal(toolCallLabel({ title: "`ls`" }, "ls"), "");
+  assert.equal(toolCallLabel({ title: "@node@" }, "node"), "");
+  assert.match(humanizePolicyReason("node no está permitido"), /allowlist/);
+  assert.match(humanizePolicyReason("variables de entorno en el comando: @"), /variable de entorno/);
+});
+
+test("permissionOutcome elige once / always según el scope", () => {
+  const options = [
+    { optionId: "a1", kind: "allow_always", name: "Siempre" },
+    { optionId: "a", kind: "allow_once", name: "Sí" },
+    { optionId: "r", kind: "reject_once", name: "No" },
+  ];
+  assert.deepEqual(permissionOutcome(options, true), { outcome: { outcome: "selected", optionId: "a" } });
+  assert.deepEqual(permissionOutcome(options, true, { always: true }), {
+    outcome: { outcome: "selected", optionId: "a1" },
+  });
+  assert.deepEqual(permissionOutcome(options, false), { outcome: { outcome: "selected", optionId: "r" } });
+  // Sin allow_once: allow “una vez” no puede inventar always.
+  assert.deepEqual(permissionOutcome([{ optionId: "a1", kind: "allow_always" }], true), {
+    outcome: { outcome: "cancelled" },
+  });
+  // Sin allow_always: “siempre” cae a once.
+  assert.deepEqual(permissionOutcome([{ optionId: "a", kind: "allow_once" }], true, { always: true }), {
+    outcome: { outcome: "selected", optionId: "a" },
+  });
+});

package/lib/acp-shell.mjs

@@ -0,0 +1,409 @@
+/**
+ * Qué comandos de terminal puede correr el agente por ACP: git de solo lectura, comandos que solo leen (cat, grep,
+ * find, sed -n …, y sus equivalentes de PowerShell) y el validate del paquete. Los paths tienen que quedar dentro
+ * del repo.
+ *
+ * El comando se tokeniza respetando comillas (un `grep "a\|b"` no es un pipe). Se aceptan `|`, `&&`, `||`, `;` y
+ * descartar salida a /dev/null; cualquier otra redirección, `$(…)`, backticks o `&` lo rechazan.
+ */
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, normalize, resolve } from "node:path";
+
+/** @typedef {{ ok: true } | { ok: false, reason: string }} ShellCheck */
+
+/** Subcomandos de git que solo leen. */
+const GIT_READ = new Set([
+  "diff",
+  "log",
+  "show",
+  "status",
+  "merge-base",
+  "rev-parse",
+  "rev-list",
+  "blame",
+  "ls-files",
+  "ls-tree",
+  "cat-file",
+  "describe",
+  "shortlog",
+  "name-rev",
+  "for-each-ref",
+  "grep",
+  "whatchanged",
+]);
+
+/** Flags de git que ejecutan algo o escriben archivos, en cualquier subcomando. */
+const GIT_UNSAFE_FLAG = /^(--output|--ext-diff|-O|--open-files-in-pager)(=|$)/;
+
+const BRANCH_LIST_FLAGS = new Set(["--show-current", "--list", "-a", "--all", "-r", "--remotes", "-v", "-vv"]);
+const CONFIG_READ_FLAGS = new Set(["--get", "--get-all", "--get-regexp", "--list", "-l"]);
+
+/** Comandos que solo leen (o imprimen). Los de PowerShell van en minúscula: no distingue mayúsculas. */
+const READ_COMMANDS = new Set([
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "ls",
+  "nl",
+  "sort",
+  "uniq",
+  "cut",
+  "tr",
+  "grep",
+  "egrep",
+  "fgrep",
+  "rg",
+  "find",
+  "sed",
+  "file",
+  "stat",
+  "du",
+  "diff",
+  "cmp",
+  "jq",
+  "basename",
+  "dirname",
+  "realpath",
+  "tree",
+  "which",
+  "type",
+  "pwd",
+  "echo",
+  "printf",
+  "true",
+  // PowerShell
+  "get-content",
+  "gc",
+  "select-string",
+  "sls",
+  "get-childitem",
+  "gci",
+  "dir",
+  "measure-object",
+  "measure",
+  "select-object",
+  "select",
+  "sort-object",
+  "get-location",
+  "test-path",
+  "resolve-path",
+  "write-output",
+  "out-string",
+  "format-list",
+  "format-table",
+]);
+
+/** Comandos cuyos argumentos son texto, no paths. */
+const TEXT_ARGS = new Set(["echo", "printf", "tr", "write-output", "which", "type"]);
+
+/** Destinos de redirección que solo descartan salida. */
+const DISCARD = new Set(["/dev/null", "nul", "$null"]);
+
+/**
+ * Paths de shell Unix → forma Windows cuando la política corre en win32:
+ * - Git Bash: `/c/Users/...` → `C:/Users/...`
+ * - WSL: `/mnt/c/Users/...` → `C:/Users/...`
+ */
+function toNativePath(p, platform) {
+  if (platform === "win32") {
+    const wsl = /^\/mnt\/([a-zA-Z])(\/|$)(.*)$/.exec(p);
+    if (wsl) return `${wsl[1].toUpperCase()}:/${wsl[3]}`;
+    const msys = /^\/([a-zA-Z])(\/|$)(.*)$/.exec(p);
+    if (msys) return `${msys[1].toUpperCase()}:/${msys[3]}`;
+  }
+  return p;
+}
+
+/**
+ * Resuelve symlinks cuando el path (o un ancestro) existe. Sin eso, un link
+ * dentro del repo puede apuntar fuera y pasar `isInside` con solo `normalize`.
+ * @param {string} path
+ */
+function canonicalPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    const parts = [];
+    let cur = normalize(path);
+    for (;;) {
+      const parent = dirname(cur);
+      if (!parent || parent === cur) return normalize(path);
+      parts.unshift(basename(cur));
+      try {
+        return resolve(realpathSync(parent), ...parts);
+      } catch {
+        cur = parent;
+      }
+    }
+  }
+}
+
+function isInside(child, root, platform) {
+  const c = normalize(canonicalPath(child)).replace(/[\\/]+$/, "");
+  const r = normalize(canonicalPath(root)).replace(/[\\/]+$/, "");
+  const [cc, rr] = platform === "win32" ? [c.toLowerCase(), r.toLowerCase()] : [c, r];
+  return cc === rr || cc.startsWith(`${rr}\\`) || cc.startsWith(`${rr}/`);
+}
+
+/** ¿El argumento parece un path que puede salir del repo? (absoluto, `~` o con `..`). */
+function escapingPath(arg) {
+  return /^([a-zA-Z]:[\\/]|[\\/]|~)/.test(arg) || /(^|[\\/])\.\.([\\/]|$)/.test(arg);
+}
+
+/**
+ * Parte el comando en cadenas (separadas por `&&`, `||`, `;`, saltos de línea) de pipelines (`|`) de argv.
+ * @param {string} command
+ * @returns {{ ok: true, pipelines: string[][][] } | { ok: false, reason: string }}
+ */
+export function tokenizeShell(command) {
+  const src = String(command ?? "");
+  /** @type {string[][][]} */
+  const pipelines = [];
+  /** @type {string[][]} */
+  let pipeline = [];
+  /** @type {string[]} */
+  let words = [];
+  let word = "";
+  let inWord = false;
+  /** @type {null | "'" | '"'} */
+  let quote = null;
+
+  const endWord = () => {
+    if (inWord) words.push(word);
+    word = "";
+    inWord = false;
+  };
+  const endSegment = () => {
+    endWord();
+    if (words.length) pipeline.push(words);
+    words = [];
+  };
+  const endPipeline = () => {
+    endSegment();
+    if (pipeline.length) pipelines.push(pipeline);
+    pipeline = [];
+  };
+  const fail = (reason) => ({ ok: /** @type {const} */ (false), reason });
+
+  for (let i = 0; i < src.length; i++) {
+    const ch = src[i];
+    const next = src[i + 1];
+
+    if (quote === "'") {
+      if (ch === "'") quote = null;
+      else word += ch;
+      continue;
+    }
+    if (quote === '"') {
+      if (ch === '"') quote = null;
+      else if (ch === "`") return fail("backticks");
+      else if (ch === "$" && next === "(") return fail("sustitución $(…)");
+      else if (ch === "\\" && next !== undefined && '"\\$`'.includes(next)) {
+        word += next;
+        i++;
+      } else word += ch;
+      continue;
+    }
+
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      inWord = true;
+      continue;
+    }
+    if (ch === "\\" && next !== undefined) {
+      word += next;
+      inWord = true;
+      i++;
+      continue;
+    }
+    if (ch === "`") return fail("backticks");
+    if (ch === "$" && next === "(") return fail("sustitución $(…)");
+    if (/\s/.test(ch) && ch !== "\n" && ch !== "\r") {
+      endWord();
+      continue;
+    }
+    if (ch === "\n" || ch === "\r" || ch === ";") {
+      endPipeline();
+      continue;
+    }
+    if ((ch === "&" && next === "&") || (ch === "|" && next === "|")) {
+      endPipeline();
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      endSegment();
+      continue;
+    }
+    if (ch === ">" || (ch === "&" && next === ">")) {
+      // `2>&1`, `2>/dev/null`, `>nul`, `&>/dev/null`: descartar o juntar salidas no escribe nada.
+      if (ch === "&") i++;
+      const fd = inWord && /^[12]$/.test(word) ? word : "";
+      if (inWord && !fd) return fail("redirección");
+      word = "";
+      inWord = false;
+      let j = i + 1;
+      if (src[j] === ">") j++;
+      if (src[j] === "&" && /[12]/.test(src[j + 1] ?? "")) {
+        i = j + 1;
+        continue;
+      }
+      while (src[j] === " " || src[j] === "\t") j++;
+      let target = "";
+      while (j < src.length && !/[\s;|&<>]/.test(src[j])) target += src[j++];
+      if (!DISCARD.has(target.toLowerCase())) return fail(`redirección a ${target || "archivo"}`);
+      i = j - 1;
+      continue;
+    }
+    if (ch === "<") return fail("redirección de entrada");
+    if (ch === "&") return fail("comando en segundo plano (&)");
+    word += ch;
+    inWord = true;
+  }
+  if (quote) return fail("comillas sin cerrar");
+  endPipeline();
+  return { ok: true, pipelines };
+}
+
+/**
+ * @param {string} arg
+ * @param {{ repo: string, platform: NodeJS.Platform }} ctx
+ * @returns {ShellCheck}
+ */
+function checkPath(arg, { repo, platform }) {
+  if (DISCARD.has(arg.toLowerCase())) return { ok: true };
+  const native = toNativePath(arg.replace(/^~(?=[\\/]|$)/, "/__home__"), platform);
+  const abs = isAbsolute(native) ? native : resolve(repo, native);
+  return isInside(abs, repo, platform) ? { ok: true } : { ok: false, reason: `path fuera del repo: ${arg}` };
+}
+
+/** Argumentos (y valores de `--opt=valor`) que parecen paths que salen del repo deben quedar adentro. */
+function checkArgsInside(args, ctx) {
+  for (const arg of args) {
+    const value = arg.startsWith("-") ? (arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : "") : arg;
+    if (value && escapingPath(value)) {
+      const res = checkPath(value, ctx);
+      if (!res.ok) return res;
+    }
+  }
+  return { ok: true };
+}
+
+/** @param {string[]} argv @returns {ShellCheck} */
+function checkGit(argv, ctx) {
+  let i = 1;
+  while (argv[i]?.startsWith("-")) {
+    const flag = argv[i];
+    if (flag === "--no-pager" || flag === "-P") i++;
+    else if (flag === "-C") {
+      const res = checkPath(argv[i + 1] ?? "", ctx);
+      if (!res.ok) return res;
+      i += 2;
+    } else return { ok: false, reason: `opción global de git no permitida: ${flag}` };
+  }
+  const sub = argv[i] ?? "";
+  const rest = argv.slice(i + 1);
+  const unsafe = rest.find((w) => GIT_UNSAFE_FLAG.test(w));
+  if (unsafe) return { ok: false, reason: `git ${sub} ${unsafe}` };
+  if (GIT_READ.has(sub)) return { ok: true };
+  if (sub === "branch" && rest.every((w) => BRANCH_LIST_FLAGS.has(w))) return { ok: true };
+  if (sub === "remote" && (rest.length === 0 || (rest.length === 1 && rest[0] === "-v") || rest[0] === "get-url"))
+    return { ok: true };
+  if (sub === "config" && rest.some((w) => CONFIG_READ_FLAGS.has(w))) return { ok: true };
+  return { ok: false, reason: `git ${sub || "(sin subcomando)"} no es de solo lectura` };
+}
+
+/** @param {string[]} argv @returns {ShellCheck} */
+function checkReadCommand(name, argv, ctx) {
+  const args = argv.slice(1);
+  if (name === "sort" && args.some((a) => /^(-o|--output)/.test(a))) return { ok: false, reason: "sort -o escribe un archivo" };
+  if (name === "uniq" && args.filter((a) => !a.startsWith("-")).length > 1)
+    return { ok: false, reason: "uniq con archivo de salida" };
+  if (name === "find" && args.some((a) => /^-(exec|execdir|ok|okdir|delete|fprint|fprint0|fprintf|fls)$/.test(a)))
+    return { ok: false, reason: "find que ejecuta o escribe" };
+  if (name === "rg" && args.some((a) => /^--pre(-glob)?(=|$)/.test(a))) return { ok: false, reason: "rg --pre ejecuta comandos" };
+  if (name === "sed") {
+    if (!args.includes("-n") || args.some((a) => /^(-i|--in-place|-e|-f|--expression|--file)/.test(a)))
+      return { ok: false, reason: "sed solo como `sed -n 'N,Mp'`" };
+    const script = args.find((a) => !a.startsWith("-"));
+    if (!script || !/^\s*(\d+|\$)(\s*,\s*(\d+|\$))?\s*p\s*$/.test(script))
+      return { ok: false, reason: "sed solo como `sed -n 'N,Mp'`" };
+    return checkArgsInside(args.filter((a) => a !== script), ctx);
+  }
+  if (TEXT_ARGS.has(name)) return { ok: true };
+  return checkArgsInside(args, ctx);
+}
+
+/** El validate del paquete (por npx o con el bin instalado), con el archivo como único argumento. */
+function isValidate(argv) {
+  const line = argv.join(" ");
+  return /^(?:npx\s+(?:--yes\s+|-y\s+)?@jpkme\/diff-review(?:@[\w.^~-]+)?|diff-review)\s+validate\s+\S+$/.test(line);
+}
+
+/**
+ * `mkdir` / `md` / `New-Item -ItemType Directory` solo bajo `.diff-review/` del repo.
+ * @param {string[]} argv
+ * @param {{ repo: string, platform: NodeJS.Platform }} ctx
+ * @returns {ShellCheck | null} null = no es este caso
+ */
+function checkReviewDirMkdir(argv, ctx) {
+  const name = argv[0].toLowerCase();
+  const reviewRoot = resolve(ctx.repo, ".diff-review");
+  /** @param {string} arg */
+  const underReviewDir = (arg) => {
+    const native = toNativePath(String(arg || "").replace(/^~(?=[\\/]|$)/, "/__home__"), ctx.platform);
+    const abs = isAbsolute(native) ? native : resolve(ctx.repo, native);
+    return isInside(abs, reviewRoot, ctx.platform);
+  };
+
+  if (name === "mkdir" || name === "md") {
+    const paths = argv.slice(1).filter((a) => !a.startsWith("-"));
+    if (!paths.length || !paths.every(underReviewDir)) {
+      return { ok: false, reason: "mkdir solo permitido bajo .diff-review/" };
+    }
+    return { ok: true };
+  }
+  if (name === "new-item") {
+    const joined = argv.join(" ").toLowerCase();
+    if (!/-itemtype\s+directory\b/.test(joined) && !/\b-type\s+directory\b/.test(joined)) return null;
+    const paths = argv.slice(1).filter((a) => !a.startsWith("-") && !/^(directory|file)$/i.test(a));
+    if (!paths.length || !paths.every(underReviewDir)) {
+      return { ok: false, reason: "New-Item Directory solo permitido bajo .diff-review/" };
+    }
+    return { ok: true };
+  }
+  return null;
+}
+
+/**
+ * @param {string} command
+ * @param {{ repo?: string, platform?: NodeJS.Platform }} [opts]
+ * @returns {ShellCheck}
+ */
+export function checkShell(command, { repo, platform = process.platform } = {}) {
+  const parsed = tokenizeShell(command);
+  if (!parsed.ok) return parsed;
+  if (!parsed.pipelines.length) return { ok: false, reason: "comando vacío" };
+  const ctx = { repo: repo || process.cwd(), platform };
+  for (const pipeline of parsed.pipelines) {
+    for (const argv of pipeline) {
+      const name = argv[0].toLowerCase();
+      if (argv[0].includes("=")) return { ok: false, reason: `variables de entorno en el comando: ${argv[0]}` };
+      /** @type {ShellCheck} */
+      let res;
+      // `cd` solo dentro del repo (sin argumento iría al home).
+      if (name === "cd" || name === "set-location")
+        res = repo && argv[1] ? checkPath(argv[1], ctx) : { ok: false, reason: "cd fuera del repo" };
+      else if (name === "git") res = checkGit(argv, ctx);
+      else if (name === "npx" || name === "diff-review") res = isValidate(argv) ? { ok: true } : { ok: false, reason: `${argv.join(" ")}` };
+      else if (READ_COMMANDS.has(name)) res = checkReadCommand(name, argv, ctx);
+      else {
+        const mkdir = checkReviewDirMkdir(argv, ctx);
+        res = mkdir ?? { ok: false, reason: `${argv[0]} no está permitido` };
+      }
+      if (!res.ok) return res;
+    }
+  }
+  return { ok: true };
+}