@danieltmn/tamnora 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -5,6 +5,31 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.3.0] - 2026-10-02
+
+### Agregado
+
+- Tool local `fetch_url` (http/https) para que el agente pueda leer docs, APIs y
+  archivos remotos; bloquea hosts privados/loopback y tiene timeout y tope de
+  tamano. Disponible en CLI/TUI/consola/Telegram y en modo plan.
+- Importar **skills desde skills.sh**: `POST /api/skills/import` y la tool
+  `install_skill` aceptan una URL de skills.sh o un id `owner/repo/skill`, bajan
+  el `SKILL.md` (y archivos de apoyo) desde GitHub y lo instalan en la casa.
+  (La API de skills.sh pide token OIDC de Vercel; resolvemos por GitHub.)
+- Importar **servidores MCP**: `POST /api/mcp/import` y la tool `install_mcp`
+  aceptan el nombre del registro oficial de MCP, un snippet JSON (bloque
+  `mcpServers`) o una URL del registro. `mcpservers.org` esta detras de
+  Cloudflare y no se puede leer desde el server; se puede pegar su JSON.
+- Consola (ajustes): barras para importar skills y MCP, con estado y aviso de
+  variables de entorno requeridas.
+
+### Pendiente
+
+- Confirmar el proveedor Xiaomi (`mimo-v2.6-flash`): respondio `429 Too Many
+  Requests` (cuota/rate limit del endpoint), no del harness.
+- Telegram: audio y voz (transcribir notas de voz y responder con audio).
+- Plugins: cargador de plugins locales (fase 2 del apartado ajustes).
+
 ## [0.2.0] - 2026-10-02
 
 ### Agregado
@@ -43,15 +68,6 @@ y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
   `No se pudo conectar con <host>...` en vez del crudo `fetch failed` (el error
   conserva el `code` para seguir siendo reintentable).
 
-### Pendiente
-
-- Publicar el fix de proveedores custom como patch (`npm run release -- patch`)
-  para que `npm i -g @danieltmn/tamnora` lo incluya; la 0.1.0 publicada todavia
-  tiene el bug.
-- Confirmar el proveedor Xiaomi (`mimo-v2.6-flash`): en la prueba respondio
-  `429 Too Many Requests` (cuota/rate limit del endpoint), no del harness.
-- Cerrar la revision del sitio en `website/` (contenido ya alineado al harness).
-
 ## [0.1.0] - 2026-10-01
 
 ### Agregado

package/harness/packages/core/src/agent/modes.js

@@ -13,7 +13,7 @@ export const MODES = {
     id: 'plan',
     label: 'Plan',
     description: 'Solo lectura: investiga y propone un plan, sin modificar nada.',
-    tools: ['read', 'list', 'glob', 'grep', 'git_status', 'git_diff', 'git_log'],
+    tools: ['read', 'list', 'glob', 'grep', 'fetch_url', 'git_status', 'git_diff', 'git_log'],
     systemPrompt:
       'Estás en modo PLAN: no modifiques archivos ni ejecutes comandos. Investigá el proyecto con las herramientas de solo lectura y respondé con un plan concreto y accionable.',
   },

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

@@ -71,6 +71,13 @@ export { summarize } from './eval/report.js';
 export { runScorers, validateSchema, extractJson, SCORERS } from './eval/scorers.js';
 export { createJudge } from './eval/judge.js';
 export { createTaskWorkspace, normalizeExpect } from './eval/task.js';
-export { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt } from './skills/index.js';
+export { parseSkillMarkdown, loadSkills, mergeSkills, writeSkillFiles, buildSkillsPrompt } from './skills/index.js';
+export { parseSkillRef, fetchSkillFromGithub } from './skills/remote.js';
+export {
+  searchMcpRegistry,
+  getMcpRegistryServer,
+  registryServerToConfig,
+  normalizeMcpConfig,
+} from './mcp/registry.js';
 export { parseTunnelmoleUrls, startTunnelmole, startTunnel } from './tunnel.js';
 export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW } from './procs/detect.js';

package/harness/packages/core/src/mcp/registry.js

@@ -0,0 +1,117 @@
+// Cliente del registro oficial de MCP (registry.modelcontextprotocol.io) y
+// normalizador de configs para importar servidores desde JSON.
+
+import { providerFetch } from '../providers/utils.js';
+
+const REGISTRY = 'https://registry.modelcontextprotocol.io';
+
+function slugifyId(name) {
+  return String(name ?? '')
+    .split('/')
+    .pop()
+    .replace(/[^a-z0-9_-]+/gi, '-')
+    .replace(/^-+|-+$/g, '')
+    .toLowerCase()
+    .slice(0, 40);
+}
+
+/** Busca servidores en el registro oficial. Devuelve la lista de `server`. */
+export async function searchMcpRegistry(query, { limit = 10 } = {}) {
+  const url = new URL(`${REGISTRY}/v0/servers`);
+  if (query) url.searchParams.set('search', String(query));
+  url.searchParams.set('limit', String(limit));
+  const res = await providerFetch(url.toString(), {
+    headers: { 'User-Agent': 'tamnora-harness', Accept: 'application/json' },
+  });
+  if (!res.ok) throw new Error(`El registro MCP respondio HTTP ${res.status}`);
+  const data = await res.json();
+  return (data.servers ?? []).map((entry) => entry.server ?? entry);
+}
+
+/** Busca por nombre exacto; con `strict` no cae en el primer resultado difuso. */
+export async function getMcpRegistryServer(query, { strict = false } = {}) {
+  const servers = await searchMcpRegistry(query, { limit: 10 });
+  const exact = servers.find(
+    (s) => s.name === query || s.title === query || slugifyId(s.name) === slugifyId(query)
+  );
+  if (exact) return exact;
+  return strict ? null : servers[0] ?? null;
+}
+
+/** Mapea un server del registro oficial a nuestra config de `mcp[]`. */
+export function registryServerToConfig(server) {
+  if (!server?.name) throw new Error('El servidor no tiene nombre.');
+  const id = slugifyId(server.name) || 'mcp';
+  const remote = (server.remotes ?? [])[0];
+  if (remote?.url) {
+    return { id, name: server.title || server.name, type: 'http', url: remote.url, enabled: true };
+  }
+  const pkg = (server.packages ?? [])[0];
+  if (pkg) {
+    const runtime = pkg.runtimeHint || (pkg.registryType === 'npm' ? 'npx' : 'uvx');
+    const args = [];
+    for (const arg of pkg.runtimeArguments ?? []) if (arg.type === 'positional' && arg.value) args.push(arg.value);
+    if (runtime === 'npx' && !args.includes('-y')) args.unshift('-y');
+    args.push(`${pkg.identifier}${pkg.version ? `@${pkg.version}` : ''}`);
+    const env = {};
+    for (const variable of pkg.environmentVariables ?? []) env[variable.name] = '';
+    const requiredEnv = (pkg.environmentVariables ?? []).filter((v) => v.isRequired).map((v) => v.name);
+    return {
+      id,
+      name: server.title || server.name,
+      type: 'stdio',
+      command: runtime,
+      args,
+      env,
+      requiredEnv,
+      enabled: true,
+    };
+  }
+  throw new Error('El servidor del registro no tiene remotes ni packages compatibles.');
+}
+
+/**
+ * Normaliza un snippet JSON a nuestra config. Acepta:
+ *  - `{ command, args, env }` o `{ url }`
+ *  - `{ mcpServers: { nombre: {...} } }` (formato Claude Desktop / mcpservers.org)
+ */
+export function normalizeMcpConfig(input, fallbackId = 'mcp') {
+  let value = input;
+  if (typeof value === 'string') {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      throw new Error('El JSON no es valido.');
+    }
+  }
+  if (!value || typeof value !== 'object') throw new Error('Falta la config del servidor.');
+
+  let id = fallbackId;
+  let def = value;
+  const servers = value.mcpServers ?? value.mcp_servers;
+  if (servers && typeof servers === 'object') {
+    const key = Object.keys(servers)[0];
+    if (!key) throw new Error('El bloque "mcpServers" esta vacio.');
+    id = key;
+    def = servers[key];
+  }
+  if (value.id) id = String(value.id);
+  if (!def || typeof def !== 'object') throw new Error('Config invalida.');
+
+  const url = def.url ?? def.serverUrl;
+  const command = def.command;
+  if (!url && !command) throw new Error('La config necesita "command" (stdio) o "url" (http).');
+
+  const rawArgs = def.args ?? def.arguments ?? [];
+  const args = Array.isArray(rawArgs) ? rawArgs.map(String) : String(rawArgs).split(/\s+/).filter(Boolean);
+  return {
+    id: slugifyId(id) || fallbackId,
+    name: def.name || id,
+    type: url ? 'http' : 'stdio',
+    command: url ? undefined : String(command),
+    args: url ? [] : args,
+    url: url ? String(url) : undefined,
+    env: def.env && typeof def.env === 'object' ? def.env : undefined,
+    enabled: def.enabled !== false,
+  };
+}

package/harness/packages/core/src/skills/index.js

@@ -3,6 +3,7 @@
 // las que esten habilitadas.
 
 import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 /** Parse a SKILL.md: frontmatter `--- key: value ---` plus body. */
@@ -59,6 +60,23 @@ export function mergeSkills(rootLists = []) {
   return [...byId.values()];
 }
 
+/** Escribe los archivos de una skill en `dir` (con guarda de traversal). */
+export async function writeSkillFiles(dir, files = []) {
+  const root = path.resolve(dir);
+  for (const file of files) {
+    const rel = String(file.path ?? '')
+      .replace(/\\/g, '/')
+      .replace(/^\/+/, '');
+    if (!rel) continue;
+    const target = path.resolve(root, rel);
+    if (target !== root && !target.startsWith(root + path.sep)) {
+      throw new Error(`Ruta de skill inválida: ${file.path}`);
+    }
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, String(file.contents ?? ''), 'utf8');
+  }
+}
+
 /** Text block appended to the system prompt with the enabled skills. */
 export function buildSkillsPrompt(skills = []) {
   if (!skills.length) return '';

package/harness/packages/core/src/skills/remote.js

@@ -0,0 +1,80 @@
+// Importa skills desde skills.sh resolviendolas por GitHub (la API de skills.sh
+// requiere un token OIDC de Vercel, pero los skills salen de repos de GitHub).
+
+const GITHUB_API = 'https://api.github.com';
+const RAW = 'https://raw.githubusercontent.com';
+
+/**
+ * Acepta una URL de skills.sh (`https://skills.sh/<owner>/<repo>/<slug>`), una
+ * de GitHub, o un id `owner/repo[/slug]`. Devuelve `{ owner, repo, slug }`.
+ */
+export function parseSkillRef(input) {
+  const raw = String(input ?? '').trim();
+  if (!raw) return null;
+  let url = null;
+  try {
+    url = new URL(raw);
+  } catch {
+    url = null;
+  }
+  if (url) {
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (/(^|\.)skills\.sh$/i.test(url.hostname) && parts.length >= 3) {
+      return { owner: parts[0], repo: parts[1], slug: parts[2] };
+    }
+    if (url.hostname === 'github.com' && parts.length >= 2) {
+      return { owner: parts[0], repo: parts[1], slug: parts[2] ?? null };
+    }
+    return null;
+  }
+  const parts = raw.replace(/^\/+/, '').split('/').filter(Boolean);
+  if (parts.length === 3) return { owner: parts[0], repo: parts[1], slug: parts[2] };
+  if (parts.length === 2) return { owner: parts[0], repo: parts[1], slug: null };
+  return null;
+}
+
+async function ghJson(url) {
+  const res = await fetch(url, {
+    headers: { 'User-Agent': 'tamnora-harness', Accept: 'application/vnd.github+json' },
+  });
+  if (!res.ok) throw new Error(`GitHub respondio HTTP ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Baja los archivos de una skill (`SKILL.md` y los del mismo directorio) desde
+ * el repositorio de GitHub. Sin `slug`, toma el `SKILL.md` de la raiz.
+ */
+export async function fetchSkillFromGithub({ owner, repo, slug }) {
+  const meta = await ghJson(`${GITHUB_API}/repos/${owner}/${repo}`);
+  const ref = meta.default_branch || 'main';
+  const tree = await ghJson(`${GITHUB_API}/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=1`);
+  const entries = (tree.tree ?? []).filter((e) => e.type === 'blob');
+
+  let dir = null;
+  if (slug) {
+    const matches = entries
+      .filter((e) => e.path.endsWith(`/${slug}/SKILL.md`) || e.path === `${slug}/SKILL.md`)
+      .sort((a, b) => a.path.length - b.path.length);
+    if (matches.length) dir = matches[0].path.slice(0, -'SKILL.md'.length).replace(/\/$/, '');
+  }
+  if (dir === null && !slug) {
+    const root = entries.find((e) => e.path === 'SKILL.md');
+    if (root) dir = '';
+  }
+  if (dir === null) throw new Error(`No encontre la skill "${slug ?? repo}" en ${owner}/${repo}.`);
+
+  const prefix = dir ? `${dir}/` : '';
+  const paths = entries
+    .filter((e) => e.path.startsWith(prefix) && e.path !== prefix)
+    .map((e) => e.path);
+  if (!paths.some((p) => p === `${prefix}SKILL.md`)) throw new Error('La skill no tiene SKILL.md.');
+
+  const files = [];
+  for (const path of paths) {
+    const res = await fetch(`${RAW}/${owner}/${repo}/${encodeURIComponent(ref)}/${path}`);
+    if (!res.ok) continue;
+    files.push({ path: path.slice(prefix.length), contents: await res.text() });
+  }
+  return { id: slug || repo, source: `${owner}/${repo}`, slug: slug || repo, files };
+}

package/harness/packages/core/src/tools/executors.js

@@ -11,6 +11,60 @@ const MAX_GLOB = 500;
 const MAX_GREP = 300;
 const MAX_GREP_FILE_BYTES = 2_000_000;
 const MAX_BASH_OUTPUT = 100_000;
+const FETCH_TIMEOUT_MS = 20000;
+const MAX_FETCH_CHARS = 200_000;
+
+function isBlockedHost(hostname) {
+  const h = String(hostname ?? '')
+    .toLowerCase()
+    .replace(/^\[|\]$/g, '');
+  if (h === 'localhost' || h.endsWith('.localhost') || h.endsWith('.local')) return true;
+  if (h === '::1' || h === '0.0.0.0') return true;
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (!m) return false;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  if (a === 127 || a === 10 || a === 0) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  return false;
+}
+
+export async function fetchUrlTool(_root, { url, maxLength } = {}) {
+  let target;
+  try {
+    target = new URL(String(url ?? ''));
+  } catch {
+    return 'Error: URL inválida.';
+  }
+  if (!/^https?:$/.test(target.protocol)) return 'Error: solo se permite http/https.';
+  if (isBlockedHost(target.hostname)) return `Error: host bloqueado (${target.hostname}).`;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(target.toString(), {
+      redirect: 'follow',
+      signal: controller.signal,
+      headers: {
+        'User-Agent': 'tamnora-harness (+https://github.com/tamnora/tamnora-harness)',
+        Accept: '*/*',
+      },
+    });
+    const type = res.headers.get('content-type') || '';
+    const limit = Math.min(Math.max(Number(maxLength) || 20000, 500), MAX_FETCH_CHARS);
+    const text = await res.text();
+    const body = text.slice(0, limit);
+    const truncated = text.length > limit ? `\n[... truncado ${text.length - limit} caracteres]` : '';
+    return `${res.status} ${res.statusText || ''} · ${type || 'sin content-type'} · ${target.toString()}\n\n${body}${truncated}`;
+  } catch (err) {
+    if (err?.name === 'AbortError') return `Error: timeout (${FETCH_TIMEOUT_MS / 1000}s) al pedir ${target}.`;
+    return `Error de red al pedir ${target}: ${err?.message ?? err}`;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 export async function readTool(root, { path: p, offset, limit } = {}) {
   const abs = resolveInRoot(root, p);
@@ -270,6 +324,7 @@ export const EXECUTORS = {
   glob: globTool,
   grep: grepTool,
   bash: bashTool,
+  fetch_url: fetchUrlTool,
   git_status: gitStatusTool,
   git_diff: gitDiffTool,
   git_log: gitLogTool,

package/harness/packages/core/src/tools/permissions.js

@@ -12,6 +12,7 @@ export const DEFAULT_PERMISSIONS = {
   git_status: 'allow',
   git_diff: 'allow',
   git_log: 'allow',
+  fetch_url: 'allow',
   write: 'ask',
   edit: 'ask',
   bash: 'ask',
@@ -40,6 +41,7 @@ function matchPattern(pattern, subject) {
 function subjectFor(name, args) {
   if (name === 'bash') return args?.command ?? '';
   if (name === 'git_commit') return args?.message ?? '';
+  if (name === 'fetch_url') return args?.url ?? '';
   return args?.path ?? '';
 }
 

package/harness/packages/core/src/tools/schema.js

@@ -116,6 +116,22 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'fetch_url',
+      description:
+        'Fetch a URL over http(s) and return its text content (status, content-type and body). Use it to read docs, APIs or raw files.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Absolute http(s) URL' },
+          maxLength: { type: 'integer', description: 'Max characters of the body (default 20000)' },
+        },
+        required: ['url'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {

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/skills.test.js

@@ -4,6 +4,7 @@ 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(
@@ -41,6 +42,25 @@ test('loadSkills scans a root and mergeSkills lets later roots win', async () =>
   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.' }]);

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 = {

package/harness/packages/server/public/app.js

@@ -2124,8 +2124,52 @@ async function submitSkill(event) {
   refreshSkills();
 }
 
+async function importMcp() {
+  const input = $('#mcp-import');
+  const value = input.value.trim();
+  if (!value) return;
+  setStatus('#mcp-import-status', 'importando…');
+  const payload = value.startsWith('{')
+    ? { json: value }
+    : /^https?:\/\//i.test(value)
+      ? { url: value }
+      : { name: value };
+  const data = await api('/api/mcp/import', { method: 'POST', body: payload }).catch((e) => ({ error: e.message }));
+  if (data?.error) return setStatus('#mcp-import-status', data.error, 'err');
+  input.value = '';
+  const required = (data.requiredEnv ?? []).length ? ` · requiere env: ${data.requiredEnv.join(', ')}` : '';
+  setStatus('#mcp-import-status', `Importado ${data.imported}${required}`, 'ok');
+  refreshMcp();
+}
+
+async function importSkill() {
+  const input = $('#skill-import');
+  const ref = input.value.trim();
+  if (!ref) return;
+  setStatus('#skill-import-status', 'importando desde GitHub…');
+  const data = await api('/api/skills/import', { method: 'POST', body: { ref } }).catch((e) => ({ error: e.message }));
+  if (data?.error) return setStatus('#skill-import-status', data.error, 'err');
+  input.value = '';
+  setStatus('#skill-import-status', `Importada ${data.installed} (${data.source})`, 'ok');
+  refreshSkills();
+}
+
 if (mcpListEl) {
   $('#mcp-new').addEventListener('click', () => openMcpForm());
+  $('#mcp-import-btn')?.addEventListener('click', importMcp);
+  $('#mcp-import')?.addEventListener('keydown', (event) => {
+    if (event.key === 'Enter') {
+      event.preventDefault();
+      importMcp();
+    }
+  });
+  $('#skill-import-btn')?.addEventListener('click', importSkill);
+  $('#skill-import')?.addEventListener('keydown', (event) => {
+    if (event.key === 'Enter') {
+      event.preventDefault();
+      importSkill();
+    }
+  });
   $('#mcp-reload').addEventListener('click', () => refreshMcp({ connect: true }));
   $('#mcp-close').addEventListener('click', closeMcpForm);
   $('#mf-cancel').addEventListener('click', closeMcpForm);

package/harness/packages/server/public/index.html

@@ -306,6 +306,11 @@
           <p class="muted verify-line">
             Se combinan con <code>mcp[]</code> de <code>tamnora.json</code>; los guardados acá viven en la base.
           </p>
+          <div class="import-bar">
+            <input id="mcp-import" placeholder="nombre del registro oficial, URL o JSON (bloque mcpServers)" spellcheck="false" />
+            <button id="mcp-import-btn" class="btn" type="button">importar</button>
+          </div>
+          <div id="mcp-import-status" class="summary"></div>
           <ul id="mcp-list" class="providers"></ul>
         </div>
 
@@ -317,6 +322,11 @@
           <p class="muted verify-line">
             Instrucciones especializadas en la casa de Tamnora (<code>skills/</code>). Las habilitadas se inyectan al system prompt.
           </p>
+          <div class="import-bar">
+            <input id="skill-import" placeholder="https://skills.sh/owner/repo/skill" spellcheck="false" />
+            <button id="skill-import-btn" class="btn" type="button">importar</button>
+          </div>
+          <div id="skill-import-status" class="summary"></div>
           <ul id="skill-list" class="providers"></ul>
         </div>
       </section>

package/harness/packages/server/public/styles.css

@@ -758,6 +758,8 @@ pre.code code { background: none; border: 0; padding: 0; font-size: 12.5px; }
 .preview-frame { flex: 1; width: 100%; border: 0; background: #fff; min-height: 0; }
 #procs-list { flex: 1; min-height: 0; overflow-y: auto; }
 .procs-log { margin: 0; padding: 8px 12px; height: 150px; overflow: auto; background: var(--theirs); border-top: 1px solid var(--border); font: 500 11px var(--mono); white-space: pre-wrap; word-break: break-word; }
+.import-bar { display: flex; gap: 6px; margin: 4px 0 10px; }
+.import-bar input { flex: 1; min-width: 0; }
 
 .file-actions { display: flex; align-items: center; gap: 10px; }
 .file-modal { width: min(880px, calc(100vw - 40px)); }

package/harness/packages/server/src/lib/agentTools.js

@@ -2,9 +2,27 @@
 // MCP, instalar skills (contenido o URL) y listarlos. Pasarlas por permisos
 // porque instalar MCP/skills puede ejecutar codigo.
 
-import { parseSkillMarkdown } from './core.js';
+import path from 'node:path';
+import {
+  parseSkillMarkdown,
+  parseSkillRef,
+  fetchSkillFromGithub,
+  writeSkillFiles,
+  getMcpRegistryServer,
+  registryServerToConfig,
+  normalizeMcpConfig,
+  homeDir,
+} from './core.js';
 import { SKILL_ID_PATTERN, skillsView, writeSkill, setSkillEnabled } from './skills.js';
 
+function sanitizeId(value) {
+  return String(value ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+}
+
 const MCP_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
 
 function definition(name, description, parameters, required = []) {
@@ -19,13 +37,15 @@ const DEFINITIONS = [
     {
       id: { type: 'string', description: 'Id corto, ej. "echo"' },
       name: { type: 'string' },
+      registry: { type: 'string', description: 'Nombre en el registro oficial de MCP, ej. "io.github.foo/bar"' },
+      json: { type: 'string', description: 'Snippet JSON (bloque mcpServers o {command,args}/{url})' },
       transport: { type: 'string', enum: ['stdio', 'http'] },
       command: { type: 'string', description: 'Para stdio, ej. "node" o "npx"' },
       args: { type: 'array', items: { type: 'string' } },
       url: { type: 'string', description: 'Para http' },
       enabled: { type: 'boolean' },
     },
-    ['id', 'transport']
+    []
   ),
   definition('remove_mcp', 'Elimina un servidor MCP guardado desde la consola.', { id: { type: 'string' } }, ['id']),
   definition('list_skills', 'Lista las skills instaladas y si están habilitadas.', {}),
@@ -38,9 +58,10 @@ const DEFINITIONS = [
       description: { type: 'string' },
       content: { type: 'string', description: 'Contenido markdown de la skill' },
       url: { type: 'string', description: 'URL para descargar el contenido' },
+      ref: { type: 'string', description: 'URL/id de skills.sh (https://skills.sh/owner/repo/skill)' },
       enabled: { type: 'boolean' },
     },
-    ['id']
+    []
   ),
 ];
 
@@ -96,6 +117,49 @@ export function createAgentTools(ctx) {
         })), null, 2);
 
       case 'install_mcp': {
+        if (args.registry || args.name) {
+          let server;
+          try {
+            server = await getMcpRegistryServer(String(args.registry || args.name), { strict: true });
+          } catch (error) {
+            return `No se pudo consultar el registro MCP: ${error.message}`;
+          }
+          if (!server) return 'No encontré ese servidor en el registro oficial.';
+          const cfg = registryServerToConfig(server);
+          ctx.store.saveMcpServer({
+            id: cfg.id,
+            name: cfg.name,
+            transport: cfg.type === 'http' ? 'http' : 'stdio',
+            command: cfg.command ?? null,
+            url: cfg.url ?? null,
+            enabled: true,
+            config: { args: cfg.args ?? [], env: cfg.env ?? null },
+          });
+          await ctx.reloadMcp();
+          const required = (cfg.requiredEnv ?? []).length ? ` Requiere env: ${cfg.requiredEnv.join(', ')}.` : '';
+          return `MCP "${cfg.id}" importado del registro oficial.${required}`;
+        }
+        if (args.json || args.config) {
+          let cfg;
+          try {
+            cfg = normalizeMcpConfig(args.json ?? args.config, args.id);
+          } catch (error) {
+            return `Config MCP inválida: ${error.message}`;
+          }
+          if (!MCP_ID_PATTERN.test(cfg.id)) return 'Id de MCP inválido.';
+          ctx.store.saveMcpServer({
+            id: cfg.id,
+            name: cfg.name,
+            transport: cfg.type === 'http' ? 'http' : 'stdio',
+            command: cfg.command ?? null,
+            url: cfg.url ?? null,
+            enabled: cfg.enabled !== false,
+            config: { args: cfg.args ?? [], env: cfg.env ?? null },
+          });
+          await ctx.reloadMcp();
+          return `MCP "${cfg.id}" importado.`;
+        }
+
         const id = String(args.id ?? '').trim();
         if (!MCP_ID_PATTERN.test(id)) return 'Id de MCP inválido.';
         const transport = args.transport === 'http' || (!args.command && args.url) ? 'http' : 'stdio';
@@ -128,6 +192,21 @@ export function createAgentTools(ctx) {
         return JSON.stringify(skillsView(ctx).map(({ id, name, enabled, description }) => ({ id, name, enabled, description })), null, 2);
 
       case 'install_skill': {
+        const ref = parseSkillRef(args.ref ?? args.url ?? '');
+        if (ref && (args.ref || (args.url && !/\.md(\?|$)/i.test(String(args.url))))) {
+          let remote;
+          try {
+            remote = await fetchSkillFromGithub(ref);
+          } catch (error) {
+            return `No se pudo importar desde GitHub: ${error.message}`;
+          }
+          const imported = sanitizeId(remote.slug || ref.slug || ref.repo);
+          if (!SKILL_ID_PATTERN.test(imported)) return 'No se pudo derivar un id de skill válido.';
+          await writeSkillFiles(path.join(homeDir(), 'skills', imported), remote.files);
+          setSkillEnabled(ctx.store, imported, true);
+          return `Skill "${imported}" importada desde ${remote.source}.`;
+        }
+
         const id = String(args.id ?? '').trim();
         if (!SKILL_ID_PATTERN.test(id)) return 'Id de skill inválido (a-z, 0-9, - y _).';
         let content = String(args.content ?? '');

package/harness/packages/server/src/routes/mcp.js

@@ -1,4 +1,10 @@
-import { buildMcpRegistry, mcpTransport } from '../lib/core.js';
+import {
+  buildMcpRegistry,
+  mcpTransport,
+  getMcpRegistryServer,
+  registryServerToConfig,
+  normalizeMcpConfig,
+} from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 
 const ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
@@ -82,6 +88,56 @@ export function registerMcp(route, ctx) {
     sendJson(res, 200, { servers });
   });
 
+  route('POST', '/api/mcp/import', async ({ req, res }) => {
+    const body = await readJson(req);
+    let record;
+    try {
+      if (body.json !== undefined || body.config !== undefined) {
+        record = normalizeMcpConfig(body.json ?? body.config, body.id);
+      } else if (body.name) {
+        const server = await getMcpRegistryServer(String(body.name), { strict: true });
+        if (!server) return sendError(res, 404, 'No encontré ese servidor en el registro oficial.');
+        record = registryServerToConfig(server);
+      } else if (body.url) {
+        const value = String(body.url);
+        if (/registry\.modelcontextprotocol\.io/i.test(value)) {
+          const name = new URL(value).searchParams.get('search') || value.split('/').filter(Boolean).pop();
+          const server = await getMcpRegistryServer(name, { strict: true });
+          if (!server) return sendError(res, 404, 'No encontré ese servidor en el registro oficial.');
+          record = registryServerToConfig(server);
+        } else if (/mcpservers\.org/i.test(value)) {
+          return sendError(
+            res,
+            400,
+            'mcpservers.org está detrás de Cloudflare y no se puede leer desde el server. Pegá el JSON del servidor (bloque "mcpServers") o usá el registro oficial (registry.modelcontextprotocol.io).'
+          );
+        } else {
+          return sendError(res, 400, 'URL no reconocida. Usá el registro oficial o pegá el JSON.');
+        }
+      } else {
+        return sendError(res, 400, 'Pasá "name" (registro), "json" (config) o "url".');
+      }
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+
+    ctx.store.saveMcpServer({
+      id: record.id,
+      name: record.name,
+      transport: record.type === 'http' ? 'http' : 'stdio',
+      command: record.command ?? null,
+      url: record.url ?? null,
+      enabled: record.enabled !== false,
+      config: { args: record.args ?? [], env: record.env ?? null },
+    });
+    await ctx.reloadMcp();
+    sendJson(res, 200, {
+      imported: record.id,
+      requiredEnv: record.requiredEnv ?? [],
+      servers: listServers(ctx),
+    });
+  });
+
   route('PUT', '/api/mcp/servers/:id', async ({ req, res, params }) => {
     const id = String(params.id);
     if (!ID_PATTERN.test(id)) return sendError(res, 400, 'Id de servidor inválido.');

package/harness/packages/server/src/routes/skills.js

@@ -1,3 +1,5 @@
+import path from 'node:path';
+import { homeDir, parseSkillRef, fetchSkillFromGithub, writeSkillFiles } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import {
   SKILL_ID_PATTERN,
@@ -8,7 +10,38 @@ import {
   setSkillEnabled,
 } from '../lib/skills.js';
 
+function sanitizeId(value) {
+  return String(value ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+}
+
 export function registerSkills(route, ctx) {
+  route('POST', '/api/skills/import', async ({ req, res }) => {
+    const body = await readJson(req);
+    const ref = parseSkillRef(body.ref ?? body.url ?? body.id);
+    if (!ref) {
+      return sendError(res, 400, 'Pegá una URL de skills.sh (https://skills.sh/owner/repo/skill) o un id owner/repo/skill.');
+    }
+    let remote;
+    try {
+      remote = await fetchSkillFromGithub(ref);
+    } catch (error) {
+      return sendError(res, 502, `No se pudo importar desde GitHub: ${error.message}`);
+    }
+    const id = sanitizeId(remote.slug || ref.slug || ref.repo);
+    if (!SKILL_ID_PATTERN.test(id)) return sendError(res, 502, 'No se pudo derivar un id de skill válido.');
+    try {
+      await writeSkillFiles(path.join(homeDir(), 'skills', id), remote.files);
+    } catch (error) {
+      return sendError(res, 500, `No se pudo escribir la skill: ${error.message}`);
+    }
+    setSkillEnabled(ctx.store, id, true);
+    sendJson(res, 200, { installed: id, source: remote.source, skills: skillsView(ctx) });
+  });
+
   route('GET', '/api/skills', ({ res }) => {
     sendJson(res, 200, { skills: skillsView(ctx) });
   });

package/harness/packages/server/test/server.test.js

@@ -175,6 +175,46 @@ test('manages MCP servers from the console', async () => {
   }
 });
 
+test('imports an MCP server from a JSON snippet', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const res = await fetch(`${base}/api/mcp/import`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ json: '{"mcpServers":{"demo":{"command":"npx","args":["-y","pkg"]}}}' }),
+    });
+    assert.equal(res.status, 200);
+    const data = await res.json();
+    assert.equal(data.imported, 'demo');
+    assert.ok(data.servers.some((s) => s.id === 'demo' && s.transport === 'stdio'));
+  } finally {
+    await instance.close();
+  }
+});
+
+test('rejects unknown import refs (skills and mcpservers.org)', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const badSkill = await fetch(`${base}/api/skills/import`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ ref: 'nope' }),
+    });
+    assert.equal(badSkill.status, 400);
+
+    const blocked = await fetch(`${base}/api/mcp/import`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ url: 'https://mcpservers.org/es/official' }),
+    });
+    assert.equal(blocked.status, 400);
+  } finally {
+    await instance.close();
+  }
+});
+
 test('manages skills from the console', async () => {
   const { instance, base } = await startServer();
   const json = { 'Content-Type': 'application/json' };
@@ -832,7 +872,7 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
         body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
       })
     ).text();
-    assert.deepEqual(captured.tools, ['git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read']);
+    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read']);
     assert.match(captured.system, /modo PLAN/);
   } finally {
     await instance.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",