@danieltmn/tamnora 0.1.0 → 0.3.0

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

@@ -0,0 +1,113 @@
+import { spawn } from 'node:child_process';
+
+/**
+ * Tuneles publicos. v1 soporta tunnelmole (gratis, sin cuenta; URL aleatoria)
+ * via `npx --yes tunnelmole <puerto>`.
+ */
+
+function killTree(child) {
+  if (!child || child.killed) return;
+  const pid = child.pid;
+  try {
+    if (process.platform === 'win32' && pid) {
+      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+    } else {
+      if (pid) {
+        try {
+          process.kill(-pid, 'SIGTERM');
+        } catch {
+          /* sin grupo */
+        }
+      }
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        /* ya murio */
+      }
+    }
+  } catch {
+    /* ya murio */
+  }
+}
+
+export function parseTunnelmoleUrls(text) {
+  const urls = [...new Set(String(text).match(/https?:\/\/[a-z0-9-]+\.tunnelmole\.net/gi) || [])];
+  return {
+    https: urls.find((u) => u.startsWith('https')) || '',
+    http: urls.find((u) => u.startsWith('http:')) || '',
+  };
+}
+
+function spawnTunnel(bin, args, opts = {}) {
+  const log = opts.log || (() => {});
+  const parse = opts.parse || (() => ({ https: '', http: '' }));
+  const timeoutMs = opts.timeoutMs || 90000;
+  const label = opts.label || bin;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(bin, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        shell: process.platform === 'win32',
+        detached: process.platform !== 'win32',
+      });
+    } catch (err) {
+      reject(new Error(`no se pudo iniciar ${label}: ${err.message}`));
+      return;
+    }
+    let buf = '';
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      killTree(child);
+      reject(new Error(`${label} no devolvio URL (${Math.round(timeoutMs / 1000)} s).`));
+    }, timeoutMs);
+    const feed = (data) => {
+      buf += String(data);
+      if (opts.verbose) process.stdout.write(String(data));
+      const urls = parse(buf);
+      const url = urls.https || urls.http;
+      if (url) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        log(`${label}: ${url} -> localhost:${opts.port}`);
+        resolve({ url, provider: opts.provider, pid: child.pid, stop: () => killTree(child) });
+      }
+    };
+    child.stdout.on('data', feed);
+    child.stderr.on('data', feed);
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`${label}: ${err.message}`));
+    });
+    child.on('exit', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`${label} termino (codigo ${code})${buf ? `: ${buf.slice(0, 200).trim()}` : ''}`));
+    });
+  });
+}
+
+export function startTunnelmole(port, opts = {}) {
+  return spawnTunnel('npx', ['--yes', 'tunnelmole', String(port)], {
+    ...opts,
+    port,
+    provider: 'tunnelmole',
+    label: 'tunnelmole',
+    parse: parseTunnelmoleUrls,
+  });
+}
+
+/** Devuelve { url, provider, pid, stop }. provider 'none' no abre nada. */
+export async function startTunnel(port, provider = 'tunnelmole', opts = {}) {
+  const p = String(provider || 'tunnelmole').toLowerCase();
+  if (p === 'none' || p === 'off' || p === '') return { url: '', provider: 'none', pid: 0, stop: () => {} };
+  if (p === 'tunnelmole' || p === 'tmole') return startTunnelmole(port, opts);
+  throw new Error(`proveedor de tunel no soportado: ${provider}`);
+}

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

@@ -31,3 +31,18 @@ test('provider presets resolve their base URL', () => {
   assert.equal(config.baseUrl, 'https://api.deepseek.com/v1');
   assert.equal(config.apiKey, 'k');
 });
+
+test('custom providers resolve to their own adapter when customProviders is passed', () => {
+  const customProviders = [{ id: 'mi-gw', label: 'Mi Gateway', baseUrl: 'https://gw.local/v1', models: ['m'] }];
+  const { provider, config } = resolveProviderRuntime({
+    providerId: 'mi-gw',
+    baseUrl: 'https://gw.local/v1',
+    customProviders,
+  });
+  assert.equal(provider.id, 'mi-gw');
+  assert.equal(provider.custom, true);
+  assert.equal(config.baseUrl, 'https://gw.local/v1');
+
+  // Sin la definición, cae al adapter por defecto (OpenRouter).
+  assert.equal(resolveProviderRuntime({ providerId: 'mi-gw' }).provider.id, 'openrouter');
+});

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

@@ -0,0 +1,49 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { registryServerToConfig, normalizeMcpConfig } from '../src/mcp/registry.js';
+
+test('registryServerToConfig maps a remote server to http', () => {
+  const cfg = registryServerToConfig({
+    name: 'ac.inference.sh/mcp',
+    title: 'inference.sh',
+    remotes: [{ type: 'streamable-http', url: 'https://sh.inference.ac' }],
+  });
+  assert.equal(cfg.type, 'http');
+  assert.equal(cfg.url, 'https://sh.inference.ac');
+  assert.equal(cfg.id, 'mcp');
+});
+
+test('registryServerToConfig maps an npm package to stdio and lists required env', () => {
+  const cfg = registryServerToConfig({
+    name: 'com.pulsemcp/remote-filesystem',
+    title: 'Remote Filesystem',
+    packages: [
+      {
+        registryType: 'npm',
+        identifier: 'remote-filesystem-mcp-server',
+        version: '0.1.2',
+        runtimeHint: 'npx',
+        runtimeArguments: [{ value: '-y', type: 'positional' }],
+        environmentVariables: [{ name: 'GCS_BUCKET', isRequired: true }, { name: 'GCS_PROJECT_ID' }],
+      },
+    ],
+  });
+  assert.equal(cfg.type, 'stdio');
+  assert.equal(cfg.command, 'npx');
+  assert.deepEqual(cfg.args, ['-y', 'remote-filesystem-mcp-server@0.1.2']);
+  assert.deepEqual(cfg.requiredEnv, ['GCS_BUCKET']);
+});
+
+test('normalizeMcpConfig handles mcpServers snippets and plain configs', () => {
+  const wrapped = normalizeMcpConfig('{"mcpServers":{"files":{"command":"npx","args":["-y","pkg"]}}}', 'fallback');
+  assert.equal(wrapped.id, 'files');
+  assert.equal(wrapped.type, 'stdio');
+  assert.deepEqual(wrapped.args, ['-y', 'pkg']);
+
+  const http = normalizeMcpConfig({ url: 'https://x/mcp' }, 'web');
+  assert.equal(http.type, 'http');
+  assert.equal(http.url, 'https://x/mcp');
+
+  assert.throws(() => normalizeMcpConfig('{bad json}', 'x'), /no es valido/);
+  assert.throws(() => normalizeMcpConfig({}, 'x'), /command|url/);
+});

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

@@ -0,0 +1,34 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW } from '../src/procs/detect.js';
+
+test('detectProcs finds node dev scripts with the right package manager', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
+  await writeFile(path.join(dir, 'package.json'), JSON.stringify({ scripts: { dev: 'vite', test: 'x' } }));
+  await writeFile(path.join(dir, 'pnpm-lock.yaml'), '');
+  assert.equal(packageManager(dir), 'pnpm');
+
+  const chips = detectProcs(dir);
+  const dev = chips.find((c) => c.command === 'pnpm' && c.args.includes('dev'));
+  assert.ok(dev);
+  assert.equal(dev.cwd, dir);
+  assert.ok(DEFAULT_PROCESS_ALLOW.includes('pnpm'));
+});
+
+test('detectProcs falls back to npm and detects php entrypoints', async () => {
+  const nodeDir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
+  await writeFile(path.join(nodeDir, 'package.json'), JSON.stringify({ scripts: { start: 'node app.js' } }));
+  assert.equal(packageManager(nodeDir), 'npm');
+  assert.ok(detectProcs(nodeDir).some((c) => c.command === 'npm' && c.args.includes('start')));
+
+  const phpDir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));
+  await mkdir(path.join(phpDir, 'public'));
+  await writeFile(path.join(phpDir, 'public', 'index.php'), '<?php');
+  const chips = detectProcs(phpDir);
+  const php = chips.find((c) => c.command === 'php');
+  assert.ok(php);
+  assert.equal(php.args[0], '-S');
+});

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

@@ -3,6 +3,8 @@ import assert from 'node:assert/strict';
 import { Store } from '../src/storage/sqlite.js';
 import { composeProviderSettings } from '../src/config/providers.js';
 import { toOllamaMessages } from '../src/providers/ollama.js';
+import { providerFetch } from '../src/providers/utils.js';
+import { isRetryableError } from '../src/providers/resilience.js';
 
 test('Store persists providers and settings', () => {
   const store = new Store(':memory:');
@@ -78,3 +80,21 @@ test('composeProviderSettings merges stored over config', () => {
   });
   assert.deepEqual(custom.customProviders, [{ id: 'my-gw', label: 'Mi Gateway', baseUrl: 'https://gw', models: ['m1'] }]);
 });
+
+test('providerFetch turns network failures into a readable, retryable error', async () => {
+  const original = globalThis.fetch;
+  const cause = Object.assign(new Error('connect ECONNREFUSED 127.9.9.9:443'), { code: 'ECONNREFUSED' });
+  globalThis.fetch = async () => {
+    throw Object.assign(new TypeError('fetch failed'), { cause });
+  };
+  try {
+    await assert.rejects(providerFetch('https://openrouter.ai/api/v1/models'), (err) => {
+      assert.match(err.message, /No se pudo conectar con openrouter\.ai/);
+      assert.equal(err.code, 'ECONNREFUSED');
+      assert.equal(isRetryableError(err), true);
+      return true;
+    });
+  } finally {
+    globalThis.fetch = original;
+  }
+});

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

@@ -52,6 +52,7 @@ test('isRetryableError classifies statuses and codes', () => {
   assert.equal(isRetryableError({ status: 503 }), true);
   assert.equal(isRetryableError({ status: 401 }), false);
   assert.equal(isRetryableError({ code: 'ETIMEDOUT' }), true);
+  assert.equal(isRetryableError({ message: 'No se pudo conectar', cause: { code: 'ECONNREFUSED' } }), true);
   assert.equal(isRetryableError({ name: 'AbortError' }), false);
 });
 

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

@@ -0,0 +1,69 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt } from '../src/skills/index.js';
+import { parseSkillRef } from '../src/skills/remote.js';
+
+test('parseSkillMarkdown reads frontmatter and body', () => {
+  const parsed = parseSkillMarkdown(
+    '---\nname: Revisar PR\ndescription: Revisa cambios\nwhen: al abrir un PR\n---\n\n# Pasos\n1. Mirá el diff.',
+    'revisar-pr'
+  );
+  assert.equal(parsed.name, 'Revisar PR');
+  assert.equal(parsed.description, 'Revisa cambios');
+  assert.equal(parsed.when, 'al abrir un PR');
+  assert.match(parsed.body, /Mirá el diff/);
+
+  const plain = parseSkillMarkdown('Solo un cuerpo.', 'x');
+  assert.equal(plain.name, 'x');
+  assert.equal(plain.body, 'Solo un cuerpo.');
+});
+
+test('loadSkills scans a root and mergeSkills lets later roots win', async () => {
+  const home = await mkdtemp(path.join(tmpdir(), 'tamnora-skills-'));
+  await mkdir(path.join(home, 'demo'));
+  await writeFile(path.join(home, 'demo', 'SKILL.md'), '---\nname: Demo\n---\nCuerpo casa.');
+  await mkdir(path.join(home, 'otra'));
+  await writeFile(path.join(home, 'otra', 'SKILL.md'), 'Sin frontmatter.');
+
+  const skills = loadSkills(home);
+  assert.deepEqual(
+    skills.map((s) => s.id),
+    ['demo', 'otra']
+  );
+  assert.equal(loadSkills(path.join(home, 'nope')).length, 0);
+
+  const workspace = await mkdtemp(path.join(tmpdir(), 'tamnora-skills-ws-'));
+  await mkdir(path.join(workspace, 'demo'));
+  await writeFile(path.join(workspace, 'demo', 'SKILL.md'), '---\nname: Demo WS\n---\nCuerpo workspace.');
+  const merged = mergeSkills([loadSkills(home), loadSkills(workspace)]);
+  assert.equal(merged.find((s) => s.id === 'demo').name, 'Demo WS');
+});
+
+test('parseSkillRef accepts skills.sh URLs, GitHub URLs and ids', () => {
+  assert.deepEqual(parseSkillRef('https://skills.sh/vercel-labs/skills/find-skills'), {
+    owner: 'vercel-labs',
+    repo: 'skills',
+    slug: 'find-skills',
+  });
+  assert.deepEqual(parseSkillRef('anthropics/skills/frontend-design'), {
+    owner: 'anthropics',
+    repo: 'skills',
+    slug: 'frontend-design',
+  });
+  assert.deepEqual(parseSkillRef('https://github.com/vercel-labs/skills'), {
+    owner: 'vercel-labs',
+    repo: 'skills',
+    slug: null,
+  });
+  assert.equal(parseSkillRef('solo-un-slug'), null);
+});
+
+test('buildSkillsPrompt lists enabled skills and is empty without skills', () => {
+  assert.equal(buildSkillsPrompt([]), '');
+  const text = buildSkillsPrompt([{ id: 'demo', name: 'Demo', description: 'desc', body: 'Hacé X.' }]);
+  assert.match(text, /Demo/);
+  assert.match(text, /Hacé X\./);
+});

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

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { resolveInRoot, toRel } from '../src/tools/paths.js';
 import { evaluatePermission } from '../src/tools/permissions.js';
 import { createTools, createToolRegistry } from '../src/tools/index.js';
+import { fetchUrlTool } from '../src/tools/executors.js';
 
 async function makeWorkspace() {
   const root = await mkdtemp(path.join(tmpdir(), 'tamnora-ws-'));
@@ -74,6 +75,15 @@ test('permission "ask" is denied by default and allowed with yes', async () => {
     assert.match(await allowed.execute('write', { path: 'z.txt', content: 'z' }), /Creado|Escrito/);
 });
 
+test('fetchUrlTool rejects invalid URLs and private hosts', async () => {
+  const root = await makeWorkspace();
+  assert.match(await fetchUrlTool(root, { url: 'not-a-url' }), /URL inválida/);
+  assert.match(await fetchUrlTool(root, { url: 'ftp://example.com' }), /http\/https/);
+  assert.match(await fetchUrlTool(root, { url: 'http://127.0.0.1:9/' }), /host bloqueado/);
+  assert.match(await fetchUrlTool(root, { url: 'http://192.168.1.10/' }), /host bloqueado/);
+  assert.match(await fetchUrlTool(root, { url: 'http://169.254.169.254/' }), /host bloqueado/);
+});
+
 test('createTools combines local and MCP tool routing', async () => {
   const root = await makeWorkspace();
   const mcp = {