magic-builder 0.1.0

package/src/lib/multipart.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const fs = require('fs');
+const crypto = require('crypto');
+const { request } = require('./http');
+
+const PART_SIZE = 10 * 1024 * 1024; // 10MB
+const MULTIPART_THRESHOLD = 16 * 1024 * 1024; // 16MB
+
+function shouldUseMultipart(fileSize) {
+  return fileSize > MULTIPART_THRESHOLD;
+}
+
+async function uploadSingle(filePath, opts = {}) {
+  const { baseUrl, key, contentType, quiet } = opts;
+  const filename = require('path').basename(filePath);
+  const mime = contentType || require('./mime').getMimeType(filePath);
+
+  const signBody = { filename, contentType: mime };
+  if (key) signBody.key = key;
+
+  const signRes = await request(`${baseUrl}/api/tos/sign`, {
+    method: 'POST',
+    body: signBody,
+  });
+
+  if (signRes.code !== 0) throw new Error(signRes.msg || 'Sign failed');
+  const { signed_url, url } = signRes.data;
+
+  const buf = fs.readFileSync(filePath);
+  if (!quiet) process.stderr.write('Uploading... ');
+
+  await request(signed_url, {
+    method: 'PUT',
+    headers: { 'Content-Type': mime },
+    body: buf,
+    timeout: 120000,
+  });
+
+  if (!quiet) process.stderr.write('done\n');
+  return { url, key: signRes.data.key, size: buf.length };
+}
+
+async function uploadMultipart(filePath, opts = {}) {
+  const { baseUrl, key, contentType, quiet } = opts;
+  const filename = require('path').basename(filePath);
+  const mime = contentType || require('./mime').getMimeType(filePath);
+  const stat = fs.statSync(filePath);
+
+  const initBody = { filename, contentType: mime };
+  if (key) initBody.key = key;
+
+  const initRes = await request(`${baseUrl}/api/tos/multipart/init`, {
+    method: 'POST',
+    body: initBody,
+  });
+  if (initRes.code !== 0) throw new Error(initRes.msg || 'Multipart init failed');
+  const { uploadId, key: tosKey, url } = initRes.data;
+
+  const fd = fs.openSync(filePath, 'r');
+  const totalParts = Math.ceil(stat.size / PART_SIZE);
+  const parts = [];
+
+  try {
+    for (let i = 0; i < totalParts; i++) {
+      const start = i * PART_SIZE;
+      const end = Math.min(start + PART_SIZE, stat.size);
+      const buf = Buffer.alloc(end - start);
+      fs.readSync(fd, buf, 0, buf.length, start);
+
+      if (!quiet) process.stderr.write(`\rUploading part ${i + 1}/${totalParts}...`);
+
+      const boundary = crypto.randomBytes(16).toString('hex');
+      const partNum = i + 1;
+      const header = `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\r\nContent-Type: ${mime}\r\n\r\n`;
+      const footer = `\r\n--${boundary}--\r\n`;
+      const multipartBody = Buffer.concat([Buffer.from(header), buf, Buffer.from(footer)]);
+
+      const partRes = await request(`${baseUrl}/api/tos/multipart/part`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'X-Upload-Id': uploadId,
+          'X-Part-Number': String(partNum),
+          'X-Key': tosKey,
+        },
+        body: multipartBody,
+        timeout: 300000,
+      });
+
+      if (partRes.code !== 0) {
+        await abortMultipart(baseUrl, uploadId, tosKey);
+        throw new Error(partRes.msg || `Part ${partNum} upload failed`);
+      }
+      parts.push({ partNumber: partNum, etag: partRes.data.etag });
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  const completeRes = await request(`${baseUrl}/api/tos/multipart/complete`, {
+    method: 'POST',
+    body: { uploadId, key: tosKey, parts },
+  });
+
+  if (completeRes.code !== 0) throw new Error(completeRes.msg || 'Multipart complete failed');
+  if (!quiet) process.stderr.write('\rUpload complete.        \n');
+
+  return { url: completeRes.data?.url || url, key: tosKey, size: stat.size };
+}
+
+async function abortMultipart(baseUrl, uploadId, key) {
+  try {
+    await request(`${baseUrl}/api/tos/multipart/abort`, {
+      method: 'POST',
+      body: { uploadId, key },
+    });
+  } catch (_) {}
+}
+
+module.exports = { uploadSingle, uploadMultipart, shouldUseMultipart, PART_SIZE, MULTIPART_THRESHOLD };

package/src/lib/output.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const EXIT = { OK: 0, ERROR: 1, AUTH: 2, NETWORK: 3 };
+
+function formatOutput(data, format = 'json') {
+  if (format === 'plain') {
+    if (typeof data === 'string') return data;
+    return Object.entries(data).map(([k, v]) => `${k}: ${v}`).join('\n');
+  }
+  if (format === 'table') {
+    if (typeof data === 'string') return data;
+    const keys = Object.keys(data);
+    const maxKey = Math.max(...keys.map(k => k.length));
+    return keys.map(k => `${k.padEnd(maxKey)}  ${data[k]}`).join('\n');
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+function success(data, opts = {}) {
+  process.stdout.write(formatOutput(data, opts.format) + '\n');
+  process.exit(EXIT.OK);
+}
+
+function fail(message, code = 'E_ERROR', exitCode = EXIT.ERROR) {
+  const out = JSON.stringify({ error: code, message });
+  process.stderr.write(out + '\n');
+  process.exit(exitCode);
+}
+
+function failFromHttpError(err) {
+  if (err.code === 'E_AUTH_FAILED' || err.code === 'E_NO_TOKEN') {
+    fail(err.message, err.code, EXIT.AUTH);
+  } else if (err.code === 'E_NETWORK') {
+    fail(err.message, err.code, EXIT.NETWORK);
+  } else {
+    fail(err.message, err.code || 'E_ERROR', EXIT.ERROR);
+  }
+}
+
+module.exports = { EXIT, formatOutput, success, fail, failFromHttpError };