@xuda.io/ai_module 1.1.5629 → 1.1.5631

package/index.mjs

@@ -195,7 +195,7 @@ const get_openai_codex_exec_args = function (codex_model, opts = {}) {
   return args;
 };
 
-global._conf = JSON.parse(fs.readFileSync(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), 'utf8'));
+global._conf = (await import(path.join(process.env.XUDA_HOME, "common", "load_conf.mjs"))).loadConf();
 
 const _defaultAppConfig = {
   credential: admin.credential.cert(_conf.firebase_serviceAccount),
@@ -1631,6 +1631,22 @@ const _sw_gen_release = async (uid) => {
   } catch (e) {}
 };
 
+// Maps a raw Codex/OpenAI failure string (stderr) onto a concise, user-friendly
+// reason. The full raw error is always logged server-side (see the failure
+// branch below); this only controls what the dashboard shows, so it must stay
+// non-technical and never echo the command, paths, or keys.
+const _sw_gen_friendly_error = (raw) => {
+  const s = (raw || '').toString().toLowerCase();
+  if (!s) return null;
+  if (/insufficient_quota|exceeded your current quota|billing|payment|spend|hard limit|usage limit/.test(s)) return 'AI generation is temporarily unavailable: the AI service is over its usage limit. Please try again later.';
+  if (/must be verified|verify your organization|verification required|organization must be verified/.test(s)) return 'AI generation is temporarily unavailable right now. Please try again later.';
+  if (/rate.?limit|too many requests|\b429\b/.test(s)) return 'The AI service is busy right now. Please try again in a moment.';
+  if (/invalid_api_key|incorrect api key|\b401\b|unauthorized|authentication/.test(s)) return 'AI generation is temporarily unavailable right now. Please try again later.';
+  if (/model.*(not found|does not exist|unsupported|no access)|does not have access to model/.test(s)) return 'AI generation is temporarily unavailable right now. Please try again later.';
+  if (/timed out|timeout|etimedout|deadline/.test(s)) return 'The AI took too long to respond. Try a shorter prompt or try again.';
+  return null;
+};
+
 export const generate_site_draft = async (req, job_id) => {
   const step = (current_step, current_step_name) => {
     if (job_id) jobs_ms.update_job({ job_id, current_step, current_step_name }).catch(() => {});
@@ -1690,7 +1706,18 @@ When done, briefly summarize what you built.`;
       const built_prompt = `[System]\n${gen_system}\n\n[User request]\n${prompt}`;
       const codex_ret = await execute_codex_request({ uid, ip: undefined, local_cwd: dir, prompt: built_prompt, stream: false, sandbox: 'workspace-write', codex_timeout: 240000 });
       if (!codex_ret || codex_ret.code < 0) {
-        const msg = (codex_ret && (typeof codex_ret.data === 'string' ? codex_ret.data : codex_ret.data?.message)) || 'Generation failed';
+        // On a non-zero codex exit, codex_ret.data is an object whose real reason
+        // lives in `stderr` (not `message`); only the early guards return a plain
+        // string. The old code read data.message (never set on the object form),
+        // so EVERY real failure collapsed to "Generation failed", hiding quota /
+        // model / verification / auth errors. Log the full raw detail server-side
+        // (operator-only) and surface a concise, sanitized reason to the client.
+        const d = codex_ret?.data;
+        const raw = typeof d === 'string' ? d : d?.stderr || d?.stdout || d?.message || '';
+        try {
+          console.error('[generate_site_draft] codex failed', JSON.stringify({ uid, code: codex_ret?.code, exit_code: d?.exit_code, stderr: (d?.stderr || '').slice(-3000), stdout: (d?.stdout || '').slice(-800) }));
+        } catch (e) {}
+        const msg = _sw_gen_friendly_error(raw) || (typeof d === 'string' && d ? d : 'Generation failed');
         return finalize({ code: -1, data: msg });
       }
 
@@ -4311,6 +4338,107 @@ export const submit_chat_gpt_prompt = async function (req) {
   }
 };
 
+// external_app: turn a scan payload (from the embed engine's window.__xuda_embed
+// .scan()) into a short list of concrete, helpful suggestions the user can act
+// on from Xuda — the semantic layer on top of the engine's mechanical scan.
+// The suggestion SCHEMA is deliberately FLAT (all fields required, no open
+// records / z.any()) because zodTextFormat runs OpenAI strict structured output
+// and rejects open-ended objects; args are carried as a JSON string (args_json)
+// and drive is flattened, then reassembled here. Suggestions map to either a
+// platform cpi_method (add_contact/send_email, args) or an in-iframe drive
+// action (click/fill/navigate, selectors taken from the scan). Destructive ones
+// are flagged; the dashboard gates them with ConfirmCodeModal + validation_code
+// (and destructive AI-initiated actions are validation_code-checked server-side)
+// before execution. req: { data: { app_id, scan } }
+export const classify_external_app_scan = async (req) => {
+  try {
+    const data = req.data || req;
+    const uid = req.uid || req.token_ret?.data?.uid;
+    const app_id = data.app_id;
+    const scan = data.scan;
+    if (!uid) return { code: -1, data: 'not authorized' };
+    if (!scan || typeof scan !== 'object') return { code: -1, data: 'scan payload required' };
+
+    // The scan came from the user's own embedded app — verify ownership.
+    if (app_id) {
+      const appr = await db_module.get_couch_doc('xuda_master', app_id);
+      if (appr.code < 0 || !appr.data) return { code: -1, data: 'app not found' };
+      const a = appr.data;
+      if (a.app_type !== 'external_app') return { code: -1, data: 'not an external_app app' };
+      if (a.app_uId !== uid && a.app_maintainer !== uid) return { code: -1, data: 'not authorized' };
+    }
+
+    // Compact the scan to bound tokens (the engine already truncates text).
+    const compact = {
+      url: scan.url,
+      title: scan.title,
+      text: String(scan.page_text_excerpt || '').slice(0, 3000),
+      entities: (scan.entities || []).slice(0, 40).map((e) => ({ type: e.type, value: e.value, label: e.label, selector: e.selector })),
+      forms: (scan.forms || []).slice(0, 8).map((f) => ({ selector: f.selector, action: f.action, fields: (f.fields || []).slice(0, 20).map((x) => ({ name: x.name, type: x.type, label: x.label, selector: x.selector })) })),
+      tables: (scan.tables || []).slice(0, 5).map((t) => ({ headers: t.headers, row_count: t.row_count, sample_rows: (t.sample_rows || []).slice(0, 2) })),
+    };
+
+    const SuggestionsSchema = z.object({
+      summary: z.string().describe('One sentence: what this page appears to be.'),
+      detected_context: z.string().describe('One of: customer, supplier, contact, invoice, order, form, listing, generic.'),
+      suggestions: z.array(
+        z.object({
+          title: z.string().describe('Short action label shown on the card.'),
+          kind: z.string().describe('add_contact | send_email | fill_form | extract | navigate | other'),
+          rationale: z.string().describe('Why this is suggested, one short sentence.'),
+          confidence: z.number().describe('0..1'),
+          destructive: z.boolean().describe('true if it sends/pays/deletes/submits.'),
+          cpi_method: z.string().describe('Platform method to call, e.g. add_contact or send_email; "" if none.'),
+          args_json: z.string().describe('JSON object string of args for cpi_method; "{}" if none.'),
+          drive_action: z.string().describe('In-iframe action: click | fill | navigate | scan; "" if none.'),
+          drive_selector: z.string().describe('Selector from the scan; "" if none.'),
+          drive_value: z.string().describe('Value for fill; "" if none. Never fabricate credentials.'),
+          drive_url: z.string().describe('URL for navigate; "" if none.'),
+        }),
+      ),
+    });
+
+    const account_profile_info = await get_active_account_profile_info(uid);
+    const prompt =
+      `You are Xuda's in-app assistant. The user is viewing an external web app embedded in their Xuda dashboard. ` +
+      `Below is a structured scan of the CURRENT page (mechanically extracted; no semantics applied yet). Identify what the page is and propose a short list of concrete, helpful actions the user can take from Xuda.\n\n` +
+      `Guidance:\n` +
+      `- If customer/supplier/contact details are present, suggest adding them to Xuda contacts (cpi_method "add_contact", args {name,email,phone,company}) or emailing them (cpi_method "send_email", args {to,subject,body}).\n` +
+      `- If the page is a form the user likely wants filled, suggest fill via drive (drive_action "fill", drive_selector from a scanned field, drive_value the suggested value). NEVER fabricate credentials or passwords.\n` +
+      `- Use in-iframe drive actions only with selectors that appear in the scan.\n` +
+      `- Set destructive:true for anything that sends, pays, deletes, or submits a form.\n` +
+      `- confidence in 0..1. Return 0-5 suggestions, best first. Only suggest what the scan supports; if nothing useful, return an empty suggestions array with a summary.\n` +
+      `- Unused string fields must be "" and args_json must be a valid JSON object string (use "{}" when no args).\n\n` +
+      `SCAN:\n${JSON.stringify(compact)}`;
+
+    const ret = await submit_chat_gpt_prompt({ uid, prompt, model: _conf.default_ai_model, response_format: SuggestionsSchema, metadata: { app_id, func: 'classify_external_app_scan' }, account_profile_info });
+    if (ret.code < 0) return { code: -1, data: ret.data };
+
+    let parsed;
+    try {
+      parsed = JSON5.parse(ret.data);
+    } catch (e) {
+      return { code: -1, data: 'classify parse error' };
+    }
+
+    // Reassemble the flat fields into the suggestion shape the cards consume.
+    const suggestions = (parsed.suggestions || []).map((s, i) => {
+      let args = {};
+      try {
+        args = s.args_json ? JSON5.parse(s.args_json) : {};
+      } catch (e) {
+        args = {};
+      }
+      const drive = s.drive_action ? { action: s.drive_action, selector: s.drive_selector || null, value: s.drive_value || null, url: s.drive_url || null } : null;
+      return { id: 'sug_' + i, title: s.title, kind: s.kind, rationale: s.rationale, confidence: s.confidence, destructive: !!s.destructive, cpi_method: s.cpi_method || null, args, drive };
+    });
+
+    return { code: 1, data: { version: 1, summary: parsed.summary, detected_context: parsed.detected_context, suggestions } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
 // Triage a CPI error incident for the central error resolver (support_module).
 // The Zod schema lives here because zodTextFormat schemas cannot cross the
 // message broker (it JSON-serializes args and strips functions). The resolver