@danieltmn/tamnora 0.20.1 → 0.21.1

package/CHANGELOG.md

@@ -5,6 +5,18 @@ 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
+
+- feat(consola): modulo de apariencia con temas, tipografia y tamano
+
 ## [0.20.1] - 2026-10-14
 
 ### Cambiado

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/app.js

@@ -3,6 +3,17 @@
 import { renderMarkdown, speechText, highlight } from './markdown.js';
 import { streamSse, followRun } from './runStream.js';
 import { diffState, pollDelayMs, localState, summarizeArgs } from './reconcile.js';
+import {
+  THEMES,
+  FONT_PRESETS,
+  DEFAULTS,
+  normalizeAppearance,
+  nextTheme,
+  readLocalAppearance,
+  applyAppearance,
+  clampChatFont,
+  clampScale,
+} from './appearance.js';
 
 const $ = (sel) => document.querySelector(sel);
 let csrfToken = '';
@@ -297,7 +308,8 @@ const PALETTE_COMMANDS = [
   { id: 'ajustes', label: 'MCP y Skills (ajustes)', run: () => activateTab('ajustes') },
   { id: 'explorer', label: 'Mostrar u ocultar archivos', run: () => setExplorerOpen(!state.explorerOpen) },
   { id: 'sidebar', label: 'Mostrar u ocultar sesiones', run: () => setSidebarOpen(!state.sidebarOpen) },
-  { id: 'theme', label: 'Cambiar tema', run: () => applyTheme(document.documentElement.dataset.theme === 'paper' ? 'dark' : 'paper') },
+  { id: 'theme', label: 'Cambiar tema', run: () => cycleTheme() },
+  { id: 'apariencia', label: 'Apariencia (tema, tipografía, tamaño)', run: () => openAppearance() },
 ];
 
 const palette = {
@@ -459,6 +471,11 @@ async function loadModes() {
     if (legacy) writeDefaultCwd(legacy);
   }
   syncDefaultCwd();
+  if (settings?.settings?.appearance) {
+    appearance = normalizeAppearance(settings.settings.appearance);
+    applyAppearance(appearance, { persist: true });
+    renderAppearanceControls();
+  }
   updateStatus();
 }
 
@@ -582,16 +599,110 @@ function updateStatus(extra = {}) {
   if (extra.running) $('#sb-rounds').textContent = 'pensando…';
 }
 
+/* --- apariencia (tema, tipografía, tamaño) -------------------------------- */
+
+let appearance = normalizeAppearance(readLocalAppearance());
 const themeToggle = $('#theme-toggle');
-function applyTheme(theme) {
-  document.documentElement.dataset.theme = theme;
-  themeToggle.title = theme === 'paper' ? 'cambiar a oscuro' : 'cambiar a papel';
-  storage.set('tamnora-console-theme', theme);
+const themeGrid = $('#apariencia-themes');
+const fontSelect = $('#apariencia-font');
+const chatFontRange = $('#apariencia-chat-font');
+const chatFontOut = $('#apariencia-chat-font-out');
+const scaleRange = $('#apariencia-scale');
+const scaleOut = $('#apariencia-scale-out');
+
+function renderAppearanceControls() {
+  if (themeGrid) {
+    themeGrid
+      .querySelectorAll('.theme-swatch')
+      .forEach((btn) => btn.classList.toggle('active', btn.dataset.themePick === appearance.theme));
+  }
+  if (fontSelect) fontSelect.value = appearance.font;
+  if (chatFontRange) chatFontRange.value = appearance.chatFont;
+  if (chatFontOut) chatFontOut.textContent = `${appearance.chatFont}px`;
+  if (scaleRange) scaleRange.value = Math.round(appearance.scale * 100);
+  if (scaleOut) scaleOut.textContent = `${Math.round(appearance.scale * 100)}%`;
+  if (themeToggle) {
+    const label = THEMES.find((t) => t.id === appearance.theme)?.label ?? appearance.theme;
+    themeToggle.title = `tema: ${label}`;
+  }
+}
+
+function persistAppearance() {
+  applyAppearance(appearance, { persist: true });
+  renderAppearanceControls();
+  api('/api/settings', { method: 'PUT', body: { appearance } }).catch(() => null);
+}
+
+function buildAppearanceControls() {
+  if (themeGrid) {
+    themeGrid.replaceChildren();
+    for (const theme of THEMES) {
+      const swatch = document.createElement('button');
+      swatch.type = 'button';
+      swatch.className = 'theme-swatch';
+      swatch.dataset.themePick = theme.id;
+      swatch.title = theme.label;
+      swatch.setAttribute('aria-label', `tema ${theme.label}`);
+      const dot = document.createElement('span');
+      dot.className = 'theme-swatch-dot';
+      dot.style.background = theme.metaColor;
+      const label = document.createElement('span');
+      label.className = 'theme-swatch-label';
+      label.textContent = theme.label;
+      swatch.append(dot, label);
+      swatch.addEventListener('click', () => {
+        appearance.theme = theme.id;
+        persistAppearance();
+      });
+      themeGrid.appendChild(swatch);
+    }
+  }
+  if (fontSelect) {
+    fontSelect.replaceChildren();
+    for (const font of FONT_PRESETS) {
+      const option = document.createElement('option');
+      option.value = font.id;
+      option.textContent = font.label;
+      fontSelect.appendChild(option);
+    }
+    fontSelect.addEventListener('change', () => {
+      appearance.font = fontSelect.value;
+      persistAppearance();
+    });
+  }
+  chatFontRange?.addEventListener('input', () => {
+    appearance.chatFont = clampChatFont(Number(chatFontRange.value));
+    applyAppearance(appearance, { persist: false });
+    if (chatFontOut) chatFontOut.textContent = `${appearance.chatFont}px`;
+  });
+  chatFontRange?.addEventListener('change', persistAppearance);
+  scaleRange?.addEventListener('input', () => {
+    appearance.scale = clampScale(Number(scaleRange.value) / 100);
+    applyAppearance(appearance, { persist: false });
+    if (scaleOut) scaleOut.textContent = `${Math.round(appearance.scale * 100)}%`;
+  });
+  scaleRange?.addEventListener('change', persistAppearance);
+  $('#apariencia-reset')?.addEventListener('click', () => {
+    appearance = normalizeAppearance(DEFAULTS);
+    persistAppearance();
+    setStatus('#apariencia-msg', 'restablecido', 'ok');
+  });
+  renderAppearanceControls();
 }
-themeToggle.addEventListener('click', () =>
-  applyTheme(document.documentElement.dataset.theme === 'paper' ? 'dark' : 'paper')
-);
-applyTheme(document.documentElement.dataset.theme || 'paper');
+
+function cycleTheme() {
+  appearance.theme = nextTheme(appearance.theme);
+  persistAppearance();
+}
+
+function openAppearance() {
+  activateTab('ajustes');
+  activateAjustesPanel('apariencia');
+}
+
+themeToggle?.addEventListener('click', cycleTheme);
+appearance = applyAppearance(appearance, { persist: false });
+buildAppearanceControls();
 
 const logout = $('#logout');
 if (logout) {
@@ -3379,7 +3490,7 @@ function renderHandsFree() {
   }
   if (handsFree.active && handsFree.phase === 'listening') renderFooterActivity('listening');
   else if (handsFree.active && handsFree.phase === 'thinking') renderFooterActivity('thinking');
-  else if (handsFree.active) renderFooterActivity(null);
+  else renderFooterActivity(null);
 }
 
 function setHandsFreePhase(phase) {