@ubox-tools/deploy-xperience 1.1.19 → 1.1.21

package/deploy.js

@@ -241,10 +241,7 @@ function generateProxy(appName) {
       // 1. Parameter token substitution (JS only — parameters live in JS files)
       if (isJS) {
         for (const key of Object.keys(params)) {
-          const re = new RegExp(
-            `((?:const|let|var)\\s+${key}\\s*=\\s*)(?:"[^"]*"|'[^']*'|\`[^\`]*\`|-?\\d+\\.?\\d*(?:[eE][+-]?\\d+)?|true|false|null|undefined)`,
-            'g'
-          );
+          const re = new RegExp(`((?:const|let|var)\\s+${key}\\s*=\\s*)(?:"[^"]*"|'[^']*')`, 'g');
           content = content.replace(re, `$1"{parameter:${key}}"`);
         }
       }
@@ -419,17 +416,33 @@ async function uploadFile(page, absPath) {
   await client.detach();
 }
 
-/** Inject text content into the active Monaco/CodeMirror/Ace editor. */
-async function injectToEditor(page, content) {
-  // Try Monaco API first (no clipboard needed)
-  const monacoOk = await page.evaluate(text => {
-    if (window.monaco?.editor) {
-      const models = window.monaco.editor.getModels();
-      if (models?.length > 0) { models[0].setValue(text); return true; }
+/** Inject text content into the active Monaco/CodeMirror/Ace editor.
+ *  @param {string} filename  Source filename (e.g. "index.html") — used to pick
+ *                            the right Monaco model by URI when multiple models are
+ *                            pre-loaded (e.g. after visiting the Parameters tab). */
+async function injectToEditor(page, content, filename) {
+  // Try Monaco API
+  const monacoResult = await page.evaluate((text, fn) => {
+    if (!window.monaco?.editor) return null;
+    const models = window.monaco.editor.getModels();
+    if (!models?.length) return null;
+
+    // Best: match model by filename in its URI — avoids the models[0] trap when
+    // multiple models are pre-loaded (happens after visiting the Parameters tab).
+    if (fn) {
+      const m = models.find(m => m.uri?.toString().includes(fn));
+      if (m) { m.setValue(text); return 'uri'; }
     }
-    return false;
-  }, content);
-  if (monacoOk) { console.log('      [editor] Monaco'); return; }
+
+    // Safe fallback: single model is always the active one (lazy-load case).
+    if (models.length === 1) { models[0].setValue(text); return 'single'; }
+
+    // Multiple models, no URI match — fall through to keyboard injection.
+    return `multi:${models.length}:${models.map(m => m.uri?.toString()).join('|')}`;
+  }, content, filename ?? null);
+
+  if (monacoResult === 'uri' || monacoResult === 'single') return;
+  if (monacoResult) console.log(`      [editor] Monaco ${monacoResult} → keyboard fallback`);
 
   // Try CodeMirror API
   const cmOk = await page.evaluate(text => {
@@ -437,19 +450,25 @@ async function injectToEditor(page, content) {
     if (cm?.CodeMirror) { cm.CodeMirror.setValue(text); return true; }
     return false;
   }, content);
-  if (cmOk) { console.log('      [editor] CodeMirror'); return; }
+  if (cmOk) return;
 
-  // Fallback: clipboard paste into Ace / generic textarea
-  console.log('      [editor] clipboard');
+  // Keyboard injection: click the visible editor, Ctrl+A, Ctrl+V.
+  // Targets whatever editor is currently focused (active tab) — model-agnostic.
   writeClipboard(content);
-  const ed = await page.$('.ace_editor, .cm-editor, .monaco-editor, textarea');
-  if (!ed) throw new Error('No code editor found on page');
-  const edRect = await page.evaluate(el => {
-    el.scrollIntoView({ block: 'nearest' });
-    const r = el.getBoundingClientRect();
-    return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
-  }, ed);
-  await page.mouse.click(edRect.x, edRect.y);
+  const edPos = await page.evaluate(() => {
+    for (const sel of ['.monaco-editor', '.ace_editor', '.cm-editor', 'textarea']) {
+      const el = Array.from(document.querySelectorAll(sel))
+        .find(e => { const r = e.getBoundingClientRect(); return r.width > 10 && r.height > 10; });
+      if (el) {
+        el.scrollIntoView({ block: 'nearest' });
+        const r = el.getBoundingClientRect();
+        return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+      }
+    }
+    return null;
+  });
+  if (!edPos) throw new Error('No code editor found on page');
+  await page.mouse.click(edPos.x, edPos.y);
   await sleep(200);
   await page.keyboard.down('Control');
   await page.keyboard.press('a');
@@ -609,6 +628,9 @@ async function configureParameters(page, params) {
 
   console.log(`  [params] Creating ${toCreate.length} new parameter(s) (${existingKeys.length} already exist)...`);
 
+  // Accept any confirm() dialogs that Save triggers
+  page.on('dialog', async d => { await d.accept(); });
+
   await clickByText(page, 'Edit', 'button');
   await sleep(1000);
 
@@ -662,20 +684,11 @@ async function configureParameters(page, params) {
 
 async function injectSource(page, proxy) {
   console.log('  [source] Injecting source files...');
-  console.log(`  [source] URL: ${page.url()}`);
   await clickByText(page, 'Source');
   await sleep(1500);
 
   await clickByText(page, 'Edit source');
   await sleep(3000);
-  // Wait for the editor (Monaco or CodeMirror) to fully initialize.
-  // On first-ever source editor visit in a session, Monaco may still be loading
-  // after 3 s — this ensures injection happens only once it's ready.
-  await page.waitForFunction(() => {
-    return !!(window.monaco?.editor?.getModels) ||
-           !!(document.querySelector('.CodeMirror')?.CodeMirror);
-  }, { timeout: 15000 }).catch(() => null);
-  console.log(`  [source] URL after Edit source: ${page.url()}`);
 
   // Tab label → filename
   const tabs = [
@@ -692,15 +705,12 @@ async function injectSource(page, proxy) {
     console.log(`    ${filename} → ${tabLabel}`);
     await clickByText(page, tabLabel);
     await sleep(1000);
-    await injectToEditor(page, proxy[filename]);
+    await injectToEditor(page, proxy[filename], filename);
     await sleep(500);
   }
 
-  const navPromise = page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 15000 }).catch(() => null);
   await clickByText(page, 'Save and back to app');
-  const navResult = await navPromise;
-  await sleep(1000);
-  console.log(`  [source] URL after save: ${page.url()} (navigated: ${navResult ? 'yes' : 'no'})`);
+  await sleep(3000);
 }
 
 async function deployApp(page, appName, projectName, { noAssets = false, noSource = false } = {}) {
@@ -729,7 +739,7 @@ async function deployApp(page, appName, projectName, { noAssets = false, noSourc
   // Extract app ID from current URL
   const appId = page.url().match(/#\/application(?:-source)?\/(\d+)/)?.[1] || '?';
   console.log(`  [app] Done — ID: ${appId}`);
-  return { appId, params };
+  return appId;
 }
 
 // ─── Phase 3: Ubox Deployment ─────────────────────────────────────────────────
@@ -1143,12 +1153,6 @@ async function main() {
   const state = {};
 
   try {
-    // Always accept any confirm() dialogs the studio may show during deployment
-    page.on('dialog', async d => {
-      console.log(`  [dialog] type=${d.type()} msg="${d.message()}" → accepted`);
-      await d.accept();
-    });
-
     // Phase 1 — Login
     await login(page, email, password);
 
@@ -1156,9 +1160,9 @@ async function main() {
     const appParamsMap = {};
     for (const appName of apps) {
       state[appName] = {};
-      const { appId, params } = await deployApp(page, appName, projectName, { noAssets, noSource });
-      state[appName].appId = appId;
+      const { params } = generateProxy(appName);
       appParamsMap[appName] = params;
+      state[appName].appId = await deployApp(page, appName, projectName, { noAssets, noSource });
     }
 
     // Phase 3 — Deploy Uboxes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubox-tools/deploy-xperience",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "description": "Deploy a Ubox experience to studio.ubox.world",
   "bin": { "deploy-xperience": "./deploy.js" },
   "dependencies": { "puppeteer": "*" },