@martintrojer/murmur 0.1.4 → 0.2.0

package/dist/extension/store.js

@@ -11,248 +11,463 @@ function stateDir() {
   return process.env.MURMUR_STATE_DIR ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "murmur");
 }
 function dbPath() {
-  return join(stateDir(), "events.db");
+  return join(stateDir(), "state.db");
 }
 
 // src/identity.ts
-function loadIdentity() {
-  const path = join2(stateDir(), "identity.json");
-  return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : null;
+function identityPath() {
+  return join2(stateDir(), "identity.json");
 }
-function ensureIdentity(displayName = hostname()) {
-  const existing = loadIdentity();
-  if (existing) return existing;
-  const identity = { host_id: randomUUID(), display_name: displayName };
-  mkdirSync(stateDir(), { recursive: true });
-  writeFileSync(join2(stateDir(), "identity.json"), `${JSON.stringify(identity, null, 2)}
-`);
+var cache = null;
+function loadIdentity() {
+  const path = identityPath();
+  if (cache?.path === path) return cache.identity;
+  const identity = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : null;
+  cache = { path, identity };
   return identity;
 }
 
 // src/store.ts
-import { rmSync } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync2, rmSync } from "fs";
+import { dirname } from "path";
 import Database from "better-sqlite3";
-var DEFAULT_RETENTION_MS = 7 * 864e5;
-var STORE_VERSION = 2;
-function resetIfStale(path) {
-  let salvaged = [];
+
+// src/ids.ts
+function asSessionId(raw) {
+  return raw;
+}
+function asWindowId(raw) {
+  return raw;
+}
+function asPaneId(raw) {
+  return raw;
+}
+
+// src/mux.ts
+import { execFileSync } from "child_process";
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+// src/version.ts
+import { createRequire } from "module";
+function readVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      return require2(candidate).version;
+    } catch {
+    }
+  }
+  throw new Error("cannot locate package.json to read the murmur version");
+}
+var MURMUR_VERSION = readVersion();
+
+// src/view.ts
+var RENDER_PRIORITY = [
+  "crashed",
+  "blocked",
+  "done",
+  "running",
+  "idle"
+];
+var ORDER = new Map(RENDER_PRIORITY.map((state, index) => [state, index]));
+
+// src/store.ts
+var SCHEMA_USER_VERSION = 3;
+var SCHEMA = `
+  CREATE TABLE agents (
+    agent_id     TEXT    NOT NULL PRIMARY KEY,
+    pane         TEXT    NOT NULL UNIQUE,
+    owner_pid    INTEGER NOT NULL CHECK (owner_pid > 0),
+    activity     TEXT    NOT NULL CHECK (activity IN ('running', 'stopped')),
+    session      TEXT    NOT NULL,
+    window       TEXT    NOT NULL,
+    session_name TEXT,
+    window_name  TEXT,
+    agent_name   TEXT,
+    pi_session   TEXT,
+    workstream   TEXT,
+    role         TEXT,
+    cli          TEXT    NOT NULL,
+    driver       TEXT    NOT NULL CHECK (driver IN ('human', 'orchestrated')),
+    claimed_at   INTEGER NOT NULL,
+    updated_at   INTEGER NOT NULL
+  ) STRICT;
+
+  CREATE TABLE attention (
+    pane         TEXT    NOT NULL,
+    kind         TEXT    NOT NULL CHECK (kind IN ('done', 'blocked', 'crashed')),
+    message      TEXT    NOT NULL,
+    source       TEXT    NOT NULL,
+    session      TEXT    NOT NULL,
+    window       TEXT    NOT NULL,
+    session_name TEXT,
+    window_name  TEXT,
+    requested_at INTEGER NOT NULL,
+    PRIMARY KEY (pane, kind)
+  ) STRICT;
+
+  CREATE TABLE peers (
+    name             TEXT NOT NULL PRIMARY KEY,
+    target           TEXT NOT NULL,
+    host_id          TEXT,
+    display_name     TEXT,
+    snapshot         TEXT,
+    snapshot_at      INTEGER,
+    fetched_at       INTEGER,
+    last_attempt_at  INTEGER,
+    last_error       TEXT,
+    murmur_version   TEXT,
+    snapshot_version INTEGER
+  ) STRICT;
+`;
+function salvagePeers(path) {
   try {
     const existing = new Database(path, { fileMustExist: true });
-    const version = existing.pragma("user_version", { simple: true }) ?? 0;
-    if (version === STORE_VERSION) {
+    try {
+      const version = existing.pragma("user_version", { simple: true }) ?? 0;
+      if (version === SCHEMA_USER_VERSION) return [];
+      return existing.prepare("SELECT name, target FROM peers").all();
+    } catch {
+      return [];
+    } finally {
       existing.close();
-      return salvaged;
     }
+  } catch {
+    return [];
+  }
+}
+function needsReset(path) {
+  try {
+    const existing = new Database(path, { fileMustExist: true });
     try {
-      salvaged = existing.prepare("SELECT name, target, host_id, display_name FROM peers").all();
-    } catch {
+      return (existing.pragma("user_version", { simple: true }) ?? 0) !== SCHEMA_USER_VERSION;
+    } finally {
+      existing.close();
     }
-    existing.close();
   } catch {
-    return salvaged;
+    return false;
   }
-  for (const suffix of ["", "-wal", "-shm"]) rmSync(`${path}${suffix}`, { force: true });
-  return salvaged;
 }
-function eventValues(event) {
-  return [
-    event.host_id,
-    event.seq,
-    event.ts,
-    event.agent_id,
-    event.session,
-    event.window,
-    event.pane,
-    event.session_name,
-    event.window_name,
-    event.agent_name,
-    event.pi_session,
-    event.workstream,
-    event.role,
-    event.cli,
-    event.driver,
-    event.kind,
-    event.state,
-    event.message,
-    event.pid,
-    Number(event.synthetic),
-    event.reason,
-    JSON.stringify(event.extra)
-  ];
+function toAttention(row) {
+  return {
+    kind: row.kind,
+    message: row.message,
+    source: row.source,
+    requested_at: row.requested_at
+  };
 }
-function toEvent(row) {
+function toAgent(row) {
   return {
-    ...row,
+    agent_id: row.agent_id,
+    activity: row.activity,
+    agent_name: row.agent_name,
+    pi_session: row.pi_session,
+    workstream: row.workstream,
+    role: row.role,
+    cli: row.cli,
     driver: row.driver,
-    synthetic: row.synthetic === 1,
-    extra: JSON.parse(row.extra)
+    claimed_at: row.claimed_at,
+    updated_at: row.updated_at
   };
 }
+var PRIORITY = new Map(RENDER_PRIORITY.map((kind, index) => [kind, index]));
+function attentionOrder(left, right) {
+  return (PRIORITY.get(left.kind) ?? 99) - (PRIORITY.get(right.kind) ?? 99);
+}
 function openStore() {
-  const identity = ensureIdentity();
   const path = dbPath();
-  const salvagedPeers = resetIfStale(path);
+  mkdirSync2(dirname(path), { recursive: true });
+  const salvaged = salvagePeers(path);
+  if (needsReset(path)) {
+    for (const suffix of ["", "-wal", "-shm"]) rmSync(`${path}${suffix}`, { force: true });
+  }
   const database = new Database(path);
   database.pragma("journal_mode = WAL");
-  database.pragma(`user_version = ${STORE_VERSION}`);
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS events (
-      host_id TEXT NOT NULL,
-      seq INTEGER NOT NULL,
-      ts INTEGER NOT NULL,
-      agent_id TEXT NOT NULL,
-      session TEXT NOT NULL,
-      window TEXT NOT NULL,
-      pane TEXT NOT NULL,
-      session_name TEXT,
-      window_name TEXT,
-      agent_name TEXT,
-      pi_session TEXT,
-      workstream TEXT,
-      role TEXT,
-      cli TEXT,
-      driver TEXT,
-      kind TEXT NOT NULL,
-      state TEXT NOT NULL,
-      message TEXT NOT NULL,
-      pid INTEGER,
-      synthetic INTEGER NOT NULL,
-      reason TEXT NOT NULL,
-      extra TEXT NOT NULL,
-      PRIMARY KEY (host_id, seq)
-    );
-    CREATE INDEX IF NOT EXISTS events_agent_seq ON events (agent_id, seq);
-    CREATE TABLE IF NOT EXISTS peers (
-      name TEXT PRIMARY KEY,
-      target TEXT NOT NULL,
-      host_id TEXT,
-      display_name TEXT,
-      watermark INTEGER NOT NULL,
-      fetched_at INTEGER,
-      -- When a jump last proved this peer's tmux was not answering. Reader
-      -- state, not an event: this node cannot author facts about another
-      -- node's agents, and a jump is a local observation, not something the
-      -- peer said. Cleared by the next successful collect.
-      tmux_down_at INTEGER
-    );
-  `);
-  try {
-    database.exec("ALTER TABLE peers ADD COLUMN tmux_down_at INTEGER");
-  } catch {
-  }
-  if (salvagedPeers.length > 0) {
-    const restore = database.prepare(
-      `INSERT OR IGNORE INTO peers (name, target, host_id, display_name, watermark, fetched_at)
-       VALUES (?, ?, ?, ?, 0, NULL)`
-    );
-    for (const peer of salvagedPeers) {
-      restore.run(peer.name, peer.target, peer.host_id ?? null, peer.display_name ?? null);
-    }
+  database.pragma("busy_timeout = 5000");
+  const version = database.pragma("user_version", { simple: true }) ?? 0;
+  if (version !== SCHEMA_USER_VERSION) {
+    database.exec(SCHEMA);
+    database.pragma(`user_version = ${SCHEMA_USER_VERSION}`);
+    const restore = database.prepare("INSERT OR IGNORE INTO peers (name, target) VALUES (?, ?)");
+    for (const peer of salvaged) restore.run(peer.name, peer.target);
   }
-  const eventColumns = `
-      host_id, seq, ts, agent_id, session, window, pane,
-      session_name, window_name, agent_name, pi_session,
-      workstream, role, cli, driver, kind, state, message, pid,
-      synthetic, reason, extra`;
-  const eventPlaceholders = new Array(22).fill("?").join(", ");
-  const insertEvent = database.prepare(
-    `INSERT INTO events (${eventColumns}) VALUES (${eventPlaceholders})`
-  );
-  const ingestEvent = database.prepare(
-    `INSERT OR IGNORE INTO events (${eventColumns}) VALUES (${eventPlaceholders})`
+  const selectAgentByPane = database.prepare("SELECT * FROM agents WHERE pane = ?");
+  const insertAgent = database.prepare(`
+    INSERT INTO agents (agent_id, pane, owner_pid, activity, session, window,
+                        session_name, window_name, agent_name, pi_session,
+                        workstream, role, cli, driver, claimed_at, updated_at)
+    VALUES (@agent_id, @pane, @owner_pid, @activity, @session, @window,
+            @session_name, @window_name, @agent_name, @pi_session,
+            @workstream, @role, @cli, @driver, @claimed_at, @updated_at)
+  `);
+  const retainAgent = database.prepare(`
+    UPDATE agents
+       SET session = @session, window = @window, session_name = @session_name,
+           window_name = @window_name, agent_name = @agent_name,
+           pi_session = @pi_session, workstream = @workstream, role = @role,
+           cli = @cli, driver = @driver, updated_at = @updated_at
+     WHERE agent_id = @agent_id
+  `);
+  const deleteAgentByPane = database.prepare("DELETE FROM agents WHERE pane = ?");
+  const deleteAttentionForPane = database.prepare("DELETE FROM attention WHERE pane = ?");
+  const updateActivity = database.prepare(`
+    UPDATE agents
+       SET activity = @activity, session = @session, window = @window,
+           session_name = @session_name, window_name = @window_name,
+           updated_at = @updated_at
+     WHERE agent_id = @agent_id AND owner_pid = @owner_pid
+  `);
+  const deleteAgentOwned = database.prepare(
+    "DELETE FROM agents WHERE agent_id = ? AND owner_pid = ?"
   );
-  const selectMaxSeq = database.prepare(
-    "SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE host_id = ?"
+  const upsertAttention = database.prepare(`
+    INSERT INTO attention (pane, kind, message, source, session, window,
+                           session_name, window_name, requested_at)
+    VALUES (@pane, @kind, @message, @source, @session, @window,
+            @session_name, @window_name, @requested_at)
+    ON CONFLICT (pane, kind) DO UPDATE SET
+      message = excluded.message,
+      source = excluded.source,
+      session = excluded.session,
+      window = excluded.window,
+      session_name = excluded.session_name,
+      window_name = excluded.window_name
+  `);
+  const selectAgents = database.prepare("SELECT * FROM agents");
+  const selectAttention = database.prepare("SELECT * FROM attention");
+  const setActivityByPane = database.prepare(
+    "UPDATE agents SET activity = ?, updated_at = ? WHERE pane = ?"
   );
-  const append = database.transaction((event) => {
-    const row = selectMaxSeq.get(identity.host_id);
-    const stored = {
-      ...event,
-      host_id: identity.host_id,
-      seq: row.seq + 1,
-      ts: event.ts ?? Date.now(),
-      session_name: event.session_name ?? null,
-      window_name: event.window_name ?? null,
-      agent_name: event.agent_name ?? null,
-      pi_session: event.pi_session ?? null
+  const claimAgent = database.transaction((claim) => {
+    const now = claim.now ?? Date.now();
+    const isAlive = claim.isAlive ?? pidAlive;
+    const { location, meta, owner_pid } = claim;
+    const incumbent = selectAgentByPane.get(location.pane);
+    const values = {
+      pane: location.pane,
+      owner_pid,
+      session: location.session,
+      window: location.window,
+      session_name: location.session_name,
+      window_name: location.window_name,
+      agent_name: meta.agent_name,
+      pi_session: meta.pi_session,
+      workstream: meta.workstream,
+      role: meta.role,
+      cli: meta.cli,
+      driver: meta.driver,
+      updated_at: now
     };
-    insertEvent.run(...eventValues(stored));
-    return stored;
-  });
-  const ingest = database.transaction((events) => {
-    let inserted = 0;
-    for (const event of events) inserted += ingestEvent.run(...eventValues(event)).changes;
-    return inserted;
+    if (!incumbent) {
+      const agentId2 = randomUUID2();
+      insertAgent.run({ ...values, agent_id: agentId2, activity: "stopped", claimed_at: now });
+      return { outcome: "claimed", agent_id: agentId2 };
+    }
+    if (incumbent.owner_pid === owner_pid) {
+      retainAgent.run({ ...values, agent_id: incumbent.agent_id });
+      return { outcome: "retained", agent_id: incumbent.agent_id };
+    }
+    if (isAlive(incumbent.owner_pid)) {
+      return { outcome: "refused", held_by_pid: incumbent.owner_pid };
+    }
+    deleteAgentByPane.run(location.pane);
+    deleteAttentionForPane.run(location.pane);
+    const agentId = randomUUID2();
+    insertAgent.run({ ...values, agent_id: agentId, activity: "stopped", claimed_at: now });
+    return { outcome: "replaced", agent_id: agentId, previous_agent_id: incumbent.agent_id };
+  }).immediate;
+  const reconcileLocal = database.transaction((world) => {
+    const summary = { crashed: [], removed: [], attention_removed: [] };
+    if (world.panes === null) return summary;
+    const live = world.panes;
+    const isAlive = world.isAlive ?? pidAlive;
+    const now = world.now ?? Date.now();
+    const alreadyCrashed = new Set(
+      selectAttention.all().filter((row) => row.kind === "crashed").map((row) => row.pane)
+    );
+    for (const row of selectAgents.all()) {
+      const pane = asPaneId(row.pane);
+      if (!live.has(pane)) {
+        deleteAgentByPane.run(row.pane);
+        deleteAttentionForPane.run(row.pane);
+        summary.removed.push(pane);
+        continue;
+      }
+      if (isAlive(row.owner_pid)) continue;
+      if (row.activity === "running") {
+        setActivityByPane.run("stopped", now, row.pane);
+        upsertAttention.run({
+          pane: row.pane,
+          kind: "crashed",
+          message: "",
+          source: "murmur",
+          session: row.session,
+          window: row.window,
+          session_name: row.session_name,
+          window_name: row.window_name,
+          requested_at: now
+        });
+        summary.crashed.push(pane);
+      } else if (!alreadyCrashed.has(row.pane)) {
+        deleteAgentByPane.run(row.pane);
+        summary.removed.push(pane);
+      }
+    }
+    for (const row of selectAttention.all()) {
+      const pane = asPaneId(row.pane);
+      if (live.has(pane)) continue;
+      deleteAttentionForPane.run(row.pane);
+      if (!summary.attention_removed.includes(pane)) summary.attention_removed.push(pane);
+    }
+    return summary;
+  }).immediate;
+  const readLocalPanes = database.transaction(() => {
+    const agents = selectAgents.all();
+    const attention = selectAttention.all();
+    const panes = /* @__PURE__ */ new Map();
+    const locate = (row) => {
+      const existing = panes.get(row.pane);
+      if (existing) return existing;
+      const created = {
+        pane: asPaneId(row.pane),
+        session: asSessionId(row.session),
+        window: asWindowId(row.window),
+        session_name: row.session_name,
+        window_name: row.window_name,
+        agent: null,
+        attention: []
+      };
+      panes.set(row.pane, created);
+      return created;
+    };
+    for (const row of agents) locate(row).agent = toAgent(row);
+    for (const row of attention) locate(row).attention.push(toAttention(row));
+    for (const pane of panes.values()) pane.attention.sort(attentionOrder);
+    return [...panes.values()].sort((left, right) => left.pane.localeCompare(right.pane));
   });
+  function peerRecord(row) {
+    let snapshot = null;
+    if (row.snapshot !== null) {
+      try {
+        snapshot = JSON.parse(row.snapshot);
+      } catch {
+        snapshot = null;
+      }
+    }
+    return {
+      name: row.name,
+      target: row.target,
+      host_id: row.host_id,
+      display_name: row.display_name,
+      snapshot,
+      snapshot_at: row.snapshot_at,
+      fetched_at: row.fetched_at,
+      last_attempt_at: row.last_attempt_at,
+      last_error: row.last_error,
+      murmur_version: row.murmur_version,
+      snapshot_version: row.snapshot_version
+    };
+  }
   return {
-    append,
-    ingest,
-    eventsSince(hostId, seq) {
-      const rows = database.prepare("SELECT * FROM events WHERE host_id = ? AND seq > ? ORDER BY seq").all(hostId, seq);
-      return rows.map(toEvent);
-    },
-    allEvents() {
-      const rows = database.prepare("SELECT * FROM events ORDER BY ts, host_id, seq").all();
-      return rows.map(toEvent);
+    claimAgent,
+    reconcileLocal,
+    setActivity(update) {
+      return updateActivity.run({
+        activity: update.activity,
+        session: update.location.session,
+        window: update.location.window,
+        session_name: update.location.session_name,
+        window_name: update.location.window_name,
+        updated_at: update.now ?? Date.now(),
+        agent_id: update.agent_id,
+        owner_pid: update.owner_pid
+      }).changes === 1;
     },
-    latestForAgent(hostId, agentId) {
-      const row = database.prepare(
-        `SELECT * FROM events
-            WHERE host_id = ? AND agent_id = ?
-            ORDER BY seq DESC LIMIT 1`
-      ).get(hostId, agentId);
-      return row ? toEvent(row) : null;
+    releaseAgent(release) {
+      return deleteAgentOwned.run(release.agent_id, release.owner_pid).changes === 1;
     },
-    maxSeq(hostId) {
-      return selectMaxSeq.get(hostId).seq;
+    requestAttention(request) {
+      upsertAttention.run({
+        pane: request.location.pane,
+        kind: request.kind,
+        message: request.message,
+        source: request.source,
+        session: request.location.session,
+        window: request.location.window,
+        session_name: request.location.session_name,
+        window_name: request.location.window_name,
+        requested_at: request.now ?? Date.now()
+      });
     },
-    prune(horizonMs = Number(process.env.MURMUR_RETENTION_MS ?? DEFAULT_RETENTION_MS)) {
-      return database.prepare(`
-          DELETE FROM events
-           WHERE ts < ?
-             AND (host_id, seq) NOT IN (
-               SELECT host_id, seq FROM (
-                 SELECT host_id, seq,
-                        ROW_NUMBER() OVER (PARTITION BY agent_id ORDER BY ts DESC, seq DESC) rn
-                   FROM events
-               ) WHERE rn = 1
-             )
-        `).run(Date.now() - horizonMs).changes;
-    },
-    peers() {
-      return database.prepare("SELECT * FROM peers ORDER BY name").all();
+    acknowledgePane(pane) {
+      return deleteAttentionForPane.run(pane).changes;
     },
-    forgetAgent(agentId) {
-      return database.prepare("DELETE FROM events WHERE agent_id = ?").run(agentId).changes;
+    localPanes() {
+      return readLocalPanes();
     },
-    forgetHost(hostId) {
-      return database.prepare("DELETE FROM events WHERE host_id = ?").run(hostId).changes;
+    buildLocalSnapshot(identity, world) {
+      reconcileLocal(world);
+      return {
+        murmur_snapshot: 1,
+        host_id: identity.host_id,
+        display_name: identity.display_name,
+        murmur_version: MURMUR_VERSION,
+        generated_at: world.now ?? Date.now(),
+        // Rule 3: a pane with no agent and no attention must not be published.
+        // A no-op against today's `readLocalPanes`, which builds a pane entry
+        // only from a row and so cannot produce an empty one -- kept because the
+        // rule belongs to the DOCUMENT, and the validator rejects such an entry
+        // outright. Without it, one narrowing of the local read would make this
+        // node reachable-but-broken on every peer that collects it, and the
+        // symptom would show up on the other machines.
+        panes: readLocalPanes().filter((pane) => pane.agent !== null || pane.attention.length > 0)
+      };
     },
-    upsertPeer(peer) {
-      const current = database.prepare("SELECT * FROM peers WHERE name = ?").get(peer.name);
-      database.prepare(`
-          INSERT INTO peers (name, target, host_id, display_name, watermark, fetched_at, tmux_down_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?)
-          ON CONFLICT(name) DO UPDATE SET
-            target = excluded.target,
-            host_id = excluded.host_id,
-            display_name = excluded.display_name,
-            watermark = excluded.watermark,
-            fetched_at = excluded.fetched_at,
-            tmux_down_at = excluded.tmux_down_at
-        `).run(
-        peer.name,
-        peer.target,
-        peer.host_id !== void 0 ? peer.host_id : current?.host_id ?? null,
-        peer.display_name !== void 0 ? peer.display_name : current?.display_name ?? null,
-        peer.watermark !== void 0 ? peer.watermark : current?.watermark ?? 0,
-        peer.fetched_at !== void 0 ? peer.fetched_at : current?.fetched_at ?? null,
-        peer.tmux_down_at !== void 0 ? peer.tmux_down_at : current?.tmux_down_at ?? null
+    peers() {
+      return database.prepare("SELECT * FROM peers ORDER BY name").all().map(
+        peerRecord
       );
     },
+    addPeer(name, target) {
+      database.prepare(
+        `INSERT INTO peers (name, target) VALUES (?, ?)
+           ON CONFLICT(name) DO UPDATE SET target = excluded.target`
+      ).run(name, target);
+    },
     removePeer(name) {
       return database.prepare("DELETE FROM peers WHERE name = ?").run(name).changes > 0;
     },
+    replacePeerSnapshot(name, fetch) {
+      if (!fetch.ok) {
+        database.prepare("UPDATE peers SET last_attempt_at = ?, last_error = ? WHERE name = ?").run(fetch.at, fetch.error, name);
+        return;
+      }
+      database.prepare(
+        `UPDATE peers
+              SET snapshot = ?, snapshot_at = ?, fetched_at = ?, last_attempt_at = ?,
+                  last_error = NULL, host_id = ?, display_name = ?,
+                  murmur_version = ?, snapshot_version = ?
+            WHERE name = ?`
+      ).run(
+        JSON.stringify(fetch.snapshot),
+        fetch.snapshot.generated_at,
+        fetch.at,
+        fetch.at,
+        fetch.snapshot.host_id,
+        fetch.snapshot.display_name,
+        fetch.snapshot.murmur_version,
+        fetch.snapshot.murmur_snapshot,
+        name
+      );
+    },
     close() {
       database.close();
     }