@danieltmn/tamnora 0.1.0 → 0.2.0

package/harness/packages/core/src/providers/openrouter.js

@@ -1,5 +1,5 @@
 import { requestStream } from './openaiCompatible.js';
-import { joinUrl, normalizeModel, sortModels } from './utils.js';
+import { joinUrl, providerFetch, normalizeModel, sortModels } from './utils.js';
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
 
@@ -23,7 +23,7 @@ export const openrouterProvider = {
   requiresKey: true,
 
   async listModels({ apiKey, siteUrl, siteName }) {
-    const res = await fetch(joinUrl(OPENROUTER_BASE_URL, '/models'), {
+    const res = await providerFetch(joinUrl(OPENROUTER_BASE_URL, '/models'), {
       headers: openrouterHeaders({ apiKey, siteUrl, siteName }),
     });
     if (!res.ok) throw new Error(`No se pudo listar modelos (HTTP ${res.status})`);

package/harness/packages/core/src/providers/resilience.js

@@ -12,7 +12,7 @@ export function isRetryableError(err) {
   if (!err || isAbortError(err)) return false;
   const status = err.status ?? err.statusCode ?? err.response?.status;
   if (status) return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
-  const code = String(err.code || '');
+  const code = String(err.code || err.cause?.code || '');
   if (
     ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'EAI_AGAIN', 'ENOTFOUND', 'UND_ERR_SOCKET', 'UND_ERR_CONNECT_TIMEOUT'].includes(
       code

package/harness/packages/core/src/providers/utils.js

@@ -10,6 +10,49 @@ export function authHeaders({ apiKey, headers = {} }) {
   return result;
 }
 
+const NETWORK_CODES = [
+  'ECONNRESET',
+  'ETIMEDOUT',
+  'ECONNREFUSED',
+  'EAI_AGAIN',
+  'ENOTFOUND',
+  'UND_ERR_SOCKET',
+  'UND_ERR_CONNECT_TIMEOUT',
+  'UND_ERR_HEADERS_TIMEOUT',
+];
+
+/**
+ * Wrap `fetch` so a low-level network failure (DNS, connection refused, TLS,
+ * offline) produces a readable message instead of the bare "fetch failed".
+ * The original error is kept as `cause` and its code is promoted so retry
+ * heuristics still recognize the failure as transient.
+ */
+export async function providerFetch(url, init) {
+  try {
+    return await fetch(url, init);
+  } catch (error) {
+    if (error?.name === 'AbortError') throw error;
+    const cause = error?.cause;
+    const code = cause?.code ?? error?.code;
+    const message = String(error?.message ?? '');
+    const networkish =
+      NETWORK_CODES.includes(code) || /fetch failed|network|socket|econnrefused|enotfound|econnreset/i.test(message);
+    if (!networkish) throw error;
+
+    let host = url;
+    try {
+      host = new URL(url).host;
+    } catch {
+      /* keep the raw url */
+    }
+    const detail = cause?.message && cause.message !== message ? ` (${cause.message})` : '';
+    const friendly = new Error(`No se pudo conectar con ${host}${detail}. Revisá la red, el DNS o el proxy.`);
+    friendly.cause = error;
+    if (code) friendly.code = code;
+    throw friendly;
+  }
+}
+
 /**
  * Build a descriptive error from a failed provider response, detecting the
  * common "model does not support tools" case.

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

@@ -0,0 +1,72 @@
+// Skills: instrucciones especializadas en `<raiz>/<slug>/SKILL.md` con
+// frontmatter simple (name, description, when). Se inyectan al system prompt
+// las que esten habilitadas.
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+/** Parse a SKILL.md: frontmatter `--- key: value ---` plus body. */
+export function parseSkillMarkdown(text, fallbackId = '') {
+  const source = String(text ?? '');
+  let name = fallbackId;
+  let description = '';
+  let when = '';
+  let body = source.trim();
+  const match = source.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/);
+  if (match) {
+    body = match[2].trim();
+    for (const line of match[1].split(/\r?\n/)) {
+      const kv = line.match(/^([A-Za-z][\w-]*)\s*:\s*(.*)$/);
+      if (!kv) continue;
+      const key = kv[1].toLowerCase();
+      const value = kv[2].trim().replace(/^["']|["']$/g, '');
+      if (key === 'name') name = value;
+      else if (key === 'description') description = value;
+      else if (key === 'when' || key === 'when_to_use') when = value;
+    }
+  }
+  return { name: name || fallbackId, description, when, body };
+}
+
+/** List the skills under a root (`<root>/<slug>/SKILL.md`). Missing root -> []. */
+export function loadSkills(root) {
+  const skills = [];
+  let entries = [];
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return skills;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = path.join(root, entry.name);
+    const file = path.join(dir, 'SKILL.md');
+    try {
+      if (!statSync(file).isFile()) continue;
+      const parsed = parseSkillMarkdown(readFileSync(file, 'utf8'), entry.name);
+      skills.push({ id: entry.name, dir, path: file, ...parsed });
+    } catch {
+      // ignore unreadable skills
+    }
+  }
+  return skills.sort((a, b) => a.id.localeCompare(b.id, 'es'));
+}
+
+/** Merge several roots; later roots win on id collisions (workspace over casa). */
+export function mergeSkills(rootLists = []) {
+  const byId = new Map();
+  for (const list of rootLists) for (const skill of list) byId.set(skill.id, skill);
+  return [...byId.values()];
+}
+
+/** Text block appended to the system prompt with the enabled skills. */
+export function buildSkillsPrompt(skills = []) {
+  if (!skills.length) return '';
+  const parts = ['Tenés acceso a estas skills (instrucciones especializadas). Aplicá la que corresponda a la tarea:'];
+  for (const skill of skills) {
+    const title = skill.name || skill.id;
+    const desc = skill.description ? `${skill.description}\n` : '';
+    parts.push(`\n## ${title}\n${desc}${skill.body}`.trimEnd());
+  }
+  return parts.join('\n');
+}

package/harness/packages/core/src/storage/sqlite.js

@@ -227,6 +227,27 @@ export class Store {
     this.db.prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
   }
 
+  /** Borra todas las sesiones (y sus mensajes) de una carpeta. No toca archivos. */
+  deleteSessionsByCwd(cwd) {
+    const value = cwd === undefined || cwd === '' ? null : cwd;
+    const messages = this.db
+      .prepare(`DELETE FROM messages WHERE session_id IN (SELECT id FROM sessions WHERE cwd IS ?)`)
+      .run(value);
+    const sessions = this.db.prepare(`DELETE FROM sessions WHERE cwd IS ?`).run(value);
+    return { sessions: sessions.changes, messages: messages.changes };
+  }
+
+  /** Carpetas de trabajo con cantidad de sesiones (los "proyectos" del sidebar). */
+  listProjects() {
+    return this.db
+      .prepare(
+        `SELECT cwd, COUNT(*) AS sessions, MAX(updated_at) AS updated_at
+         FROM sessions GROUP BY cwd ORDER BY updated_at DESC`
+      )
+      .all()
+      .map((row) => ({ cwd: row.cwd, sessions: row.sessions, updatedAt: row.updated_at }));
+  }
+
   // --- Messages -----------------------------------------------------------
 
   addMessage(sessionId, message) {

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/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,49 @@
+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';
+
+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('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\./);
+});