@volter/supercode-teams 0.3.159 → 0.3.161

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.159",
+  "version": "0.3.161",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/record-state.mjs

@@ -0,0 +1,143 @@
+// Machine-record snapshots are rows, and their deltas share the mail database's
+// sequence. A normal change never serializes every followed machine to a file.
+import { lstatSync, readFileSync, unlinkSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+
+export const RECORD_SCHEMA = `
+CREATE TABLE IF NOT EXISTS machine_record_heads (
+  role TEXT NOT NULL,
+  machine TEXT NOT NULL,
+  value TEXT NOT NULL CHECK (json_valid(value)),
+  PRIMARY KEY (role, machine)
+) STRICT;
+CREATE TABLE IF NOT EXISTS machine_record_rows (
+  role TEXT NOT NULL,
+  machine TEXT NOT NULL,
+  section TEXT NOT NULL,
+  key TEXT NOT NULL,
+  position INTEGER NOT NULL,
+  value TEXT NOT NULL CHECK (json_valid(value)),
+  PRIMARY KEY (role, machine, section, key)
+) STRICT;
+CREATE INDEX IF NOT EXISTS machine_record_order ON machine_record_rows(role, machine, section, position, key);
+`;
+
+export class RecordState {
+  constructor(store, role) { this.store = store; this.role = role; }
+
+  load(machine) {
+    const head = this.store.statement('SELECT value FROM machine_record_heads WHERE role = ? AND machine = ?').get(this.role, machine);
+    if (!head) return null;
+    const { record: summary, meta } = JSON.parse(head.value);
+    if (summary == null) return { record: null, meta };
+    const record = { ...summary, sessions: summary.sessions_rows ? [] : null, mail: {}, panes: null, capabilities: null, unread: {} };
+    delete record.sessions_rows;
+    for (const { section, key, value } of this.store.statement(`SELECT section, key, value FROM machine_record_rows
+      WHERE role = ? AND machine = ? ORDER BY section, position, key`).all(this.role, machine)) {
+      const parsed = JSON.parse(value);
+      if (section === 'sessions') record.sessions.push(parsed);
+      else if (section === 'mail') record.mail[key] = parsed;
+      else record[section] = parsed;
+    }
+    return { record, meta };
+  }
+
+  all() {
+    return this.store.statement('SELECT machine FROM machine_record_heads WHERE role = ? ORDER BY machine').all(this.role)
+      .map(({ machine }) => [machine, this.load(machine)]);
+  }
+
+  save(record, changed = {}, { meta = {}, publish = false } = {}) {
+    const machine = record.machine;
+    return this.store.transaction(() => {
+      const remove = this.store.statement('DELETE FROM machine_record_rows WHERE role = ? AND machine = ? AND section = ? AND key = ?');
+      const put = this.store.statement(`INSERT INTO machine_record_rows(role, machine, section, key, position, value) VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(role, machine, section, key) DO UPDATE SET position = excluded.position, value = excluded.value
+        WHERE position <> excluded.position OR value <> excluded.value`);
+      for (const [section, delta] of Object.entries(changed)) {
+        if (section === 'sessions') {
+          const rows = Array.isArray(record.sessions) ? record.sessions : [];
+          const positions = new Map(rows.map((row, at) => [row.address, at]));
+          if (delta?.delta) {
+            for (const key of delta.removed ?? []) remove.run(this.role, machine, section, key);
+            for (const row of delta.upsert ?? []) put.run(this.role, machine, section, row.address, positions.get(row.address) ?? 0, JSON.stringify(row));
+            // Only moved positions are written; the session objects stay rows.
+            const move = this.store.statement(`UPDATE machine_record_rows SET position = ?
+              WHERE role = ? AND machine = ? AND section = 'sessions' AND key = ? AND position <> ?`);
+            for (const [key, position] of positions) move.run(position, this.role, machine, key, position);
+          } else {
+            const keys = new Set(rows.map((row) => row.address));
+            for (const { key } of this.store.statement("SELECT key FROM machine_record_rows WHERE role = ? AND machine = ? AND section = 'sessions'").all(this.role, machine)) {
+              if (!keys.has(key)) remove.run(this.role, machine, section, key);
+            }
+            for (const row of rows) put.run(this.role, machine, section, row.address, positions.get(row.address), JSON.stringify(row));
+          }
+        } else if (section === 'mail') {
+          const boxes = delta && '*' in delta ? delta['*'] ?? {} : delta ?? {};
+          if (delta && '*' in delta) {
+            for (const { key } of this.store.statement("SELECT key FROM machine_record_rows WHERE role = ? AND machine = ? AND section = 'mail'").all(this.role, machine)) {
+              if (!(key in boxes)) remove.run(this.role, machine, section, key);
+            }
+          }
+          for (const [key, box] of Object.entries(boxes)) {
+            if (box == null) remove.run(this.role, machine, section, key);
+            else put.run(this.role, machine, section, key, 0, JSON.stringify(box));
+          }
+        } else put.run(this.role, machine, section, '', 0, JSON.stringify(record[section] ?? null));
+      }
+      const cursor = publish ? this.store.changes.append('machine-record', { machine }, { seq: record.seq, at: record.at, sections: changed }) : record.cursor;
+      const { sessions, mail, panes, capabilities, unread, ...summary } = record;
+      const head = { record: { ...summary, ...(cursor ? { cursor } : {}), sessions_rows: Array.isArray(sessions) }, meta };
+      this.store.statement(`INSERT INTO machine_record_heads(role, machine, value) VALUES (?, ?, ?)
+        ON CONFLICT(role, machine) DO UPDATE SET value = excluded.value`).run(this.role, machine, JSON.stringify(head));
+      return cursor;
+    });
+  }
+
+  saveEmpty(machine, meta) {
+    this.store.transaction(() => {
+      this.store.statement('DELETE FROM machine_record_rows WHERE role = ? AND machine = ?').run(this.role, machine);
+      this.store.statement(`INSERT INTO machine_record_heads(role, machine, value) VALUES (?, ?, ?)
+        ON CONFLICT(role, machine) DO UPDATE SET value = excluded.value`).run(this.role, machine, JSON.stringify({ record: null, meta }));
+    });
+  }
+
+  remove(machine) {
+    this.store.transaction(() => {
+      this.store.statement('DELETE FROM machine_record_rows WHERE role = ? AND machine = ?').run(this.role, machine);
+      this.store.statement('DELETE FROM machine_record_heads WHERE role = ? AND machine = ?').run(this.role, machine);
+    });
+  }
+
+  /** One-time read of the old holder file. Only an unchanged, regular source
+   * is removed after its snapshots and receipt commit together. */
+  importLegacy(file) {
+    const receiptKey = 'machine_records_file_import';
+    const previous = this.store.database.metadata(receiptKey);
+    let stat, bytes;
+    try { stat = lstatSync(file); }
+    catch (error) { if (error.code === 'ENOENT') return; throw error; }
+    if (!stat.isFile()) throw new Error(`legacy machine records at ${file} are not a regular file; retained`);
+    if (stat.size > 64 * 1024 * 1024) throw new Error(`legacy machine records at ${file} exceed the 64 MiB import bound; retained`);
+    bytes = readFileSync(file);
+    const digest = createHash('sha256').update(bytes).digest('hex');
+    if (previous && (previous.file !== file || previous.sha256 !== digest)) throw new Error(`legacy machine records changed after import; ${file} is retained`);
+    if (!previous) {
+      const parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+      if (parsed.version !== 1 || !parsed.machines || typeof parsed.machines !== 'object' || Array.isArray(parsed.machines)) throw new Error(`unrecognized legacy machine records at ${file}; retained`);
+      this.store.transaction(() => {
+        for (const [machine, held] of Object.entries(parsed.machines)) {
+          // Older holders saved linked machines that had not supplied any
+          // snapshot yet. They have no rows to import; presence follows them.
+          if (held && typeof held === 'object' && !Array.isArray(held) && held.record == null) continue;
+          if (!held?.record || held.record.machine !== machine || !Number.isSafeInteger(held.record.seq) || held.record.seq < 0 || (held.record.sessions != null && !Array.isArray(held.record.sessions)) || (held.record.mail != null && (typeof held.record.mail !== 'object' || Array.isArray(held.record.mail)))) throw new Error(`invalid legacy record of ${machine}; ${file} is retained`);
+          if (!this.load(machine)) this.save(held.record, { sessions: held.record.sessions, mail: { '*': held.record.mail ?? {} }, panes: held.record.panes, capabilities: held.record.capabilities, unread: held.record.unread ?? {} }, { meta: { received_at: held.received_at ?? null } });
+        }
+        this.store.database.setMetadata(receiptKey, { file, sha256: digest, at_ms: Date.now() });
+      });
+    }
+    const now = lstatSync(file);
+    if (!now.isFile() || now.ino !== stat.ino || now.dev !== stat.dev || !readFileSync(file).equals(bytes)) throw new Error(`legacy machine records changed before retirement; ${file} is retained`);
+    unlinkSync(file);
+  }
+}