nodio-cli 1.0.1 → 1.0.3

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "nodio-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Nodio distributed storage network",
   "main": "src/server/index.js",
   "type": "commonjs",
   "bin": {
+    "nodio-cli": "src/cli/index.js",
     "nodio-server": "src/server/index.js",
     "nodio-node": "src/node/index.js",
     "nodio": "src/user/index.js"

package/src/cli/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+const path = require('path');
+const { spawn } = require('child_process');
+
+const commandMap = {
+  'nodio-node': path.join(__dirname, '..', 'node', 'index.js'),
+  'nodio-server': path.join(__dirname, '..', 'server', 'index.js'),
+  nodio: path.join(__dirname, '..', 'user', 'index.js')
+};
+
+function printHelp() {
+  console.log('Nodio CLI dispatcher');
+  console.log('');
+  console.log('Usage:');
+  console.log('  nodio-cli <command> [...args]');
+  console.log('');
+  console.log('Commands:');
+  console.log('  nodio-node      Start donor node runtime');
+  console.log('  nodio-server    Start central server');
+  console.log('  nodio           User CLI (upload/download/delete)');
+  console.log('');
+  console.log('Example:');
+  console.log('  npx nodio-cli nodio-node 10gb');
+}
+
+const [command, ...restArgs] = process.argv.slice(2);
+
+if (!command || command === '--help' || command === '-h') {
+  printHelp();
+  process.exit(0);
+}
+
+const scriptPath = commandMap[command];
+if (!scriptPath) {
+  console.error(`[nodio-cli] Unknown command: ${command}`);
+  printHelp();
+  process.exit(1);
+}
+
+const child = spawn(process.execPath, [scriptPath, ...restArgs], {
+  stdio: 'inherit'
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 0);
+});

package/src/node/deviceIdentity.js

@@ -0,0 +1,45 @@
+const fs = require('fs/promises');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const DEVICE_DIR = path.join(os.homedir(), '.nodio');
+const DEVICE_FILE = path.join(DEVICE_DIR, 'device-identity.json');
+
+async function readDeviceIdentity() {
+  try {
+    const raw = await fs.readFile(DEVICE_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+async function getOrCreateDeviceKey() {
+  const identity = await readDeviceIdentity();
+  if (identity.deviceKey) {
+    return identity.deviceKey;
+  }
+
+  const deviceKey = crypto.randomUUID();
+  await fs.mkdir(DEVICE_DIR, { recursive: true });
+  await fs.writeFile(
+    DEVICE_FILE,
+    JSON.stringify(
+      {
+        deviceKey,
+        createdAt: new Date().toISOString()
+      },
+      null,
+      2
+    ),
+    'utf-8'
+  );
+
+  return deviceKey;
+}
+
+module.exports = {
+  getOrCreateDeviceKey
+};

package/src/node/index.js

@@ -1,31 +1,85 @@
 #!/usr/bin/env node
 const path = require('path');
 const os = require('os');
+const net = require('net');
 const { Command } = require('commander');
-const { v4: uuidv4 } = require('uuid');
 const { NodioNodeRuntime } = require('./runtime');
 
 const program = new Command();
 
+function parseCapacityGb(value) {
+  if (value === undefined || value === null || value === '') {
+    return null;
+  }
+
+  const raw = String(value).trim().toLowerCase();
+  const match = raw.match(/^([0-9]+(?:\.[0-9]+)?)(gb)?$/);
+  if (!match) {
+    throw new Error('capacity must be a number or <number>gb, e.g. 10 or 10gb');
+  }
+
+  return Number(match[1]);
+}
+
+async function isPortFree(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+async function findFreePort(startPort, endPort) {
+  for (let port = startPort; port <= endPort; port += 1) {
+    // eslint-disable-next-line no-await-in-loop
+    if (await isPortFree(port)) {
+      return port;
+    }
+  }
+
+  throw new Error(`no free port found in range ${startPort}-${endPort}`);
+}
+
 program
   .name('nodio-node')
   .description('Nodio donor node CLI')
-  .option('--node-id <id>', 'unique node ID', uuidv4())
-  .option('--server <url>', 'central server URL', 'http://127.0.0.1:4000')
+  .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('--port <port>', 'port to expose shard API', '5001')
-  .option('--storage-dir <path>', 'local shard storage directory', path.join(os.homedir(), '.nodio-node'))
+  .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')
+  .option('--auto-port-start <port>', 'start of auto-port range', '5001')
+  .option('--auto-port-end <port>', 'end of auto-port range', '5999')
   .option('--heartbeat-ms <ms>', 'heartbeat interval in milliseconds', '30000');
 
-program.action(async (options) => {
-  const port = Number(options.port);
-  const capacityGb = Number(options.capacityGb);
+program.action(async (capacityArg, options) => {
+  const autoPortStart = Number(options.autoPortStart);
+  const autoPortEnd = Number(options.autoPortEnd);
+  const port = options.port
+    ? Number(options.port)
+    : await findFreePort(autoPortStart, autoPortEnd);
+
+  const parsedCapacityArg = parseCapacityGb(capacityArg);
+  const capacityGb = parsedCapacityArg ?? Number(options.capacityGb);
   const heartbeatMs = Number(options.heartbeatMs);
+  const storageDir = options.storageDir
+    ? path.resolve(options.storageDir)
+    : path.join(os.homedir(), '.nodio-nodes', `node-${port}`);
 
   if (!Number.isInteger(port) || port <= 0) {
     throw new Error('port must be a positive integer');
   }
+  if (!Number.isInteger(autoPortStart) || !Number.isInteger(autoPortEnd) || autoPortStart <= 0 || autoPortEnd < autoPortStart) {
+    throw new Error('auto-port range is invalid');
+  }
   if (!Number.isFinite(capacityGb) || capacityGb <= 0) {
     throw new Error('capacity-gb must be greater than 0');
   }
@@ -38,7 +92,7 @@ program.action(async (options) => {
     serverUrl: options.server,
     publicUrl: `http://${options.host}:${port}`,
     port,
-    storageDir: path.resolve(options.storageDir),
+    storageDir,
     capacityBytes: Math.floor(capacityGb * 1024 * 1024 * 1024),
     heartbeatIntervalMs: heartbeatMs
   });

package/src/node/runtime.js

@@ -1,6 +1,7 @@
 const express = require('express');
 const axios = require('axios');
 const { LocalShardStore } = require('./storage');
+const { getOrCreateDeviceKey } = require('./deviceIdentity');
 
 function normalizeUrl(url) {
   return String(url || '').replace(/\/+$/, '');
@@ -8,7 +9,7 @@ function normalizeUrl(url) {
 
 class NodioNodeRuntime {
   constructor(options) {
-    this.nodeId = options.nodeId;
+    this.nodeId = options.nodeId || null;
     this.serverUrl = normalizeUrl(options.serverUrl);
     this.publicUrl = normalizeUrl(options.publicUrl);
     this.port = Number(options.port);
@@ -20,6 +21,11 @@ class NodioNodeRuntime {
 
   async start() {
     await this.shardStore.init();
+
+    if (!this.nodeId) {
+      this.nodeId = await this.shardStore.getSavedNodeId();
+    }
+
     await this.startShardServer();
     await this.registerNode();
     await this.sendHeartbeat();
@@ -93,13 +99,23 @@ 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()
     });
 
+    this.nodeId = response.data.nodeId;
+    await this.shardStore.saveAssignedNodeId(this.nodeId);
+
     const interval = Number(response.data.heartbeatIntervalMs);
     if (Number.isFinite(interval) && interval > 0) {
       this.heartbeatIntervalMs = interval;

package/src/node/storage.js

@@ -1,5 +1,6 @@
 const fs = require('fs/promises');
 const path = require('path');
+const crypto = require('crypto');
 const { sha256Hex } = require('../common/crypto');
 
 class LocalShardStore {
@@ -7,6 +8,7 @@ class LocalShardStore {
     this.baseDir = baseDir;
     this.indexFile = path.join(baseDir, 'index.json');
     this.shardsDir = path.join(baseDir, 'shards');
+    this.identityFile = path.join(baseDir, 'node-identity.json');
   }
 
   async init() {
@@ -31,6 +33,90 @@ class LocalShardStore {
     await fs.writeFile(this.indexFile, JSON.stringify(index, null, 2), 'utf-8');
   }
 
+  async readIdentity() {
+    try {
+      const raw = await fs.readFile(this.identityFile, 'utf-8');
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+
+  async writeIdentity(identity) {
+    await fs.writeFile(this.identityFile, JSON.stringify(identity, null, 2), 'utf-8');
+  }
+
+  async getIdentity() {
+    return this.readIdentity();
+  }
+
+  async getOrCreateNodeKey() {
+    const identity = await this.readIdentity();
+    if (identity.nodeKey) {
+      return identity.nodeKey;
+    }
+
+    const nodeKey = crypto.randomUUID();
+    await this.writeIdentity({ ...identity, nodeKey, updatedAt: new Date().toISOString() });
+    return nodeKey;
+  }
+
+  async getSavedNodeId() {
+    const identity = await this.readIdentity();
+    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;
+    }
+
+    const identity = await this.readIdentity();
+    await this.writeIdentity({
+      ...identity,
+      nodeId,
+      updatedAt: new Date().toISOString()
+    });
+  }
+
   shardPath(shardId) {
     return path.join(this.shardsDir, `${shardId}.bin`);
   }

package/src/server/models.js

@@ -3,6 +3,8 @@ const mongoose = require('mongoose');
 const nodeSchema = new mongoose.Schema(
   {
     nodeId: { type: String, required: true, unique: true, index: true },
+    deviceKey: { type: String, index: true },
+    nodeKey: { type: String, unique: true, sparse: true, index: true },
     url: { type: String, required: true },
     capacityBytes: { type: Number, required: true, min: 1 },
     freeBytes: { type: Number, required: true, min: 0 },

package/src/server/routes.js

@@ -31,10 +31,10 @@ function buildRoutes(config) {
 
   router.post('/nodes/register', async (req, res, next) => {
     try {
-      const { nodeId, url, capacityBytes, freeBytes } = req.body;
+      const { nodeId, deviceKey, nodeKey, knownNodeIds, url, capacityBytes, freeBytes } = req.body;
 
-      if (!nodeId || !url) {
-        return res.status(400).json({ error: 'nodeId and url are required' });
+      if (!url) {
+        return res.status(400).json({ error: 'url is required' });
       }
 
       const capacity = Number(capacityBytes);
@@ -42,11 +42,53 @@ function buildRoutes(config) {
       if (!Number.isFinite(capacity) || capacity <= 0 || !Number.isFinite(free) || free < 0) {
         return res.status(400).json({ error: 'capacityBytes and freeBytes must be valid numbers' });
       }
+      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) {
+        existingByNodeKey = await NodeModel.findOne({ nodeKey }).lean();
+      }
+
+      if (existingByNodeKey && nodeId && nodeId !== existingByNodeKey.nodeId) {
+        return res.status(409).json({ error: 'nodeKey is already associated with a different nodeId' });
+      }
+
+      let effectiveNodeId = nodeId || existingByNodeKey?.nodeId || null;
+
+      if (!effectiveNodeId && deviceKey && normalizedKnownNodeIds.length > 0) {
+        const oldestOfflineKnownNode = await NodeModel.findOne({
+          deviceKey,
+          status: 'offline',
+          nodeId: { $in: normalizedKnownNodeIds }
+        })
+          .sort({ createdAt: 1 })
+          .lean();
+
+        if (oldestOfflineKnownNode) {
+          effectiveNodeId = oldestOfflineKnownNode.nodeId;
+        }
+      }
+
+      if (!effectiveNodeId) {
+        effectiveNodeId = `donor-${uuidv4().slice(0, 8)}`;
+      }
 
       const node = await NodeModel.findOneAndUpdate(
-        { nodeId },
+        { nodeId: effectiveNodeId },
         {
           $set: {
+            nodeId: effectiveNodeId,
+            ...(deviceKey ? { deviceKey } : {}),
+            ...(nodeKey ? { nodeKey } : {}),
             url,
             capacityBytes: capacity,
             freeBytes: free,
@@ -343,15 +385,21 @@ function buildRoutes(config) {
       const nodeUrlMap = new Map(onlineNodes.map((node) => [node.nodeId, node.url]));
 
       const shardDeleteFailures = [];
+      let deleteAttempts = 0;
+      let deleteSuccesses = 0;
+      let deleteSkippedOffline = 0;
       for (const placement of placements) {
         const nodeUrl = nodeUrlMap.get(placement.nodeId);
         if (!nodeUrl) {
+          deleteSkippedOffline += 1;
           continue;
         }
 
         const deleteUrl = `${normalizeUrl(nodeUrl)}/shards/${placement.shardId}`;
+        deleteAttempts += 1;
         try {
           await axios.delete(deleteUrl, { timeout: 15000 });
+          deleteSuccesses += 1;
         } catch (error) {
           shardDeleteFailures.push({
             shardId: placement.shardId,
@@ -376,6 +424,9 @@ function buildRoutes(config) {
         fileId,
         deletedShards: shardIds.length,
         deletedPlacements: placements.length,
+        donorDeleteAttempts: deleteAttempts,
+        donorDeleteSuccesses: deleteSuccesses,
+        donorDeleteSkippedOffline: deleteSkippedOffline,
         shardDeleteFailures
       });
     } catch (error) {

package/src/user/commands.js

@@ -210,7 +210,10 @@ async function deleteFile(options) {
   console.log('Delete complete');
   console.log(`fileId: ${payload.fileId || fileId}`);
   console.log(`deletedShards: ${payload.deletedShards || 0}`);
-  console.log(`deletedPlacements: ${payload.deletedPlacements || 0}`);
+  console.log(`deletedPlacementsMetadata: ${payload.deletedPlacements || 0}`);
+  console.log(`donorDeleteAttempts: ${payload.donorDeleteAttempts || 0}`);
+  console.log(`donorDeleteSuccesses: ${payload.donorDeleteSuccesses || 0}`);
+  console.log(`donorDeleteSkippedOffline: ${payload.donorDeleteSkippedOffline || 0}`);
   console.log(`shardDeleteFailures: ${(payload.shardDeleteFailures || []).length}`);
 }
 

package/src/user/index.js

@@ -10,7 +10,7 @@ program
   .command('upload')
   .description('Encrypt, shard, and distribute a file across donor nodes')
   .requiredOption('--file <path>', 'path to local file')
-  .option('--server <url>', 'central server URL', 'http://127.0.0.1:4000')
+  .option('--server <url>', 'central server URL', 'https://api.nodio.me')
   .option('--file-id <id>', 'custom file ID (optional)')
   .option('--shard-size-mb <mb>', 'plaintext shard size in MB', '1')
   .option('--replicas <count>', 'replicas per shard (minimum 5)', '5')
@@ -24,7 +24,7 @@ program
   .description('Download, verify, decrypt, and reconstruct a file')
   .requiredOption('--file-id <id>', 'file ID to download')
   .requiredOption('--key-base64 <key>', '32-byte AES key in base64 from upload output')
-  .option('--server <url>', 'central server URL', 'http://127.0.0.1:4000')
+  .option('--server <url>', 'central server URL', 'https://api.nodio.me')
   .option('--output <path>', 'output file path')
   .action(async (options) => {
     await downloadFile(options);
@@ -34,7 +34,7 @@ program
   .command('delete')
   .description('Delete a file and its shard replicas from the network')
   .requiredOption('--file-id <id>', 'file ID to delete')
-  .option('--server <url>', 'central server URL', 'http://127.0.0.1:4000')
+  .option('--server <url>', 'central server URL', 'https://api.nodio.me')
   .action(async (options) => {
     await deleteFile(options);
   });