theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/scripts/hooks/block-no-verify.js

@@ -0,0 +1,556 @@
+#!/usr/bin/env node
+/**
+ * Hook PreToolUse: bloquear el flag --no-verify
+ *
+ * Bloquea los flags de git que evitan la ejecucion de hooks (--no-verify,
+ * -c core.hooksPath=) para proteger los hooks pre-commit, commit-msg y
+ * pre-push de ser omitidos por agentes de IA.
+ *
+ * Reemplaza una invocacion previa basada en npx que fallaba en proyectos
+ * solo-pnpm (EBADDEVENGINES) y que no podia deshabilitarse via
+ * THEUS_DISABLED_HOOKS.
+ *
+ * Codigos de salida:
+ *   0 = permitir (no es un comando git o no hay flags de bypass)
+ *   2 = bloquear (se detecto un flag de bypass)
+ */
+
+'use strict';
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+/**
+ * Comandos de git que aceptan el flag --no-verify.
+ */
+const GIT_COMMANDS_WITH_NO_VERIFY = [
+  'commit',
+  'push',
+  'merge',
+  'cherry-pick',
+  'rebase',
+  'am',
+];
+
+/**
+ * Caracteres que pueden aparecer inmediatamente antes de 'git' en una cadena de comando.
+ */
+const VALID_BEFORE_GIT = ' \t\n\r;&|$`(<{!"\']/.~\\';
+
+// Los nombres de seccion y de variable en la configuracion de git no
+// distinguen mayusculas de minusculas (los nombres de subseccion si, pero
+// core.hooksPath no tiene subseccion), asi que normalizamos el token
+// candidato a minusculas antes de comparar.
+// Ver https://git-scm.com/docs/git-config — "The variable names are
+// case-insensitive."
+const GIT_CONFIG_KEY_PREFIX = 'core.hookspath=';
+
+const COMMIT_OPTIONS_WITH_VALUE = new Set([
+  '-m',
+  '--message',
+  '-F',
+  '--file',
+  '-C',
+  '--reuse-message',
+  '-c',
+  '--reedit-message',
+  '--author',
+  '--date',
+  '--template',
+  '--fixup',
+  '--squash',
+  '--pathspec-from-file',
+]);
+
+const COMMIT_OPTIONS_WITH_INLINE_VALUE = [
+  '--message=',
+  '--file=',
+  '--reuse-message=',
+  '--reedit-message=',
+  '--author=',
+  '--date=',
+  '--template=',
+  '--fixup=',
+  '--squash=',
+  '--pathspec-from-file=',
+];
+
+// Opciones cortas que reciben un valor. Cuando aparecen dentro de un token
+// de opciones cortas combinadas (p. ej. -tn), el parser de git trata el
+// resto del token como el valor de la opcion (aqui la ruta de plantilla
+// 'n'), asi que el escaner debe detenerse en ese caracter: todo lo que
+// sigue es el valor en linea, no otro flag.
+const COMMIT_SHORT_OPTIONS_WITH_VALUE = new Set(['m', 'F', 'C', 'c', 't']);
+
+function tokenizeShellWords(input, start = 0, end = input.length) {
+  const tokens = [];
+  let value = '';
+  let tokenStart = null;
+  let quote = null;
+  let escaped = false;
+
+  function beginToken(index) {
+    if (tokenStart === null) {
+      tokenStart = index;
+    }
+  }
+
+  function pushToken(index) {
+    if (tokenStart === null) {
+      return;
+    }
+
+    tokens.push({
+      value,
+      start: tokenStart,
+      end: index,
+    });
+    value = '';
+    tokenStart = null;
+  }
+
+  for (let i = start; i < end; i++) {
+    const char = input.charAt(i);
+
+    if (escaped) {
+      beginToken(i - 1);
+      value += char;
+      escaped = false;
+      continue;
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+
+      if (quote === '"' && char === '\\') {
+        beginToken(i);
+        escaped = true;
+        continue;
+      }
+
+      beginToken(i);
+      value += char;
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      beginToken(i);
+      quote = char;
+      continue;
+    }
+
+    if (char === '\\') {
+      beginToken(i);
+      escaped = true;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      pushToken(i);
+      continue;
+    }
+
+    beginToken(i);
+    value += char;
+  }
+
+  if (escaped) {
+    value += '\\';
+  }
+  pushToken(end);
+
+  return tokens;
+}
+
+function findCommandSegmentEnd(input, start) {
+  let quote = null;
+  let escaped = false;
+
+  for (let i = start; i < input.length; i++) {
+    const char = input.charAt(i);
+
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+
+    if (quote) {
+      if (quote === '"' && char === '\\') {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+
+    if (char === '\\') {
+      escaped = true;
+      continue;
+    }
+
+    if (char === ';' || char === '|' || char === '&' || char === '\n') {
+      return i;
+    }
+  }
+
+  return input.length;
+}
+
+function commitOptionConsumesNextValue(value) {
+  if (isCommitNoVerifyShortFlag(value)) {
+    return false;
+  }
+
+  if (COMMIT_OPTIONS_WITH_VALUE.has(value)) {
+    return true;
+  }
+
+  const shortValueOption = getCommitShortValueOption(value);
+  return Boolean(shortValueOption && shortValueOption.consumesNextValue);
+}
+
+function commitOptionContainsInlineValue(value) {
+  if (isCommitNoVerifyShortFlag(value)) {
+    return false;
+  }
+
+  if (COMMIT_OPTIONS_WITH_INLINE_VALUE.some(prefix => value.startsWith(prefix))) {
+    return true;
+  }
+
+  const shortValueOption = getCommitShortValueOption(value);
+  return Boolean(shortValueOption && shortValueOption.containsInlineValue);
+}
+
+function getCommitShortValueOption(value) {
+  if (!value.startsWith('-') || value.startsWith('--') || value === '-') {
+    return null;
+  }
+
+  const options = value.slice(1);
+  for (let i = 0; i < options.length; i++) {
+    if (COMMIT_SHORT_OPTIONS_WITH_VALUE.has(options.charAt(i))) {
+      return {
+        consumesNextValue: i === options.length - 1,
+        containsInlineValue: i < options.length - 1,
+      };
+    }
+  }
+
+  return null;
+}
+
+function isCommitNoVerifyShortFlag(value) {
+  return value === '-n' || /^-n[a-zA-Z]/.test(value);
+}
+
+/**
+ * Comprueba si una posicion de la entrada esta dentro de un comentario de shell.
+ */
+function isInComment(input, idx) {
+  const lineStart = input.lastIndexOf('\n', idx - 1) + 1;
+  const before = input.slice(lineStart, idx);
+  for (let i = 0; i < before.length; i++) {
+    if (before.charAt(i) === '#') {
+      const prev = i > 0 ? before.charAt(i - 1) : '';
+      if (prev !== '$' && prev !== '\\') return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Busca el siguiente token 'git' en la entrada a partir de una posicion.
+ */
+function findGit(input, start) {
+  let pos = start;
+  while (pos < input.length) {
+    const idx = input.indexOf('git', pos);
+    if (idx === -1) return null;
+
+    const isExe = input.slice(idx + 3, idx + 7).toLowerCase() === '.exe';
+    const len = isExe ? 7 : 3;
+    const after = input[idx + len] || ' ';
+    if (!/[\s"']/.test(after)) {
+      pos = idx + 1;
+      continue;
+    }
+
+    const before = idx > 0 ? input[idx - 1] : ' ';
+    if (VALID_BEFORE_GIT.includes(before)) return { idx, len };
+    pos = idx + 1;
+  }
+  return null;
+}
+
+/**
+ * Detecta que subcomando de git (commit, push, etc.) se esta invocando.
+ * Devuelve { command, offset } donde offset es la posicion justo despues de
+ * la palabra clave del subcomando, para que quien llame pueda acotar la
+ * comprobacion de flags solo a esa porcion.
+ */
+function detectGitCommand(input, start = 0) {
+  while (start < input.length) {
+    const git = findGit(input, start);
+    if (!git) return null;
+
+    if (isInComment(input, git.idx)) {
+      start = git.idx + git.len;
+      continue;
+    }
+
+    // Busca el primer token de subcomando coincidente despues de "git".
+    // Elegimos el mas cercano a "git" para que valores de argumentos como
+    // "git push origin commit" no clasifiquen erroneamente "commit" como el
+    // subcomando.
+    let bestCmd = null;
+    let bestIdx = Infinity;
+
+    for (const cmd of GIT_COMMANDS_WITH_NO_VERIFY) {
+      let searchPos = git.idx + git.len;
+      while (searchPos < input.length) {
+        const cmdIdx = input.indexOf(cmd, searchPos);
+        if (cmdIdx === -1) break;
+
+        const before = cmdIdx > 0 ? input[cmdIdx - 1] : ' ';
+        const after = input[cmdIdx + cmd.length] || ' ';
+        if (!/\s/.test(before)) { searchPos = cmdIdx + 1; continue; }
+        if (!/[\s;&#|>)\]}"']/.test(after) && after !== '') { searchPos = cmdIdx + 1; continue; }
+        if (/[;|]/.test(input.slice(git.idx + git.len, cmdIdx))) break;
+        if (isInComment(input, cmdIdx)) { searchPos = cmdIdx + 1; continue; }
+
+        // Verifica que este token sea la primera palabra que no es flag
+        // despues de "git" — es decir, el subcomando real, y no el valor de
+        // un argumento de otro subcomando.
+        const gap = input.slice(git.idx + git.len, cmdIdx);
+        const tokens = gap.trim().split(/\s+/).filter(Boolean);
+        // Todo token anterior al candidato debe ser un flag o el argumento
+        // de un flag. Los flags globales de git como -c reciben un valor
+        // (p. ej. -c clave=valor).
+        let onlyFlagsAndArgs = true;
+        let expectFlagArg = false;
+        for (const t of tokens) {
+          if (expectFlagArg) { expectFlagArg = false; continue; }
+          if (t.startsWith('-')) {
+            // -c es un flag global de git que toma el siguiente token como argumento
+            if (t === '-c' || t === '-C' || t === '--work-tree' || t === '--git-dir' ||
+                t === '--namespace' || t === '--super-prefix') {
+              expectFlagArg = true;
+            }
+            continue;
+          }
+          onlyFlagsAndArgs = false;
+          break;
+        }
+        if (!onlyFlagsAndArgs) { searchPos = cmdIdx + 1; continue; }
+
+        if (cmdIdx < bestIdx) {
+          bestIdx = cmdIdx;
+          bestCmd = cmd;
+        }
+        break;
+      }
+    }
+
+    if (bestCmd) {
+      return {
+        command: bestCmd,
+        offset: bestIdx + bestCmd.length,
+        gitStart: git.idx,
+        gitEnd: git.idx + git.len,
+        commandStart: bestIdx,
+      };
+    }
+
+    start = git.idx + git.len;
+  }
+  return null;
+}
+
+/**
+ * Comprueba si la entrada contiene un flag --no-verify para un comando git
+ * concreto. Solo inspecciona la porcion de la entrada que empieza en `offset`
+ * (la posicion justo despues de la palabra clave del subcomando detectado)
+ * para no emparejar por error flags que pertenecen a comandos anteriores de
+ * una cadena.
+ */
+function hasNoVerifyFlag(input, command, offset) {
+  const segmentEnd = findCommandSegmentEnd(input, offset);
+  const tokens = tokenizeShellWords(input, offset, segmentEnd);
+  let skipNext = false;
+
+  for (const token of tokens) {
+    const value = token.value;
+
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+
+    if (value === '--') {
+      break;
+    }
+
+    if (command === 'commit') {
+      if (commitOptionConsumesNextValue(value)) {
+        skipNext = true;
+        continue;
+      }
+
+      if (commitOptionContainsInlineValue(value)) {
+        continue;
+      }
+    }
+
+    if (value === '--no-verify') return true;
+
+    // Para commit, -n es el atajo de --no-verify.
+    if (command === 'commit' && isCommitNoVerifyShortFlag(value)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Comprueba si la entrada contiene una anulacion -c core.hooksPath=.
+ */
+function hasHooksPathOverride(input, detected) {
+  const tokens = tokenizeShellWords(input, detected.gitEnd, detected.commandStart);
+
+  for (let i = 0; i < tokens.length; i++) {
+    const value = tokens[i].value;
+    // Los nombres de seccion + variable de la configuracion de git no
+    // distinguen mayusculas, asi que un intento de bypass como
+    // `core.HOOKSPATH=...` o `core.hookspath=...` debe compararse contra el
+    // token en minusculas.
+    const lowered = value.toLowerCase();
+
+    if (value === '-c') {
+      const next = tokens[i + 1] && tokens[i + 1].value;
+      if (typeof next === 'string' && next.toLowerCase().startsWith(GIT_CONFIG_KEY_PREFIX)) {
+        return true;
+      }
+      i++;
+      continue;
+    }
+
+    if (lowered.startsWith(`-c${GIT_CONFIG_KEY_PREFIX}`)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Analiza una cadena de comando en busca de intentos de bypass de hooks de git.
+ */
+function checkCommand(input) {
+  let start = 0;
+
+  while (start < input.length) {
+    const detected = detectGitCommand(input, start);
+    if (!detected) return { blocked: false };
+
+    const { command: gitCommand, offset } = detected;
+
+    if (hasHooksPathOverride(input, detected)) {
+      return {
+        blocked: true,
+        reason: `BLOQUEADO: no se permite anular core.hooksPath con git ${gitCommand}. Los hooks de git no deben omitirse.`,
+      };
+    }
+
+    if (hasNoVerifyFlag(input, gitCommand, offset)) {
+      return {
+        blocked: true,
+        reason: `BLOQUEADO: no se permite el flag --no-verify con git ${gitCommand}. Los hooks de git no deben omitirse.`,
+      };
+    }
+
+    start = findCommandSegmentEnd(input, offset) + 1;
+  }
+
+  return { blocked: false };
+}
+
+/**
+ * Extrae la cadena de comando de la entrada del hook (JSON o texto plano).
+ */
+function extractCommand(rawInput) {
+  const trimmed = rawInput.trim();
+  if (!trimmed.startsWith('{')) return trimmed;
+
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== 'object' || parsed === null) return trimmed;
+
+    // Formato del motor Theus: { tool_input: { command: "..." } }
+    const cmd = parsed.tool_input?.command;
+    if (typeof cmd === 'string') return cmd;
+
+    // Formatos JSON genericos
+    for (const key of ['command', 'cmd', 'input', 'shell', 'script']) {
+      if (typeof parsed[key] === 'string') return parsed[key];
+    }
+
+    return trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+
+/**
+ * run() exportable para ejecucion en el mismo proceso via run-with-flags.js.
+ */
+function run(rawInput) {
+  const command = extractCommand(rawInput);
+  const result = checkCommand(command);
+
+  if (result.blocked) {
+    return {
+      exitCode: 2,
+      stderr: result.reason,
+    };
+  }
+
+  return { exitCode: 0 };
+}
+
+module.exports = { run };
+
+// Respaldo por stdin para ejecucion via spawnSync — solo cuando se invoca
+// directamente, no via require()
+if (require.main === module) {
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      const remaining = MAX_STDIN - raw.length;
+      raw += chunk.substring(0, remaining);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    const command = extractCommand(raw);
+    const result = checkCommand(command);
+
+    if (result.blocked) {
+      process.stderr.write(result.reason + '\n');
+      process.exit(2);
+    }
+
+    process.stdout.write(raw);
+  });
+}

package/vendor/theus-arsenal/scripts/hooks/check-console-log.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Hook Stop: detectar sentencias console.log en archivos modificados
+ *
+ * Multiplataforma (Windows, macOS, Linux)
+ *
+ * Se ejecuta despues de cada respuesta y comprueba si algun archivo
+ * JavaScript/TypeScript modificado contiene sentencias console.log.
+ * Emite avisos para ayudar a recordar eliminar las sentencias de depuracion
+ * antes de hacer commit.
+ *
+ * Exclusiones: archivos de test, archivos de configuracion y el directorio
+ * scripts/ (donde console.log suele ser intencional).
+ */
+
+const fs = require('fs');
+const { isGitRepo, getGitModifiedFiles, readFile, log } = require('../lib/utils');
+
+// Archivos donde console.log es esperable y no debe generar avisos
+const EXCLUDED_PATTERNS = [
+  /\.test\.[jt]sx?$/,
+  /\.spec\.[jt]sx?$/,
+  /\.config\.[jt]s$/,
+  /scripts\//,
+  /__tests__\//,
+  /__mocks__\//,
+];
+
+const MAX_STDIN = 1024 * 1024; // limite de 1 MB
+let data = '';
+let truncated = false;
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', chunk => {
+  if (data.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - data.length;
+    data += chunk.substring(0, remaining);
+    if (chunk.length > remaining) truncated = true;
+  } else {
+    truncated = true;
+  }
+});
+
+/**
+ * Reenvía stdin de vuelta (convencion de paso directo de Theus) y sale una
+ * vez vaciado el pipe. La entrada truncada nunca se reenvía: un documento
+ * JSON cortado a mitad de flujo lo reporta el motor como un fallo de
+ * validacion JSON del hook Stop.
+ */
+function passThroughAndExit() {
+  if (truncated) {
+    log('[Hook] check-console-log: stdin supero 1 MB; se suprime el paso directo (fail-open)');
+    process.exit(0);
+  }
+  if (!data) {
+    process.exit(0);
+  }
+  process.stdout.write(data, () => process.exit(0));
+}
+
+process.stdin.on('end', () => {
+  try {
+    if (!isGitRepo()) {
+      passThroughAndExit();
+      return;
+    }
+
+    const files = getGitModifiedFiles(['\\.tsx?$', '\\.jsx?$'])
+      .filter(f => fs.existsSync(f))
+      .filter(f => !EXCLUDED_PATTERNS.some(pattern => pattern.test(f)));
+
+    let hasConsole = false;
+
+    for (const file of files) {
+      const content = readFile(file);
+      if (content && content.includes('console.log')) {
+        log(`[Hook] AVISO: se encontro console.log en ${file}`);
+        hasConsole = true;
+      }
+    }
+
+    if (hasConsole) {
+      log('[Hook] Elimina las sentencias console.log antes de hacer commit');
+    }
+  } catch (err) {
+    log(`[Hook] error en check-console-log: ${err.message}`);
+  }
+
+  // Siempre reenvía los datos originales (salvo que esten truncados)
+  passThroughAndExit();
+});

package/vendor/theus-arsenal/scripts/hooks/check-hook-enabled.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+'use strict';
+
+// Utilidad de linea de comandos: imprime "yes" o "no" segun si un hook esta
+// habilitado bajo THEUS_DISABLED_HOOKS / THEUS_HOOK_PROFILE.
+// Uso: check-hook-enabled.js <hookId> [perfilesCsv]
+
+const { isHookEnabled } = require('../lib/hook-flags');
+
+const [, , hookId, profilesCsv] = process.argv;
+if (!hookId) {
+  process.stdout.write('yes');
+  process.exit(0);
+}
+
+process.stdout.write(isHookEnabled(hookId, { profiles: profilesCsv }) ? 'yes' : 'no');