nodio-cli 1.0.0 → 1.0.2

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "nodio-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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"
@@ -30,4 +31,4 @@
     "mongoose": "^8.18.0",
     "uuid": "^13.0.0"
   }
-}
+}

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();
@@ -65,6 +71,16 @@ class NodioNodeRuntime {
       }
     });
 
+    app.delete('/shards/:shardId', async (req, res) => {
+      try {
+        const { shardId } = req.params;
+        const result = await this.shardStore.deleteShard(shardId);
+        res.json({ ok: true, shard: result });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
     app.get('/health', (_req, res) => {
       res.json({ ok: true, nodeId: this.nodeId });
     });
@@ -83,13 +99,21 @@ class NodioNodeRuntime {
   }
 
   async registerNode() {
+    const deviceKey = await getOrCreateDeviceKey();
+    const nodeKey = await this.shardStore.getOrCreateNodeKey();
+
     const response = await axios.post(`${this.serverUrl}/api/nodes/register`, {
       nodeId: this.nodeId,
+      deviceKey,
+      nodeKey,
       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,53 @@ 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 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`);
   }
@@ -64,6 +113,26 @@ class LocalShardStore {
     }
   }
 
+  async deleteShard(shardId) {
+    const filePath = this.shardPath(shardId);
+
+    try {
+      await fs.unlink(filePath);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+
+    const index = await this.readIndex();
+    if (index.shards[shardId]) {
+      delete index.shards[shardId];
+      await this.writeIndex(index);
+    }
+
+    return { shardId, deleted: true };
+  }
+
   async listShardIds() {
     const index = await this.readIndex();
     return Object.keys(index.shards);

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

@@ -1,4 +1,5 @@
 const express = require('express');
+const axios = require('axios');
 const { v4: uuidv4 } = require('uuid');
 const {
   NodeModel,
@@ -17,6 +18,10 @@ function parsePositiveInt(value, fallback) {
   return Number.isInteger(n) && n > 0 ? n : fallback;
 }
 
+function normalizeUrl(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
 function buildRoutes(config) {
   const router = express.Router();
 
@@ -26,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, 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);
@@ -37,11 +42,28 @@ 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' });
+      }
+
+      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' });
+      }
+
+      const effectiveNodeId = nodeId || existingByNodeKey?.nodeId || `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,
@@ -84,29 +106,34 @@ function buildRoutes(config) {
       await node.save();
 
       if (Array.isArray(shardIds) && shardIds.length > 0) {
-        const normalizedShardIds = [...new Set(shardIds.filter(Boolean))];
-        const knownShards = await ShardModel.find({ shardId: { $in: normalizedShardIds } })
-          .select('shardId fileId')
-          .lean();
+        try {
+          const normalizedShardIds = [...new Set(shardIds.filter(Boolean))];
+          const knownShards = await ShardModel.find({ shardId: { $in: normalizedShardIds } })
+            .select('shardId fileId')
+            .lean();
+
+          for (const shard of knownShards) {
+            if (!shard.fileId) {
+              continue;
+            }
 
-        for (const shard of knownShards) {
-          await ShardPlacementModel.updateOne(
-            { shardId: shard.shardId, nodeId },
-            {
-              $set: {
-                status: 'available',
-                fileId: shard.fileId,
-                updatedAt: new Date()
+            await ShardPlacementModel.updateOne(
+              { shardId: shard.shardId, nodeId },
+              {
+                $set: {
+                  status: 'available',
+                  fileId: shard.fileId
+                },
+                $setOnInsert: {
+                  shardId: shard.shardId,
+                  nodeId
+                }
               },
-              $setOnInsert: {
-                shardId: shard.shardId,
-                nodeId,
-                fileId: shard.fileId,
-                createdAt: new Date()
-              }
-            },
-            { upsert: true }
-          );
+              { upsert: true }
+            );
+          }
+        } catch (syncError) {
+          console.warn('[heartbeat-sync]', nodeId, syncError.message);
         }
       }
 
@@ -313,6 +340,75 @@ function buildRoutes(config) {
     }
   });
 
+  router.delete('/files/:fileId', async (req, res, next) => {
+    try {
+      const { fileId } = req.params;
+      const file = await FileModel.findOne({ fileId }).lean();
+      if (!file) {
+        return res.status(404).json({ error: 'file not found' });
+      }
+
+      const shards = await ShardModel.find({ fileId }).select('shardId').lean();
+      const shardIds = shards.map((shard) => shard.shardId);
+
+      const placements = await ShardPlacementModel.find({ fileId }).lean();
+      const nodeIds = [...new Set(placements.map((placement) => placement.nodeId))];
+
+      const onlineNodes = await NodeModel.find({ nodeId: { $in: nodeIds }, status: 'online' })
+        .select('nodeId url')
+        .lean();
+      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,
+            nodeId: placement.nodeId,
+            error: error.response?.data?.error || error.message
+          });
+        }
+      }
+
+      await ReplicationTaskModel.deleteMany({
+        $or: [
+          { fileId },
+          { shardId: { $in: shardIds } }
+        ]
+      });
+      await ShardPlacementModel.deleteMany({ fileId });
+      await ShardModel.deleteMany({ fileId });
+      await FileModel.deleteOne({ fileId });
+
+      res.json({
+        ok: true,
+        fileId,
+        deletedShards: shardIds.length,
+        deletedPlacements: placements.length,
+        donorDeleteAttempts: deleteAttempts,
+        donorDeleteSuccesses: deleteSuccesses,
+        donorDeleteSkippedOffline: deleteSkippedOffline,
+        shardDeleteFailures
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
   router.get('/files/:fileId/manifest', async (req, res, next) => {
     try {
       const { fileId } = req.params;

package/src/user/commands.js

@@ -199,7 +199,26 @@ async function downloadFile(options) {
   console.log(`sizeBytes: ${reconstructed.length}`);
 }
 
+async function deleteFile(options) {
+  const fileId = options.fileId;
+  const serverUrl = options.server;
+
+  const api = createApiClient(serverUrl);
+  const response = await api.delete(`/files/${fileId}`);
+  const payload = response.data || {};
+
+  console.log('Delete complete');
+  console.log(`fileId: ${payload.fileId || fileId}`);
+  console.log(`deletedShards: ${payload.deletedShards || 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}`);
+}
+
 module.exports = {
   uploadFile,
-  downloadFile
+  downloadFile,
+  deleteFile
 };

package/src/user/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 const { Command } = require('commander');
-const { uploadFile, downloadFile } = require('./commands');
+const { uploadFile, downloadFile, deleteFile } = require('./commands');
 
 const program = new Command();
 
@@ -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,12 +24,21 @@ 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);
   });
 
+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', 'https://api.nodio.me')
+  .action(async (options) => {
+    await deleteFile(options);
+  });
+
 program.parseAsync(process.argv).catch((error) => {
   console.error('[nodio]', error.message);
   process.exit(1);