@danieltmn/tamnora 0.21.0 → 0.21.1

package/CHANGELOG.md

@@ -5,6 +5,12 @@ 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.21.1] - 2026-10-16
+
+### Cambios
+
+- feat(config): export/import de la configuracion de la casa
+
 ## [0.21.0] - 2026-10-14
 
 ### Cambios

package/harness/packages/cli/src/cli.js

@@ -10,6 +10,7 @@ import { bridgeCommand } from './commands/bridge.js';
 import { updateCommand } from './commands/update.js';
 import { autostartCommand } from './commands/autostart.js';
 import { doctorCommand } from './commands/doctor.js';
+import { configCommand } from './commands/config.js';
 import { tuiCommand } from './commands/tui.js';
 import { ensureUtf8Console } from './lib/util.js';
 import { readPackageVersion } from './lib/core.js';
@@ -29,6 +30,7 @@ const COMMANDS = {
   update: updateCommand,
   autostart: autostartCommand,
   doctor: doctorCommand,
+  config: configCommand,
 };
 
 function readVersion() {
@@ -76,6 +78,7 @@ Uso:
   tamnora autostart install|remove    Arranque automatico del server
   tamnora serve                   Consola web local (primer plano)
   tamnora doctor                  Verificar Node, casa, puerto y base
+  tamnora config export|import    Exportar/importar la configuracion (proveedores + ajustes)
   tamnora update                  Buscar/instalar una version nueva
   tamnora init                    Crear tamnora.json
 

package/harness/packages/cli/src/commands/config.js

@@ -0,0 +1,141 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  appConfigPath,
+  databasePath,
+  exportConfig,
+  homeDir,
+  importConfig,
+  Store,
+} from '../../../core/src/index.js';
+import { parse } from '../lib/util.js';
+import { applyHomeOverride, stopRunningServer } from '../lib/daemon.js';
+
+const DEFAULT_FILE = 'tamnora-config.json';
+
+const OPTIONS = {
+  home: { type: 'string' },
+  out: { type: 'string', short: 'o' },
+  'with-secrets': { type: 'boolean' },
+  stdout: { type: 'boolean' },
+  'dry-run': { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export async function configCommand(argv) {
+  const { values, positionals } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+  applyHomeOverride(values);
+
+  const sub = (positionals[0] || 'path').toLowerCase();
+  const target = positionals[1] || values.out;
+
+  if (sub === 'export') return doExport(values, target);
+  if (sub === 'import') return doImport(values, target);
+  if (sub === 'path') {
+    printPaths();
+    return 0;
+  }
+  printHelp();
+  return 1;
+}
+
+function withStore(fn) {
+  const store = new Store(databasePath());
+  try {
+    return fn(store);
+  } finally {
+    store.close();
+  }
+}
+
+function doExport(values, target) {
+  const data = withStore((store) => exportConfig({ store, withSecrets: Boolean(values['with-secrets']) }));
+  const json = `${JSON.stringify(data, null, 2)}\n`;
+  if (values.stdout || target === '-') {
+    process.stdout.write(json);
+    return 0;
+  }
+  const file = path.resolve(target || DEFAULT_FILE);
+  writeFileSync(file, json);
+  console.log(`Configuracion exportada a ${file}`);
+  console.log(`  proveedores: ${data.providers.length}  ·  ajustes: ${Object.keys(data.settings).length}`);
+  console.log(`  secretos: ${data.secrets ? 'incluidos' : 'enmascarados (usa --with-secrets para incluirlos)'}`);
+  return 0;
+}
+
+function doImport(values, target) {
+  if (!target) {
+    console.error('Falta el archivo: tamnora config import <archivo.json>');
+    return 1;
+  }
+  const file = path.resolve(target);
+  let data;
+  try {
+    data = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (error) {
+    console.error(`No pude leer ${file}: ${error.message}`);
+    return 1;
+  }
+
+  const dryRun = Boolean(values['dry-run']);
+  if (!dryRun && stopRunningServer()) {
+    console.log('Habia un server corriendo; lo detuve para aplicar los cambios.');
+  }
+
+  let summary;
+  try {
+    summary = withStore((store) => importConfig(store, data, { dryRun }));
+  } catch (error) {
+    console.error(error.message);
+    return 1;
+  }
+
+  if (dryRun) {
+    console.log('Simulacion (--dry-run): no se cambio nada.');
+    printSummary(summary);
+    return 0;
+  }
+  printSummary(summary);
+  console.log('Volve a arrancar el server: tamnora server --start');
+  return 0;
+}
+
+function printSummary(summary) {
+  console.log(`Importado: ${summary.providers} proveedor(es), ${summary.settings} ajuste(s), app.json actualizado.`);
+  if (summary.missingKeys.length) {
+    console.log(`  Ojo: ${summary.missingKeys.join(', ')} quedaron sin API key (venian enmascaradas); cargalas en la consola.`);
+  }
+}
+
+function printPaths() {
+  console.log(`Casa de Tamnora : ${homeDir()}`);
+  console.log(`  config app    : ${appConfigPath()}`);
+  console.log(`  base de datos : ${databasePath()}`);
+  console.log('  por proyecto  : <cwd>/tamnora.json y <cwd>/.tamnora/');
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora config <export|import|path> [archivo] [opciones]
+
+Exporta o importa la configuracion de la casa (app.json + proveedores + ajustes).
+No incluye sesiones, historial, MCP servers ni tareas programadas.
+
+  export [archivo]     Vuelca la configuracion a JSON (default: ${DEFAULT_FILE})
+  import <archivo>     Aplica el JSON sobre esta instalacion
+  path                 Muestra donde vive la configuracion
+
+Opciones:
+  --with-secrets       Incluye API keys y secretos reales (default: enmascarados)
+  -o, --out <archivo>  Archivo de salida para export
+  --stdout             Imprime el JSON por stdout (export)
+  --dry-run            Muestra que haria el import sin escribir nada
+  --home <path>        Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+
+Ejemplos:
+  tamnora config export tamnora-config.json --with-secrets
+  tamnora config import tamnora-config.json`);
+}

package/harness/packages/core/src/config/portable.js

@@ -0,0 +1,138 @@
+import { readApp, writeApp } from './app.js';
+
+/**
+ * Export/import portable de la configuracion de la casa (app.json + tablas
+ * `providers` y `settings` de la base global). Los secretos (API keys, hash de
+ * usuario, token de Telegram, `authSecret`) se enmascaran salvo `withSecrets`;
+ * al importar, los valores enmascarados se saltan y se conserva lo existente.
+ */
+
+export const CONFIG_KIND = 'tamnora-config';
+export const CONFIG_VERSION = 1;
+export const MASKED = '<<tamnora:secreto>>';
+
+const LINKAGE_PREFIXES = ['telegram:', 'scheduleSession:'];
+
+function isSecretValue(value) {
+  return typeof value === 'string' && value !== '' && !value.startsWith('env:');
+}
+
+function isLinkageKey(key) {
+  return LINKAGE_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+
+function maskApp(app) {
+  const out = structuredClone(app);
+  if (isSecretValue(out.authSecret)) out.authSecret = MASKED;
+  if (out.user) out.user = MASKED;
+  if (out.telegram && isSecretValue(out.telegram.token)) out.telegram.token = MASKED;
+  if (out.tunnel && isSecretValue(out.tunnel.token)) out.tunnel.token = MASKED;
+  return out;
+}
+
+function providerToPortable(provider, withSecrets) {
+  const apiKey = withSecrets || !isSecretValue(provider.apiKey) ? provider.apiKey ?? '' : MASKED;
+  return {
+    id: provider.id,
+    label: provider.label,
+    baseUrl: provider.baseUrl ?? '',
+    apiKey,
+    models: provider.models ?? [],
+    requiresKey: provider.requiresKey,
+    custom: Boolean(provider.custom),
+    enabled: provider.enabled !== false,
+  };
+}
+
+function exportableSettings(all) {
+  const out = {};
+  for (const [key, value] of Object.entries(all)) {
+    if (isLinkageKey(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+
+function normalizePayload(data) {
+  if (!data || typeof data !== 'object') {
+    throw new Error('El archivo no es un objeto JSON valido.');
+  }
+  if (data.kind !== CONFIG_KIND) {
+    throw new Error(`No parece un export de Tamnora (kind: ${data.kind ?? 'desconocido'}).`);
+  }
+  if (Number(data.version) > CONFIG_VERSION) {
+    throw new Error(`Version de export no soportada: ${data.version} (max ${CONFIG_VERSION}).`);
+  }
+  return data;
+}
+
+function mergeMaskAware(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (value === MASKED) continue;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const base = target[key] && typeof target[key] === 'object' && !Array.isArray(target[key]) ? target[key] : {};
+      target[key] = mergeMaskAware({ ...base }, value);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+
+/** Arma el payload portable a partir del store y `app.json`. */
+export function exportConfig({ store, withSecrets = false, now } = {}) {
+  const app = readApp();
+  return {
+    kind: CONFIG_KIND,
+    version: CONFIG_VERSION,
+    exportedAt: new Date(now ?? Date.now()).toISOString(),
+    secrets: withSecrets,
+    app: withSecrets ? app : maskApp(app),
+    providers: store.listProviders().map((provider) => providerToPortable(provider, withSecrets)),
+    settings: exportableSettings(store.allSettings()),
+  };
+}
+
+/**
+ * Aplica un payload portable sobre el store y `app.json`. Con `dryRun` no
+ * escribe nada. Devuelve un resumen (proveedores, ajustes y claves faltantes).
+ */
+export function importConfig(store, data, { dryRun = false } = {}) {
+  const payload = normalizePayload(data);
+  const summary = { app: true, providers: 0, settings: 0, missingKeys: [] };
+
+  const app = readApp();
+  mergeMaskAware(app, payload.app ?? {});
+
+  for (const provider of payload.providers ?? []) {
+    if (!provider?.id) continue;
+    const existing = store.getProvider(provider.id);
+    let apiKey = provider.apiKey ?? '';
+    if (apiKey === MASKED) {
+      apiKey = existing?.apiKey ?? '';
+      if (!apiKey) summary.missingKeys.push(provider.id);
+    }
+    if (!dryRun) {
+      store.saveProvider({
+        id: provider.id,
+        label: provider.label,
+        baseUrl: provider.baseUrl,
+        apiKey,
+        models: provider.models,
+        requiresKey: provider.requiresKey,
+        custom: provider.custom,
+        enabled: provider.enabled !== false,
+      });
+    }
+    summary.providers += 1;
+  }
+
+  for (const [key, value] of Object.entries(payload.settings ?? {})) {
+    if (isLinkageKey(key)) continue;
+    if (!dryRun) store.setSetting(key, value);
+    summary.settings += 1;
+  }
+
+  if (!dryRun) writeApp(app);
+  return summary;
+}

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

@@ -70,6 +70,7 @@ export {
   migrateLegacyDb,
 } from './config/home.js';
 export { DEFAULT_APP, readApp, writeApp, ensureApp, randomToken } from './config/app.js';
+export { exportConfig, importConfig, CONFIG_KIND, CONFIG_VERSION, MASKED } from './config/portable.js';
 export { hashPassword, verifyPassword, userValidName, makeUser } from './config/identity.js';
 export { composeProviderSettings } from './config/providers.js';
 export {

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

@@ -0,0 +1,150 @@
+import { test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  setHome,
+  databasePath,
+  Store,
+  ensureApp,
+  readApp,
+  writeApp,
+  exportConfig,
+  importConfig,
+  MASKED,
+} from '../src/index.js';
+
+const prevHome = process.env.TAMNORA_HOME;
+const prevDb = process.env.TAMNORA_DB;
+
+afterEach(() => {
+  setHome(null);
+  if (prevHome === undefined) delete process.env.TAMNORA_HOME;
+  else process.env.TAMNORA_HOME = prevHome;
+  if (prevDb === undefined) delete process.env.TAMNORA_DB;
+  else process.env.TAMNORA_DB = prevDb;
+});
+
+async function freshHome() {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-portable-'));
+  setHome(dir);
+  process.env.TAMNORA_DB = path.join(dir, 'tamnora.db');
+  return dir;
+}
+
+test('exportConfig enmascara los secretos y respeta las referencias env:', async () => {
+  await freshHome();
+  ensureApp();
+  const app = readApp();
+  app.user = { name: 'daniel', password: { algo: 'scrypt', salt: 'x', hash: 'y' } };
+  app.telegram = { token: '123:abc', allowedChatIds: ['7'] };
+  writeApp(app);
+
+  const store = new Store(databasePath());
+  store.saveProvider({ id: 'deepseek', apiKey: 'sk-real', baseUrl: 'https://deepseek', enabled: true });
+  store.saveProvider({ id: 'env', apiKey: 'env:OPENAI_API_KEY' });
+  store.setSetting('activeProvider', 'deepseek');
+  store.setSetting('telegram:chat:7', 'sess-1');
+  const data = exportConfig({ store, now: 0 });
+  store.close();
+
+  assert.equal(data.kind, 'tamnora-config');
+  assert.equal(data.version, 1);
+  assert.equal(data.secrets, false);
+  assert.equal(data.app.authSecret, MASKED);
+  assert.equal(data.app.user, MASKED);
+  assert.equal(data.app.telegram.token, MASKED);
+  assert.deepEqual(data.app.telegram.allowedChatIds, ['7']);
+  assert.equal(data.providers.find((p) => p.id === 'deepseek').apiKey, MASKED);
+  assert.equal(data.providers.find((p) => p.id === 'env').apiKey, 'env:OPENAI_API_KEY');
+  assert.equal(data.settings.activeProvider, 'deepseek');
+  assert.equal('telegram:chat:7' in data.settings, false);
+});
+
+test('exportConfig con withSecrets incluye las claves reales', async () => {
+  await freshHome();
+  ensureApp();
+  const app = readApp();
+  app.authSecret = 'super-secret';
+  writeApp(app);
+
+  const store = new Store(databasePath());
+  store.saveProvider({ id: 'deepseek', apiKey: 'sk-real' });
+  const data = exportConfig({ store, withSecrets: true });
+  store.close();
+
+  assert.equal(data.secrets, true);
+  assert.equal(data.app.authSecret, 'super-secret');
+  assert.equal(data.providers[0].apiKey, 'sk-real');
+});
+
+test('importConfig aplica proveedores y ajustes y conserva los secretos enmascarados', async () => {
+  await freshHome();
+  ensureApp();
+  const current = readApp();
+  current.authSecret = 'keep-me';
+  writeApp(current);
+
+  const store = new Store(databasePath());
+  store.saveProvider({ id: 'deepseek', apiKey: 'old-key' });
+  store.close();
+
+  const payload = {
+    kind: 'tamnora-config',
+    version: 1,
+    app: { port: 4599, authSecret: MASKED, user: MASKED, profile: { name: 'Daniel' } },
+    providers: [
+      { id: 'deepseek', baseUrl: 'https://api.deepseek.com', apiKey: MASKED, models: ['chat'], enabled: true },
+      { id: 'groq', baseUrl: 'https://groq', apiKey: 'gsk-new', enabled: true },
+    ],
+    settings: { activeProvider: 'groq', strictScope: true, 'telegram:chat:7': 'ignored' },
+  };
+
+  const store2 = new Store(databasePath());
+  const summary = importConfig(store2, payload);
+  const deepseek = store2.getProvider('deepseek');
+  const groq = store2.getProvider('groq');
+  const strict = store2.getSetting('strictScope');
+  store2.close();
+
+  assert.equal(summary.providers, 2);
+  assert.equal(summary.settings, 2);
+  assert.equal(readApp().port, 4599);
+  assert.equal(readApp().authSecret, 'keep-me');
+  assert.equal(readApp().profile.name, 'Daniel');
+  assert.equal(deepseek.apiKey, 'old-key');
+  assert.equal(deepseek.baseUrl, 'https://api.deepseek.com');
+  assert.equal(groq.apiKey, 'gsk-new');
+  assert.equal(strict, true);
+});
+
+test('importConfig avisa cuando una clave enmascarada no tiene existente y no escribe con dryRun', async () => {
+  await freshHome();
+  const store = new Store(databasePath());
+  const payload = {
+    kind: 'tamnora-config',
+    version: 1,
+    providers: [{ id: 'nuevo', apiKey: MASKED }],
+    settings: { activeModel: 'x' },
+  };
+
+  const dry = importConfig(store, payload, { dryRun: true });
+  assert.deepEqual(dry.missingKeys, ['nuevo']);
+  assert.equal(store.getProvider('nuevo'), null);
+  assert.equal(store.getSetting('activeModel'), null);
+
+  const real = importConfig(store, payload);
+  assert.deepEqual(real.missingKeys, ['nuevo']);
+  assert.ok(store.getProvider('nuevo'));
+  assert.equal(store.getSetting('activeModel'), 'x');
+  store.close();
+});
+
+test('importConfig rechaza archivos que no son un export de Tamnora', async () => {
+  await freshHome();
+  const store = new Store(databasePath());
+  assert.throws(() => importConfig(store, { hello: 'world' }), /no parece un export/i);
+  assert.throws(() => importConfig(store, { kind: 'tamnora-config', version: 99 }), /no soportada/i);
+  store.close();
+});

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

@@ -75,7 +75,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.21.0</span></div>
+      <div class="brand"><span class="logo"><img src="/icons/logo.png" alt="Tamnora" /></span> <span id="topbar-section" class="topbar-section">chat</span> <span class="ver">v0.21.1</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "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",