@xuda.io/drive_module 1.1.1494 → 1.1.1495

package/index.mjs

@@ -1790,6 +1790,7 @@ export const upload_drive_file = async (req, job_id, headers = {}, file_obj) =>
         filename: file_obj.originalname,
         file_url,
         file_path,
+        bucket: doc.bucket, // region->{Bucket,Key,Location}; undefined for scp/datacenter paths
       },
       rename: check_existing_file_ret < 0,
     };
@@ -1797,6 +1798,175 @@ export const upload_drive_file = async (req, job_id, headers = {}, file_obj) =>
     return { code: -400, data: err.message };
   }
 };
+// ============================================================================
+//   Custom login-screen background (personal + sponsor image)
+// ============================================================================
+// A non-free user's login-screen background lives on the account doc at
+// account_info.login_screen_obj and is served pre-auth (see account_module
+// resolve_effective_login_screen). It is set either by uploading a picture
+// (set_login_screen) or by AI generation (ai_module.generate_login_screen); both
+// funnel their temp file through store_login_screen_from_path so there is exactly
+// one writer of login_screen_obj. SVG is rejected (pre-auth XSS vector) and the
+// magic-bytes are cross-checked against the extension to block image polyglots.
+export const LOGIN_SCREEN_SPEC = {
+  formats: ['jpg', 'jpeg', 'png', 'webp'],
+  max_bytes: 5 * 1024 * 1024,
+  min_w: 1280,
+  min_h: 720,
+  max_w: 5000,
+  max_h: 5000,
+  aspect_min: 1.2,
+  aspect_max: 2.1,
+};
+
+// Validate a login-screen image on disk against LOGIN_SCREEN_SPEC. Always unlinks
+// the temp file on failure (mirrors upload_drive_file's cleanup); on success it
+// leaves the file for the uploader and returns the measured { w, h, bytes, mime, ext }.
+export const validate_login_screen_file = async (file_obj) => {
+  const S = LOGIN_SCREEN_SPEC;
+  const temp_path = file_obj?.path;
+  const fail = async (error) => {
+    try {
+      if (temp_path) await fs_module.unlink(temp_path);
+    } catch (e) {}
+    return { valid: false, error };
+  };
+  if (!file_obj?.originalname || !temp_path) return await fail('file data missing');
+
+  const ext = path.extname(file_obj.originalname).replace('.', '').toLowerCase();
+  if (!S.formats.includes(ext)) return await fail(`Only ${S.formats.join(', ')} images are allowed`);
+
+  const validation = file_upload_validator(file_obj.originalname);
+  if (!validation.valid || validation.category !== 'image') return await fail('File type not allowed');
+
+  let bytes = 0;
+  try {
+    bytes = (await fs.promises.stat(temp_path)).size;
+  } catch (e) {
+    return await fail('cannot read uploaded file');
+  }
+  if (bytes > S.max_bytes) return await fail(`Image is too large (max ${Math.round(S.max_bytes / 1024 / 1024)} MB)`);
+
+  let dim;
+  try {
+    dim = imageSize(temp_path);
+  } catch (e) {
+    dim = null;
+  }
+  if (!dim?.width || !dim?.height) return await fail('could not read image dimensions');
+
+  // magic-byte type must itself be an accepted raster format — blocks a .png that
+  // is actually an SVG/HTML polyglot, and svg smuggled under a jpg/webp name.
+  const magic = String(dim.type || '').toLowerCase();
+  if (!S.formats.includes(magic)) return await fail('image content does not match an allowed format');
+
+  const { width: w, height: h } = dim;
+  if (w < S.min_w || h < S.min_h) return await fail(`Image must be at least ${S.min_w}x${S.min_h}px`);
+  if (w > S.max_w || h > S.max_h) return await fail(`Image must be at most ${S.max_w}x${S.max_h}px`);
+  const aspect = w / h;
+  if (aspect < S.aspect_min || aspect > S.aspect_max) return await fail(`Image must be landscape (aspect ratio ${S.aspect_min}–${S.aspect_max})`);
+
+  return { valid: true, w, h, bytes, mime: validation.mime, ext };
+};
+
+// Shared writer for a login-screen image: paid-plan gate -> validate -> persist
+// through the user-drive path avatars use (so file_url is served publicly by the
+// region; a direct R2 URL is NOT anonymously readable) -> free the previous asset
+// -> save account_info.login_screen_obj. Called with a local temp file (same box)
+// by set_login_screen and, over the drive_module queue, by ai_module.generate_login_screen.
+export const store_login_screen_from_path = async (uid, file_obj, job_id = null, headers = {}) => {
+  const temp_path = file_obj?.path;
+  const cleanup = async () => {
+    try {
+      if (temp_path) await fs_module.unlink(temp_path);
+    } catch (e) {}
+  };
+  try {
+    if (!uid) {
+      await cleanup();
+      return { code: -401, data: 'not authorized (no uid)' };
+    }
+
+    const { code: acc_code, data: account_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
+    if (acc_code < 0 || !account_obj) {
+      await cleanup();
+      return { code: -404, data: 'account not found' };
+    }
+    // Paid-plan gate (defense-in-depth on top of the min_plan cpi gate).
+    if ((account_obj.membership_plan || 'free') === 'free') {
+      await cleanup();
+      return { code: -403, data: 'A custom login screen requires a paid plan' };
+    }
+
+    const validation = await validate_login_screen_file(file_obj); // unlinks temp on failure
+    if (!validation.valid) return { code: -400, data: validation.error };
+
+    const up = await upload_drive_file_user({ uid, path: '/Login Screen' }, job_id, headers, file_obj);
+    if (!up || up.code < 0 || !up.data?.file_url) {
+      await cleanup();
+      return { code: -500, data: up?.data || 'upload failed' };
+    }
+
+    const login_screen_obj = {
+      file_url: up.data.file_url,
+      server_file_name: up.data.server_file_name,
+      bucket: up.data.bucket || null,
+      w: validation.w,
+      h: validation.h,
+      bytes: validation.bytes,
+      mime: validation.mime,
+      uploaded_ts: Date.now(),
+    };
+
+    // Free the previous asset's bytes so replacing the screen never orphans R2 blobs.
+    const prev = account_obj.account_info?.login_screen_obj;
+    if (prev?.bucket) {
+      try {
+        await delete_file_from_bucket(prev.bucket);
+      } catch (e) {}
+    }
+
+    account_obj.account_info = account_obj.account_info || {};
+    account_obj.account_info.login_screen_obj = login_screen_obj;
+    account_obj.ts = Date.now();
+    await db_module.save_couch_doc('xuda_accounts', account_obj);
+
+    return { code: 1, data: { login_screen_obj } };
+  } catch (err) {
+    await cleanup();
+    return { code: -400, data: err.message };
+  }
+};
+
+// set_login_screen: authenticated multipart upload (upload:true cpi_method). The
+// router passes the parsed file as the 4th arg; uid comes from the token, never the
+// body (spoof-safe). Returns the effective personal screen for an instant client
+// update; the authoritative resolve (sponsored > personal > default) runs in
+// account_module.get_account_data on the next bootstrap.
+export const set_login_screen = async (req, job_id, headers = {}, file_obj) => {
+  const uid = req.uid || req.token_ret?.data?.uid;
+  if (!uid) return { code: -401, data: 'not authorized (no uid)' };
+  if (!file_obj?.originalname) return { code: -400, data: 'file data missing' };
+
+  const ret = await store_login_screen_from_path(uid, file_obj, job_id, headers);
+  if (ret.code !== 1) return ret;
+  const o = ret.data.login_screen_obj;
+  return {
+    code: 1,
+    data: {
+      login_screen: {
+        source: 'personal',
+        media_type: 'image',
+        file_url: o.file_url,
+        w: o.w,
+        h: o.h,
+        bytes: o.bytes,
+        uploaded_ts: o.uploaded_ts,
+      },
+    },
+  };
+};
+
 const check_single_drive_file = async (req, job_id, headers, file_obj) => {
   const { type = 'file', drive_type, app_id, uid, file_path, folder_name } = req;
 

package/index_ms.mjs

@@ -97,6 +97,18 @@ export const upload_drive_file = async function (...args) {
   return await broker.send_to_queue("upload_drive_file", ...args);
 };
 
+export const validate_login_screen_file = async function (...args) {
+  return await broker.send_to_queue("validate_login_screen_file", ...args);
+};
+
+export const store_login_screen_from_path = async function (...args) {
+  return await broker.send_to_queue("store_login_screen_from_path", ...args);
+};
+
+export const set_login_screen = async function (...args) {
+  return await broker.send_to_queue("set_login_screen", ...args);
+};
+
 export const check_drive_files = async function (...args) {
   return await broker.send_to_queue("check_drive_files", ...args);
 };

package/index_msa.mjs

@@ -97,6 +97,18 @@ export const upload_drive_file =  function (...args) {
    broker.send_to_queue_async("upload_drive_file", ...args);
 };
 
+export const validate_login_screen_file =  function (...args) {
+   broker.send_to_queue_async("validate_login_screen_file", ...args);
+};
+
+export const store_login_screen_from_path =  function (...args) {
+   broker.send_to_queue_async("store_login_screen_from_path", ...args);
+};
+
+export const set_login_screen =  function (...args) {
+   broker.send_to_queue_async("set_login_screen", ...args);
+};
+
 export const check_drive_files =  function (...args) {
    broker.send_to_queue_async("check_drive_files", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/drive_module",
-  "version": "1.1.1494",
+  "version": "1.1.1495",
   "description": "Xuda Drive Server Module",
   "main": "index.mjs",
   "dependencies": {
@@ -24,5 +24,8 @@
     "pub": "npm version patch --force && npm publish "
   },
   "author": "Xuda Llc",
-  "license": "ISC"
+  "license": "ISC",
+  "publishConfig": {
+    "access": "restricted"
+  }
 }