@walkhi/code-relax 0.1.0-beta.66 → 0.1.0-beta.68

package/dist/src/self-relay/device-store.mjs

@@ -1,92 +1,92 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { connectionInfo, validConnectionInfo } from './device-info.mjs';
-
-export const validId = value => typeof value === 'string' && /^[\w-]{16,128}$/.test(value);
-const hash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
-export function deviceStore(file, { initialize = false } = {}) {
-  let devices = new Map();
-  function validate(record) {
-    if (!validId(record.id) || !hash(record.hostHash) || !['active', 'revoked'].includes(record.status) ||
-        !Number.isSafeInteger(record.revision) || record.revision < 0 ||
-        !Array.isArray(record.clients) ||
-        record.clients.some(client => !validId(client.id) || !hash(client.hash) || !validConnectionInfo(client) ||
-          !Number.isFinite(Date.parse(client.createdAt)) || !Number.isFinite(Date.parse(client.updatedAt))) ||
-        new Set(record.clients.map(client => client.id)).size !== record.clients.length ||
-        !Number.isFinite(Date.parse(record.createdAt)) || !Number.isFinite(Date.parse(record.updatedAt)) ||
-        !validOfficialComputer(record.officialComputer)) {
-      throw new Error('Invalid relay device record');
-    }
-  }
-  function write(next) {
-    if (!file) return;
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    let fd;
-    try {
-      fd = fs.openSync(temporary, 'wx', 0o600);
-      fs.writeFileSync(fd, JSON.stringify({ version: 4, devices: [...next.values()] }));
-      fs.fsyncSync(fd); fs.closeSync(fd); fd = undefined;
-      fs.renameSync(temporary, file);
-      if (process.platform !== 'win32') {
-        const directory = fs.openSync(path.dirname(file), 'r');
-        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
-      }
-    } finally {
-      if (fd !== undefined) fs.closeSync(fd);
-      fs.rmSync(temporary, { force: true });
-    }
-  }
-  if (file) {
-    if (!fs.existsSync(file)) {
-      if (!initialize) throw new Error('Device store missing; explicit --init-state required for first installation');
-      fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 }); write(devices);
-    } else {
-      if (initialize) throw new Error('Device store already exists; initialization refused');
-      const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
-      if (![2, 3, 4].includes(saved.version) || !Array.isArray(saved.devices)) throw new Error('Invalid relay device store version');
-      for (const source of saved.devices) {
-        const record = saved.version === 2 ? {
-          ...source,
-          clients: source.clientHash == null ? [] : [{
-            id: source.clientId,
-            hash: source.clientHash,
-            createdAt: source.updatedAt,
-            updatedAt: source.updatedAt,
-          }],
-        } : source;
-        delete record.clientHash; delete record.clientId;
-        validate(record);
-        if (devices.has(record.id)) throw new Error('Duplicate relay device identity');
-        devices.set(record.id, record);
-      }
-    }
-  }
-  return {
-    entries: () => [...devices.values()],
-    recordConnection(id, clientId, at, info) {
-      const record = devices.get(id), client = record?.clients.find(item => item.id === clientId);
-      if (!client) return;
-      const updated = connectionInfo(client, at, info);
-      this.save({ ...record, clients: record.clients.map(item => item.id === clientId ? updated : item) });
-      return updated;
-    },
-    // Synchronous single-writer commit: publish only after durable replacement.
-    save(record) {
-      validate(record);
-      const next = new Map(devices); next.set(record.id, record); write(next); devices = next;
-    },
-  };
-}
-
-function validOfficialComputer(value) {
-  if (value === undefined) return true;
-  return value && typeof value === 'object' && plain(value.environmentId, 256, false) &&
-    plain(value.name, 80, true) && plain(value.hostname, 80, true) &&
-    Number.isFinite(Date.parse(value.updatedAt));
-}
-
-function plain(value, limit, empty) {
-  return typeof value === 'string' && (empty || value.trim().length > 0) &&
-    value.trim().length <= limit && !/[\u0000-\u001f\u007f]/.test(value);
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { connectionInfo, validConnectionInfo } from './device-info.mjs';
+
+export const validId = value => typeof value === 'string' && /^[\w-]{16,128}$/.test(value);
+const hash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+export function deviceStore(file, { initialize = false } = {}) {
+  let devices = new Map();
+  function validate(record) {
+    if (!validId(record.id) || !hash(record.hostHash) || !['active', 'revoked'].includes(record.status) ||
+        !Number.isSafeInteger(record.revision) || record.revision < 0 ||
+        !Array.isArray(record.clients) ||
+        record.clients.some(client => !validId(client.id) || !hash(client.hash) || !validConnectionInfo(client) ||
+          !Number.isFinite(Date.parse(client.createdAt)) || !Number.isFinite(Date.parse(client.updatedAt))) ||
+        new Set(record.clients.map(client => client.id)).size !== record.clients.length ||
+        !Number.isFinite(Date.parse(record.createdAt)) || !Number.isFinite(Date.parse(record.updatedAt)) ||
+        !validOfficialComputer(record.officialComputer)) {
+      throw new Error('Invalid relay device record');
+    }
+  }
+  function write(next) {
+    if (!file) return;
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    let fd;
+    try {
+      fd = fs.openSync(temporary, 'wx', 0o600);
+      fs.writeFileSync(fd, JSON.stringify({ version: 4, devices: [...next.values()] }));
+      fs.fsyncSync(fd); fs.closeSync(fd); fd = undefined;
+      fs.renameSync(temporary, file);
+      if (process.platform !== 'win32') {
+        const directory = fs.openSync(path.dirname(file), 'r');
+        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
+      }
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+      fs.rmSync(temporary, { force: true });
+    }
+  }
+  if (file) {
+    if (!fs.existsSync(file)) {
+      if (!initialize) throw new Error('Device store missing; explicit --init-state required for first installation');
+      fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 }); write(devices);
+    } else {
+      if (initialize) throw new Error('Device store already exists; initialization refused');
+      const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (![2, 3, 4].includes(saved.version) || !Array.isArray(saved.devices)) throw new Error('Invalid relay device store version');
+      for (const source of saved.devices) {
+        const record = saved.version === 2 ? {
+          ...source,
+          clients: source.clientHash == null ? [] : [{
+            id: source.clientId,
+            hash: source.clientHash,
+            createdAt: source.updatedAt,
+            updatedAt: source.updatedAt,
+          }],
+        } : source;
+        delete record.clientHash; delete record.clientId;
+        validate(record);
+        if (devices.has(record.id)) throw new Error('Duplicate relay device identity');
+        devices.set(record.id, record);
+      }
+    }
+  }
+  return {
+    entries: () => [...devices.values()],
+    recordConnection(id, clientId, at, info) {
+      const record = devices.get(id), client = record?.clients.find(item => item.id === clientId);
+      if (!client) return;
+      const updated = connectionInfo(client, at, info);
+      this.save({ ...record, clients: record.clients.map(item => item.id === clientId ? updated : item) });
+      return updated;
+    },
+    // Synchronous single-writer commit: publish only after durable replacement.
+    save(record) {
+      validate(record);
+      const next = new Map(devices); next.set(record.id, record); write(next); devices = next;
+    },
+  };
+}
+
+function validOfficialComputer(value) {
+  if (value === undefined) return true;
+  return value && typeof value === 'object' && plain(value.environmentId, 256, false) &&
+    plain(value.name, 80, true) && plain(value.hostname, 80, true) &&
+    Number.isFinite(Date.parse(value.updatedAt));
+}
+
+function plain(value, limit, empty) {
+  return typeof value === 'string' && (empty || value.trim().length > 0) &&
+    value.trim().length <= limit && !/[\u0000-\u001f\u007f]/.test(value);
+}

package/dist/src/self-relay/lan-authorizations.mjs

@@ -1,71 +1,71 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import { digest, matches } from './wire.mjs';
-import { validId } from './device-store.mjs';
-import { deviceInfo } from './device-info.mjs';
-
-const recordPath = stateRoot => path.join(stateRoot, 'lan-device-authorizations.json');
-const validHash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
-const authorizationChanges = new EventEmitter();
-const deviceConnections = new EventEmitter();
-const authorizationKey = stateRoot => {
-  const resolved = path.resolve(stateRoot);
-  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
-};
-
-export function onLanAuthorizationsChanged(stateRoot, listener) {
-  const key = authorizationKey(stateRoot);
-  authorizationChanges.on(key, listener);
-  return () => authorizationChanges.off(key, listener);
-}
-
-export function saveLanAuthorizations(stateRoot, hostId, clients, revision) {
-  if (!validId(hostId) || !Array.isArray(clients) ||
-      clients.some(client => !validId(client.id) || !validHash(client.hash)) ||
-      !Number.isSafeInteger(revision) || revision < 0) throw new Error('Invalid LAN device authorization state');
-  const file = recordPath(stateRoot), temporary = `${file}.${randomUUID()}.tmp`;
-  const previous = readAuthorizations(stateRoot);
-  const known = new Map(previous?.hostId === hostId ? previous.clients.map(client => [client.id, client]) : []);
-  const record = { version: 1, hostId, revision, clients: clients.map(client => ({ id: client.id, hash: client.hash,
-    ...(known.get(client.id)?.lastLanConnectedAt ? { lastLanConnectedAt: known.get(client.id).lastLanConnectedAt,
-      lanInfo: known.get(client.id).lanInfo } : {}), lastConnectedAt: client.lastConnectedAt || null })) };
-  try {
-    fs.writeFileSync(temporary, JSON.stringify(record), { mode: 0o600, flag: 'wx' });
-    fs.renameSync(temporary, file);
-  } finally { fs.rmSync(temporary, { force: true }); }
-  authorizationChanges.emit(authorizationKey(stateRoot));
-}
-function readAuthorizations(stateRoot) {
-  try { return JSON.parse(fs.readFileSync(recordPath(stateRoot), 'utf8')); }
-  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
-}
-export function recordLanConnection(stateRoot, clientId, info) {
-  const record = readAuthorizations(stateRoot), client = record?.clients.find(item => item.id === clientId);
-  if (!client) return;
-  client.lastLanConnectedAt = new Date().toISOString(); client.lanInfo = { ...client.lanInfo, ...deviceInfo(info) };
-  const file = recordPath(stateRoot), temporary = `${file}.${randomUUID()}.tmp`;
-  try {
-    fs.writeFileSync(temporary, JSON.stringify(record), { mode: 0o600, flag: 'wx' }); fs.renameSync(temporary, file);
-  } finally { fs.rmSync(temporary, { force: true }); }
-  deviceConnections.emit(authorizationKey(stateRoot), { clientId, at: client.lastLanConnectedAt, ...client.lanInfo });
-}
-export function pendingLanConnections(stateRoot) {
-  return (readAuthorizations(stateRoot)?.clients || []).filter(client => client.lastLanConnectedAt &&
-    (!client.lastConnectedAt || client.lastLanConnectedAt > client.lastConnectedAt))
-    .map(client => ({ clientId: client.id, at: client.lastLanConnectedAt, ...client.lanInfo }));
-}
-export function onLanDeviceConnected(stateRoot, listener) {
-  const key = authorizationKey(stateRoot); deviceConnections.on(key, listener);
-  return () => deviceConnections.off(key, listener);
-}
-export function authorizeLanDevice(stateRoot, clientId, credential) {
-  if (!validId(clientId)) return false;
-  let record;
-  try { record = JSON.parse(fs.readFileSync(recordPath(stateRoot), 'utf8')); }
-  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
-  if (record?.version !== 1 || !validId(record.hostId) || !Array.isArray(record.clients)) return false;
-  const client = record.clients.find(item => item?.id === clientId && validHash(item.hash));
-  return Boolean(client && matches(credential, client.hash));
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { digest, matches } from './wire.mjs';
+import { validId } from './device-store.mjs';
+import { deviceInfo } from './device-info.mjs';
+
+const recordPath = stateRoot => path.join(stateRoot, 'lan-device-authorizations.json');
+const validHash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const authorizationChanges = new EventEmitter();
+const deviceConnections = new EventEmitter();
+const authorizationKey = stateRoot => {
+  const resolved = path.resolve(stateRoot);
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+};
+
+export function onLanAuthorizationsChanged(stateRoot, listener) {
+  const key = authorizationKey(stateRoot);
+  authorizationChanges.on(key, listener);
+  return () => authorizationChanges.off(key, listener);
+}
+
+export function saveLanAuthorizations(stateRoot, hostId, clients, revision) {
+  if (!validId(hostId) || !Array.isArray(clients) ||
+      clients.some(client => !validId(client.id) || !validHash(client.hash)) ||
+      !Number.isSafeInteger(revision) || revision < 0) throw new Error('Invalid LAN device authorization state');
+  const file = recordPath(stateRoot), temporary = `${file}.${randomUUID()}.tmp`;
+  const previous = readAuthorizations(stateRoot);
+  const known = new Map(previous?.hostId === hostId ? previous.clients.map(client => [client.id, client]) : []);
+  const record = { version: 1, hostId, revision, clients: clients.map(client => ({ id: client.id, hash: client.hash,
+    ...(known.get(client.id)?.lastLanConnectedAt ? { lastLanConnectedAt: known.get(client.id).lastLanConnectedAt,
+      lanInfo: known.get(client.id).lanInfo } : {}), lastConnectedAt: client.lastConnectedAt || null })) };
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(record), { mode: 0o600, flag: 'wx' });
+    fs.renameSync(temporary, file);
+  } finally { fs.rmSync(temporary, { force: true }); }
+  authorizationChanges.emit(authorizationKey(stateRoot));
+}
+function readAuthorizations(stateRoot) {
+  try { return JSON.parse(fs.readFileSync(recordPath(stateRoot), 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+export function recordLanConnection(stateRoot, clientId, info) {
+  const record = readAuthorizations(stateRoot), client = record?.clients.find(item => item.id === clientId);
+  if (!client) return;
+  client.lastLanConnectedAt = new Date().toISOString(); client.lanInfo = { ...client.lanInfo, ...deviceInfo(info) };
+  const file = recordPath(stateRoot), temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(record), { mode: 0o600, flag: 'wx' }); fs.renameSync(temporary, file);
+  } finally { fs.rmSync(temporary, { force: true }); }
+  deviceConnections.emit(authorizationKey(stateRoot), { clientId, at: client.lastLanConnectedAt, ...client.lanInfo });
+}
+export function pendingLanConnections(stateRoot) {
+  return (readAuthorizations(stateRoot)?.clients || []).filter(client => client.lastLanConnectedAt &&
+    (!client.lastConnectedAt || client.lastLanConnectedAt > client.lastConnectedAt))
+    .map(client => ({ clientId: client.id, at: client.lastLanConnectedAt, ...client.lanInfo }));
+}
+export function onLanDeviceConnected(stateRoot, listener) {
+  const key = authorizationKey(stateRoot); deviceConnections.on(key, listener);
+  return () => deviceConnections.off(key, listener);
+}
+export function authorizeLanDevice(stateRoot, clientId, credential) {
+  if (!validId(clientId)) return false;
+  let record;
+  try { record = JSON.parse(fs.readFileSync(recordPath(stateRoot), 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+  if (record?.version !== 1 || !validId(record.hostId) || !Array.isArray(record.clients)) return false;
+  const client = record.clients.find(item => item?.id === clientId && validHash(item.hash));
+  return Boolean(client && matches(credential, client.hash));
+}