@danieltmn/tamnora 0.1.0 → 0.3.0

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

@@ -0,0 +1,69 @@
+import path from 'node:path';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { homeDir, loadSkills, mergeSkills, buildSkillsPrompt } from './core.js';
+
+export const SKILL_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
+
+/** Skill roots, lowest priority first: casa skills, then the workspace's. */
+export function skillRoots(cwd) {
+  return [path.join(homeDir(), 'skills'), path.join(cwd, '.tamnora', 'skills')];
+}
+
+export function allSkills(cwd) {
+  const home = path.join(homeDir(), 'skills');
+  return mergeSkills(skillRoots(cwd).map((root) => loadSkills(root).map((s) => ({ ...s, root, home: root === home }))));
+}
+
+function disabledIds(store) {
+  const raw = store.getSetting('disabledSkills');
+  return new Set(Array.isArray(raw) ? raw.map(String) : []);
+}
+
+export function skillsView(ctx) {
+  const disabled = disabledIds(ctx.store);
+  return allSkills(ctx.cwd).map((s) => ({
+    id: s.id,
+    name: s.name || s.id,
+    description: s.description || '',
+    when: s.when || '',
+    enabled: !disabled.has(s.id),
+    removable: Boolean(s.home),
+  }));
+}
+
+export function findSkill(ctx, id) {
+  return allSkills(ctx.cwd).find((s) => s.id === id) ?? null;
+}
+
+export function enabledSkills(ctx) {
+  const disabled = disabledIds(ctx.store);
+  return allSkills(ctx.cwd)
+    .filter((s) => !disabled.has(s.id))
+    .map((s) => ({ id: s.id, name: s.name || s.id, description: s.description, when: s.when, body: s.body }));
+}
+
+export function skillsPrompt(ctx) {
+  return buildSkillsPrompt(enabledSkills(ctx));
+}
+
+export async function writeSkill(id, { name, description, when, body }) {
+  const dir = path.join(homeDir(), 'skills', id);
+  await mkdir(dir, { recursive: true });
+  const lines = ['---', `name: ${name || id}`];
+  if (description) lines.push(`description: ${description}`);
+  if (when) lines.push(`when: ${when}`);
+  lines.push('---', '', String(body ?? '').trim(), '');
+  await writeFile(path.join(dir, 'SKILL.md'), lines.join('\n'), 'utf8');
+  return dir;
+}
+
+export async function removeSkill(id) {
+  await rm(path.join(homeDir(), 'skills', id), { recursive: true, force: true });
+}
+
+export function setSkillEnabled(store, id, enabled) {
+  const current = new Set(Array.isArray(store.getSetting('disabledSkills')) ? store.getSetting('disabledSkills') : []);
+  if (enabled) current.delete(id);
+  else current.add(id);
+  store.setSetting('disabledSkills', [...current]);
+}

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

@@ -0,0 +1,267 @@
+import { runAgent, createTools, resolveMode } from './core.js';
+import { resolveExistingDir } from './workspace.js';
+
+const API = 'https://api.telegram.org';
+
+const HELP = [
+  'Tamnora Harness — bot',
+  '',
+  '/new — nueva sesión',
+  '/status — proveedor, modelo, modo y sesión',
+  '/model <id> — cambia el modelo',
+  '/provider <id> — cambia el proveedor',
+  '/mode plan|build — cambia el modo',
+  '/stop — cancela la respuesta en curso',
+  '/help — esta ayuda',
+  '',
+  'Cualquier otro texto se envía al agente.',
+].join('\n');
+
+async function tg(token, method, payload) {
+  const res = await fetch(`${API}/bot${token}/${method}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload ?? {}),
+  });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+    data = null;
+  }
+  if (!data?.ok) {
+    const error = new Error(data?.description || `HTTP ${res.status}`);
+    error.status = res.status;
+    throw error;
+  }
+  return data.result;
+}
+
+function splitMessage(text, max = 3900) {
+  const value = String(text ?? '').trim() || '(sin texto)';
+  const parts = [];
+  for (let i = 0; i < value.length; i += max) parts.push(value.slice(i, i + max));
+  return parts;
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * Bot de Telegram por long polling (no necesita URL publica). Los chats
+ * autorizados conversan con el mismo engine del harness; cada chat mapea a una
+ * sesion. Devuelve `{ stop }` o `null` si no hay token.
+ */
+export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () => {} } = {}) {
+  if (!token) return null;
+  const allowed = new Set(allowedChatIds.map(String));
+  const controllers = new Map();
+  let running = true;
+  let offset = 0;
+
+  const authorized = (chatId) => allowed.size > 0 && allowed.has(String(chatId));
+  const sessionKey = (chatId) => `telegram:chat:${chatId}`;
+
+  async function send(chatId, text) {
+    let first = null;
+    for (const chunk of splitMessage(text)) {
+      const result = await tg(token, 'sendMessage', { chat_id: chatId, text: chunk, disable_web_page_preview: true });
+      if (!first) first = result;
+    }
+    return first;
+  }
+
+  async function edit(chatId, messageId, text) {
+    const parts = splitMessage(text);
+    await tg(token, 'editMessageText', { chat_id: chatId, message_id: messageId, text: parts[0], disable_web_page_preview: true }).catch(() => null);
+    for (let i = 1; i < parts.length; i++) {
+      await tg(token, 'sendMessage', { chat_id: chatId, text: parts[i], disable_web_page_preview: true }).catch(() => null);
+    }
+  }
+
+  function ensureSession(chatId) {
+    const key = sessionKey(chatId);
+    let sessionId = ctx.store.getSetting(key);
+    if (!sessionId || !ctx.store.getSession(sessionId)) {
+      sessionId = ctx.store.createSession({
+        title: `Telegram ${chatId}`,
+        provider: ctx.effectiveProviderId(),
+        model: ctx.effectiveModel(),
+        cwd: ctx.cwd,
+        meta: { telegramChatId: String(chatId) },
+      });
+      ctx.store.setSetting(key, sessionId);
+    }
+    return sessionId;
+  }
+
+  async function run(chatId, input) {
+    const sessionId = ensureSession(chatId);
+    const session = ctx.store.getSession(sessionId);
+    const providerId = session.provider || ctx.effectiveProviderId();
+    const model = session.model || ctx.effectiveModel();
+    if (!model) {
+      await send(chatId, 'Falta el modelo. Usá /model <id> o configurá uno en Ajustes.');
+      return;
+    }
+    const mode = resolveMode(ctx.effectiveMode());
+    const cwd = resolveExistingDir(session.cwd || ctx.cwd);
+    const history = ctx.store.getMessages(sessionId);
+
+    let mcp = null;
+    try {
+      mcp = await ctx.getMcp();
+    } catch {
+      mcp = null;
+    }
+
+    const local = createTools({
+      root: cwd,
+      enabled: mode.tools ?? undefined,
+      permissions: ctx.config.permissions,
+      yes: false,
+      mcp,
+    });
+    const exposeAdmin = !mode.tools;
+    const admin = ctx.agentTools;
+    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
+    const execute = (name, args, context) =>
+      exposeAdmin && admin.handles(name)
+        ? admin.execute(name, args, { approve: async () => false })
+        : local.execute(name, args, context);
+    const { provider, config } = ctx.resolveProvider({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    });
+    const basePrompt = await ctx.systemPromptFor(cwd);
+    const messages = [
+      { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
+      ...history,
+      { role: 'user', content: input },
+    ];
+
+    const controller = new AbortController();
+    controllers.set(String(chatId), controller);
+    const message = await send(chatId, '…');
+    let full = '';
+    let lastEdit = 0;
+
+    try {
+      const result = await runAgent({
+        provider,
+        config,
+        model,
+        messages,
+        tools: definitions,
+        execute,
+        signal: controller.signal,
+        maxRounds: ctx.config.maxRounds,
+        onEvent(event) {
+          if (event.type !== 'text') return;
+          full = event.full;
+          const now = Date.now();
+          if (now - lastEdit > 1200) {
+            lastEdit = now;
+            edit(chatId, message.message_id, full || '…');
+          }
+        },
+      });
+      await edit(chatId, message.message_id, result.content?.trim() || full || '(sin texto)');
+      const newMessages = result.messages.slice(1 + history.length);
+      ctx.store.addMessages(sessionId, newMessages);
+      ctx.store.touchSession(sessionId, { provider: providerId, model });
+    } catch (error) {
+      await edit(chatId, message.message_id, error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`);
+    } finally {
+      controllers.delete(String(chatId));
+      mcp?.close?.();
+    }
+  }
+
+  async function handleCommand(chatId, text) {
+    const [raw, ...rest] = text.slice(1).split(/\s+/);
+    const cmd = raw.toLowerCase();
+    const arg = rest.join(' ').trim();
+    const sessionId = ctx.store.getSetting(sessionKey(chatId));
+    if (cmd === 'start' || cmd === 'help' || cmd === 'ayuda') return send(chatId, HELP);
+    if (cmd === 'new' || cmd === 'nueva') {
+      ctx.store.setSetting(sessionKey(chatId), null);
+      return send(chatId, 'Nueva sesión. Mandá tu mensaje.');
+    }
+    if (cmd === 'status') {
+      const session = sessionId ? ctx.store.getSession(sessionId) : null;
+      return send(
+        chatId,
+        `proveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
+      );
+    }
+    if (cmd === 'model') {
+      if (!arg) return send(chatId, `modelo actual: ${ctx.effectiveModel() || '—'}`);
+      ctx.store.setSetting('activeModel', arg);
+      if (sessionId) ctx.store.touchSession(sessionId, { model: arg });
+      return send(chatId, `modelo: ${arg}`);
+    }
+    if (cmd === 'provider') {
+      if (!arg) return send(chatId, `proveedor actual: ${ctx.effectiveProviderId()}`);
+      ctx.store.setSetting('activeProvider', arg);
+      if (sessionId) ctx.store.touchSession(sessionId, { provider: arg });
+      return send(chatId, `proveedor: ${arg}`);
+    }
+    if (cmd === 'mode' || cmd === 'modo') {
+      if (!arg) return send(chatId, `modo actual: ${ctx.effectiveMode()}`);
+      const id = arg.toLowerCase() === 'build' ? 'agent' : arg.toLowerCase();
+      ctx.store.setSetting('activeMode', resolveMode(id).id);
+      return send(chatId, `modo: ${resolveMode(id).label}`);
+    }
+    if (cmd === 'stop' || cmd === 'parar') {
+      controllers.get(String(chatId))?.abort();
+      return send(chatId, 'Cancelando…');
+    }
+    return send(chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
+  }
+
+  async function handleMessage(message) {
+    const chatId = String(message.chat.id);
+    if (!authorized(chatId)) {
+      await send(chatId, `No autorizado. Tu chat id es ${chatId}; agregalo a telegram.allowedChatIds para habilitarlo.`);
+      return;
+    }
+    const text = String(message.text ?? '').trim();
+    if (!text) return;
+    if (text.startsWith('/')) return handleCommand(chatId, text);
+    return run(chatId, text);
+  }
+
+  async function loop() {
+    while (running) {
+      let updates = [];
+      try {
+        updates = await tg(token, 'getUpdates', { offset, timeout: 25, allowed_updates: ['message'] });
+      } catch (error) {
+        if (error.status === 401 || error.status === 404) {
+          log(`telegram: token inválido (${error.message}); se detiene el bot.`);
+          running = false;
+          return;
+        }
+        await sleep(3000);
+        continue;
+      }
+      for (const update of updates) {
+        offset = update.update_id + 1;
+        if (update.message?.text) {
+          handleMessage(update.message).catch((error) => log(`telegram: ${error?.message ?? error}`));
+        }
+      }
+    }
+  }
+
+  // Arranca en segundo plano; no bloquea el server.
+  loop().catch((error) => log(`telegram: ${error?.message ?? error}`));
+
+  return {
+    stop() {
+      running = false;
+      for (const controller of controllers.values()) controller.abort();
+      controllers.clear();
+    },
+  };
+}

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

@@ -123,7 +123,7 @@ export function registerChat(route, ctx) {
           sse.event('permission_resolved', { askId, allow });
           return allow;
         };
-    const { definitions, execute } = createTools({
+    const local = createTools({
       root: sessionCwd,
       enabled,
       permissions: ctx.config.permissions,
@@ -131,6 +131,14 @@ export function registerChat(route, ctx) {
       onAsk,
       mcp,
     });
+    // En modo plan (solo lectura) no exponemos las tools de administración.
+    const exposeAdmin = !mode.tools;
+    const admin = ctx.agentTools;
+    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
+    const execute = (name, args, context) =>
+      exposeAdmin && admin.handles(name)
+        ? admin.execute(name, args, { approve: autoApprove ? async () => true : onAsk })
+        : local.execute(name, args, context);
 
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),

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

@@ -1,5 +1,13 @@
-import { buildMcpRegistry, mcpTransport } from '../lib/core.js';
-import { sendJson } from '../lib/http.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;
 
 function safeTransport(server) {
   try {
@@ -9,17 +17,49 @@ function safeTransport(server) {
   }
 }
 
+function listServers(ctx) {
+  return ctx.mergedMcpServers().map((server) => ({
+    id: server.id,
+    name: server.name ?? server.id,
+    transport: safeTransport(server),
+    enabled: server.enabled !== false,
+    source: server.source ?? 'config',
+    command: server.command ?? null,
+    args: Array.isArray(server.args) ? server.args : [],
+    url: server.url ?? null,
+    env: server.env ?? null,
+  }));
+}
+
+function parseServer(body, id) {
+  const transport = body.transport === 'http' ? 'http' : 'stdio';
+  const command = String(body.command ?? '').trim();
+  const url = String(body.url ?? '').trim();
+  if (transport === 'stdio' && !command) throw new Error('Un servidor stdio necesita "command".');
+  if (transport === 'http' && !url) throw new Error('Un servidor http necesita "url".');
+  const args = Array.isArray(body.args)
+    ? body.args.map((a) => String(a))
+    : String(body.args ?? '')
+        .split(/\s+/)
+        .filter(Boolean);
+  return {
+    id,
+    name: String(body.name ?? id).trim() || id,
+    transport,
+    command: transport === 'stdio' ? command : null,
+    url: transport === 'http' ? url : null,
+    enabled: body.enabled !== false,
+    config: { args, env: body.env ?? null },
+  };
+}
+
 export function registerMcp(route, ctx) {
   route('GET', '/api/mcp', async ({ res, query }) => {
-    const servers = (ctx.config.mcp ?? []).map((server) => ({
-      id: server.id,
-      name: server.name,
-      transport: safeTransport(server),
-      enabled: server.enabled !== false,
-    }));
+    const servers = listServers(ctx);
 
     if (query.get('connect')) {
-      const registry = await buildMcpRegistry(ctx.config.mcp ?? []);
+      const connectable = ctx.mergedMcpServers().filter((s) => s.enabled !== false);
+      const registry = await buildMcpRegistry(connectable);
       try {
         for (const server of servers) {
           const session = registry.sessions.find((s) => s.server.id === server.id);
@@ -47,4 +87,83 @@ 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.');
+    const body = await readJson(req);
+    let record;
+    try {
+      record = parseServer(body, id);
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+    ctx.store.saveMcpServer(record);
+    await ctx.reloadMcp();
+    sendJson(res, 200, { servers: listServers(ctx) });
+  });
+
+  route('DELETE', '/api/mcp/servers/:id', async ({ res, params }) => {
+    const id = String(params.id);
+    const stored = ctx.store.listMcpServers().some((s) => s.id === id);
+    if (!stored) return sendError(res, 404, 'Ese servidor está definido en tamnora.json y no se borra desde acá.');
+    ctx.store.deleteMcpServer(id);
+    await ctx.reloadMcp();
+    sendJson(res, 200, { servers: listServers(ctx) });
+  });
+
+  route('POST', '/api/mcp/reload', async ({ res }) => {
+    await ctx.reloadMcp();
+    sendJson(res, 200, { ok: true, servers: listServers(ctx) });
+  });
 }

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

@@ -0,0 +1,58 @@
+import { startTunnel } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+/**
+ * Preview de un dev server para acceso remoto: abre un tunel aparte al puerto
+ * del proceso (asi el celular puede embeber la app aunque este detras del
+ * tunel del harness). Devuelve `{ close }` para liberar el tunel al apagar.
+ */
+export function registerPreview(route, ctx) {
+  let tunnel = null;
+
+  route('GET', '/api/preview', ({ res }) => {
+    sendJson(res, 200, { tunnel: tunnel ? { url: tunnel.url, port: tunnel.port } : null });
+  });
+
+  route('POST', '/api/preview/tunnel', async ({ req, res }) => {
+    const body = await readJson(req);
+    const port = Number(body.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) return sendError(res, 400, 'Puerto inválido.');
+    if (tunnel) {
+      try {
+        tunnel.stop?.();
+      } catch {
+        // ignore
+      }
+      tunnel = null;
+    }
+    const provider = ctx.config.preview?.provider || 'tunnelmole';
+    try {
+      const started = await startTunnel(port, provider);
+      tunnel = { url: started.url, port, stop: started.stop };
+      sendJson(res, 200, { tunnel: { url: tunnel.url, port } });
+    } catch (error) {
+      sendError(res, 502, `No se pudo abrir el túnel: ${error.message}`);
+    }
+  });
+
+  route('DELETE', '/api/preview/tunnel', ({ res }) => {
+    try {
+      tunnel?.stop?.();
+    } catch {
+      // ignore
+    }
+    tunnel = null;
+    sendJson(res, 200, { ok: true });
+  });
+
+  return {
+    close() {
+      try {
+        tunnel?.stop?.();
+      } catch {
+        // ignore
+      }
+      tunnel = null;
+    },
+  };
+}

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

@@ -0,0 +1,47 @@
+import { detectProcs } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import { resolveExistingDir } from '../lib/workspace.js';
+
+export function registerProcs(route, ctx) {
+  route('GET', '/api/procs', ({ res }) => {
+    sendJson(res, 200, { enabled: ctx.procsEnabled, allow: ctx.procs.allowed, procs: ctx.procs.list() });
+  });
+
+  route('GET', '/api/procs/detect', ({ res, query }) => {
+    let dir;
+    try {
+      dir = resolveExistingDir(query.get('cwd') || ctx.cwd);
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+    sendJson(res, 200, { cwd: dir, chips: detectProcs(dir) });
+  });
+
+  route('POST', '/api/procs/start', async ({ req, res }) => {
+    if (!ctx.procsEnabled) return sendError(res, 403, 'Los procesos están deshabilitados (processes.enabled = false).');
+    const body = await readJson(req);
+    let dir;
+    try {
+      dir = resolveExistingDir(body.cwd || ctx.cwd);
+    } catch (error) {
+      return sendError(res, 400, error.message);
+    }
+    try {
+      const proc = ctx.procs.start({ cwd: dir, command: body.command, args: body.args, port: body.port });
+      sendJson(res, 201, { proc });
+    } catch (error) {
+      sendError(res, 400, error.message);
+    }
+  });
+
+  route('GET', '/api/procs/:id/logs', ({ res, params, query }) => {
+    const data = ctx.procs.logs(params.id, Number(query.get('since')) || 0);
+    if (!data) return sendError(res, 404, 'Proceso no encontrado.');
+    sendJson(res, 200, data);
+  });
+
+  route('POST', '/api/procs/:id/stop', ({ res, params }) => {
+    if (!ctx.procs.stop(params.id)) return sendError(res, 404, 'Proceso no encontrado.');
+    sendJson(res, 200, { ok: true });
+  });
+}

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

@@ -154,4 +154,14 @@ export function registerSessions(route, ctx) {
     ctx.store.deleteSession(params.id);
     sendJson(res, 200, { ok: true });
   });
+
+  route('GET', '/api/projects', ({ res }) => {
+    sendJson(res, 200, { projects: ctx.store.listProjects() });
+  });
+
+  route('DELETE', '/api/projects', ({ res, query }) => {
+    if (!query.has('cwd')) return sendError(res, 400, 'Falta "cwd".');
+    const removed = ctx.store.deleteSessionsByCwd(query.get('cwd'));
+    sendJson(res, 200, { ok: true, ...removed });
+  });
 }