ai-agentmanager 0.0.0-stage → 1.0.0

package/src/preview.js

@@ -0,0 +1,334 @@
+// Browser tabs: look at a page as this machine sees it (the agent's dev server on
+// http://localhost:5173, a staging site on the VPN, any URL) from another device.
+//
+// On this computer the tab loads the URL directly. From another device each site gets its
+// own HTTPS listener (same certificate and sign-in as remote access) that relays everything
+// to it at the root path, so apps that use absolute paths, redirects and WebSockets (hot
+// reload) keep working. This daemon's own ports are never relayed, and the Agent Manager
+// session cookie is stripped before forwarding.
+import http from 'node:http';
+import https from 'node:https';
+
+const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]', '0.0.0.0']);
+const MAX_LISTENERS = 20;
+const HOP = ['connection', 'keep-alive', 'proxy-connection', 'proxy-authorization', 'te', 'trailer', 'upgrade'];
+
+export const isLoopback = (url) => LOOPBACK.has(url.hostname);
+
+/**
+ * "5173", "localhost:5173/app", "10.0.0.7:8080" or "example.com/docs" -> a normalized URL.
+ * Without a scheme, local and numbered addresses and ones with a port get http, names https.
+ */
+export function parseUrl(input) {
+  let s = String(input ?? '').trim();
+  if (/^\d{1,5}$/.test(s)) s = `localhost:${s}`;
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(s)) {
+    const host = s.split(/[/?#]/)[0];
+    const plain = /^(localhost|0\.0\.0\.0|[\d.]+|\[[\da-f:]+\])(:\d+)?$/i.test(host) || /:\d+$/.test(host);
+    s = `${plain ? 'http' : 'https'}://${s}`;
+  }
+  let url;
+  try {
+    url = new URL(s);
+  } catch {
+    throw Object.assign(new Error('Enter an address, like localhost:5173, 3000 or example.com'), { status: 400 });
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || !url.hostname) throw Object.assign(new Error('Only http and https addresses can be opened'), { status: 400 });
+  if (url.username || url.password) throw Object.assign(new Error("Addresses can't carry a user name or password"), { status: 400 });
+  if (url.hostname === '0.0.0.0') url.hostname = 'localhost';
+  return url;
+}
+
+const targetPort = (url) => Number(url.port || (url.protocol === 'https:' ? 443 : 80));
+
+/** Local URLs mentioned in terminal output ("Local: http://localhost:5173/"), newest first. */
+export function findLocalUrls(text) {
+  const plain = text.replace(/\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*\x07/g, '');
+  const out = [];
+  for (const m of plain.matchAll(/https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]):\d{2,5}(?:\/[^\s'"<>)\]]*)?/g)) {
+    try {
+      const href = parseUrl(m[0].replace(/[.,;:]+$/, '')).href;
+      const i = out.indexOf(href);
+      if (i >= 0) out.splice(i, 1);
+      out.push(href);
+    } catch {}
+  }
+  return out.reverse().slice(0, 8);
+}
+
+const LOOPBACK_NAMES = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
+
+const OTHER_ANSI = /\x1b\[[0-9;?<>=]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b[=>78c]/g;
+
+/**
+ * Terminal output as plain lines. Claude Code's interface places words with cursor moves
+ * (column jumps, not spaces) and ends lines with \r\r\n, so column jumps become padding.
+ */
+function plainLines(text) {
+  const out = [];
+  for (const line of text.replace(/\x1b\[\d*(;\d*)?[Hf]/g, '\n').split(/\r*\n|\r/)) {
+    let cur = '';
+    for (const part of line.split(/(\x1b\[\d*[CG])/)) {
+      const m = part.match(/^\x1b\[(\d*)([CG])$/);
+      if (!m) cur += part.replace(OTHER_ANSI, '');
+      else if (m[2] === 'C') cur += ' '.repeat(Number(m[1] || 1));
+      else cur = cur.length < Number(m[1] || 1) - 1 ? cur.padEnd(Number(m[1] || 1) - 1) : `${cur} `;
+    }
+    out.push(cur.replace(/\s+$/, ''));
+  }
+  return out;
+}
+
+const URL_TAIL = /https?:\/\/\S*$/;
+const URL_PIECE = /^[A-Za-z0-9\-._~%!$&'()*+,;=:@/?#[\]]+$/;
+
+/**
+ * Sign-in links a CLI printed (`railway login`, `gh auth login --web`, `gcloud auth login`...):
+ * an http(s) address whose redirect / callback parameter points back at a port on this machine.
+ * `cols` is the terminal width, to rejoin links wrapped across lines (by the terminal or by
+ * Claude Code, which indents the continuation). Newest first: [{ url, port, callback }].
+ */
+export function findSignInLinks(text, cols = 0) {
+  const lines = [];
+  let lastLen = 0; // visual length of the previous physical line
+  for (const line of plainLines(text)) {
+    const prev = lines.at(-1);
+    const piece = line.replace(/^[\s│┃|⎿]+/, '');
+    if (prev !== undefined && lastLen >= (cols > 20 ? cols - 12 : 70) && URL_TAIL.test(prev) && piece && URL_PIECE.test(piece)) lines[lines.length - 1] = prev + piece;
+    else lines.push(line);
+    lastLen = line.length;
+  }
+  const found = [];
+  for (const m of lines.join('\n').matchAll(/https?:\/\/[^\s'"<>`]+/g)) {
+    let u;
+    try {
+      u = new URL(m[0].replace(/[.,;:)\]]+$/, ''));
+    } catch {
+      continue;
+    }
+    if (LOOPBACK_NAMES.has(u.hostname)) continue;
+    for (const [k, v] of u.searchParams) {
+      if (!/redirect|callback|return/i.test(k)) continue;
+      let r;
+      try {
+        r = new URL(v);
+      } catch {
+        continue;
+      }
+      if (!/^https?:$/.test(r.protocol) || !LOOPBACK_NAMES.has(r.hostname)) continue;
+      const port = Number(r.port || (r.protocol === 'https:' ? 443 : 80));
+      const i = found.findIndex((f) => f.url === u.href);
+      if (i >= 0) found.splice(i, 1);
+      found.push({ url: u.href, port, callback: `${r.origin}${r.pathname}` });
+      break;
+    }
+  }
+  return found.reverse().slice(0, 4);
+}
+
+/** A loopback callback address (pasted after signing in), checked against the expected port. */
+export function parseCallback(input, port) {
+  let u;
+  try {
+    u = new URL(String(input ?? '').trim());
+  } catch {
+    return null;
+  }
+  if (!/^https?:$/.test(u.protocol) || !LOOPBACK_NAMES.has(u.hostname) || u.username || u.password) return null;
+  if (Number(u.port || (u.protocol === 'https:' ? 443 : 80)) !== port) return null;
+  return u;
+}
+
+export class Previews {
+  /**
+   * @param {object} o
+   * @param {() => {key: Buffer, cert: Buffer}} o.tls
+   * @param {(port: number) => Set<string>} o.allowedHosts  Host headers the listener answers to
+   * @param {(cookieHeader: string) => boolean} o.signedIn
+   * @param {string} o.cookieName  stripped before forwarding
+   * @param {() => number[]} o.reserved  this daemon's own ports, never relayed
+   * @param {() => Set<string>} o.ownHosts  this machine's own names and addresses (besides loopback)
+   * @param {() => object} [o.savedPorts]  site -> relay port from before; a device accepts the
+   *   self-signed certificate per port, so a site keeps its port across restarts
+   * @param {(ports: object) => void} [o.savePorts]
+   */
+  constructor({ tls, allowedHosts, signedIn, cookieName, reserved, ownHosts = () => new Set(), savedPorts = () => ({}), savePorts = () => {} }) {
+    Object.assign(this, { tls, allowedHosts, signedIn, cookieName, reserved, ownHosts, savedPorts, savePorts });
+    this.listeners = new Map(); // "http://localhost:5173" -> { server, port, target }
+    this.okCookies = new Map(); // cookie header -> checked until (ms)
+  }
+
+  /** The address another device uses for `input`, e.g. https://mini:53122/app. */
+  async frameUrl(input, requestHost) {
+    const url = parseUrl(input);
+    const port = await this.listen(url);
+    const host = String(requestHost ?? '').replace(/:\d+$/, '');
+    return `https://${host}:${port}${url.pathname}${url.search}${url.hash}`;
+  }
+
+  async listen(url) {
+    const tport = targetPort(url);
+    const own = new Set([...this.reserved(), ...[...this.listeners.values()].map((l) => l.port)]);
+    const self = isLoopback(url) || this.ownHosts().has(url.hostname.replace(/^\[|\]$/g, '').toLowerCase());
+    if (self && own.has(tport)) throw Object.assign(new Error("That is Agent Manager's own port"), { status: 400 });
+    const key = `${url.protocol}//${url.hostname}:${tport}`;
+    const existing = this.listeners.get(key);
+    if (existing) return existing.port;
+    if (this.listeners.size >= MAX_LISTENERS) throw Object.assign(new Error(`At most ${MAX_LISTENERS} sites can be open at once`), { status: 400 });
+
+    const target = { protocol: url.protocol, host: url.hostname.replace(/^\[|\]$/g, ''), port: tport, label: url.host, loopback: isLoopback(url) };
+    const { key: k, cert } = this.tls();
+    const server = https.createServer({ key: k, cert });
+    const entry = { server, port: 0, target };
+    server.on('request', (req, res) => this.relay(entry, req, res));
+    server.on('upgrade', (req, socket, head) => this.relayUpgrade(entry, req, socket, head));
+    server.on('clientError', (_err, socket) => socket.destroy());
+    const listenOn = (p) =>
+      new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(p, '0.0.0.0', () => {
+          server.off('error', reject);
+          resolve();
+        });
+      });
+    const saved = this.savedPorts();
+    const before = Number(saved[key]) || 0;
+    try {
+      if (!before || own.has(before)) throw new Error('no saved port');
+      await listenOn(before);
+    } catch {
+      await listenOn(0); // taken by something else now: a new port (and one more certificate prompt)
+    }
+    entry.port = server.address().port;
+    this.listeners.set(key, entry);
+    if (entry.port !== before) this.savePorts({ ...saved, [key]: entry.port });
+    return entry.port;
+  }
+
+  async stopAll() {
+    const all = [...this.listeners.values()];
+    this.listeners.clear();
+    await Promise.all(
+      all.map(({ server }) => {
+        server.closeAllConnections?.();
+        return new Promise((r) => server.close(() => r()));
+      }),
+    );
+  }
+
+  /** Why this request may not go through, or null. */
+  refuse(entry, req) {
+    const host = (req.headers.host ?? '').toLowerCase();
+    if (!this.allowedHosts(entry.port).has(host)) return [403, 'Unknown host'];
+    const cookies = req.headers.cookie ?? '';
+    const until = this.okCookies.get(cookies);
+    if (until && until > Date.now()) return null;
+    if (!this.signedIn(cookies)) return [401, 'Sign in to Agent Manager on this machine first, then open this tab again.'];
+    if (this.okCookies.size > 100) this.okCookies.clear();
+    this.okCookies.set(cookies, Date.now() + 10_000);
+    return null;
+  }
+
+  /** Request headers as the local server expects them: its own Host and Origin, no Agent Manager cookie. */
+  forwardHeaders(entry, req, upgrade) {
+    const { target } = entry;
+    const self = `${target.protocol}//${target.label}`;
+    const viewer = `https://${req.headers.host}`;
+    const headers = { ...req.headers };
+    for (const h of HOP) if (!(upgrade && (h === 'connection' || h === 'upgrade'))) delete headers[h];
+    headers.host = target.label;
+    if (headers.origin) headers.origin = self;
+    if (headers.referer?.startsWith(viewer)) headers.referer = self + headers.referer.slice(viewer.length);
+    const cookie = (headers.cookie ?? '')
+      .split(';')
+      .filter((c) => c.trim() && !c.trim().startsWith(`${this.cookieName}=`))
+      .join(';');
+    if (cookie) headers.cookie = cookie;
+    else delete headers.cookie;
+    return headers;
+  }
+
+  request(entry, req, upgrade) {
+    const { target } = entry;
+    const mod = target.protocol === 'https:' ? https : http;
+    return mod.request({
+      host: target.host,
+      port: target.port,
+      method: req.method,
+      path: req.url,
+      headers: this.forwardHeaders(entry, req, upgrade),
+      autoSelectFamily: true, // "localhost" may be ::1 or 127.0.0.1, whichever the dev server took
+      rejectUnauthorized: !target.loopback, // a local dev server may use its own self-signed certificate
+    });
+  }
+
+  relay(entry, req, res) {
+    const no = this.refuse(entry, req);
+    if (no) return page(res, no[0], no[1]);
+    const preq = this.request(entry, req, false);
+    preq.on('response', (pres) => {
+      res.writeHead(pres.statusCode, pres.statusMessage, this.responseHeaders(entry, req, pres.headers));
+      pres.pipe(res);
+    });
+    preq.on('error', (err) => {
+      if (res.headersSent) return res.destroy();
+      page(res, 502, err.code === 'ECONNREFUSED' ? `Nothing is answering on ${entry.target.label} yet. Start the server, then reload.` : `Could not reach ${entry.target.label}: ${err.message}`);
+    });
+    req.pipe(preq);
+  }
+
+  /** Let the page load inside the tab and keep its redirects and cookies on this address. */
+  responseHeaders(entry, req, headers) {
+    const out = { ...headers };
+    for (const h of HOP) delete out[h];
+    delete out['x-frame-options'];
+    if (out['content-security-policy']) {
+      out['content-security-policy'] = String(out['content-security-policy'])
+        .split(';')
+        .filter((d) => !/^\s*frame-ancestors\b/i.test(d))
+        .join(';');
+    }
+    const { target } = entry;
+    if (out.location) {
+      const selves = [`${target.protocol}//${target.label}`];
+      if (target.loopback) selves.push(`${target.protocol}//localhost:${target.port}`, `${target.protocol}//127.0.0.1:${target.port}`);
+      for (const self of selves) {
+        if (out.location.startsWith(self)) out.location = `https://${req.headers.host}${out.location.slice(self.length)}`;
+      }
+    }
+    if (out['set-cookie']) out['set-cookie'] = [].concat(out['set-cookie']).map((c) => c.replace(/;\s*domain=[^;]*/gi, ''));
+    return out;
+  }
+
+  relayUpgrade(entry, req, socket, head) {
+    socket.on('error', () => {});
+    const no = this.refuse(entry, req);
+    if (no) {
+      socket.end(`HTTP/1.1 ${no[0]} ${http.STATUS_CODES[no[0]]}\r\nConnection: close\r\n\r\n`);
+      return;
+    }
+    const preq = this.request(entry, req, true);
+    preq.on('upgrade', (pres, psock, phead) => {
+      psock.on('error', () => socket.destroy());
+      const lines = [`HTTP/1.1 ${pres.statusCode} ${pres.statusMessage}`];
+      for (let i = 0; i < pres.rawHeaders.length; i += 2) lines.push(`${pres.rawHeaders[i]}: ${pres.rawHeaders[i + 1]}`);
+      socket.write(lines.join('\r\n') + '\r\n\r\n');
+      if (phead?.length) socket.write(phead);
+      if (head?.length) psock.write(head);
+      psock.pipe(socket).pipe(psock);
+      socket.on('close', () => psock.destroy());
+    });
+    preq.on('response', (pres) => {
+      socket.end(`HTTP/1.1 ${pres.statusCode} ${pres.statusMessage}\r\nConnection: close\r\n\r\n`);
+      pres.resume();
+    });
+    preq.on('error', () => socket.destroy());
+    preq.end();
+  }
+}
+
+function page(res, status, message) {
+  const esc = message.replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' })[c]);
+  res.writeHead(status, { 'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store' });
+  res.end(`<!doctype html><meta name="viewport" content="width=device-width"><body style="font:15px system-ui;color:#c9d1d9;background:#0f1117;padding:24px"><p>${esc}</p></body>`);
+}

package/src/races.js

@@ -0,0 +1,192 @@
+// Agent races: one intent, N agents with different models or approaches, compared side by
+// side (outcome, checks, size of change, cost, a test command run in each worktree) so the
+// user can pick a winner. Races live in the state file next to the agents.
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import * as git from './git.js';
+
+const err = (status, message) => Object.assign(new Error(message), { status });
+const now = () => new Date().toISOString();
+
+export class Races extends EventEmitter {
+  constructor({ manager, store }) {
+    super();
+    this.manager = manager;
+    this.store = store;
+    store.data.races ??= {};
+    this.running = new Map(); // `${raceId}:${agentId}` -> child process
+    // Interrupted test runs can't be finished after a restart.
+    for (const race of Object.values(store.data.races)) {
+      for (const t of Object.values(race.tests ?? {})) if (t.status === 'running') Object.assign(t, { status: 'error', output: 'Interrupted by a daemon restart' });
+    }
+    manager.on('change', (a) => a.raceId && this.emit('change', a.raceId));
+    manager.on('removed', (id) => {
+      for (const race of Object.values(store.data.races)) {
+        if (race.members.includes(id)) {
+          race.members = race.members.filter((m) => m !== id);
+          if (race.winner === id) race.winner = null;
+          this.save(race);
+        }
+      }
+    });
+  }
+
+  save(race) {
+    this.store.save();
+    if (race) this.emit('change', race.id);
+  }
+
+  /**
+   * variants: [{ label?, model?, instructions? }] (at least 2). Everything else is passed to
+   * agent creation (repo / dir / project / base / permissionMode ...). Each variant gets its
+   * own worktree, so a repo URL or a git folder is required.
+   */
+  create({ intent, variants, testCommand, ...opts }) {
+    intent = String(intent ?? '').trim();
+    if (!intent) throw err(400, 'Intent is required');
+    if (!Array.isArray(variants) || variants.length < 2) throw err(400, 'A race needs at least two variants');
+    if (variants.length > 6) throw err(400, 'At most six variants');
+    if (!opts.repo && !opts.dir && !opts.project) throw err(400, 'A race needs a repository URL, a git folder or a project');
+    const id = `r${crypto.randomBytes(3).toString('hex')}`;
+    const race = { id, intent, testCommand: testCommand?.trim() || null, createdAt: now(), members: [], tests: {}, winner: null };
+    this.store.data.races[id] = race;
+    variants.forEach((v, i) => {
+      const label = (v.label?.trim() || v.model?.trim() || `v${i + 1}`).replace(/[^\w.-]+/g, '-').slice(0, 20);
+      const a = this.manager.create({
+        ...opts,
+        intent: v.instructions?.trim() ? `${intent}\n\nApproach for this attempt: ${v.instructions.trim()}` : intent,
+        name: `${opts.name || intent.split(/\s+/).slice(0, 4).join('-').toLowerCase().replace(/[^\w-]+/g, '')}-${label}`,
+        model: v.model?.trim() || opts.model,
+        worktree: true,
+        race: { id, variant: { label, model: v.model?.trim() || opts.model || null, instructions: v.instructions?.trim() || null } },
+      });
+      race.members.push(a.id);
+    });
+    this.save(race);
+    return this.view(id);
+  }
+
+  get(id) {
+    const race = this.store.data.races[id];
+    if (!race) throw err(404, `No race ${id}`);
+    return race;
+  }
+
+  list() {
+    return Object.values(this.store.data.races).sort((a, b) => b.createdAt.localeCompare(a.createdAt)).map((r) => this.view(r.id));
+  }
+
+  /** Scoreboard: one row per attempt. */
+  view(id) {
+    const race = this.get(id);
+    const rows = race.members
+      .map((mid) => this.manager.get(mid))
+      .filter(Boolean)
+      .map((a) => {
+        const files = this.manager.changeSets.get(a.id)?.files ?? {};
+        const counted = Object.values(files);
+        const checks = a.brief?.checks ?? [];
+        const started = Date.parse(a.lastStartedAt ?? a.createdAt);
+        const last = Date.parse(a.runtime.lastOutputAt ?? a.sessions.at(-1)?.lastActivity ?? a.updatedAt);
+        return {
+          id: a.id,
+          name: a.name,
+          variant: a.variant ?? null,
+          status: a.status,
+          working: a.runtime.busy,
+          outcome: a.results?.outcome ?? null,
+          briefStatus: a.brief?.status ?? null,
+          checks: { passed: checks.filter((c) => c.state === 'passed').length, failed: checks.filter((c) => c.state === 'failed').length, total: checks.length },
+          files: counted.length,
+          added: counted.reduce((n, f) => n + (f.added ?? 0), 0),
+          removed: counted.reduce((n, f) => n + (f.removed ?? 0), 0),
+          costUsd: a.costUsd,
+          tokens: a.usage?.io ?? 0,
+          minutes: Number.isFinite(last - started) && last > started ? Math.round((last - started) / 60_000) : null,
+          prs: a.prs.map((p) => ({ url: p.url, number: p.number, state: p.state })),
+          tests: race.tests[a.id] ?? null,
+        };
+      });
+    return { ...race, rows };
+  }
+
+  /** Run the race's test command in every attempt's worktree (two at a time). */
+  async runTests(id, { command } = {}) {
+    const race = this.get(id);
+    if (command !== undefined) race.testCommand = command.trim() || null;
+    if (!race.testCommand) throw err(400, 'Set a test command first');
+    const queue = race.members.map((m) => this.manager.store.get(m)).filter((a) => a?.workdir);
+    for (const a of queue) race.tests[a.id] = { status: 'queued', at: now() };
+    this.save(race);
+    const worker = async () => {
+      for (let a = queue.shift(); a; a = queue.shift()) await this.runOne(race, a);
+    };
+    Promise.all([worker(), worker()]).catch(() => {});
+    return this.view(id);
+  }
+
+  runOne(race, agent) {
+    race.tests[agent.id] = { status: 'running', at: now() };
+    this.save(race);
+    return new Promise((resolve) => {
+      const child = spawn(process.env.SHELL || '/bin/sh', ['-lc', race.testCommand], { cwd: agent.workdir, env: this.manager.childEnv(agent), detached: true });
+      this.running.set(`${race.id}:${agent.id}`, child);
+      let out = '';
+      const keep = (d) => (out = (out + d).slice(-6000));
+      child.stdout.on('data', keep);
+      child.stderr.on('data', keep);
+      const started = Date.now();
+      const timer = setTimeout(() => {
+        try {
+          process.kill(-child.pid, 'SIGKILL');
+        } catch {}
+      }, (this.manager.config.raceTestTimeoutSec ?? 900) * 1000);
+      const finish = (code, error) => {
+        clearTimeout(timer);
+        this.running.delete(`${race.id}:${agent.id}`);
+        race.tests[agent.id] = {
+          status: error ? 'error' : code === 0 ? 'passed' : 'failed',
+          exitCode: code,
+          seconds: Math.round((Date.now() - started) / 1000),
+          output: (error ? `${error}\n` : '') + out.slice(-4000),
+          at: now(),
+        };
+        this.save(race);
+        resolve();
+      };
+      child.on('error', (e) => finish(null, e.message));
+      child.on('close', (code) => finish(code));
+    });
+  }
+
+  async diff(id, agentId) {
+    const race = this.get(id);
+    if (!race.members.includes(agentId)) throw err(404, 'Not part of this race');
+    const a = this.manager.store.get(agentId);
+    const baseSha = a?.baseRef?.split(' @ ')[1];
+    if (!a?.workdir || !baseSha) return { diff: '' };
+    return { diff: await git.fullDiff(a.workdir, baseSha) };
+  }
+
+  /** Pick the winner. With cleanup, the other attempts are closed and deleted with their worktrees. */
+  async pick(id, agentId, { cleanup = false } = {}) {
+    const race = this.get(id);
+    if (!race.members.includes(agentId)) throw err(404, 'Not part of this race');
+    race.winner = agentId;
+    race.decidedAt = now();
+    this.save(race);
+    if (cleanup) {
+      for (const m of race.members.filter((x) => x !== agentId)) await this.manager.remove(m, { deleteWorkspace: true }).catch(() => {});
+    }
+    return this.view(id);
+  }
+
+  remove(id) {
+    this.get(id);
+    delete this.store.data.races[id];
+    this.save();
+    this.emit('removed', id);
+    return { ok: true };
+  }
+}