@walkhi/code-relax 0.1.0-beta.24 → 0.1.0-beta.25

package/dist/bin/self-relay-server.mjs

@@ -56,7 +56,7 @@ const relay = await startSelfRelay({ port, hostKey, stateFile, mysqlConfigFile,
   usageDiagnosticKeyFile: process.env.RELAY_USAGE_DIAGNOSTIC_KEY_FILE,
   publicRelayUrl: process.env.RELAY_PUBLIC_URL || serviceEndpoints.relayUrl, appDownloadUrl: process.env.RELAY_APP_DOWNLOAD_URL || serviceEndpoints.installUrl,
   log: entry => console.log(JSON.stringify({ time: new Date().toISOString(), ...entry })) });
-console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 32, maxRelaySessions,
+console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 128, maxRelaySessions,
   maxFrameMiB: 8, encryption: 'TLS must be supplied by reverse proxy; no end-to-end encryption' }));
 await new Promise(resolve => { process.once('SIGTERM', resolve); process.once('SIGINT', resolve); });
 await relay.close();

package/dist/src/self-relay/server.mjs

@@ -16,7 +16,7 @@ import { relayDiagnostics } from './diagnostics.mjs';
 
 // Always loopback; a TLS reverse proxy supplies the private-trial Internet endpoint.
 export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlMs = 120000,
-  maxConnections = 32, maxClientsPerHost = 16, maxPayload = 8 * 1024 * 1024, stateFile,
+  maxConnections = 128, maxClientsPerHost = 16, maxPayload = 8 * 1024 * 1024, stateFile,
   maxRelaySessions = 8, adminStateFile, mysqlConfigFile, accountConfigFile, usageDiagnosticKeyFile,
   publicRelayUrl = '', appDownloadUrl = '', debugAllowlistFile, log = () => {} } = {}) {
   if (!validSecret(hostKey)) throw new Error('Invalid host credential');
@@ -46,18 +46,34 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
   let activeRelaySessions = 0;
   for (const record of store.entries()) rooms.set(record.id, { ...record, durable: true, connections: new Map(), observers: new Map(), uploadClients: new Map() });
   let commitTail = Promise.resolve();
+  function queueStore(operation) {
+    const pending = commitTail.then(operation);
+    commitTail = pending.catch(() => {});
+    return pending;
+  }
   function commit(room, changes) {
-    const operation = commitTail.then(async () => {
-    changes = typeof changes === 'function' ? changes(room) : changes;
-    const next = { ...room, ...changes, updatedAt: new Date().toISOString() };
-    if (room.durable) {
-      const { id, hostHash, clients, revision, status, createdAt, updatedAt, officialComputer } = next;
-      await store.save({ id, hostHash, clients, revision, status, createdAt, updatedAt, ...(officialComputer ? { officialComputer } : {}) });
-    }
-    Object.assign(room, changes, { updatedAt: next.updatedAt });
+    return queueStore(async () => {
+      changes = typeof changes === 'function' ? changes(room) : changes;
+      const next = { ...room, ...changes, updatedAt: new Date().toISOString() };
+      if (room.durable) {
+        const { id, hostHash, clients, revision, status, createdAt, updatedAt, officialComputer } = next;
+        await store.save({ id, hostHash, clients, revision, status, createdAt, updatedAt, ...(officialComputer ? { officialComputer } : {}) });
+      }
+      Object.assign(room, changes, { updatedAt: next.updatedAt });
+    });
+  }
+  function registerRoom(id, durable, credential) {
+    return queueStore(async () => {
+      // Resolve concurrent first connections before writing the device identity.
+      if (durable && rooms.has(id)) return rooms.get(id);
+      const now = new Date().toISOString();
+      const record = { id, revision: 0, status: 'active', clients: [], createdAt: now, updatedAt: now,
+        ...(durable ? { hostHash: digest(credential) } : {}) };
+      if (durable) await store.save(record);
+      const room = { ...record, durable, connections: new Map(), observers: new Map(), uploadClients: new Map() };
+      rooms.set(id, room);
+      return room;
     });
-    commitTail = operation.catch(() => {});
-    return operation;
   }
   function invitation(room) {
     const code = secret(); room.pairingHash = digest(code); room.expires = Date.now() + pairingTtlMs;
@@ -298,7 +314,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n'); return;
     }
     if (Date.now() - admissionStart >= 60000) { admissionStart = Date.now(); admissions = 0; }
-    if (wss.clients.size >= maxConnections || ++admissions > 60) {
+    if (wss.clients.size >= maxConnections || ++admissions > 240) {
       socket.end('HTTP/1.1 429 Too Many Requests\r\nConnection: close\r\n\r\n'); return;
     }
     wss.handleUpgrade(request, socket, head, ws => wss.emit('connection', ws));
@@ -435,18 +451,12 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             }
             catch { return fail(1008, 'Invalid LAN candidates'); }
             room = durable ? rooms.get(message.deviceId) : undefined;
-            if (room && (room.status !== 'active' || !matches(message.deviceSecret, room.hostHash))) return fail();
             if (!room) {
-              // Durable computers prove future ownership with their generated device secret.
-              // The legacy deployment key remains accepted, but is no longer required for first registration.
               if (!durable && !matches(message.key, hostHash)) return fail();
-              if (rooms.size >= 256) return fail(4429, 'Device limit reached');
-              const now = new Date().toISOString();
-              room = { id: durable ? message.deviceId : randomUUID(), durable,
-                revision: 0, status: 'active', clients: [], connections: new Map(), observers: new Map(), uploadClients: new Map(), createdAt: now, updatedAt: now,
-                ...(durable ? { hostHash: digest(message.deviceSecret) } : {}) };
-              await commit(room, {}); rooms.set(room.id, room);
+              room = await registerRoom(durable ? message.deviceId : randomUUID(), durable, message.deviceSecret);
+              if (ws.readyState !== ws.OPEN) return;
             }
+            if (durable && (room.status !== 'active' || !matches(message.deviceSecret, room.hostHash))) return fail();
             const oldHost = room.host;
             room.observers ||= new Map();
             if (oldHost && oldHost !== ws) {
@@ -490,6 +500,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               await commit(room, current => ({ clients: [...current.clients.filter(item => item.id !== clientId), client], revision: current.revision + 1 }));
               room.pairingHash = undefined;
             } finally { room.pairingInProgress = false; }
+            if (!room.host) return fail(4410, 'Computer offline; authorization retained');
             send(room.host, { type: 'authorization-changed', clients: room.clients, revision: room.revision });
           } else {
             clientId = message.clientId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.24",
+  "version": "0.1.0-beta.25",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {