@xuda.io/ai_module 1.1.5613 → 1.1.5615

package/index.mjs

@@ -2085,6 +2085,10 @@ const create_image = async function (uid, prompt, model = 'gpt-image-1-mini', si
         prompt,
         size,
         n,
+        // Output is downscaled to width×height (default 256²) right below, so a
+        // high-quality 1024² render is wasted. 'low' is indistinguishable at
+        // thumbnail size and 2-8x cheaper. Tunable via _conf.chat_image_quality.
+        quality: _conf.chat_image_quality || 'low',
       });
       report_ai_status(model);
     } catch (err) {
@@ -9178,6 +9182,78 @@ export const is_spam_email = async function (uid, email, subject, account_profil
   } catch (error) {}
 };
 
+// AI screening for a marketplace publish. Receives plain-JSON context from
+// marketplace_module (zod schemas cannot cross the broker, so the prompt +
+// structured schema must live here). Returns a structured verdict across the
+// approval rule dimensions. The caller (marketplace_approval_review) merges
+// this with deterministic account-standing checks and decides the final stat.
+export const marketplace_review_item = async function (req) {
+  const { uid, item_type, item = {}, account_context = {}, account_name = '', model = _conf.default_ai_model, account_profile_info } = req || {};
+
+  const check_schema = z.object({
+    flag: z.boolean().describe('true if this concern is present'),
+    severity: z.enum(['none', 'low', 'medium', 'high']).describe('how serious the concern is'),
+    note: z.string().describe('one short sentence of evidence; empty string if no concern'),
+  });
+
+  const response_format = z.object({
+    decision: z.enum(['approve', 'reject', 'manual_review']).describe('approve = safe to publish; reject = clear violation; manual_review = uncertain, needs a human'),
+    confidence: z.number().min(0).max(100).describe('confidence in the decision, 0-100'),
+    checks: z.object({
+      ai_bot_activity: check_schema.describe('automated/bot publishing: high velocity, near-duplicate items, low-effort generated bulk'),
+      commercial_undisclosed: check_schema.describe('undisclosed commercial intent: external paid links, lead-gen, off-platform payment, advertising inconsistent with declared price/category'),
+      harmful_code: check_schema.describe('destructive ops, data exfiltration, crypto-miners, obfuscation, malicious network calls in the submitted code'),
+      suspicious_activity: check_schema.describe('mismatched metadata, hidden payloads, evasion patterns'),
+      malformed_account_name: check_schema.describe('gibberish, homoglyphs, embedded URLs, or impersonation in the account name'),
+      spam_low_quality: check_schema.describe('spam, filler, or low-quality content with no real utility'),
+      impersonation_trademark: check_schema.describe('impersonates a brand/person or abuses a trademark'),
+      prohibited_content: check_schema.describe('adult, illegal, hateful, or otherwise disallowed content'),
+      plagiarism_duplicate: check_schema.describe('appears copied from or duplicates an existing item'),
+      secrets_pii_leak: check_schema.describe('hardcoded API keys, tokens, credentials, or exposed PII in the code'),
+    }),
+    reasons: z.array(z.string()).describe('short user-facing lines explaining the decision (empty if approved cleanly)'),
+  });
+
+  const prompt = `You are the xuda marketplace moderation reviewer. Decide whether the following ${item_type} should be published to the public marketplace.
+
+Account name: ${account_name}
+Account context (signals): ${JSON.stringify(account_context)}
+
+Item:
+- name: ${item.name || ''}
+- description: ${item.description || ''}
+- category: ${item.category || ''}
+- tags: ${JSON.stringify(item.tags || [])}
+- price: ${item.price ?? 0}
+- code/content summary: ${item.code_summary || '(none provided)'}
+
+Evaluate every check honestly. Set decision to:
+- "approve" when no medium/high concerns and the item is genuine and useful.
+- "reject" when there is a clear high-severity violation (harmful code, leaked secrets, prohibited content, obvious impersonation/spam, or clear bot abuse).
+- "manual_review" when concerns are present but ambiguous, or you are not confident.
+Keep "reasons" concise, factual, and user-facing (no internal jargon).`;
+
+  const ret = await submit_chat_gpt_prompt({
+    uid,
+    prompt,
+    model,
+    response_format,
+    metadata: { func: 'marketplace_review_item', item_type },
+    account_profile_info,
+  });
+
+  if (ret.code < 0) {
+    return { code: ret.code, data: ret.data };
+  }
+
+  try {
+    const verdict = JSON.parse(ret.data);
+    return { code: 1, data: { ...verdict, model } };
+  } catch (err) {
+    return { code: -1, data: `marketplace_review_item parse error: ${err.message}` };
+  }
+};
+
 export const is_business_contact = async function (uid, email, name, subject, body, account_profile_info) {
   let prompt = `detect if the email "${email}", subject "${subject}", name "${name}", or body "${body}" is business  or personal. Return true if it is a business , false otherwise.
   
@@ -9403,9 +9479,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.',
     });
@@ -14256,7 +14332,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 } = req;
+  const { profile_id, email, name, widget_origin, google_sub, 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' };
 
@@ -14268,19 +14344,19 @@ const _widget_signup_core = async function (req, job_id, headers, opts) {
   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);
+  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);
 };
 
 export const widget_signup = async function (req, job_id, headers) {
   try {
-    let { profile_id, email, name, widget_origin } = req;
+    let { profile_id, email, name, widget_origin, visitor_lang } = req;
     if (typeof email !== 'string' || typeof name !== 'string') return { code: -1, data: 'invalid_input' };
     email = email.toLowerCase().trim();
     name = name.trim();
     if (!email || !name) return { code: -1, data: 'invalid_input' };
     if (!WIDGET_EMAIL_RE.test(email)) return { code: -1, data: 'invalid_email' };
 
-    return await _widget_signup_core({ profile_id, email, name, widget_origin, signup_method: 'email' }, job_id, headers);
+    return await _widget_signup_core({ profile_id, email, name, widget_origin, visitor_lang, signup_method: 'email' }, job_id, headers);
   } catch (err) {
     return { code: -1, data: err.message || String(err) };
   }
@@ -14288,7 +14364,7 @@ export const widget_signup = async function (req, job_id, headers) {
 
 export const widget_signup_google = async function (req, job_id, headers) {
   try {
-    const { profile_id, id_token, widget_origin } = req;
+    const { profile_id, id_token, widget_origin, visitor_lang } = req;
     if (!id_token || typeof id_token !== 'string') return { code: -1, data: 'missing_id_token' };
 
     let payload;
@@ -14304,13 +14380,13 @@ export const widget_signup_google = async function (req, job_id, headers) {
     const name = String(payload.name || payload.email?.split('@')[0] || 'Friend').trim();
     if (!email) return { code: -1, data: 'no_email_in_token' };
 
-    return await _widget_signup_core({ profile_id, email, name, widget_origin, google_sub: payload.sub, signup_method: 'google' }, job_id, headers);
+    return await _widget_signup_core({ profile_id, email, name, widget_origin, visitor_lang, google_sub: payload.sub, signup_method: 'google' }, job_id, headers);
   } 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) {
+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) {
   try {
     let team_req_doc = await _widget_find_existing_team_req(visitor_uid, canonical_profile_id);
     let assigned_uid;
@@ -14374,12 +14450,20 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
 
     const widget_token = `wds_${crypto.randomUUID().replace(/-/g, '')}`;
     const now = Date.now();
+    // Normalize visitor_lang to a short tag (e.g. "ja-JP" → "ja"). The
+    // auto-reply agent reads this from the session to respond in the
+    // visitor's language. Empty / missing → English fallback at reply time.
+    const visitor_lang_base = String(visitor_lang || '')
+      .toLowerCase()
+      .split('-')[0]
+      .slice(0, 8);
     const session_doc = {
       _id: widget_token,
       docType: 'widget_session',
       stat: 2,
       state,
       visitor_uid,
+      visitor_lang: visitor_lang_base || '',
       team_req_id: team_req_doc._id,
       assigned_uid,
       owner_uid: canonical_owner_uid,
@@ -14398,6 +14482,12 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
     const assigned_avatar = assigned_info_ret?.data?.profile_picture || assigned_info_ret?.data?.profile_avatar || '';
     const greeting = ap_doc?.widget_config?.greeting || WIDGET_DEFAULT_GREETING;
 
+    // Surface the visitor's first name so the chat widget can personalize the
+    // greeting on the page ("Hi {visitor_first_name}, I'm Valentina..."). The
+    // widget reads this from the persisted session and replaces the
+    // {visitor_name} placeholder client-side.
+    const visitor_first_name = _widget_split_name(name).first_name || '';
+
     return {
       code: 1,
       data: {
@@ -14407,6 +14497,7 @@ const _widget_signup_finalize = async function (visitor_uid, email, name, widget
         assigned_avatar,
         greeting,
         conversation_id,
+        visitor_first_name,
         signup_method: signup_method || 'email',
         account_active: signup_method === 'google',
         signin_url: signup_method === 'google' ? `https://${_conf.domain || 'xuda.ai'}/dashboard/login` : undefined,
@@ -14542,3 +14633,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);
 };

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);
 };

package/package.json

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