cbyte 1.0.0 → 1.3.0

package/cbyte.js

@@ -1,49 +1,23 @@
 #!/usr/bin/env node
 
-// Prevent MaxListenersExceededWarning
 require('events').defaultMaxListeners = 6000;
 
 const fs = require('fs');
 const crypto = require('crypto');
 const { program } = require('commander');
-const { request } = require('undici');
-const FormData = require('form-data');
+const { create } = require('ipfs-core');
 const os = require('os');
 const path = require('path');
-const { spawn } = require('child_process');
-const net = require('net');
-
-const IPFS_API = process.env.IPFS_API || 'http://127.0.0.1:5001/api/v0';
-
-// ------------------- IPFS Daemon Helpers -------------------
-function isPortOpen(host, port) {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    socket.setTimeout(1000);
-    socket.once('connect', () => { socket.destroy(); resolve(true); });
-    socket.once('timeout', () => { socket.destroy(); resolve(false); });
-    socket.once('error', () => { resolve(false); });
-    socket.connect(port, host);
-  });
-}
-
-async function ensureIpfsDaemon() {
-  const host = '127.0.0.1';
-  const port = 5001;
 
-  const running = await isPortOpen(host, port);
-  if (running) return;
+let ipfs = null;
 
-  console.log('IPFS daemon not running. Starting it now...');
-  const daemon = spawn('ipfs', ['daemon'], { stdio: 'ignore', detached: true });
-  daemon.unref();
-
-  let attempts = 0;
-  while (!(await isPortOpen(host, port))) {
-    if (attempts++ > 20) throw new Error('Failed to start IPFS daemon.');
-    await new Promise(r => setTimeout(r, 500));
+// ------------------- IPFS Initialization -------------------
+async function ensureIpfs() {
+  if (!ipfs) {
+    console.log('Starting embedded IPFS node...');
+    ipfs = await create({ repo: path.join(process.cwd(), '.ipfs') });
+    console.log('IPFS node started.');
   }
-  console.log('IPFS daemon started.');
 }
 
 // ------------------- Utility Functions -------------------
@@ -59,30 +33,10 @@ function renderProgress(completed, total, label = '') {
   process.stderr.write(`\r${label} [${bar}] ${(ratio*100).toFixed(1)}% (${completed}/${total})`);
 }
 
-// ------------------- IPFS Block Operations -------------------
-async function ipfsBlockPut(data) {
-  const form = new FormData();
-  form.append('file', data, { filename: 'chunk' });
-
-  const res = await request(`${IPFS_API}/block/put?format=raw&mhtype=sha2-256`, {
-    method: 'POST',
-    body: form,
-    headers: form.getHeaders()
-  });
-
-  const body = await res.body.text();
-  const json = JSON.parse(body);
-  return json.Key;
-}
-
-async function ipfsBlockGet(cid) {
-  const res = await request(`${IPFS_API}/block/get?arg=${cid}`);
-  const buffer = await res.body.arrayBuffer();
-  return Buffer.from(buffer);
-}
-
-// ------------------- Pack Function -------------------
+// ------------------- Pack -------------------
 async function pack(filePath, output, chunkSize = 4096, pin = false) {
+  await ensureIpfs();
+
   if (!output) {
     const base = path.basename(filePath, path.extname(filePath));
     output = `${base}.cbyte`;
@@ -90,6 +44,7 @@ async function pack(filePath, output, chunkSize = 4096, pin = false) {
 
   const data = fs.readFileSync(filePath);
   const chunksMap = {};
+
   for (let offset = 0; offset < data.length; offset += chunkSize) {
     const chunk = data.slice(offset, offset + chunkSize);
     const hash = sha256(chunk);
@@ -102,24 +57,24 @@ async function pack(filePath, output, chunkSize = 4096, pin = false) {
     version: 1,
     chunk_size: chunkSize,
     original_size: data.length,
-    original_ext: path.extname(filePath), // store original file extension
+    original_ext: path.extname(filePath),
     chunks: []
   };
 
   const hashes = Object.keys(chunksMap);
   const total = hashes.length;
-  let uploaded = 0;
+  let completed = 0;
 
   const concurrency = Math.max(1, Math.min(8, os.cpus().length));
   for (let i = 0; i < hashes.length; i += concurrency) {
     const batch = hashes.slice(i, i + concurrency);
     await Promise.all(batch.map(async (hash) => {
       const info = chunksMap[hash];
-      const cid = await ipfsBlockPut(info.chunk);
-      if (pin) await request(`${IPFS_API}/pin/add?arg=${cid}`);
-      manifest.chunks.push({ cid, length: info.chunk.length, count: info.count });
-      uploaded++;
-      renderProgress(uploaded, total, 'Uploading chunks');
+      const { cid } = await ipfs.block.put(info.chunk);
+      if (pin) await ipfs.pin.add(cid);
+      manifest.chunks.push({ cid: cid.toString(), length: info.chunk.length, count: info.count });
+      completed++;
+      renderProgress(completed, total, 'Packing');
     }));
   }
   process.stderr.write('\n');
@@ -128,8 +83,10 @@ async function pack(filePath, output, chunkSize = 4096, pin = false) {
   console.log(`Packed ${filePath} -> ${output}`);
 }
 
-// ------------------- Unpack Function -------------------
+// ------------------- Unpack -------------------
 async function unpack(manifestPath, output) {
+  await ensureIpfs();
+
   const manifest = JSON.parse(fs.readFileSync(manifestPath));
   if (!output) {
     const base = path.basename(manifestPath, path.extname(manifestPath));
@@ -145,7 +102,7 @@ async function unpack(manifestPath, output) {
   for (let i = 0; i < manifest.chunks.length; i += concurrency) {
     const batch = manifest.chunks.slice(i, i + concurrency);
     await Promise.all(batch.map(async (entry) => {
-      const data = await ipfsBlockGet(entry.cid);
+      const data = Buffer.from(await ipfs.block.get(entry.cid));
       for (let j = 0; j < entry.count; j++) {
         fs.writeSync(outFd, data.slice(0, entry.length));
         completed++;
@@ -160,16 +117,19 @@ async function unpack(manifestPath, output) {
   console.log(`Unpacked -> ${output}`);
 }
 
-// ------------------- Verify Function -------------------
+// ------------------- Verify -------------------
 async function verify(manifestPath) {
+  await ensureIpfs();
+
   const manifest = JSON.parse(fs.readFileSync(manifestPath));
   let verified = 0;
+
   for (const { cid } of manifest.chunks) {
     try {
-      await ipfsBlockGet(cid);
+      await ipfs.block.get(cid);
       verified++;
       renderProgress(verified, manifest.chunks.length, 'Verifying');
-    } catch (e) {
+    } catch {
       console.error(`Missing block ${cid}`);
       process.exit(1);
     }
@@ -178,12 +138,15 @@ async function verify(manifestPath) {
   console.log('All blocks verified');
 }
 
-// ------------------- Pin Function -------------------
+// ------------------- Pin -------------------
 async function pin(manifestPath) {
+  await ensureIpfs();
+
   const manifest = JSON.parse(fs.readFileSync(manifestPath));
   let pinned = 0;
+
   for (const { cid } of manifest.chunks) {
-    await request(`${IPFS_API}/pin/add?arg=${cid}`);
+    await ipfs.pin.add(cid);
     pinned++;
     renderProgress(pinned, manifest.chunks.length, 'Pinning');
   }
@@ -200,29 +163,25 @@ program
   .option('--chunk-size <bytes>', 'Chunk size', '4096')
   .option('--pin', 'Pin blocks after upload', false)
   .action(async (file, options) => {
-    await ensureIpfsDaemon();
-    await pack(file, options.output, parseInt(options['chunkSize']), options.pin);
+    await pack(file, options.output, parseInt(options.chunkSize), options.pin);
   });
 
 program
   .command('unpack <manifest>')
   .option('-o, --output <file>', 'Output file')
   .action(async (manifest, options) => {
-    await ensureIpfsDaemon();
     await unpack(manifest, options.output);
   });
 
 program
   .command('verify <manifest>')
   .action(async (manifest) => {
-    await ensureIpfsDaemon();
     await verify(manifest);
   });
 
 program
   .command('pin <manifest>')
   .action(async (manifest) => {
-    await ensureIpfsDaemon();
     await pin(manifest);
   });
 

package/package.json

@@ -1,18 +1,29 @@
 {
   "name": "cbyte",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "Content-addressed deduplicated storage CLI using IPFS with automatic unpack extension retention",
   "main": "cbyte.js",
-  "bin": { "cbyte": "./cbyte.js" },
-  "scripts": { "test": "node test.js" },
-  "keywords": ["ipfs","cli","deduplication","storage","content-addressed"],
+  "bin": {
+    "cbyte": "./cbyte.js"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "ipfs",
+    "cli",
+    "deduplication",
+    "storage",
+    "content-addressed"
+  ],
   "author": "Your Name <you@example.com>",
   "license": "MIT",
   "dependencies": {
     "commander": "^11.0.0",
-    "undici": "^6.0.0",
-    "form-data": "^4.0.0"
+    "form-data": "^4.0.0",
+    "undici": "^6.0.0"
   },
-  "engines": { "node": ">=20" }
+  "engines": {
+    "node": ">=20"
+  }
 }
-