nodio-cli 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodio-cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Nodio distributed storage network",
   "main": "src/server/index.js",
   "type": "commonjs",

package/src/node/index.js

@@ -31,7 +31,7 @@ async function isPortFree(port) {
       server.close(() => resolve(true));
     });
 
-    server.listen(port, '127.0.0.1');
+    server.listen({ port, exclusive: true });
   });
 }
 

package/src/node/runtime.js

@@ -85,11 +85,18 @@ class NodioNodeRuntime {
       res.json({ ok: true, nodeId: this.nodeId });
     });
 
-    await new Promise((resolve) => {
-      app.listen(this.port, () => {
+    await new Promise((resolve, reject) => {
+      const server = app.listen({ port: this.port, exclusive: true }, () => {
         console.log(`Nodio node ${this.nodeId} listening on port ${this.port}`);
         resolve();
       });
+
+      server.once('error', (error) => {
+        if (error && error.code === 'EADDRINUSE') {
+          return reject(new Error(`port ${this.port} is already in use`));
+        }
+        return reject(error);
+      });
     });
   }
 
@@ -101,11 +108,13 @@ class NodioNodeRuntime {
   async registerNode() {
     const deviceKey = await getOrCreateDeviceKey();
     const nodeKey = await this.shardStore.getOrCreateNodeKey();
+    const knownNodeIds = await this.shardStore.discoverKnownNodeIds();
 
     const response = await axios.post(`${this.serverUrl}/api/nodes/register`, {
       nodeId: this.nodeId,
       deviceKey,
       nodeKey,
+      knownNodeIds,
       url: this.publicUrl,
       capacityBytes: this.capacityBytes,
       freeBytes: await this.freeBytes()

package/src/node/storage.js

@@ -67,6 +67,43 @@ class LocalShardStore {
     return identity.nodeId || null;
   }
 
+  async discoverKnownNodeIds() {
+    const known = new Set();
+
+    const current = await this.readIdentity();
+    if (current.nodeId) {
+      known.add(current.nodeId);
+    }
+
+    const parentDir = path.dirname(this.baseDir);
+    let entries = [];
+    try {
+      entries = await fs.readdir(parentDir, { withFileTypes: true });
+    } catch {
+      return [...known];
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      const identityPath = path.join(parentDir, entry.name, 'node-identity.json');
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const raw = await fs.readFile(identityPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.nodeId && typeof parsed.nodeId === 'string') {
+          known.add(parsed.nodeId);
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    return [...known];
+  }
+
   async saveAssignedNodeId(nodeId) {
     if (!nodeId) {
       return;

package/src/server/routes.js

@@ -31,7 +31,7 @@ function buildRoutes(config) {
 
   router.post('/nodes/register', async (req, res, next) => {
     try {
-      const { nodeId, deviceKey, nodeKey, url, capacityBytes, freeBytes } = req.body;
+      const { nodeId, deviceKey, nodeKey, knownNodeIds, url, capacityBytes, freeBytes } = req.body;
 
       if (!url) {
         return res.status(400).json({ error: 'url is required' });
@@ -45,6 +45,13 @@ function buildRoutes(config) {
       if (deviceKey && typeof deviceKey !== 'string') {
         return res.status(400).json({ error: 'deviceKey must be a string when provided' });
       }
+      if (knownNodeIds !== undefined && !Array.isArray(knownNodeIds)) {
+        return res.status(400).json({ error: 'knownNodeIds must be an array when provided' });
+      }
+
+      const normalizedKnownNodeIds = Array.isArray(knownNodeIds)
+        ? [...new Set(knownNodeIds.filter((value) => typeof value === 'string' && value.length > 0))]
+        : [];
 
       let existingByNodeKey = null;
       if (nodeKey) {
@@ -55,24 +62,58 @@ function buildRoutes(config) {
         return res.status(409).json({ error: 'nodeKey is already associated with a different nodeId' });
       }
 
-      const effectiveNodeId = nodeId || existingByNodeKey?.nodeId || `donor-${uuidv4().slice(0, 8)}`;
+      let effectiveNodeId = nodeId || existingByNodeKey?.nodeId || null;
+      let claimedKnownNode = null;
 
-      const node = await NodeModel.findOneAndUpdate(
-        { nodeId: effectiveNodeId },
-        {
-          $set: {
-            nodeId: effectiveNodeId,
-            ...(deviceKey ? { deviceKey } : {}),
-            ...(nodeKey ? { nodeKey } : {}),
-            url,
-            capacityBytes: capacity,
-            freeBytes: free,
-            status: 'online',
-            lastHeartbeatAt: new Date()
+      if (!effectiveNodeId && deviceKey && normalizedKnownNodeIds.length > 0) {
+        claimedKnownNode = await NodeModel.findOneAndUpdate(
+          {
+            deviceKey,
+            status: 'offline',
+            nodeId: { $in: normalizedKnownNodeIds }
+          },
+          {
+            $set: {
+              url,
+              capacityBytes: capacity,
+              freeBytes: free,
+              status: 'online',
+              lastHeartbeatAt: new Date(),
+              ...(nodeKey ? { nodeKey } : {})
+            }
+          },
+          {
+            new: true,
+            sort: { createdAt: 1 }
           }
-        },
-        { upsert: true, new: true, setDefaultsOnInsert: true }
-      );
+        );
+
+        if (claimedKnownNode) {
+          effectiveNodeId = claimedKnownNode.nodeId;
+        }
+      }
+
+      if (!effectiveNodeId) {
+        effectiveNodeId = `donor-${uuidv4().slice(0, 8)}`;
+      }
+
+      const node = claimedKnownNode
+        || await NodeModel.findOneAndUpdate(
+          { nodeId: effectiveNodeId },
+          {
+            $set: {
+              nodeId: effectiveNodeId,
+              ...(deviceKey ? { deviceKey } : {}),
+              ...(nodeKey ? { nodeKey } : {}),
+              url,
+              capacityBytes: capacity,
+              freeBytes: free,
+              status: 'online',
+              lastHeartbeatAt: new Date()
+            }
+          },
+          { upsert: true, new: true, setDefaultsOnInsert: true }
+        );
 
       res.json({
         nodeId: node.nodeId,