nodio-cli 1.0.4 → 1.0.6

package/package.json

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

package/src/node/index.js

@@ -46,13 +46,35 @@ async function findFreePort(startPort, endPort) {
   throw new Error(`no free port found in range ${startPort}-${endPort}`);
 }
 
+function detectAdvertisedHost() {
+  const interfaces = os.networkInterfaces();
+  for (const addresses of Object.values(interfaces)) {
+    if (!Array.isArray(addresses)) {
+      continue;
+    }
+
+    for (const address of addresses) {
+      if (address.family === 'IPv4' && !address.internal) {
+        return address.address;
+      }
+    }
+  }
+
+  return '127.0.0.1';
+}
+
+function isLoopbackHost(host) {
+  const normalized = String(host || '').trim().toLowerCase();
+  return normalized === '127.0.0.1' || normalized === 'localhost' || normalized === '::1';
+}
+
 program
   .name('nodio-node')
   .description('Nodio donor node CLI')
   .argument('[capacity]', 'optional capacity shorthand, e.g. 10gb')
   .option('--node-id <id>', 'unique node ID (optional; auto-assigned and persisted if omitted)')
   .option('--server <url>', 'central server URL', 'https://api.nodio.me')
-  .option('--host <host>', 'host/IP exposed to network', '127.0.0.1')
+  .option('--host <host>', 'host/IP exposed to network (default: auto-detected LAN IP)', 'auto')
   .option('--port <port>', 'port to expose shard API (auto-picked when omitted)')
   .option('--storage-dir <path>', 'local shard storage directory (defaults to ~/.nodio-nodes/node-<port>)')
   .option('--capacity-gb <gb>', 'donated capacity in GB', '10')
@@ -70,6 +92,7 @@ program.action(async (capacityArg, options) => {
   const parsedCapacityArg = parseCapacityGb(capacityArg);
   const capacityGb = parsedCapacityArg ?? Number(options.capacityGb);
   const heartbeatMs = Number(options.heartbeatMs);
+  const advertisedHost = options.host === 'auto' ? detectAdvertisedHost() : options.host;
   const storageDir = options.storageDir
     ? path.resolve(options.storageDir)
     : path.join(os.homedir(), '.nodio-nodes', `node-${port}`);
@@ -87,10 +110,14 @@ program.action(async (capacityArg, options) => {
     throw new Error('heartbeat-ms must be greater than 0');
   }
 
+  if (isLoopbackHost(advertisedHost)) {
+    console.warn('[nodio-node] warning: loopback host is advertised; only this machine can reach this donor');
+  }
+
   const runtime = new NodioNodeRuntime({
     nodeId: options.nodeId,
     serverUrl: options.server,
-    publicUrl: `http://${options.host}:${port}`,
+    publicUrl: `http://${advertisedHost}:${port}`,
     port,
     storageDir,
     capacityBytes: Math.floor(capacityGb * 1024 * 1024 * 1024),

package/src/server/routes.js

@@ -58,6 +58,10 @@ function buildRoutes(config) {
         existingByNodeKey = await NodeModel.findOne({ nodeKey }).lean();
       }
 
+      if (existingByNodeKey && deviceKey && existingByNodeKey.deviceKey && existingByNodeKey.deviceKey !== deviceKey) {
+        return res.status(409).json({ error: 'nodeKey belongs to a different device' });
+      }
+
       if (existingByNodeKey && nodeId && nodeId !== existingByNodeKey.nodeId) {
         return res.status(409).json({ error: 'nodeKey is already associated with a different nodeId' });
       }
@@ -65,6 +69,17 @@ function buildRoutes(config) {
       let effectiveNodeId = nodeId || existingByNodeKey?.nodeId || null;
       let claimedKnownNode = null;
 
+      if (effectiveNodeId && deviceKey) {
+        const existingByNodeId = await NodeModel.findOne({ nodeId: effectiveNodeId }).lean();
+        if (
+          existingByNodeId
+          && existingByNodeId.deviceKey
+          && existingByNodeId.deviceKey !== deviceKey
+        ) {
+          return res.status(409).json({ error: 'nodeId belongs to a different device' });
+        }
+      }
+
       if (!effectiveNodeId && deviceKey && normalizedKnownNodeIds.length > 0) {
         claimedKnownNode = await NodeModel.findOneAndUpdate(
           {

package/src/user/commands.js

@@ -85,12 +85,28 @@ async function uploadFile(options) {
       throw new Error(`placement failed for ${shardId}: expected ${replicas} replicas`);
     }
 
+    const successfulReplicas = [];
+    const failedReplicas = [];
+
     for (const replica of plannedReplicas) {
-      const putUrl = `${normalizeUrl(replica.url)}/shards/${shardId}`;
-      await axios.put(putUrl, encrypted.cipherText, {
-        headers: { 'Content-Type': 'application/octet-stream' },
-        timeout: 30000
-      });
+      try {
+        const putUrl = `${normalizeUrl(replica.url)}/shards/${shardId}`;
+        await axios.put(putUrl, encrypted.cipherText, {
+          headers: { 'Content-Type': 'application/octet-stream' },
+          timeout: 30000
+        });
+        successfulReplicas.push(replica);
+      } catch (error) {
+        failedReplicas.push({ nodeId: replica.nodeId, url: replica.url, error: error.message });
+      }
+    }
+
+    if (successfulReplicas.length === 0) {
+      throw new Error(`failed to write shard ${shardId} to any replica: ${failedReplicas.map((r) => `${r.url} (${r.error})`).join(', ')}`);
+    }
+
+    if (failedReplicas.length > 0) {
+      console.warn(`[upload] shard ${shardId} failed on ${failedReplicas.length} replica(s), but succeeded on ${successfulReplicas.length}`);
     }
 
     await api.post('/shards/register', {
@@ -99,7 +115,7 @@ async function uploadFile(options) {
       order,
       sizeBytes: encrypted.cipherText.length,
       checksum,
-      nodeIds: plannedReplicas.map((replica) => replica.nodeId)
+      nodeIds: successfulReplicas.map((replica) => replica.nodeId)
     });
 
     encryptionShardMeta.push({