@danieltmn/tamnora 0.6.1 → 0.7.0

package/harness/packages/core/src/redact.js

@@ -0,0 +1,104 @@
+// Redaccion de secretos para no filtrarlos a la conversacion (y de ahi al
+// historial, a la UI o a un canal de mensajeria). Es defensa en profundidad:
+// la barrera principal es no inyectar secretos en el entorno de los MCP.
+
+import { getEnv } from './env.js';
+
+/** Un nombre de variable "sensible" (token, password, key, credencial...). */
+const SECRET_NAME = /(TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTH|COOKIE|SESSION)/i;
+
+/** Patrones de tokens conocidos, utiles aunque no vengan de una variable. */
+const SECRET_PATTERNS = [
+  /npm_[A-Za-z0-9]{16,}/g,
+  /sk-[A-Za-z0-9_-]{16,}/g,
+  /ghp_[A-Za-z0-9]{20,}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  /AIza[0-9A-Za-z_-]{30,}/g,
+  /xox[baprs]-[A-Za-z0-9-]{10,}/g,
+  /ya29\.[A-Za-z0-9_-]{20,}/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+];
+
+export const REDACTED = '[REDACTADO]';
+
+/** ¿El nombre de la variable parece contener un secreto? */
+export function isSecretName(name) {
+  return SECRET_NAME.test(String(name ?? ''));
+}
+
+/**
+ * Valores de entorno que hay que redactar: los de variables con nombre
+ * sensible y al menos 8 caracteres (evita tapar valores triviales).
+ * @param {Record<string,string>} [env]
+ * @returns {string[]} ordenados de mayor a menor (los mas largos primero)
+ */
+export function secretValues(env = getEnv()) {
+  const values = new Set();
+  for (const [name, value] of Object.entries(env ?? {})) {
+    if (!isSecretName(name)) continue;
+    const text = String(value ?? '');
+    if (text.length >= 8) values.add(text);
+  }
+  return [...values].sort((a, b) => b.length - a.length);
+}
+
+/**
+ * Redacta secretos conocidos (valores de env sensibles + patrones de tokens).
+ * @param {string} text
+ * @param {{env?:Record<string,string>, extra?:string[]}} [opts]
+ * @returns {string}
+ */
+export function redactSecrets(text, { env, extra = [] } = {}) {
+  let output = String(text ?? '');
+  if (!output) return output;
+
+  const values = [...secretValues(env), ...extra].filter((v) => v && v.length >= 8);
+  for (const value of values) {
+    if (output.includes(value)) output = output.split(value).join(REDACTED);
+  }
+  for (const pattern of SECRET_PATTERNS) {
+    output = output.replace(pattern, REDACTED);
+  }
+  return output;
+}
+
+/**
+ * Redacta recursivamente strings y valores bajo claves sensibles en un objeto.
+ * @param {unknown} value
+ * @param {{env?:Record<string,string>, extra?:string[]}} [opts]
+ */
+export function redactDeep(value, opts = {}) {
+  if (typeof value === 'string') return redactSecrets(value, opts);
+  if (Array.isArray(value)) return value.map((item) => redactDeep(item, opts));
+  if (value && typeof value === 'object') {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = isSecretName(key) ? REDACTED : redactDeep(item, opts);
+    }
+    return result;
+  }
+  return value;
+}
+
+/**
+ * Enmascara un valor para mostrarlo al cliente (nunca el secreto completo).
+ * `env:VAR` se conserva para que se vea la indireccion.
+ */
+export function maskSecret(value) {
+  const text = String(value ?? '');
+  if (!text) return '';
+  if (text.startsWith('env:')) return text;
+  if (text.length <= 4) return '••••';
+  return `••••${text.slice(-4)}`;
+}
+
+/** Enmascara un mapa de env para devolverlo por la API. */
+export function maskEnv(env) {
+  if (!env || typeof env !== 'object') return env ?? null;
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = isSecretName(key) ? maskSecret(value) : String(value ?? '');
+  }
+  return result;
+}

package/harness/packages/core/test/agent.test.js

@@ -235,3 +235,96 @@ test('agent aggregates usage and stamps tokens on assistant messages', async ()
   assert.equal(assistants[1].tokens_in, 20);
   assert.equal(assistants[1].tokens_out, 5);
 });
+
+test('agent sigue solo hasta end_turn sin tope de rondas', async () => {
+  let round = 0;
+  const provider = {
+    async streamChat(_config, { tools }) {
+      if (!tools || tools.length === 0) return { content: 'listo', reasoning: '', toolCalls: [] };
+      round += 1;
+      if (round <= 10) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [{ id: `c${round}`, function: { name: 'step', arguments: JSON.stringify({ n: round }) } }],
+        };
+      }
+      return { content: 'terminado', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'step', parameters: {} } }],
+    execute: async () => 'ok',
+  });
+
+  assert.equal(result.stopReason, 'end_turn');
+  assert.equal(result.rounds, 11);
+  assert.equal(result.content, 'terminado');
+});
+
+test('agent corta por no progreso y cierra con resumen sin tools', async () => {
+  const provider = {
+    async streamChat(_config, { tools }) {
+      if (!tools || tools.length === 0) return { content: 'resumen final', reasoning: '', toolCalls: [] };
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [{ id: 'x', function: { name: 'noop', arguments: '{}' } }],
+      };
+    },
+  };
+  let executions = 0;
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'noop', parameters: {} } }],
+    execute: async () => {
+      executions += 1;
+      return 'ok';
+    },
+    repeatLimit: 2,
+  });
+
+  assert.equal(result.stopReason, 'no_progress');
+  assert.equal(result.wrappedUp, true);
+  assert.equal(result.content, 'resumen final');
+  assert.equal(executions, 2);
+});
+
+test('agent respeta el presupuesto de tokens y cierra con resumen', async () => {
+  let round = 0;
+  const provider = {
+    async streamChat(_config, { tools }) {
+      if (!tools || tools.length === 0) {
+        return { content: 'cierre', reasoning: '', toolCalls: [], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } };
+      }
+      round += 1;
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [{ id: `c${round}`, function: { name: 'step', arguments: JSON.stringify({ n: round }) } }],
+        usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
+      };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'step', parameters: {} } }],
+    execute: async () => 'ok',
+    maxTokens: 50,
+  });
+
+  assert.equal(result.stopReason, 'budget');
+  assert.equal(result.content, 'cierre');
+});

package/harness/packages/core/test/mcp.test.js

@@ -6,7 +6,9 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import {
   buildMcpRegistry,
+  childEnv,
   connectMcpStdioServer,
+  mcpResultToText,
   mcpTransport,
 } from '../src/index.js';
 
@@ -156,3 +158,68 @@ test('buildMcpRegistry connects over HTTP (JSON responses)', async () => {
     server.close();
   }
 });
+
+const ENV_SERVER = `
+import readline from 'node:readline';
+readline.createInterface({ input: process.stdin }).on('line', (line) => {
+  if (!line.trim()) return;
+  const m = JSON.parse(line);
+  let r = null;
+  if (m.method === 'initialize') r = { jsonrpc: '2.0', id: m.id, result: { protocolVersion: '2025-06-18', capabilities: { tools: {} } } };
+  else if (m.method === 'tools/list') r = { jsonrpc: '2.0', id: m.id, result: { tools: [{ name: 'env', inputSchema: { type: 'object' } }] } };
+  else if (m.method === 'tools/call') r = { jsonrpc: '2.0', id: m.id, result: { content: [{ type: 'text', text: String(process.env.TAMNORA_TEST_VALUE ?? '') }] } };
+  if (r) process.stdout.write(JSON.stringify(r) + '\\n');
+});
+`;
+
+async function makeEnvServer() {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-mcp-env-'));
+  const file = path.join(dir, 'env-server.mjs');
+  await writeFile(file, ENV_SERVER);
+  return { id: 'env', command: process.execPath, args: [file] };
+}
+
+test('childEnv no hereda process.env por defecto y resuelve env:VAR', () => {
+  process.env.TAMNORA_TEST_VALUE = 'visible123';
+  try {
+    assert.equal(childEnv({}).TAMNORA_TEST_VALUE, undefined);
+    const declared = childEnv({ env: { VAL: 'env:TAMNORA_TEST_VALUE' } });
+    assert.equal(declared.VAL, 'visible123');
+    assert.equal(childEnv({ inheritEnv: true }).TAMNORA_TEST_VALUE, 'visible123');
+  } finally {
+    delete process.env.TAMNORA_TEST_VALUE;
+  }
+});
+
+test('un MCP stdio no ve el entorno del padre salvo inheritEnv o env declarado', async () => {
+  process.env.TAMNORA_TEST_VALUE = 'visible123';
+  try {
+    const hidden = await connectMcpStdioServer(await makeEnvServer());
+    assert.equal(await hidden.callTool('env', {}), '');
+    hidden.close();
+
+    const declared = await connectMcpStdioServer({
+      ...(await makeEnvServer()),
+      env: { TAMNORA_TEST_VALUE: 'env:TAMNORA_TEST_VALUE' },
+    });
+    assert.equal(await declared.callTool('env', {}), 'visible123');
+    declared.close();
+
+    const inherited = await connectMcpStdioServer({ ...(await makeEnvServer()), inheritEnv: true });
+    assert.equal(await inherited.callTool('env', {}), 'visible123');
+    inherited.close();
+  } finally {
+    delete process.env.TAMNORA_TEST_VALUE;
+  }
+});
+
+test('mcpResultToText redacta secretos del entorno', () => {
+  process.env.TAMNORA_TEST_SECRET = 'ultrasecreto123';
+  try {
+    const text = mcpResultToText({ content: [{ type: 'text', text: 'valor=ultrasecreto123 fin' }] });
+    assert.match(text, /REDACTADO/);
+    assert.doesNotMatch(text, /ultrasecreto123/);
+  } finally {
+    delete process.env.TAMNORA_TEST_SECRET;
+  }
+});

package/harness/packages/core/test/redact.test.js

@@ -0,0 +1,45 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  REDACTED,
+  isSecretName,
+  maskEnv,
+  maskSecret,
+  redactDeep,
+  redactSecrets,
+  secretValues,
+} from '../src/redact.js';
+
+test('isSecretName detecta nombres sensibles', () => {
+  assert.equal(isSecretName('NPM_TOKEN'), true);
+  assert.equal(isSecretName('MYSQL_PASSWORD'), true);
+  assert.equal(isSecretName('OPENAI_API_KEY'), true);
+  assert.equal(isSecretName('PATH'), false);
+  assert.equal(isSecretName('USERNAME'), false);
+});
+
+test('secretValues toma valores de nombres sensibles (>= 8 chars)', () => {
+  const values = secretValues({ NPM_TOKEN: 'npm_abcdefgh', PATH: '/usr/bin', SHORT: 'x' });
+  assert.deepEqual(values, ['npm_abcdefgh']);
+});
+
+test('redactSecrets tapa valores de env y patrones conocidos', () => {
+  const env = { NPM_TOKEN: 'npm_secretvalue123456' };
+  assert.equal(redactSecrets('token= npm_secretvalue123456', { env }), `token= ${REDACTED}`);
+  assert.equal(redactSecrets('ghp_abcdefghijklmnopqrst'), REDACTED);
+  assert.equal(redactSecrets('hola mundo'), 'hola mundo');
+});
+
+test('redactDeep tapa claves sensibles dentro de objetos', () => {
+  const result = redactDeep({ user: 'ana', password: 'hunter2', nested: { apiKey: 'abc123' } });
+  assert.deepEqual(result, { user: 'ana', password: REDACTED, nested: { apiKey: REDACTED } });
+});
+
+test('maskSecret y maskEnv enmascaran sin exponer el valor', () => {
+  assert.equal(maskSecret('supersecret'), '••••cret');
+  assert.equal(maskSecret('env:NPM_TOKEN'), 'env:NPM_TOKEN');
+  assert.deepEqual(maskEnv({ MYSQL_HOST: 'db.local', MYSQL_PASSWORD: 'supersecret' }), {
+    MYSQL_HOST: 'db.local',
+    MYSQL_PASSWORD: '••••cret',
+  });
+});