@xuda.io/ai_module 1.1.5614 → 1.1.5616

package/index.mjs

@@ -2076,7 +2076,7 @@ export const unarchive_ai_chat = async function (req) {
 //   }
 // };
 
-const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', size = '1024x1024', n = 1, width = 256, height = 256, metadata = {}, account_profile_info) {
+const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', size = '1024x1024', n = 1, width = 256, height = 256, metadata = {}, account_profile_info, quality) {
   try {
     let response;
     try {
@@ -2085,6 +2085,11 @@ const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', si
         prompt,
         size,
         n,
+        // Chat-image output is downscaled to width×height (default 256²) right
+        // below, so a high-quality 1024² render is wasted there → default 'low'.
+        // Callers that need a real avatar (e.g. the factual avatar) pass an explicit
+        // `quality` ('medium'). Tunable via _conf.chat_image_quality for the default.
+        quality: quality || _conf.chat_image_quality || 'low',
       });
       report_ai_status(model);
     } catch (err) {
@@ -8334,7 +8339,9 @@ export const get_profile_picture = async function (uid, account_type = 'business
       }
 
       if (factual_image_mode) {
-        imageBase64 = await create_image(uid, factual_prompt, undefined, undefined, 1, undefined, undefined, {}, account_profile_info);
+        // Factual avatar is a real user-facing profile image, not a chat thumbnail —
+        // generate at medium (overridable via _conf.factual_avatar_quality), not the low default.
+        imageBase64 = await create_image(uid, factual_prompt, undefined, undefined, 1, undefined, undefined, {}, account_profile_info, _conf.factual_avatar_quality || 'medium');
       } else {
         const model = 'gpt-image-1-mini'; // 'chatgpt-image-latest';
         const prompt = `
@@ -9475,9 +9482,9 @@ async function restoreFaceWithOpenAI(base64Image, ctx = {}) {
     response = await client.images.edit({
       model,
       image: imageFile,
-      input_fidelity: 'high',
-      quality: 'high',
-      size: 'auto',
+      input_fidelity: 'high', // identity preservation — keep high (don't degrade)
+      quality: _conf.avatar_image_quality || 'low', // 'low' approved 2026-06-02 (A/B vs high/medium); identity held by input_fidelity:high. ~$0.08 vs $0.23 high. Override via _conf.avatar_image_quality.
+      size: _conf.avatar_image_size || '1024x1024', // was 'auto' (could pick 1536 = ~1.5x output tokens); avatars are square
       prompt:
         'Restore this portrait photograph. Remove scratches, dust, grain, noise, faded color, and any age-related damage. Recover natural skin texture, sharpen face details, and balance lighting and color. Preserve the exact same person completely unchanged: same face shape, same eye shape and color, same nose, same mouth, same hairline and hair, same skin tone, same age, same gender, same facial expression, and same clothing. Do not alter, beautify, age, or de-age the person. Output a clean, naturally lit photograph of the same person.',
     });
@@ -14131,7 +14138,7 @@ const _widget_verify_google_id_token = async function (id_token) {
   return payload;
 };
 
-const _widget_find_or_create_visitor = async function (email, name, google_sub) {
+const _widget_find_or_create_visitor = async function (email, name, google_sub, picture) {
   const ret = await db_module.find_couch_query('xuda_accounts', {
     selector: { 'account_info.email': email },
     fields: ['_id'],
@@ -14139,14 +14146,26 @@ const _widget_find_or_create_visitor = async function (email, name, google_sub)
   });
   if (ret.docs && ret.docs.length) {
     // If we have a google_sub and the existing account lacks one, attach it.
-    if (google_sub) {
+    // Also seed the Google photo as the profile_picture when the account has no
+    // avatar yet, so avatar generation has a source to work from.
+    if (google_sub || picture) {
       try {
         const acct_ret = await db_module.get_couch_doc('xuda_accounts', ret.docs[0]._id);
         if (acct_ret.code > -1) {
           const acct = acct_ret.data;
-          if (!acct.google_sub) {
+          let dirty = false;
+          if (google_sub && !acct.google_sub) {
             acct.google_sub = google_sub;
             acct.google_linked = true;
+            dirty = true;
+          }
+          acct.account_info = acct.account_info || {};
+          if (picture && !acct.account_info.profile_picture && !acct.account_info.profile_avatar) {
+            acct.account_info.profile_picture = picture;
+            acct.account_info.profile_picture_source = 'google';
+            dirty = true;
+          }
+          if (dirty) {
             acct.ts = Date.now();
             await db_module.save_couch_doc('xuda_accounts', acct);
           }
@@ -14160,6 +14179,13 @@ const _widget_find_or_create_visitor = async function (email, name, google_sub)
   const secret = _utils.get_id('tmp_pass', 5);
   const hash = _utils.hash(secret);
   const { first_name, last_name } = _widget_split_name(name);
+  const account_info = { email, username: _utils.get_id('xu'), first_name, last_name, full_name: name };
+  // Seed the Google profile photo so the avatar-generation step has a source.
+  if (picture) {
+    account_info.profile_picture = picture;
+    account_info.profile_picture_source = 'google';
+    account_info.profile_avatar_stat = 0;
+  }
   const doc = {
     _id: await _common.xuda_get_uuid('account'),
     stat: 1,
@@ -14167,7 +14193,7 @@ const _widget_find_or_create_visitor = async function (email, name, google_sub)
     source: 'widget',
     password: hash,
     email,
-    account_info: { email, username: _utils.get_id('xu'), first_name, last_name, full_name: name },
+    account_info,
   };
   if (google_sub) {
     doc.google_sub = google_sub;
@@ -14328,7 +14354,7 @@ export const get_widget_embed_snippet = async function (req, job_id, headers) {
 };
 
 const _widget_signup_core = async function (req, job_id, headers, opts) {
-  const { profile_id, email, name, widget_origin, google_sub, signup_method, visitor_lang } = req;
+  const { profile_id, email, name, widget_origin, google_sub, picture, signup_method, visitor_lang } = req;
   const [owner_uid_part, pid_part] = String(profile_id || '').split('.');
   if (!owner_uid_part || !pid_part) return { code: -404, data: 'invalid_profile' };
 
@@ -14339,8 +14365,17 @@ const _widget_signup_core = async function (req, job_id, headers, opts) {
   const ap_doc = account_profile_info.account_profile_obj || {};
   if (ap_doc.widget_enabled === false) return { code: -404, data: 'widget_disabled' };
 
-  const visitor_uid = await _widget_find_or_create_visitor(email, name, google_sub);
-  return await _widget_signup_finalize(visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang);
+  const visitor_uid = await _widget_find_or_create_visitor(email, name, google_sub, picture);
+
+  // Kick off persona-avatar generation for the visitor from their Google photo.
+  // Fire-and-forget in the account_module worker; the client polls widget_get_avatar.
+  if (picture) {
+    try {
+      account_msa.ensure_profile_avatar({ uid: visitor_uid }, job_id, headers);
+    } catch (err) {}
+  }
+
+  return await _widget_signup_finalize(visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang, picture);
 };
 
 export const widget_signup = async function (req, job_id, headers) {
@@ -14375,14 +14410,177 @@ export const widget_signup_google = async function (req, job_id, headers) {
       .trim();
     const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
     if (!email) return { code: -1, data: 'no_email_in_token' };
+    const picture = typeof payload.picture === 'string' ? payload.picture : '';
+
+    return await _widget_signup_core({ profile_id, email, name, widget_origin, visitor_lang, google_sub: payload.sub, picture, signup_method: 'google' }, job_id, headers);
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+// Site-level Google sign-in (e.g. the xuda.network topbar). Unlike
+// widget_signup_google this is NOT tied to a persona/chat — it performs the
+// same "complete setup of the user in xuda" the widget does (verify the Google
+// token, then find-or-create + link the visitor's free xuda account by
+// google_sub, and kick off avatar generation from their Google photo), so a
+// visitor is fully provisioned at site login, before they ever open a chat.
+// The chat widget later just links the already-provisioned account to a persona.
+export const site_signup_google = async function (req, job_id, headers) {
+  try {
+    const { id_token } = req;
+    if (!id_token || typeof id_token !== 'string') return { code: -1, data: 'missing_id_token' };
+
+    let payload;
+    try {
+      payload = await _widget_verify_google_id_token(id_token);
+    } catch (err) {
+      return { code: -401, data: err.message || 'google_token_invalid' };
+    }
+
+    const email = String(payload.email || '')
+      .toLowerCase()
+      .trim();
+    const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
+    if (!email) return { code: -1, data: 'no_email_in_token' };
+    const picture = typeof payload.picture === 'string' ? payload.picture : '';
+
+    const visitor_uid = await _widget_find_or_create_visitor(email, name, payload.sub, picture);
+
+    // Fire-and-forget avatar generation from the Google photo, same as the widget.
+    if (picture) {
+      try {
+        account_msa.ensure_profile_avatar({ uid: visitor_uid }, job_id, headers);
+      } catch (err) {}
+    }
+
+    const { first_name, last_name } = _widget_split_name(name);
+    return {
+      code: 1,
+      data: {
+        uid: visitor_uid,
+        email,
+        name,
+        first_name,
+        last_name,
+        picture,
+        account_active: true,
+        signin_url: `https://${_conf.domain || 'xuda.ai'}/dashboard/login`,
+      },
+    };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+// Public-profile "Ask Friendship". A visitor on /public_profiles/<target_uid>
+// signs in with Google (same find-or-create as site_signup_google), then we send
+// a contact_connection team_request to the profile owner. Auto-accepts (canonical
+// bidirectional contacts) when the owner has auto_respond enabled; otherwise the
+// owner gets an invitation email and the request stays pending. Never direct
+// add_contact — always the team_request invitation flow.
+export const public_profile_ask_friendship = async function (req, job_id, headers) {
+  try {
+    const { id_token, target_uid } = req;
+    if (!id_token || typeof id_token !== 'string') return { code: -1, data: 'missing_id_token' };
+    if (!target_uid || typeof target_uid !== 'string') return { code: -1, data: 'missing_target_uid' };
+
+    let payload;
+    try {
+      payload = await _widget_verify_google_id_token(id_token);
+    } catch (err) {
+      return { code: -401, data: err.message || 'google_token_invalid' };
+    }
+    const email = String(payload.email || '')
+      .toLowerCase()
+      .trim();
+    const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
+    if (!email) return { code: -1, data: 'no_email_in_token' };
+    const picture = typeof payload.picture === 'string' ? payload.picture : '';
+
+    // Target must be an active, non-opted-out account.
+    const target_ret = await account_ms.get_account_name({ uid_query: target_uid });
+    if (!target_ret || target_ret.code < 0) return { code: -404, data: 'target_not_found' };
+    const target = target_ret.data || {};
+    if (target.stat !== 3 || target.public_profile_disabled === true) return { code: -404, data: 'target_unavailable' };
+    const target_name = [target.first_name, target.last_name].filter(Boolean).join(' ') || target.username || 'Xuda Member';
+
+    // Find or create the visitor's xuda account (same setup as site_signup_google).
+    const visitor_uid = await _widget_find_or_create_visitor(email, name, payload.sub, picture);
+    if (visitor_uid === target_uid) return { code: -1, data: 'cannot_friend_self' };
+    if (picture) {
+      try {
+        account_msa.ensure_profile_avatar({ uid: visitor_uid }, job_id, headers);
+      } catch (err) {}
+    }
+
+    const { first_name, last_name } = _widget_split_name(name);
+    const visitor_first_name = first_name || '';
+
+    // Dedupe: reuse an existing request from this visitor to this target.
+    const existing_ret = await db_module.find_couch_query('xuda_team', {
+      selector: {
+        docType: 'team_request',
+        access_type: 'contact_connection',
+        team_req_from_uid: visitor_uid,
+        team_req_to_uid: target_uid,
+        contact_source: 'public_profile',
+      },
+      limit: 1,
+    });
+    let team_req_doc = existing_ret?.docs?.[0] || null;
 
-    return await _widget_signup_core({ profile_id, email, name, widget_origin, visitor_lang, google_sub: payload.sub, signup_method: 'google' }, job_id, headers);
+    if (!team_req_doc) {
+      const team_req_id = await _common.xuda_get_uuid('team_req');
+      team_req_doc = {
+        _id: team_req_id,
+        team_req_id,
+        team_req_date: Date.now(),
+        team_req_status_date: null,
+        team_req_to_email: target.email || '',
+        team_req_to_uid: target_uid,
+        team_req_stat: 2,
+        team_req_stat_desc: 'public profile friend request',
+        team_req_from_uid: visitor_uid,
+        docType: 'team_request',
+        team_req_app_id: null,
+        access_type: 'contact_connection',
+        uid: visitor_uid,
+        contact_source: 'public_profile',
+        share_item_id: target_uid,
+        sender_account_info: { email, first_name, last_name, full_name: name },
+      };
+      const tr_save = await db_module.save_couch_doc('xuda_team', team_req_doc);
+      if (tr_save.code < 0) return { code: -1, data: tr_save.data || 'team_request_create_failed' };
+
+      // fire-and-forget — the invitation email shouldn't block the response
+      team_ms.send_access_invitation({ team_req_id: team_req_doc._id }).catch(() => {});
+    }
+
+    let state = team_req_doc.team_req_stat === 3 ? 'open' : team_req_doc.team_req_stat === 4 ? 'declined' : 'pending';
+
+    // Auto-accept when the owner's active profile has auto_respond — performs the
+    // canonical bidirectional contact creation via confirm_team_request.
+    if (state === 'pending') {
+      let auto_accept = false;
+      try {
+        const tgt_ap = await get_active_account_profile_info(target_uid);
+        auto_accept = !!tgt_ap?.account_profile_obj?.auto_respond;
+      } catch (err) {}
+      if (auto_accept) {
+        try {
+          const cret = await team_ms.confirm_team_request({ team_req_id: team_req_doc._id });
+          if (cret && cret.code > -1) state = 'open';
+        } catch (err) {}
+      }
+    }
+
+    return { code: 1, data: { state, visitor_first_name, target_name } };
   } catch (err) {
     return { code: -1, data: err.message || String(err) };
   }
 };
 
-const _widget_signup_finalize = async function (visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang) {
+const _widget_signup_finalize = async function (visitor_uid, email, name, widget_origin, signup_method, account_profile_info, canonical_owner_uid, canonical_profile_id, ap_doc, job_id, headers, visitor_lang, picture) {
   try {
     let team_req_doc = await _widget_find_existing_team_req(visitor_uid, canonical_profile_id);
     let assigned_uid;
@@ -14494,6 +14692,9 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
         greeting,
         conversation_id,
         visitor_first_name,
+        visitor_uid,
+        // 1 = avatar generation kicked off (poll widget_get_avatar); 0 = none in flight
+        avatar_stat: picture ? 1 : 0,
         signup_method: signup_method || 'email',
         account_active: signup_method === 'google',
         signin_url: signup_method === 'google' ? `https://${_conf.domain || 'xuda.ai'}/dashboard/login` : undefined,
@@ -14504,6 +14705,59 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
   }
 };
 
+// Build the avatar-poll payload for an account: generation status plus the
+// avatar as base64 so an embedding page can draw it to a <canvas> without a
+// cross-origin taint (drive URLs may not send CORS headers).
+const _account_avatar_payload = async function (uid) {
+  const acct_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  if (acct_ret.code < 0 || !acct_ret.data) return null;
+  const info = acct_ret.data.account_info || {};
+  let avatar_b64 = null;
+  if (info.profile_avatar) {
+    try {
+      const blob_ret = await get_image_blob_from_downloaded_image(info.profile_avatar);
+      avatar_b64 = Buffer.from(await blob_ret.image_blob.arrayBuffer()).toString('base64');
+    } catch (err) {}
+  }
+  return {
+    // 0 none · 1 started · 2 generating · 3 done (profile_avatar set)
+    profile_avatar_stat: info.profile_avatar_stat || 0,
+    profile_avatar: info.profile_avatar || null,
+    profile_avatar_error: info.profile_avatar_error || null,
+    avatar_b64,
+  };
+};
+
+// Poll the visitor's generated persona avatar after a widget Google signup.
+// Auth is the widget_token (the session resolves the visitor uid).
+export const widget_get_avatar = async function (req) {
+  try {
+    const { widget_token } = req || {};
+    const session = await _widget_load_session(widget_token);
+    if (!session) return { code: -401, data: 'invalid_session' };
+    const payload = await _account_avatar_payload(session.visitor_uid);
+    if (!payload) return { code: -1, data: 'visitor_not_found' };
+    return { code: 1, data: payload };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
+// Poll the generated avatar after a site_signup_google (no widget session). The
+// uid is the long random account id returned by site_signup_google — not
+// enumerable — and only non-sensitive avatar fields are returned.
+export const site_get_avatar = async function (req) {
+  try {
+    const { uid } = req || {};
+    if (!uid || typeof uid !== 'string') return { code: -1, data: 'missing_uid' };
+    const payload = await _account_avatar_payload(uid);
+    if (!payload) return { code: -1, data: 'account_not_found' };
+    return { code: 1, data: payload };
+  } catch (err) {
+    return { code: -1, data: err.message || String(err) };
+  }
+};
+
 export const widget_send_message = async function (req, job_id, headers) {
   try {
     const { widget_token, prompt = '', attachments = [] } = req;
@@ -14629,3 +14883,557 @@ export const widget_get_messages = async function (req, job_id, headers) {
     return { code: -1, data: err.message || String(err) };
   }
 };
+
+// ============================================================================
+//   Static-website generation pipeline (helpers + orchestrator)
+// ============================================================================
+//
+// pick_image_source     - three-bucket router (Pexels / gpt-image-1 / chatgpt-image-latest)
+// pexels_search         - first consumer of _conf.pexels.api_key
+// estimate_static_website_cost - credit pre-check for create + modify
+// ingest_attachments    - categorize user-uploaded files into the output tree + manifest
+// generate_site_files   - planning prompt + per-page HTML + per-image source + SEO files
+// modify_site_files     - modify-by-prompt over existing file set
+//
+// Image-source bucket order (cheapest -> most expensive): Pexels (free) ->
+// gpt-image-1 (cheap AI) -> chatgpt-image-latest (premium AI). Decision is
+// driven by membership/workspace tier and credit balance so a paid user
+// running low auto-degrades from premium to cheap rather than failing.
+
+const LOW_CREDIT_THRESHOLD = _conf.static_website?.low_credit_threshold ?? 10;
+const HIGH_CREDIT_THRESHOLD = _conf.static_website?.high_credit_threshold ?? 100;
+
+export const pick_image_source = (account_doc, credit_balance) => {
+  const free_mem = (account_doc?.membership_plan || 'free') === 'free';
+  const free_ws = (account_doc?.ai_workspace_plan || 'free_ai_workspace') === 'free_ai_workspace';
+  const credits = Number(credit_balance ?? 0);
+  const paid_tier = !free_mem || !free_ws;
+
+  // Bucket 1: no AI option (fully-free + no credits)
+  if (!paid_tier && credits < LOW_CREDIT_THRESHOLD) return 'pexels';
+  // Bucket 3: premium, only for paid users with a comfortable buffer
+  if (paid_tier && credits >= HIGH_CREDIT_THRESHOLD) return 'chatgpt-image-latest';
+  // Bucket 2: cheaper AI - free users with credits, paid users running low (auto-degrade)
+  return 'gpt-image-1';
+};
+
+export const pexels_search = async (query, n = 1) => {
+  const api_key = _conf.pexels?.api_key;
+  if (!api_key) throw new Error('pexels.api_key not configured');
+  const url = `https://api.pexels.com/v1/search?query=${encodeURIComponent(query)}&per_page=${Math.max(1, Math.min(80, Number(n) || 1))}`;
+  const r = await fetch(url, { headers: { Authorization: api_key } });
+  if (!r.ok) throw new Error(`pexels search failed: ${r.status}`);
+  const j = await r.json();
+  const photos = (j.photos || []).slice(0, n);
+  return Promise.all(
+    photos.map(async (p) => {
+      const img = await fetch(p.src.large || p.src.medium || p.src.original);
+      if (!img.ok) throw new Error(`pexels fetch failed: ${img.status}`);
+      const buf = Buffer.from(await img.arrayBuffer());
+      return {
+        content_b64: buf.toString('base64'),
+        content_type: 'image/jpeg',
+        src_url: p.url,
+        photographer: p.photographer,
+        photographer_url: p.photographer_url,
+      };
+    }),
+  );
+};
+
+// Expected per-tier work for the credit estimator. Real generated count is
+// usually a fraction of the hard cap (page_count_limit in PLAN_OBJ).
+const EXPECTED_STATIC_WEBSITE_WORK = {
+  landing: { pages: 1, imgs_per_page: 2, seo: 0, css: 1 },
+  full: { pages: 8, imgs_per_page: 3, seo: 0, css: 1 },
+  seo: { pages: 25, imgs_per_page: 3, seo: 2, css: 1 },
+  enterprise: { pages: 100, imgs_per_page: 3, seo: 2, css: 1 },
+};
+
+const _image_price = (image_source) => {
+  if (image_source === 'pexels') return 0;
+  const m = _conf.ai_models?.[image_source];
+  return m?.price ?? Math.max(m?.input ?? 0, m?.output ?? 0) ?? 5;
+};
+
+const _text_price = () => {
+  const k = _conf.default_ai_model || 'gpt-5.4-mini';
+  const m = _conf.ai_models?.[k];
+  return m?.price ?? 1;
+};
+
+export const estimate_static_website_cost = (req) => {
+  const plan_tier = req?.plan_tier;
+  const image_source = req?.image_source || 'gpt-image-1';
+  const mode = req?.mode || 'create';
+  const current_page_count = Number(req?.current_page_count || 0);
+
+  const W = EXPECTED_STATIC_WEBSITE_WORK[plan_tier] || EXPECTED_STATIC_WEBSITE_WORK.landing;
+  const pages =
+    mode === 'modify'
+      ? Math.max(1, Math.ceil(current_page_count * 0.3)) // modify touches ~30% by default
+      : W.pages;
+  const text_calls = 1 /* site plan */ + W.css + pages /* per-page HTML */ + W.seo;
+  const image_calls = pages * W.imgs_per_page;
+
+  const text_unit = _text_price();
+  const image_unit = _image_price(image_source);
+  const credits_needed = text_calls * text_unit + image_calls * image_unit;
+
+  return {
+    credits_needed,
+    breakdown: { text_calls, text_unit, image_calls, image_unit, pages, mode },
+    image_source,
+  };
+};
+
+// ── Attachment ingestion ────────────────────────────────────────────────
+//
+// Shape: [{ filename, mime_type, drive_path? | content_b64? | url? }]
+// At least one source field must be present. Files land in the deployed site
+// at a stable /uploads/{img,docs,text,data,files}/{slug} path so the LLM can
+// reference them by URL in generated HTML.
+
+const _categorize_attachment = (att) => {
+  const mt = (att?.mime_type || '').toLowerCase();
+  if (mt.startsWith('image/')) return 'image';
+  if (mt === 'application/pdf') return 'pdf';
+  if (mt === 'text/csv' || mt === 'application/vnd.ms-excel') return 'data';
+  if (mt === 'application/json' || mt === 'text/markdown' || mt.startsWith('text/')) return 'text';
+  return 'binary';
+};
+
+const _load_attachment_bytes = async (att) => {
+  if (att.content_b64) return Buffer.from(att.content_b64, 'base64');
+  if (att.drive_path) {
+    const abs = path.join(_conf.studio_drive_path, att.drive_path);
+    return await readFile(abs);
+  }
+  if (att.url) {
+    const r = await fetch(att.url);
+    if (!r.ok) throw new Error(`attachment fetch ${att.url}: ${r.status}`);
+    return Buffer.from(await r.arrayBuffer());
+  }
+  throw new Error(`attachment ${att.filename} has no source (drive_path | content_b64 | url)`);
+};
+
+export const ingest_attachments = async (attachments = []) => {
+  const out = { manifest: [], file_entries: [], text_corpus: [] };
+  for (const att of attachments) {
+    if (!att || !att.filename) continue;
+    const kind = _categorize_attachment(att);
+    let bytes;
+    try {
+      bytes = await _load_attachment_bytes(att);
+    } catch (err) {
+      console.error('[ingest_attachments] skip', att.filename, err.message);
+      continue;
+    }
+    const slug = String(att.filename)
+      .replace(/[^a-z0-9.-]/gi, '_')
+      .toLowerCase();
+    let public_path;
+    if (kind === 'image') public_path = `/uploads/img/${slug}`;
+    else if (kind === 'pdf') public_path = `/uploads/docs/${slug}`;
+    else if (kind === 'text') public_path = `/uploads/text/${slug}`;
+    else if (kind === 'data') public_path = `/uploads/data/${slug}`;
+    else public_path = `/uploads/files/${slug}`;
+
+    out.file_entries.push({
+      path: public_path,
+      content_b64: bytes.toString('base64'),
+      content_type: att.mime_type || 'application/octet-stream',
+    });
+
+    const manifest_entry = { filename: att.filename, kind, public_path };
+    if (kind === 'text' || kind === 'data') {
+      const text = bytes.toString('utf8').slice(0, 8000);
+      manifest_entry.excerpt = text;
+      out.text_corpus.push({ filename: att.filename, text });
+    }
+    if (kind === 'image') {
+      manifest_entry.usage = `Embed via <img src="${public_path}" alt="..."> on relevant pages.`;
+    }
+    out.manifest.push(manifest_entry);
+  }
+  return out;
+};
+
+// ── Generation orchestrator ─────────────────────────────────────────────
+//
+// generate_site_files runs the prompt -> plan -> pages -> images -> SEO chain.
+// Returns a flat [{ path, content_b64, content_type }] list ready for
+// domains_module.deploy_site.
+
+const _safe_json_parse = (s) => {
+  if (!s || typeof s !== 'string') return null;
+  // The LLM sometimes wraps JSON in ```json fences despite instructions.
+  const cleaned = s
+    .trim()
+    .replace(/^```(?:json)?\s*/i, '')
+    .replace(/\s*```\s*$/i, '');
+  try {
+    return JSON.parse(cleaned);
+  } catch (_) {
+    return null;
+  }
+};
+
+const _chat = async (uid, prompt, account_profile_info, metadata) => {
+  const ret = await submit_chat_gpt_prompt({
+    uid,
+    prompt,
+    model: _conf.default_ai_model,
+    metadata: metadata || {},
+    account_profile_info,
+  });
+  if (ret.code < 0) throw new Error(`LLM call failed: ${ret.data}`);
+  return ret.data || '';
+};
+
+const _site_planning_prompt = (user_prompt, attachments_manifest, plan_tier, page_count_limit) => {
+  const W = EXPECTED_STATIC_WEBSITE_WORK[plan_tier] || EXPECTED_STATIC_WEBSITE_WORK.landing;
+  const default_pages = Math.min(W.pages, page_count_limit);
+  return `You are planning a static website. Output STRICT JSON only, no prose, no markdown fences.
+
+User brief:
+${user_prompt}
+
+User-uploaded files (manifest). The generated pages MUST use these where appropriate: embed images via <img src="$public_path">, quote / paraphrase text excerpts where they fit, link to PDFs, structure pages around data when relevant.
+${JSON.stringify(attachments_manifest, null, 2)}
+
+Hard rules:
+- Hosting tier: ${plan_tier}. Maximum ${page_count_limit} pages total. Aim for ${default_pages} pages unless the brief clearly implies more.
+- Each page has a slug (kebab-case path component, "" for home), title, and an ordered list of sections.
+- Each page also lists image_specs: image slots needed on that page. For each slot, decide source: 'attachment' (when an uploaded image fits) OR 'generate' (when one must be created).
+- For 'generate' slots, write a concise visual prompt AND a Pexels-friendly query string.
+- For 'attachment' slots, set attachment_path to one of the public_paths from the manifest.
+- style_directive is one paragraph describing the desired visual style (palette, typography, density) used to generate the global stylesheet.
+
+Schema:
+{
+  "pages": [
+    {
+      "slug": "string (empty for home)",
+      "title": "string",
+      "sections": [{"kind": "prose|image|quote|data_table|callout", "...": "..."}],
+      "image_specs": [
+        {"slot": "kebab-slug", "source": "generate|attachment", "prompt": "...", "query": "...", "attachment_path": "/uploads/...", "aspect": "16/10|1/1|3/2"}
+      ]
+    }
+  ],
+  "style_directive": "string"
+}
+
+Respond with ONLY the JSON object.`;
+};
+
+const _page_html_prompt = (page, style_directive, attachments_manifest) => `Generate a single static HTML page. Output ONLY the HTML, no markdown fences, no commentary.
+
+Page brief:
+${JSON.stringify(page, null, 2)}
+
+Global style directive (matches /style.css that's already written):
+${style_directive}
+
+Attachments available (use these public_paths verbatim when referenced):
+${JSON.stringify(attachments_manifest, null, 2)}
+
+Hard rules:
+- DOCTYPE html, lang="en", responsive viewport meta.
+- Link to /style.css.
+- Reference images from /img/{slot}.{ext} for 'generate' slots and from their public_path for 'attachment' slots, exactly as listed in image_specs.
+- Semantic HTML5 (header, main, section, footer). No inline styles unless absolutely necessary.
+- No external CDNs, no JavaScript.
+- Title from page.title.
+
+Respond with ONLY the raw HTML document.`;
+
+const _css_prompt = (style_directive, plan_tier) => `Generate ONE global stylesheet for a ${plan_tier}-tier static website. Output ONLY the CSS, no markdown fences, no commentary.
+
+Style directive:
+${style_directive}
+
+Hard rules:
+- Modern CSS only (no preprocessors). Use CSS variables for palette.
+- Responsive: mobile-first, breakpoints at 640px and 980px.
+- Typography: choose a serif heading + sans-serif body OR all sans, consistent with the directive.
+- Include base resets, layout containers, header, footer, basic image styling (max-width 100%, rounded), button styles.
+- Keep under 6 KB.
+
+Respond with ONLY the raw CSS text.`;
+
+const _sitemap_xml = (pages, hostname) => {
+  const base = `https://${hostname}`;
+  const urls = pages
+    .map((p) => {
+      const loc = p.slug ? `${base}/${p.slug}/` : `${base}/`;
+      return `  <url><loc>${loc}</loc></url>`;
+    })
+    .join('\n');
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls}\n</urlset>\n`;
+};
+
+const _robots_txt = (hostname) => `User-agent: *\nAllow: /\nSitemap: https://${hostname}/sitemap.xml\n`;
+
+// Picks an extension for a generated image filename from its content-type.
+const _image_ext = (content_type) => {
+  if (!content_type) return 'png';
+  if (/webp/i.test(content_type)) return 'webp';
+  if (/jpe?g/i.test(content_type)) return 'jpg';
+  if (/png/i.test(content_type)) return 'png';
+  if (/svg/i.test(content_type)) return 'svg';
+  return 'png';
+};
+
+export const generate_site_files = async (req) => {
+  try {
+    const { uid, prompt, attachments, plan_tier, page_count_limit, image_source, account_profile_info, hostname = 'sites.xuda.io' } = req;
+    if (!uid || !prompt) return { code: -1, data: 'uid + prompt required' };
+    if (!plan_tier) return { code: -1, data: 'plan_tier required' };
+
+    // 1. Ingest attachments (copies them into the output file list verbatim)
+    const ingestion = await ingest_attachments(attachments || []);
+
+    // 2. Plan the site
+    const plan_text = await _chat(uid, _site_planning_prompt(prompt, ingestion.manifest, plan_tier, page_count_limit), account_profile_info, { stage: 'static_website_plan', plan_tier });
+    const plan = _safe_json_parse(plan_text);
+    if (!plan || !Array.isArray(plan.pages) || !plan.pages.length) {
+      return { code: -2, data: 'planning JSON malformed', plan_text };
+    }
+
+    // 3. Hard-cap page count
+    plan.pages = plan.pages.slice(0, Math.max(1, Math.min(page_count_limit, plan.pages.length)));
+
+    // 4. Global CSS
+    const css = await _chat(uid, _css_prompt(plan.style_directive || '', plan_tier), account_profile_info, { stage: 'static_website_css', plan_tier });
+
+    // 5. Per-page HTML
+    const html_files = [];
+    for (const page of plan.pages) {
+      const html = await _chat(uid, _page_html_prompt(page, plan.style_directive || '', ingestion.manifest), account_profile_info, { stage: 'static_website_page', plan_tier, slug: page.slug || '' });
+      const rel = page.slug ? `/${page.slug}/index.html` : '/index.html';
+      html_files.push({
+        path: rel,
+        content_b64: Buffer.from(html, 'utf8').toString('base64'),
+        content_type: 'text/html',
+      });
+    }
+
+    // 6. Per-image generation
+    const image_files = [];
+    for (const page of plan.pages) {
+      const specs = Array.isArray(page.image_specs) ? page.image_specs : [];
+      for (const spec of specs) {
+        try {
+          if (spec.source === 'attachment') {
+            // already in ingestion.file_entries — nothing to add
+            continue;
+          }
+          if (image_source === 'pexels') {
+            const [img] = await pexels_search(spec.query || spec.prompt || page.title, 1);
+            if (!img) continue;
+            image_files.push({
+              path: `/img/${spec.slot}.jpg`,
+              content_b64: img.content_b64,
+              content_type: 'image/jpeg',
+            });
+          } else {
+            const b64 = await create_image(
+              uid,
+              spec.prompt || spec.query || page.title,
+              image_source, // 'gpt-image-1' | 'chatgpt-image-latest'
+              '1024x1024',
+              1,
+              1024,
+              1024, // full-resolution output
+              { kind: 'static_website', slot: spec.slot },
+              account_profile_info,
+            );
+            if (!b64) continue;
+            image_files.push({
+              path: `/img/${spec.slot}.png`,
+              content_b64: b64,
+              content_type: 'image/png',
+            });
+          }
+        } catch (err) {
+          console.error('[generate_site_files] image fail', spec.slot, err.message);
+        }
+      }
+    }
+
+    // 7. SEO files (seo + enterprise tiers only)
+    const seo_files = [];
+    if (plan_tier === 'seo' || plan_tier === 'enterprise') {
+      seo_files.push({
+        path: '/sitemap.xml',
+        content_b64: Buffer.from(_sitemap_xml(plan.pages, hostname), 'utf8').toString('base64'),
+        content_type: 'application/xml',
+      });
+      seo_files.push({
+        path: '/robots.txt',
+        content_b64: Buffer.from(_robots_txt(hostname), 'utf8').toString('base64'),
+        content_type: 'text/plain',
+      });
+    }
+
+    // 8. Compose final flat file list
+    const css_file = {
+      path: '/style.css',
+      content_b64: Buffer.from(css, 'utf8').toString('base64'),
+      content_type: 'text/css',
+    };
+    const files = [css_file, ...html_files, ...image_files, ...seo_files, ...ingestion.file_entries];
+
+    return {
+      code: 1,
+      data: {
+        files,
+        plan,
+        manifest: ingestion.manifest,
+        stats: {
+          page_count: plan.pages.length,
+          image_count: image_files.length,
+          attachment_count: ingestion.file_entries.length,
+        },
+      },
+    };
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};
+
+// ── Modify orchestrator ────────────────────────────────────────────────
+//
+// Loads current files, asks LLM what to change, writes back only the deltas.
+// Image source stays pinned to whatever was chosen at creation - modify does
+// NOT silently upgrade Pexels -> AI (that would surprise free users).
+
+const _modify_prompt = (user_prompt, current_files_index, attachments_manifest) => `You are editing an existing static website. Output STRICT JSON only, no prose, no markdown fences.
+
+User request:
+${user_prompt}
+
+Current file index (path + size + content-type — NOT full content; ask the user to re-attach if you need to read a file's body):
+${JSON.stringify(current_files_index, null, 2)}
+
+New attachments uploaded with this request:
+${JSON.stringify(attachments_manifest, null, 2)}
+
+For each change you want to make, emit one entry in "changes":
+  { "path": "/index.html", "action": "replace", "new_content": "...full new file content..." }
+  { "path": "/about/index.html", "action": "create", "new_content": "..." }
+  { "path": "/old-page/index.html", "action": "delete" }
+
+Image regeneration: emit { "image_change": { "path": "/img/hero.png", "new_prompt": "..." } } and the orchestrator will re-render via the locked image source.
+
+Hard rules:
+- Touch only files you actually need to change. Do NOT rewrite the whole site.
+- new_content for HTML files: full document, DOCTYPE through </html>. Link /style.css unchanged unless explicitly told to restyle.
+- Do NOT change file paths for unchanged pages.
+
+Schema:
+{ "changes": [...], "summary": "one sentence" }
+
+Respond with ONLY the JSON object.`;
+
+export const modify_site_files = async (req) => {
+  try {
+    const { uid, current_files, prompt, attachments, plan_tier, image_source, account_profile_info } = req;
+    if (!uid || !prompt) return { code: -1, data: 'uid + prompt required' };
+    if (!Array.isArray(current_files) || !current_files.length) return { code: -1, data: 'current_files required' };
+
+    const ingestion = await ingest_attachments(attachments || []);
+    const index = current_files.map((f) => ({
+      path: f.path,
+      content_type: f.content_type,
+      size_b64: (f.content_b64 || '').length,
+    }));
+
+    const diff_text = await _chat(uid, _modify_prompt(prompt, index, ingestion.manifest), account_profile_info, { stage: 'static_website_modify', plan_tier });
+    const diff = _safe_json_parse(diff_text);
+    if (!diff || !Array.isArray(diff.changes)) {
+      return { code: -2, data: 'modify JSON malformed', diff_text };
+    }
+
+    const changed_paths = [];
+    const updated_files = [...current_files];
+
+    const _find = (p) => updated_files.findIndex((f) => f.path === p);
+
+    for (const ch of diff.changes) {
+      // Re-rendered image
+      if (ch.image_change && ch.image_change.path && ch.image_change.new_prompt) {
+        const ip = ch.image_change.path;
+        try {
+          if (image_source === 'pexels') {
+            const [img] = await pexels_search(ch.image_change.new_prompt, 1);
+            if (img) {
+              const entry = { path: ip, content_b64: img.content_b64, content_type: 'image/jpeg' };
+              const idx = _find(ip);
+              if (idx >= 0) updated_files[idx] = entry;
+              else updated_files.push(entry);
+              changed_paths.push(ip);
+            }
+          } else {
+            const b64 = await create_image(uid, ch.image_change.new_prompt, image_source, '1024x1024', 1, 1024, 1024, { kind: 'static_website_modify' }, account_profile_info);
+            if (b64) {
+              const entry = { path: ip, content_b64: b64, content_type: 'image/png' };
+              const idx = _find(ip);
+              if (idx >= 0) updated_files[idx] = entry;
+              else updated_files.push(entry);
+              changed_paths.push(ip);
+            }
+          }
+        } catch (err) {
+          console.error('[modify_site_files] image regen fail', ip, err.message);
+        }
+        continue;
+      }
+
+      if (!ch.path || !ch.action) continue;
+      const idx = _find(ch.path);
+
+      if (ch.action === 'delete') {
+        if (idx >= 0) {
+          updated_files.splice(idx, 1);
+          changed_paths.push(ch.path);
+        }
+        continue;
+      }
+
+      if ((ch.action === 'replace' || ch.action === 'create') && typeof ch.new_content === 'string') {
+        const ext = (ch.path.match(/\.([a-z0-9]+)$/i) || [, ''])[1].toLowerCase();
+        const content_type = ext === 'html' ? 'text/html' : ext === 'css' ? 'text/css' : ext === 'js' ? 'application/javascript' : ext === 'json' ? 'application/json' : ext === 'xml' ? 'application/xml' : ext === 'txt' ? 'text/plain' : 'text/plain';
+        const entry = {
+          path: ch.path,
+          content_b64: Buffer.from(ch.new_content, 'utf8').toString('base64'),
+          content_type,
+        };
+        if (idx >= 0) updated_files[idx] = entry;
+        else updated_files.push(entry);
+        changed_paths.push(ch.path);
+      }
+    }
+
+    // Any new attachments uploaded this round join the file set verbatim.
+    for (const entry of ingestion.file_entries) {
+      const idx = _find(entry.path);
+      if (idx >= 0) updated_files[idx] = entry;
+      else updated_files.push(entry);
+      changed_paths.push(entry.path);
+    }
+
+    return {
+      code: 1,
+      data: {
+        updated_files,
+        changed_paths,
+        summary: diff.summary || '',
+      },
+    };
+  } catch (err) {
+    return { code: -400, data: err.message };
+  }
+};

package/index_ms.mjs

@@ -17,6 +17,30 @@
 
  
 
+export const pick_image_source = async function (...args) {
+  return await broker.send_to_queue("pick_image_source", ...args);
+};
+
+export const pexels_search = async function (...args) {
+  return await broker.send_to_queue("pexels_search", ...args);
+};
+
+export const estimate_static_website_cost = async function (...args) {
+  return await broker.send_to_queue("estimate_static_website_cost", ...args);
+};
+
+export const ingest_attachments = async function (...args) {
+  return await broker.send_to_queue("ingest_attachments", ...args);
+};
+
+export const generate_site_files = async function (...args) {
+  return await broker.send_to_queue("generate_site_files", ...args);
+};
+
+export const modify_site_files = async function (...args) {
+  return await broker.send_to_queue("modify_site_files", ...args);
+};
+
 export const execute_codex_request = async function (...args) {
   return await broker.send_to_queue("execute_codex_request", ...args);
 };
@@ -193,6 +217,10 @@ export const is_spam_email = async function (...args) {
   return await broker.send_to_queue("is_spam_email", ...args);
 };
 
+export const marketplace_review_item = async function (...args) {
+  return await broker.send_to_queue("marketplace_review_item", ...args);
+};
+
 export const is_business_contact = async function (...args) {
   return await broker.send_to_queue("is_business_contact", ...args);
 };
@@ -253,6 +281,22 @@ export const widget_signup_google = async function (...args) {
   return await broker.send_to_queue("widget_signup_google", ...args);
 };
 
+export const site_signup_google = async function (...args) {
+  return await broker.send_to_queue("site_signup_google", ...args);
+};
+
+export const public_profile_ask_friendship = async function (...args) {
+  return await broker.send_to_queue("public_profile_ask_friendship", ...args);
+};
+
+export const widget_get_avatar = async function (...args) {
+  return await broker.send_to_queue("widget_get_avatar", ...args);
+};
+
+export const site_get_avatar = async function (...args) {
+  return await broker.send_to_queue("site_get_avatar", ...args);
+};
+
 export const widget_send_message = async function (...args) {
   return await broker.send_to_queue("widget_send_message", ...args);
 };
@@ -260,7 +304,3 @@ export const widget_send_message = async function (...args) {
 export const widget_get_messages = async function (...args) {
   return await broker.send_to_queue("widget_get_messages", ...args);
 };
-
-export const marketplace_review_item = async function (...args) {
-  return await broker.send_to_queue("marketplace_review_item", ...args);
-};

package/index_msa.mjs

@@ -17,6 +17,30 @@
 
  
 
+export const pick_image_source =  function (...args) {
+   broker.send_to_queue_async("pick_image_source", ...args);
+};
+
+export const pexels_search =  function (...args) {
+   broker.send_to_queue_async("pexels_search", ...args);
+};
+
+export const estimate_static_website_cost =  function (...args) {
+   broker.send_to_queue_async("estimate_static_website_cost", ...args);
+};
+
+export const ingest_attachments =  function (...args) {
+   broker.send_to_queue_async("ingest_attachments", ...args);
+};
+
+export const generate_site_files =  function (...args) {
+   broker.send_to_queue_async("generate_site_files", ...args);
+};
+
+export const modify_site_files =  function (...args) {
+   broker.send_to_queue_async("modify_site_files", ...args);
+};
+
 export const execute_codex_request =  function (...args) {
    broker.send_to_queue_async("execute_codex_request", ...args);
 };
@@ -193,6 +217,10 @@ export const is_spam_email =  function (...args) {
    broker.send_to_queue_async("is_spam_email", ...args);
 };
 
+export const marketplace_review_item =  function (...args) {
+   broker.send_to_queue_async("marketplace_review_item", ...args);
+};
+
 export const is_business_contact =  function (...args) {
    broker.send_to_queue_async("is_business_contact", ...args);
 };
@@ -253,6 +281,22 @@ export const widget_signup_google =  function (...args) {
    broker.send_to_queue_async("widget_signup_google", ...args);
 };
 
+export const site_signup_google =  function (...args) {
+   broker.send_to_queue_async("site_signup_google", ...args);
+};
+
+export const public_profile_ask_friendship =  function (...args) {
+   broker.send_to_queue_async("public_profile_ask_friendship", ...args);
+};
+
+export const widget_get_avatar =  function (...args) {
+   broker.send_to_queue_async("widget_get_avatar", ...args);
+};
+
+export const site_get_avatar =  function (...args) {
+   broker.send_to_queue_async("site_get_avatar", ...args);
+};
+
 export const widget_send_message =  function (...args) {
    broker.send_to_queue_async("widget_send_message", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.5614",
+  "version": "1.1.5616",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",