@empirical-gauzza/cli 1.0.37 → 1.0.39

package/lib/http.js

@@ -138,6 +138,163 @@ function httpJson(urlString, method, payload, headers = {}, timeoutMs = 0) {
   });
 }
 
+// A filename travels to the server inside a Content-Disposition header we build by hand. Local
+// filenames are arbitrary bytes: a quote ends the parameter early and a CR/LF splits the part
+// header, so either one lets a filename forge headers or a whole extra part. multer/busboy also
+// has no portable unescaping here, so these characters are replaced rather than escaped.
+function sanitizeMultipartFilename(value) {
+  const cleaned = String(value || '')
+    .replace(/[\r\n"\\]/g, '_')
+    // C0 controls would be sent verbatim into a header line.
+    .replace(/[\x00-\x1f\x7f]/g, '_')
+    .trim();
+  return cleaned || 'attachment';
+}
+
+function buildMultipartBody(boundary, fields, file) {
+  const parts = [];
+  for (const [name, value] of Object.entries(fields || {})) {
+    if (value === undefined || value === null || value === '') continue;
+    parts.push(Buffer.from(
+      `--${boundary}\r\nContent-Disposition: form-data; name="${sanitizeMultipartFilename(name)}"\r\n\r\n${String(value)}\r\n`,
+      'utf8'
+    ));
+  }
+  parts.push(Buffer.from(
+    `--${boundary}\r\n`
+    + `Content-Disposition: form-data; name="${sanitizeMultipartFilename(file.field || 'file')}";`
+    + ` filename="${sanitizeMultipartFilename(file.filename)}"\r\n`
+    + `Content-Type: ${sanitizeMultipartFilename(file.contentType || 'application/octet-stream')}\r\n\r\n`,
+    'utf8'
+  ));
+  parts.push(file.buffer);
+  parts.push(Buffer.from(`\r\n--${boundary}--\r\n`, 'utf8'));
+  return Buffer.concat(parts);
+}
+
+/**
+ * multipart/form-data with exactly one file part, for attachment uploads. The CLI ships with one
+ * dependency and no form-data library, and the body is already fully buffered (the per-file cap
+ * is 25MB), so the body is assembled here rather than streamed.
+ *
+ * Resolves/rejects on the same contract as httpJson, so callers can use printApiError unchanged.
+ */
+function httpMultipart(urlString, method, { fields = {}, file }, headers = {}, timeoutMs = 0) {
+  return new Promise((resolve, reject) => {
+    if (!file || !Buffer.isBuffer(file.buffer)) {
+      reject(new Error('httpMultipart requires file.buffer'));
+      return;
+    }
+    const parsed = new URL(urlString);
+    const lib = parsed.protocol === 'https:' ? https : http;
+    const boundary = `----empiricalcli${Date.now().toString(16)}${Math.random().toString(16).slice(2)}`;
+    const body = buildMultipartBody(boundary, fields, file);
+
+    const req = lib.request(
+      parsed,
+      {
+        method,
+        headers: {
+          Accept: 'application/json',
+          // The server infers source 'cli' from this (see @empirical/core memoryAuthorship).
+          'User-Agent': 'empirical-cli/1.0',
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': body.length,
+          ...headers
+        }
+      },
+      (res) => {
+        let raw = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          raw += chunk;
+        });
+        res.on('end', () => {
+          let data = {};
+          try {
+            data = raw ? JSON.parse(raw) : {};
+          } catch (_error) {
+            data = { raw };
+          }
+
+          if (data && Array.isArray(data.alerts) && data.alerts.length) {
+            process.stderr.write(renderCliAlertBanner(data.alerts));
+          }
+
+          const statusCode = res.statusCode || 0;
+          if (statusCode < 200 || statusCode >= 300) {
+            reject(httpErrorFromResponse(method, urlString, statusCode, data));
+            return;
+          }
+          resolve(data);
+        });
+      }
+    );
+
+    req.on('error', reject);
+    if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      req.setTimeout(timeoutMs, () => {
+        req.destroy(new Error(`request timeout after ${timeoutMs}ms`));
+      });
+    }
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * GET that keeps the response as BYTES. httpJson would decode the body as utf8 and corrupt any
+ * binary, so downloads cannot reuse it. A non-2xx body is still JSON here (the attachment
+ * download route answers 404/410 as JSON), so failures are parsed and rejected on the same
+ * contract as httpJson.
+ *
+ * @returns {Promise<{ statusCode: number, headers: object, buffer: Buffer }>}
+ */
+function httpDownload(urlString, headers = {}, timeoutMs = 0) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(urlString);
+    const lib = parsed.protocol === 'https:' ? https : http;
+
+    const req = lib.request(
+      parsed,
+      {
+        method: 'GET',
+        headers: {
+          'User-Agent': 'empirical-cli/1.0',
+          ...headers
+        }
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => {
+          const buffer = Buffer.concat(chunks);
+          const statusCode = res.statusCode || 0;
+          if (statusCode < 200 || statusCode >= 300) {
+            let data = {};
+            try {
+              data = JSON.parse(buffer.toString('utf8'));
+            } catch (_error) {
+              data = { raw: buffer.toString('utf8').slice(0, 500) };
+            }
+            reject(httpErrorFromResponse('GET', urlString, statusCode, data));
+            return;
+          }
+          resolve({ statusCode, headers: res.headers || {}, buffer });
+        });
+      }
+    );
+
+    req.on('error', reject);
+    if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      req.setTimeout(timeoutMs, () => {
+        req.destroy(new Error(`request timeout after ${timeoutMs}ms`));
+      });
+    }
+    req.end();
+  });
+}
+
 function httpForm(urlString, method, params, headers = {}) {
   return new Promise((resolve, reject) => {
     const parsed = new URL(urlString);
@@ -196,5 +353,8 @@ module.exports = {
   formatApiError,
   printApiError,
   httpJson,
+  httpMultipart,
+  httpDownload,
+  sanitizeMultipartFilename,
   httpForm
 };